pax_global_header00006660000000000000000000000064140002621570014507gustar00rootroot0000000000000052 comment=9acb9ec31f5a8ef80ea6b994bb77be787b08d3d1 spirv-cross-2021.01.15/000077500000000000000000000000001400026215700143725ustar00rootroot00000000000000spirv-cross-2021.01.15/.clang-format000077500000000000000000000135071400026215700167560ustar00rootroot00000000000000# The style used for all options not specifically set in the configuration. BasedOnStyle: LLVM # The extra indent or outdent of access modifiers, e.g. public:. AccessModifierOffset: -4 # If true, aligns escaped newlines as far left as possible. Otherwise puts them into the right-most column. AlignEscapedNewlinesLeft: true # If true, aligns trailing comments. AlignTrailingComments: false # Allow putting all parameters of a function declaration onto the next line even if BinPackParameters is false. AllowAllParametersOfDeclarationOnNextLine: false # Allows contracting simple braced statements to a single line. AllowShortBlocksOnASingleLine: false # If true, short case labels will be contracted to a single line. AllowShortCaseLabelsOnASingleLine: false # Dependent on the value, int f() { return 0; } can be put on a single line. Possible values: None, Inline, All. AllowShortFunctionsOnASingleLine: None # If true, if (a) return; can be put on a single line. AllowShortIfStatementsOnASingleLine: false # If true, while (true) continue; can be put on a single line. AllowShortLoopsOnASingleLine: false # If true, always break after function definition return types. AlwaysBreakAfterDefinitionReturnType: false # If true, always break before multiline string literals. AlwaysBreakBeforeMultilineStrings: false # If true, always break after the template<...> of a template declaration. AlwaysBreakTemplateDeclarations: true # If false, a function call's arguments will either be all on the same line or will have one line each. BinPackArguments: true # If false, a function declaration's or function definition's parameters will either all be on the same line # or will have one line each. BinPackParameters: true # The way to wrap binary operators. Possible values: None, NonAssignment, All. BreakBeforeBinaryOperators: None # The brace breaking style to use. Possible values: Attach, Linux, Stroustrup, Allman, GNU. BreakBeforeBraces: Allman # If true, ternary operators will be placed after line breaks. BreakBeforeTernaryOperators: false # Always break constructor initializers before commas and align the commas with the colon. BreakConstructorInitializersBeforeComma: true # The column limit. A column limit of 0 means that there is no column limit. ColumnLimit: 120 # A regular expression that describes comments with special meaning, which should not be split into lines or otherwise changed. CommentPragmas: '^ *' # If the constructor initializers don't fit on a line, put each initializer on its own line. ConstructorInitializerAllOnOneLineOrOnePerLine: false # The number of characters to use for indentation of constructor initializer lists. ConstructorInitializerIndentWidth: 4 # Indent width for line continuations. ContinuationIndentWidth: 4 # If true, format braced lists as best suited for C++11 braced lists. Cpp11BracedListStyle: false # Disables formatting at all. DisableFormat: false # A vector of macros that should be interpreted as foreach loops instead of as function calls. #ForEachMacros: '' # Indent case labels one level from the switch statement. # When false, use the same indentation level as for the switch statement. # Switch statement body is always indented one level more than case labels. IndentCaseLabels: false # The number of columns to use for indentation. IndentWidth: 4 # Indent if a function definition or declaration is wrapped after the type. IndentWrappedFunctionNames: false # If true, empty lines at the start of blocks are kept. KeepEmptyLinesAtTheStartOfBlocks: true # Language, this format style is targeted at. Possible values: None, Cpp, Java, JavaScript, Proto. Language: Cpp # The maximum number of consecutive empty lines to keep. MaxEmptyLinesToKeep: 1 # The indentation used for namespaces. Possible values: None, Inner, All. NamespaceIndentation: None # The penalty for breaking a function call after "call(". PenaltyBreakBeforeFirstCallParameter: 19 # The penalty for each line break introduced inside a comment. PenaltyBreakComment: 300 # The penalty for breaking before the first <<. PenaltyBreakFirstLessLess: 120 # The penalty for each line break introduced inside a string literal. PenaltyBreakString: 1000 # The penalty for each character outside of the column limit. PenaltyExcessCharacter: 1000000 # Penalty for putting the return type of a function onto its own line. PenaltyReturnTypeOnItsOwnLine: 1000000000 # Pointer and reference alignment style. Possible values: Left, Right, Middle. PointerAlignment: Right # If true, a space may be inserted after C style casts. SpaceAfterCStyleCast: false # If false, spaces will be removed before assignment operators. SpaceBeforeAssignmentOperators: true # Defines in which cases to put a space before opening parentheses. Possible values: Never, ControlStatements, Always. SpaceBeforeParens: ControlStatements # If true, spaces may be inserted into '()'. SpaceInEmptyParentheses: false # The number of spaces before trailing line comments (// - comments). SpacesBeforeTrailingComments: 1 # If true, spaces will be inserted after '<' and before '>' in template argument lists. SpacesInAngles: false # If true, spaces may be inserted into C style casts. SpacesInCStyleCastParentheses: false # If true, spaces are inserted inside container literals (e.g. ObjC and Javascript array and dict literals). SpacesInContainerLiterals: false # If true, spaces will be inserted after '(' and before ')'. SpacesInParentheses: false # If true, spaces will be inserted after '[' and befor']'. SpacesInSquareBrackets: false # Format compatible with this standard, e.g. use A > instead of A> for LS_Cpp03. Possible values: Cpp03, Cpp11, Auto. Standard: Cpp11 # The number of columns used for tab stops. TabWidth: 4 # The way to use tab characters in the resulting file. Possible values: Never, ForIndentation, Always. UseTab: ForIndentation # Do not reflow comments ReflowComments: false spirv-cross-2021.01.15/.gitignore000066400000000000000000000002411400026215700163570ustar00rootroot00000000000000*.o *.d *.txt /test /spirv-cross /obj /msvc/x64 /msvc/Debug /msvc/Release *.suo *.sdf *.opensdf *.shader *.a *.bc /external .vs/ *.vcxproj.user !CMakeLists.txt spirv-cross-2021.01.15/.travis.yml000066400000000000000000000051301400026215700165020ustar00rootroot00000000000000language: - cpp - python python: 3.9 matrix: include: - os: linux dist: trusty compiler: gcc env: - GENERATOR="Unix Makefiles" - ARTIFACT=gcc-trusty-64bit - os: linux dist: trusty compiler: clang env: - GENERATOR="Unix Makefiles" - ARTIFACT=clang-trusty-64bit - os: osx compiler: clang osx_image: xcode10 env: - GENERATOR="Unix Makefiles" - ARTIFACT=clang-macos-64bit - os: windows before_install: - choco install python3 - export PATH="/c/Python39:/c/Python39/Scripts:$PATH" env: - GENERATOR="Visual Studio 15 2017" - ARTIFACT=vs2017-32bit - os: windows before_install: - choco install python3 - export PATH="/c/Python39:/c/Python39/Scripts:$PATH" env: - GENERATOR="Visual Studio 15 2017 Win64" - ARTIFACT=vs2017-64bit before_script: - "./checkout_glslang_spirv_tools.sh" script: - if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then PYTHON3=$(which python); fi - if [[ "$TRAVIS_OS_NAME" != "windows" ]]; then PYTHON3=$(which python3); fi - "./build_glslang_spirv_tools.sh Release" - mkdir build - cd build - cmake .. -DSPIRV_CROSS_WERROR=ON -DSPIRV_CROSS_MISC_WARNINGS=ON -DSPIRV_CROSS_SHARED=ON -DCMAKE_INSTALL_PREFIX=output -DCMAKE_BUILD_TYPE=Release -G "${GENERATOR}" -DPYTHON_EXECUTABLE:FILEPATH="${PYTHON3}" -DSPIRV_CROSS_ENABLE_TESTS=ON - cmake --build . --config Release - cmake --build . --config Release --target install - ctest --verbose -C Release - cd .. before_deploy: - REV=${ARTIFACT}-$(git rev-parse --short=10 HEAD) - cd build/output - tar cf spirv-cross-${REV}.tar * - gzip spirv-cross-${REV}.tar - cd ../.. - export FILE_TO_UPLOAD=build/output/spirv-cross-${REV}.tar.gz deploy: provider: releases api_key: secure: c7YEOyzhE19TFo76UnbLWk/kikRQxsHsOxzkOqN6Q2aL8joNRw5kmcG84rGd+Rf6isX62cykCzA6qHkyJCv9QTIzcyXnLju17rLvgib7cXDcseaq8x4mFvet2yUxCglthDpFY2M2LB0Aqws71lPeYIrKXa6hCFEh8jO3AWxnaor7O3RYfNZylM9d33HgH6KLT3sDx/cukwBstmKeg7EG9OUnrSvairkPW0W2+jlq3SXPlq/WeVhf8hQs3Yg0BluExGbmLOwe9EaeUpeGuJMyHRxXypnToQv1/KwoScKpap5tYxdNWiwRGZ4lYcmKrjAYVvilTioh654oX5LQpn34mE/oe8Ko9AaATkSaoiisRFp6meWtnB39oFBoL5Yn15DqLQpRXPr1AJsnBXSGAac3aDBO1j4MIqTHmYlYlfRw3n2ZsBaFaTZnv++438SNQ54nkivyoDTIWjoOmYa9+K4mQc3415RDdQmjZTJM+lu+GAlMmNBTVbfNvrbU55Usu9Lo6BZJKKdUMvdBB78kJ5FHvcBlL+eMgmk1pABQY0IZROCt7NztHcv1UmAxoWNxveSFs5glydPNNjNS8bogc4dzBGYG0KMmILbBHihVbY2toA1M9CMdDHdp+LucfDMmzECmYSEmlx0h8win+Jjb74/qpOhaXuUZ0NnzVgCOyeUYuMQ= file: "${FILE_TO_UPLOAD}" skip_cleanup: true on: tags: true spirv-cross-2021.01.15/CMakeLists.txt000066400000000000000000000626571400026215700171520ustar00rootroot00000000000000# Copyright 2016-2021 Google Inc. # # 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. # # At your option, you may choose to accept this material under either: # 1. The Apache License, Version 2.0, found at , or # 2. The MIT License, found at . # SPDX-License-Identifier: Apache-2.0 OR MIT. # cmake_minimum_required(VERSION 3.0) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_EXTENSIONS OFF) # Avoid a warning if parent project sets VERSION in project(). if (${CMAKE_VERSION} VERSION_GREATER "3.0.1") cmake_policy(SET CMP0048 NEW) endif() project(SPIRV-Cross LANGUAGES CXX C) enable_testing() include(GNUInstallDirs) option(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS "Instead of throwing exceptions assert" OFF) option(SPIRV_CROSS_SHARED "Build the C API as a single shared library." OFF) option(SPIRV_CROSS_STATIC "Build the C and C++ API as static libraries." ON) option(SPIRV_CROSS_CLI "Build the CLI binary. Requires SPIRV_CROSS_STATIC." ON) option(SPIRV_CROSS_ENABLE_TESTS "Enable SPIRV-Cross tests." ON) option(SPIRV_CROSS_ENABLE_GLSL "Enable GLSL support." ON) option(SPIRV_CROSS_ENABLE_HLSL "Enable HLSL target support." ON) option(SPIRV_CROSS_ENABLE_MSL "Enable MSL target support." ON) option(SPIRV_CROSS_ENABLE_CPP "Enable C++ target support." ON) option(SPIRV_CROSS_ENABLE_REFLECT "Enable JSON reflection target support." ON) option(SPIRV_CROSS_ENABLE_C_API "Enable C API wrapper support in static library." ON) option(SPIRV_CROSS_ENABLE_UTIL "Enable util module support." ON) option(SPIRV_CROSS_SANITIZE_ADDRESS "Sanitize address" OFF) option(SPIRV_CROSS_SANITIZE_MEMORY "Sanitize memory" OFF) option(SPIRV_CROSS_SANITIZE_THREADS "Sanitize threads" OFF) option(SPIRV_CROSS_SANITIZE_UNDEFINED "Sanitize undefined" OFF) option(SPIRV_CROSS_NAMESPACE_OVERRIDE "" "Override the namespace used in the C++ API.") option(SPIRV_CROSS_FORCE_STL_TYPES "Force use of STL types instead of STL replacements in certain places. Might reduce performance." OFF) option(SPIRV_CROSS_SKIP_INSTALL "Skips installation targets." OFF) option(SPIRV_CROSS_WERROR "Fail build on warnings." OFF) option(SPIRV_CROSS_MISC_WARNINGS "Misc warnings useful for Travis runs." OFF) option(SPIRV_CROSS_FORCE_PIC "Force position-independent code for all targets." OFF) if(${CMAKE_GENERATOR} MATCHES "Makefile") if(${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR}) message(FATAL_ERROR "Build out of tree to avoid overwriting Makefile") endif() endif() set(spirv-compiler-options "") set(spirv-compiler-defines "") set(spirv-cross-link-flags "") message(STATUS "SPIRV-Cross: Finding Git version for SPIRV-Cross.") set(spirv-cross-build-version "unknown") find_package(Git) if (GIT_FOUND) execute_process( COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} OUTPUT_VARIABLE spirv-cross-build-version ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) message(STATUS "SPIRV-Cross: Git hash: ${spirv-cross-build-version}") else() message(STATUS "SPIRV-Cross: Git not found, using unknown build version.") endif() string(TIMESTAMP spirv-cross-timestamp) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/gitversion.in.h ${CMAKE_CURRENT_BINARY_DIR}/gitversion.h @ONLY) if (SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS) set(spirv-compiler-defines ${spirv-compiler-defines} SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS) if (NOT MSVC) set(spirv-compiler-options ${spirv-compiler-options} -fno-exceptions) endif() endif() if (SPIRV_CROSS_FORCE_STL_TYPES) set(spirv-compiler-defines ${spirv-compiler-defines} SPIRV_CROSS_FORCE_STL_TYPES) endif() if (WIN32) set(CMAKE_DEBUG_POSTFIX "d") endif() if (CMAKE_COMPILER_IS_GNUCXX OR ((${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") AND NOT MSVC)) set(spirv-compiler-options ${spirv-compiler-options} -Wall -Wextra -Wshadow -Wno-deprecated-declarations) if (SPIRV_CROSS_MISC_WARNINGS) if (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") set(spirv-compiler-options ${spirv-compiler-options} -Wshorten-64-to-32) endif() endif() if (SPIRV_CROSS_WERROR) set(spirv-compiler-options ${spirv-compiler-options} -Werror) endif() if (SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS) set(spirv-compiler-options ${spirv-compiler-options} -fno-exceptions) endif() if (SPIRV_CROSS_SANITIZE_ADDRESS) set(spirv-compiler-options ${spirv-compiler-options} -fsanitize=address) set(spirv-cross-link-flags "${spirv-cross-link-flags} -fsanitize=address") endif() if (SPIRV_CROSS_SANITIZE_UNDEFINED) set(spirv-compiler-options ${spirv-compiler-options} -fsanitize=undefined) set(spirv-cross-link-flags "${spirv-cross-link-flags} -fsanitize=undefined") endif() if (SPIRV_CROSS_SANITIZE_MEMORY) set(spirv-compiler-options ${spirv-compiler-options} -fsanitize=memory) set(spirv-cross-link-flags "${spirv-cross-link-flags} -fsanitize=memory") endif() if (SPIRV_CROSS_SANITIZE_THREADS) set(spirv-compiler-options ${spirv-compiler-options} -fsanitize=thread) set(spirv-cross-link-flags "${spirv-cross-link-flags} -fsanitize=thread") endif() elseif (MSVC) set(spirv-compiler-options ${spirv-compiler-options} /wd4267 /wd4996) endif() macro(extract_headers out_abs file_list) set(${out_abs}) # absolute paths foreach(_a ${file_list}) # get_filename_component only returns the longest extension, so use a regex string(REGEX REPLACE ".*\\.(h|hpp)" "\\1" ext ${_a}) # For shared library, we are only interested in the C header. if (SPIRV_CROSS_STATIC) if(("${ext}" STREQUAL "h") OR ("${ext}" STREQUAL "hpp")) list(APPEND ${out_abs} "${_a}") endif() else() if("${ext}" STREQUAL "h") list(APPEND ${out_abs} "${_a}") endif() endif() endforeach() endmacro() macro(spirv_cross_add_library name config_name library_type) add_library(${name} ${library_type} ${ARGN}) extract_headers(hdrs "${ARGN}") target_include_directories(${name} PUBLIC $ $) set_target_properties(${name} PROPERTIES PUBLIC_HEADERS "${hdrs}") if (SPIRV_CROSS_FORCE_PIC) set_target_properties(${name} PROPERTIES POSITION_INDEPENDENT_CODE ON) endif() target_compile_options(${name} PRIVATE ${spirv-compiler-options}) target_compile_definitions(${name} PRIVATE ${spirv-compiler-defines}) if (SPIRV_CROSS_NAMESPACE_OVERRIDE) if (${library_type} MATCHES "STATIC") target_compile_definitions(${name} PUBLIC SPIRV_CROSS_NAMESPACE_OVERRIDE=${SPIRV_CROSS_NAMESPACE_OVERRIDE}) else() target_compile_definitions(${name} PRIVATE SPIRV_CROSS_NAMESPACE_OVERRIDE=${SPIRV_CROSS_NAMESPACE_OVERRIDE}) endif() endif() if (NOT SPIRV_CROSS_SKIP_INSTALL) install(TARGETS ${name} EXPORT ${config_name}Config RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/spirv_cross) install(FILES ${hdrs} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/spirv_cross) install(EXPORT ${config_name}Config DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${config_name}/cmake) export(TARGETS ${name} FILE ${config_name}Config.cmake) endif() endmacro() set(spirv-cross-core-sources ${CMAKE_CURRENT_SOURCE_DIR}/GLSL.std.450.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_common.hpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross_containers.hpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross_error_handling.hpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv.hpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross.hpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_parser.hpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_parser.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross_parsed_ir.hpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross_parsed_ir.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cfg.hpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cfg.cpp) set(spirv-cross-c-sources spirv.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross_c.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross_c.h) set(spirv-cross-glsl-sources ${CMAKE_CURRENT_SOURCE_DIR}/spirv_glsl.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_glsl.hpp) set(spirv-cross-cpp-sources ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cpp.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cpp.hpp) set(spirv-cross-msl-sources ${CMAKE_CURRENT_SOURCE_DIR}/spirv_msl.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_msl.hpp) set(spirv-cross-hlsl-sources ${CMAKE_CURRENT_SOURCE_DIR}/spirv_hlsl.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_hlsl.hpp) set(spirv-cross-reflect-sources ${CMAKE_CURRENT_SOURCE_DIR}/spirv_reflect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_reflect.hpp) set(spirv-cross-util-sources ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross_util.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_cross_util.hpp) if (SPIRV_CROSS_STATIC) spirv_cross_add_library(spirv-cross-core spirv_cross_core STATIC ${spirv-cross-core-sources}) if (SPIRV_CROSS_ENABLE_GLSL) spirv_cross_add_library(spirv-cross-glsl spirv_cross_glsl STATIC ${spirv-cross-glsl-sources}) target_link_libraries(spirv-cross-glsl PRIVATE spirv-cross-core) endif() if (SPIRV_CROSS_ENABLE_CPP) spirv_cross_add_library(spirv-cross-cpp spirv_cross_cpp STATIC ${spirv-cross-cpp-sources}) if (SPIRV_CROSS_ENABLE_GLSL) target_link_libraries(spirv-cross-cpp PRIVATE spirv-cross-glsl) else() message(FATAL_ERROR "Must enable GLSL support to enable C++ support.") endif() endif() if (SPIRV_CROSS_ENABLE_REFLECT) if (SPIRV_CROSS_ENABLE_GLSL) spirv_cross_add_library(spirv-cross-reflect spirv_cross_reflect STATIC ${spirv-cross-reflect-sources}) else() message(FATAL_ERROR "Must enable GLSL support to enable JSON reflection support.") endif() endif() if (SPIRV_CROSS_ENABLE_MSL) spirv_cross_add_library(spirv-cross-msl spirv_cross_msl STATIC ${spirv-cross-msl-sources}) if (SPIRV_CROSS_ENABLE_GLSL) target_link_libraries(spirv-cross-msl PRIVATE spirv-cross-glsl) else() message(FATAL_ERROR "Must enable GLSL support to enable MSL support.") endif() endif() if (SPIRV_CROSS_ENABLE_HLSL) spirv_cross_add_library(spirv-cross-hlsl spirv_cross_hlsl STATIC ${spirv-cross-hlsl-sources}) if (SPIRV_CROSS_ENABLE_GLSL) target_link_libraries(spirv-cross-hlsl PRIVATE spirv-cross-glsl) else() message(FATAL_ERROR "Must enable GLSL support to enable HLSL support.") endif() endif() if (SPIRV_CROSS_ENABLE_UTIL) spirv_cross_add_library(spirv-cross-util spirv_cross_util STATIC ${spirv-cross-util-sources}) target_link_libraries(spirv-cross-util PRIVATE spirv-cross-core) endif() if (SPIRV_CROSS_ENABLE_C_API) spirv_cross_add_library(spirv-cross-c spirv_cross_c STATIC ${spirv-cross-c-sources}) target_include_directories(spirv-cross-c PRIVATE ${CMAKE_CURRENT_BINARY_DIR}) target_compile_definitions(spirv-cross-c PRIVATE HAVE_SPIRV_CROSS_GIT_VERSION) if (SPIRV_CROSS_ENABLE_GLSL) target_link_libraries(spirv-cross-c PRIVATE spirv-cross-glsl) target_compile_definitions(spirv-cross-c PRIVATE SPIRV_CROSS_C_API_GLSL=1) endif() if (SPIRV_CROSS_ENABLE_HLSL) target_link_libraries(spirv-cross-c PRIVATE spirv-cross-hlsl) target_compile_definitions(spirv-cross-c PRIVATE SPIRV_CROSS_C_API_HLSL=1) endif() if (SPIRV_CROSS_ENABLE_MSL) target_link_libraries(spirv-cross-c PRIVATE spirv-cross-msl) target_compile_definitions(spirv-cross-c PRIVATE SPIRV_CROSS_C_API_MSL=1) endif() if (SPIRV_CROSS_ENABLE_CPP) target_link_libraries(spirv-cross-c PRIVATE spirv-cross-cpp) target_compile_definitions(spirv-cross-c PRIVATE SPIRV_CROSS_C_API_CPP=1) endif() if (SPIRV_CROSS_ENABLE_REFLECT) target_link_libraries(spirv-cross-c PRIVATE spirv-cross-reflect) target_compile_definitions(spirv-cross-c PRIVATE SPIRV_CROSS_C_API_REFLECT=1) endif() endif() endif() set(spirv-cross-abi-major 0) set(spirv-cross-abi-minor 44) set(spirv-cross-abi-patch 0) if (SPIRV_CROSS_SHARED) set(SPIRV_CROSS_VERSION ${spirv-cross-abi-major}.${spirv-cross-abi-minor}.${spirv-cross-abi-patch}) if (NOT SPIRV_CROSS_SKIP_INSTALL) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/pkg-config/spirv-cross-c-shared.pc.in ${CMAKE_CURRENT_BINARY_DIR}/spirv-cross-c-shared.pc @ONLY) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/spirv-cross-c-shared.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) endif() spirv_cross_add_library(spirv-cross-c-shared spirv_cross_c_shared SHARED ${spirv-cross-core-sources} ${spirv-cross-c-sources}) target_include_directories(spirv-cross-c-shared PRIVATE ${CMAKE_CURRENT_BINARY_DIR}) target_compile_definitions(spirv-cross-c-shared PRIVATE HAVE_SPIRV_CROSS_GIT_VERSION) if (SPIRV_CROSS_ENABLE_GLSL) target_sources(spirv-cross-c-shared PRIVATE ${spirv-cross-glsl-sources}) target_compile_definitions(spirv-cross-c-shared PRIVATE SPIRV_CROSS_C_API_GLSL=1) endif() if (SPIRV_CROSS_ENABLE_HLSL) if (SPIRV_CROSS_ENABLE_GLSL) target_sources(spirv-cross-c-shared PRIVATE ${spirv-cross-hlsl-sources}) else() message(FATAL_ERROR "Must enable GLSL support to enable HLSL support.") endif() target_compile_definitions(spirv-cross-c-shared PRIVATE SPIRV_CROSS_C_API_HLSL=1) endif() if (SPIRV_CROSS_ENABLE_MSL) if (SPIRV_CROSS_ENABLE_GLSL) target_sources(spirv-cross-c-shared PRIVATE ${spirv-cross-msl-sources}) else() message(FATAL_ERROR "Must enable GLSL support to enable MSL support.") endif() target_compile_definitions(spirv-cross-c-shared PRIVATE SPIRV_CROSS_C_API_MSL=1) endif() if (SPIRV_CROSS_ENABLE_CPP) if (SPIRV_CROSS_ENABLE_GLSL) target_sources(spirv-cross-c-shared PRIVATE ${spirv-cross-cpp-sources}) else() message(FATAL_ERROR "Must enable GLSL support to enable C++ support.") endif() target_compile_definitions(spirv-cross-c-shared PRIVATE SPIRV_CROSS_C_API_CPP=1) endif() if (SPIRV_CROSS_ENABLE_REFLECT) if (SPIRV_CROSS_ENABLE_GLSL) target_sources(spirv-cross-c-shared PRIVATE ${spirv-cross-reflect-sources}) else() message(FATAL_ERROR "Must enable GLSL support to enable JSON reflection support.") endif() target_compile_definitions(spirv-cross-c-shared PRIVATE SPIRV_CROSS_C_API_REFLECT=1) endif() if (CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")) # Only export the C API. target_compile_options(spirv-cross-c-shared PRIVATE -fvisibility=hidden) if (NOT APPLE) set_target_properties(spirv-cross-c-shared PROPERTIES LINK_FLAGS "${spirv-cross-link-flags}") endif() endif() target_compile_definitions(spirv-cross-c-shared PRIVATE SPVC_EXPORT_SYMBOLS) set_target_properties(spirv-cross-c-shared PROPERTIES VERSION ${SPIRV_CROSS_VERSION} SOVERSION ${spirv-cross-abi-major}) endif() if (SPIRV_CROSS_CLI) if (NOT SPIRV_CROSS_ENABLE_GLSL) message(FATAL_ERROR "Must enable GLSL if building CLI.") endif() if (NOT SPIRV_CROSS_ENABLE_HLSL) message(FATAL_ERROR "Must enable HLSL if building CLI.") endif() if (NOT SPIRV_CROSS_ENABLE_MSL) message(FATAL_ERROR "Must enable MSL if building CLI.") endif() if (NOT SPIRV_CROSS_ENABLE_CPP) message(FATAL_ERROR "Must enable C++ if building CLI.") endif() if (NOT SPIRV_CROSS_ENABLE_REFLECT) message(FATAL_ERROR "Must enable reflection if building CLI.") endif() if (NOT SPIRV_CROSS_ENABLE_UTIL) message(FATAL_ERROR "Must enable utils if building CLI.") endif() if (NOT SPIRV_CROSS_STATIC) message(FATAL_ERROR "Must build static libraries if building CLI.") endif() add_executable(spirv-cross main.cpp) target_compile_options(spirv-cross PRIVATE ${spirv-compiler-options}) target_include_directories(spirv-cross PRIVATE ${CMAKE_CURRENT_BINARY_DIR}) target_compile_definitions(spirv-cross PRIVATE ${spirv-compiler-defines} HAVE_SPIRV_CROSS_GIT_VERSION) set_target_properties(spirv-cross PROPERTIES LINK_FLAGS "${spirv-cross-link-flags}") if (NOT SPIRV_CROSS_SKIP_INSTALL) install(TARGETS spirv-cross RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) endif() target_link_libraries(spirv-cross PRIVATE spirv-cross-glsl spirv-cross-hlsl spirv-cross-cpp spirv-cross-reflect spirv-cross-msl spirv-cross-util spirv-cross-core) if (SPIRV_CROSS_ENABLE_TESTS) # Set up tests, using only the simplest modes of the test_shaders # script. You have to invoke the script manually to: # - Update the reference files # - Get cycle counts from malisc # - Keep failing outputs find_package(PythonInterp) find_program(spirv-cross-glslang NAMES glslangValidator PATHS ${CMAKE_CURRENT_SOURCE_DIR}/external/glslang-build/output/bin NO_DEFAULT_PATH) find_program(spirv-cross-spirv-as NAMES spirv-as PATHS ${CMAKE_CURRENT_SOURCE_DIR}/external/spirv-tools-build/output/bin NO_DEFAULT_PATH) find_program(spirv-cross-spirv-val NAMES spirv-val PATHS ${CMAKE_CURRENT_SOURCE_DIR}/external/spirv-tools-build/output/bin NO_DEFAULT_PATH) find_program(spirv-cross-spirv-opt NAMES spirv-opt PATHS ${CMAKE_CURRENT_SOURCE_DIR}/external/spirv-tools-build/output/bin NO_DEFAULT_PATH) if ((${spirv-cross-glslang} MATCHES "NOTFOUND") OR (${spirv-cross-spirv-as} MATCHES "NOTFOUND") OR (${spirv-cross-spirv-val} MATCHES "NOTFOUND") OR (${spirv-cross-spirv-opt} MATCHES "NOTFOUND")) set(SPIRV_CROSS_ENABLE_TESTS OFF) message("SPIRV-Cross: Testing will be disabled for SPIRV-Cross. Could not find glslang or SPIRV-Tools build under external/. To enable testing, run ./checkout_glslang_spirv_tools.sh and ./build_glslang_spirv_tools.sh first.") else() set(SPIRV_CROSS_ENABLE_TESTS ON) message("SPIRV-Cross: Found glslang and SPIRV-Tools. Enabling test suite.") message("SPIRV-Cross: Found glslangValidator in: ${spirv-cross-glslang}.") message("SPIRV-Cross: Found spirv-as in: ${spirv-cross-spirv-as}.") message("SPIRV-Cross: Found spirv-val in: ${spirv-cross-spirv-val}.") message("SPIRV-Cross: Found spirv-opt in: ${spirv-cross-spirv-opt}.") endif() set(spirv-cross-externals --glslang "${spirv-cross-glslang}" --spirv-as "${spirv-cross-spirv-as}" --spirv-opt "${spirv-cross-spirv-opt}" --spirv-val "${spirv-cross-spirv-val}") if (${PYTHONINTERP_FOUND} AND SPIRV_CROSS_ENABLE_TESTS) if (${PYTHON_VERSION_MAJOR} GREATER 2) add_executable(spirv-cross-c-api-test tests-other/c_api_test.c) target_link_libraries(spirv-cross-c-api-test spirv-cross-c) set_target_properties(spirv-cross-c-api-test PROPERTIES LINK_FLAGS "${spirv-cross-link-flags}") add_executable(spirv-cross-small-vector-test tests-other/small_vector.cpp) target_link_libraries(spirv-cross-small-vector-test spirv-cross-core) set_target_properties(spirv-cross-small-vector-test PROPERTIES LINK_FLAGS "${spirv-cross-link-flags}") add_executable(spirv-cross-msl-constexpr-test tests-other/msl_constexpr_test.cpp) target_link_libraries(spirv-cross-msl-constexpr-test spirv-cross-c) set_target_properties(spirv-cross-msl-constexpr-test PROPERTIES LINK_FLAGS "${spirv-cross-link-flags}") add_executable(spirv-cross-msl-resource-binding-test tests-other/msl_resource_bindings.cpp) target_link_libraries(spirv-cross-msl-resource-binding-test spirv-cross-c) set_target_properties(spirv-cross-msl-resource-binding-test PROPERTIES LINK_FLAGS "${spirv-cross-link-flags}") add_executable(spirv-cross-hlsl-resource-binding-test tests-other/hlsl_resource_bindings.cpp) target_link_libraries(spirv-cross-hlsl-resource-binding-test spirv-cross-c) set_target_properties(spirv-cross-hlsl-resource-binding-test PROPERTIES LINK_FLAGS "${spirv-cross-link-flags}") add_executable(spirv-cross-msl-ycbcr-conversion-test tests-other/msl_ycbcr_conversion_test.cpp) target_link_libraries(spirv-cross-msl-ycbcr-conversion-test spirv-cross-c) set_target_properties(spirv-cross-msl-ycbcr-conversion-test PROPERTIES LINK_FLAGS "${spirv-cross-link-flags}") add_executable(spirv-cross-typed-id-test tests-other/typed_id_test.cpp) target_link_libraries(spirv-cross-typed-id-test spirv-cross-core) set_target_properties(spirv-cross-typed-id-test PROPERTIES LINK_FLAGS "${spirv-cross-link-flags}") if (CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")) target_compile_options(spirv-cross-c-api-test PRIVATE -std=c89 -Wall -Wextra) endif() add_test(NAME spirv-cross-c-api-test COMMAND $ ${CMAKE_CURRENT_SOURCE_DIR}/tests-other/c_api_test.spv ${spirv-cross-abi-major} ${spirv-cross-abi-minor} ${spirv-cross-abi-patch}) add_test(NAME spirv-cross-small-vector-test COMMAND $) add_test(NAME spirv-cross-msl-constexpr-test COMMAND $ ${CMAKE_CURRENT_SOURCE_DIR}/tests-other/msl_constexpr_test.spv) add_test(NAME spirv-cross-msl-resource-binding-test COMMAND $ ${CMAKE_CURRENT_SOURCE_DIR}/tests-other/msl_resource_binding.spv) add_test(NAME spirv-cross-hlsl-resource-binding-test COMMAND $ ${CMAKE_CURRENT_SOURCE_DIR}/tests-other/hlsl_resource_binding.spv) add_test(NAME spirv-cross-msl-ycbcr-conversion-test COMMAND $ ${CMAKE_CURRENT_SOURCE_DIR}/tests-other/msl_ycbcr_conversion_test.spv) add_test(NAME spirv-cross-msl-ycbcr-conversion-test-2 COMMAND $ ${CMAKE_CURRENT_SOURCE_DIR}/tests-other/msl_ycbcr_conversion_test_2.spv) add_test(NAME spirv-cross-typed-id-test COMMAND $) add_test(NAME spirv-cross-test COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-no-opt COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-no-opt WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-metal COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --metal --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-msl WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-metal-no-opt COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --metal --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-msl-no-opt WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-hlsl COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --hlsl --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-hlsl WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-hlsl-no-opt COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --hlsl --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-hlsl-no-opt WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-opt COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --opt --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-metal-opt COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --metal --opt --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-msl WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-hlsl-opt COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --hlsl --opt --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-hlsl WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-reflection COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --reflect --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-reflection WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-ue4 COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --msl --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-ue4 WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-ue4-opt COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --msl --opt --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-ue4 WORKING_DIRECTORY $) add_test(NAME spirv-cross-test-ue4-no-opt COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_shaders.py --msl --parallel ${spirv-cross-externals} ${CMAKE_CURRENT_SOURCE_DIR}/shaders-ue4-no-opt WORKING_DIRECTORY $) endif() elseif(NOT ${PYTHONINTERP_FOUND}) message(WARNING "SPIRV-Cross: Testing disabled. Could not find python3. If you have python3 installed try running " "cmake with -DPYTHON_EXECUTABLE:FILEPATH=/path/to/python3 to help it find the executable") endif() endif() endif() spirv-cross-2021.01.15/CODE_OF_CONDUCT.md000066400000000000000000000004301400026215700171660ustar00rootroot00000000000000A reminder that this issue tracker is managed by the Khronos Group. Interactions here should follow the Khronos Code of Conduct (https://www.khronos.org/developers/code-of-conduct), which prohibits aggressive or derogatory language. Please keep the discussion friendly and civil. spirv-cross-2021.01.15/GLSL.std.450.h000066400000000000000000000100371400026215700164050ustar00rootroot00000000000000/* ** Copyright (c) 2014-2016 The Khronos Group Inc. ** ** Permission is hereby granted, free of charge, to any person obtaining a copy ** of this software and/or associated documentation files (the "Materials"), ** to deal in the Materials without restriction, including without limitation ** the rights to use, copy, modify, merge, publish, distribute, sublicense, ** and/or sell copies of the Materials, and to permit persons to whom the ** Materials are furnished to do so, subject to the following conditions: ** ** The above copyright notice and this permission notice shall be included in ** all copies or substantial portions of the Materials. ** ** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS ** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND ** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ** ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING ** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS ** IN THE MATERIALS. */ #ifndef GLSLstd450_H #define GLSLstd450_H static const int GLSLstd450Version = 100; static const int GLSLstd450Revision = 3; enum GLSLstd450 { GLSLstd450Bad = 0, // Don't use GLSLstd450Round = 1, GLSLstd450RoundEven = 2, GLSLstd450Trunc = 3, GLSLstd450FAbs = 4, GLSLstd450SAbs = 5, GLSLstd450FSign = 6, GLSLstd450SSign = 7, GLSLstd450Floor = 8, GLSLstd450Ceil = 9, GLSLstd450Fract = 10, GLSLstd450Radians = 11, GLSLstd450Degrees = 12, GLSLstd450Sin = 13, GLSLstd450Cos = 14, GLSLstd450Tan = 15, GLSLstd450Asin = 16, GLSLstd450Acos = 17, GLSLstd450Atan = 18, GLSLstd450Sinh = 19, GLSLstd450Cosh = 20, GLSLstd450Tanh = 21, GLSLstd450Asinh = 22, GLSLstd450Acosh = 23, GLSLstd450Atanh = 24, GLSLstd450Atan2 = 25, GLSLstd450Pow = 26, GLSLstd450Exp = 27, GLSLstd450Log = 28, GLSLstd450Exp2 = 29, GLSLstd450Log2 = 30, GLSLstd450Sqrt = 31, GLSLstd450InverseSqrt = 32, GLSLstd450Determinant = 33, GLSLstd450MatrixInverse = 34, GLSLstd450Modf = 35, // second operand needs an OpVariable to write to GLSLstd450ModfStruct = 36, // no OpVariable operand GLSLstd450FMin = 37, GLSLstd450UMin = 38, GLSLstd450SMin = 39, GLSLstd450FMax = 40, GLSLstd450UMax = 41, GLSLstd450SMax = 42, GLSLstd450FClamp = 43, GLSLstd450UClamp = 44, GLSLstd450SClamp = 45, GLSLstd450FMix = 46, GLSLstd450IMix = 47, // Reserved GLSLstd450Step = 48, GLSLstd450SmoothStep = 49, GLSLstd450Fma = 50, GLSLstd450Frexp = 51, // second operand needs an OpVariable to write to GLSLstd450FrexpStruct = 52, // no OpVariable operand GLSLstd450Ldexp = 53, GLSLstd450PackSnorm4x8 = 54, GLSLstd450PackUnorm4x8 = 55, GLSLstd450PackSnorm2x16 = 56, GLSLstd450PackUnorm2x16 = 57, GLSLstd450PackHalf2x16 = 58, GLSLstd450PackDouble2x32 = 59, GLSLstd450UnpackSnorm2x16 = 60, GLSLstd450UnpackUnorm2x16 = 61, GLSLstd450UnpackHalf2x16 = 62, GLSLstd450UnpackSnorm4x8 = 63, GLSLstd450UnpackUnorm4x8 = 64, GLSLstd450UnpackDouble2x32 = 65, GLSLstd450Length = 66, GLSLstd450Distance = 67, GLSLstd450Cross = 68, GLSLstd450Normalize = 69, GLSLstd450FaceForward = 70, GLSLstd450Reflect = 71, GLSLstd450Refract = 72, GLSLstd450FindILsb = 73, GLSLstd450FindSMsb = 74, GLSLstd450FindUMsb = 75, GLSLstd450InterpolateAtCentroid = 76, GLSLstd450InterpolateAtSample = 77, GLSLstd450InterpolateAtOffset = 78, GLSLstd450NMin = 79, GLSLstd450NMax = 80, GLSLstd450NClamp = 81, GLSLstd450Count }; #endif // #ifndef GLSLstd450_H spirv-cross-2021.01.15/LICENSE000066400000000000000000000261361400026215700154070ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. 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. spirv-cross-2021.01.15/Makefile000066400000000000000000000014701400026215700160340ustar00rootroot00000000000000TARGET := spirv-cross SOURCES := $(wildcard spirv_*.cpp) CLI_SOURCES := main.cpp OBJECTS := $(SOURCES:.cpp=.o) CLI_OBJECTS := $(CLI_SOURCES:.cpp=.o) STATIC_LIB := lib$(TARGET).a DEPS := $(OBJECTS:.o=.d) $(CLI_OBJECTS:.o=.d) CXXFLAGS += -std=c++11 -Wall -Wextra -Wshadow -Wno-deprecated-declarations ifeq ($(DEBUG), 1) CXXFLAGS += -O0 -g else CXXFLAGS += -O2 -DNDEBUG endif ifeq ($(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS), 1) CXXFLAGS += -DSPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS -fno-exceptions endif all: $(TARGET) -include $(DEPS) $(TARGET): $(CLI_OBJECTS) $(STATIC_LIB) $(CXX) -o $@ $(CLI_OBJECTS) $(STATIC_LIB) $(LDFLAGS) $(STATIC_LIB): $(OBJECTS) $(AR) rcs $@ $(OBJECTS) %.o: %.cpp $(CXX) -c -o $@ $< $(CXXFLAGS) -MMD clean: rm -f $(TARGET) $(OBJECTS) $(CLI_OBJECTS) $(STATIC_LIB) $(DEPS) .PHONY: clean spirv-cross-2021.01.15/README.md000066400000000000000000000514271400026215700156620ustar00rootroot00000000000000# SPIRV-Cross SPIRV-Cross is a tool designed for parsing and converting SPIR-V to other shader languages. [![Build Status](https://travis-ci.org/KhronosGroup/SPIRV-Cross.svg?branch=master)](https://travis-ci.org/KhronosGroup/SPIRV-Cross) [![Build Status](https://ci.appveyor.com/api/projects/status/github/KhronosGroup/SPIRV-Cross?svg=true&branch=master)](https://ci.appveyor.com/project/HansKristian-Work/SPIRV-Cross) ## Features - Convert SPIR-V to readable, usable and efficient GLSL - Convert SPIR-V to readable, usable and efficient Metal Shading Language (MSL) - Convert SPIR-V to readable, usable and efficient HLSL - Convert SPIR-V to debuggable C++ [DEPRECATED] - Convert SPIR-V to a JSON reflection format [EXPERIMENTAL] - Reflection API to simplify the creation of Vulkan pipeline layouts - Reflection API to modify and tweak OpDecorations - Supports "all" of vertex, fragment, tessellation, geometry and compute shaders. SPIRV-Cross tries hard to emit readable and clean output from the SPIR-V. The goal is to emit GLSL or MSL that looks like it was written by a human and not awkward IR/assembly-like code. NOTE: Individual features are expected to be mostly complete, but it is possible that certain obscure GLSL features are not yet supported. However, most missing features are expected to be "trivial" improvements at this stage. ## Building SPIRV-Cross has been tested on Linux, iOS/OSX, Windows and Android. CMake is the main build system. ### Linux and macOS Building with CMake is recommended, as it is the only build system which is tested in continuous integration. It is also the only build system which has install commands and other useful build system features. However, you can just run `make` on the command line as a fallback if you only care about the CLI tool. A non-ancient GCC (4.8+) or Clang (3.x+) compiler is required as SPIRV-Cross uses C++11 extensively. ### Windows Building with CMake is recommended, which is the only way to target MSVC. MinGW-w64 based compilation works with `make` as a fallback. ### Android SPIRV-Cross is only useful as a library here. Use the CMake build to link SPIRV-Cross to your project. ### C++ exceptions The make and CMake build flavors offer the option to treat exceptions as assertions. To disable exceptions for make just append `SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS=1` to the command line. For CMake append `-DSPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS=ON`. By default exceptions are enabled. ### Static, shared and CLI You can use `-DSPIRV_CROSS_STATIC=ON/OFF` `-DSPIRV_CROSS_SHARED=ON/OFF` `-DSPIRV_CROSS_CLI=ON/OFF` to control which modules are built (and installed). ## Usage ### Using the C++ API The C++ API is the main API for SPIRV-Cross. For more in-depth documentation than what's provided in this README, please have a look at the [Wiki](https://github.com/KhronosGroup/SPIRV-Cross/wiki). **NOTE**: This API is not guaranteed to be ABI-stable, and it is highly recommended to link against this API statically. The API is generally quite stable, but it can change over time, see the C API for more stability. To perform reflection and convert to other shader languages you can use the SPIRV-Cross API. For example: ```c++ #include "spirv_glsl.hpp" #include #include extern std::vector load_spirv_file(); int main() { // Read SPIR-V from disk or similar. std::vector spirv_binary = load_spirv_file(); spirv_cross::CompilerGLSL glsl(std::move(spirv_binary)); // The SPIR-V is now parsed, and we can perform reflection on it. spirv_cross::ShaderResources resources = glsl.get_shader_resources(); // Get all sampled images in the shader. for (auto &resource : resources.sampled_images) { unsigned set = glsl.get_decoration(resource.id, spv::DecorationDescriptorSet); unsigned binding = glsl.get_decoration(resource.id, spv::DecorationBinding); printf("Image %s at set = %u, binding = %u\n", resource.name.c_str(), set, binding); // Modify the decoration to prepare it for GLSL. glsl.unset_decoration(resource.id, spv::DecorationDescriptorSet); // Some arbitrary remapping if we want. glsl.set_decoration(resource.id, spv::DecorationBinding, set * 16 + binding); } // Set some options. spirv_cross::CompilerGLSL::Options options; options.version = 310; options.es = true; glsl.set_options(options); // Compile to GLSL, ready to give to GL driver. std::string source = glsl.compile(); } ``` ### Using the C API wrapper To facilitate C compatibility and compatibility with foreign programming languages, a C89-compatible API wrapper is provided. Unlike the C++ API, the goal of this wrapper is to be fully stable, both API and ABI-wise. This is the only interface which is supported when building SPIRV-Cross as a shared library. An important point of the wrapper is that all memory allocations are contained in the `spvc_context`. This simplifies the use of the API greatly. However, you should destroy the context as soon as reasonable, or use `spvc_context_release_allocations()` if you intend to reuse the `spvc_context` object again soon. Most functions return a `spvc_result`, where `SPVC_SUCCESS` is the only success code. For brevity, the code below does not do any error checking. ```c #include const SpvId *spirv = get_spirv_data(); size_t word_count = get_spirv_word_count(); spvc_context context = NULL; spvc_parsed_ir ir = NULL; spvc_compiler compiler_glsl = NULL; spvc_compiler_options options = NULL; spvc_resources resources = NULL; const spvc_reflected_resource *list = NULL; const char *result = NULL; size_t count; size_t i; // Create context. spvc_context_create(&context); // Set debug callback. spvc_context_set_error_callback(context, error_callback, userdata); // Parse the SPIR-V. spvc_context_parse_spirv(context, spirv, word_count, &ir); // Hand it off to a compiler instance and give it ownership of the IR. spvc_context_create_compiler(context, SPVC_BACKEND_GLSL, ir, SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler_glsl); // Do some basic reflection. spvc_compiler_create_shader_resources(compiler_glsl, &resources); spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_UNIFORM_BUFFER, &list, &count); for (i = 0; i < count; i++) { printf("ID: %u, BaseTypeID: %u, TypeID: %u, Name: %s\n", list[i].id, list[i].base_type_id, list[i].type_id, list[i].name); printf(" Set: %u, Binding: %u\n", spvc_compiler_get_decoration(compiler_glsl, list[i].id, SpvDecorationDescriptorSet), spvc_compiler_get_decoration(compiler_glsl, list[i].id, SpvDecorationBinding)); } // Modify options. spvc_compiler_create_compiler_options(context, &options); spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_GLSL_VERSION, 330); spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES, SPVC_FALSE); spvc_compiler_install_compiler_options(compiler_glsl, options); spvc_compiler_compile(compiler, &result); printf("Cross-compiled source: %s\n", result); // Frees all memory we allocated so far. spvc_context_destroy(context); ``` ### Linking #### CMake add_subdirectory() This is the recommended way if you are using CMake and want to link against SPIRV-Cross statically. #### Integrating SPIRV-Cross in a custom build system To add SPIRV-Cross to your own codebase, just copy the source and header files from root directory and build the relevant .cpp files you need. Make sure to build with C++11 support, e.g. `-std=c++11` in GCC and Clang. Alternatively, the Makefile generates a libspirv-cross.a static library during build that can be linked in. #### Linking against SPIRV-Cross as a system library It is possible to link against SPIRV-Cross when it is installed as a system library, which would be mostly relevant for Unix-like platforms. ##### pkg-config For Unix-based systems, a pkg-config is installed for the C API, e.g.: ``` $ pkg-config spirv-cross-c-shared --libs --cflags -I/usr/local/include/spirv_cross -L/usr/local/lib -lspirv-cross-c-shared ``` ##### CMake If the project is installed, it can be found with `find_package()`, e.g.: ``` cmake_minimum_required(VERSION 3.5) set(CMAKE_C_STANDARD 99) project(Test LANGUAGES C) find_package(spirv_cross_c_shared) if (spirv_cross_c_shared_FOUND) message(STATUS "Found SPIRV-Cross C API! :)") else() message(STATUS "Could not find SPIRV-Cross C API! :(") endif() add_executable(test test.c) target_link_libraries(test spirv-cross-c-shared) ``` test.c: ```c #include int main(void) { spvc_context context; spvc_context_create(&context); spvc_context_destroy(context); } ``` ### CLI The CLI is suitable for basic cross-compilation tasks, but it cannot support the full flexibility that the API can. Some examples below. #### Creating a SPIR-V file from GLSL with glslang ``` glslangValidator -H -V -o test.spv test.frag ``` #### Converting a SPIR-V file to GLSL ES ``` glslangValidator -H -V -o test.spv shaders/comp/basic.comp ./spirv-cross --version 310 --es test.spv ``` #### Converting to desktop GLSL ``` glslangValidator -H -V -o test.spv shaders/comp/basic.comp ./spirv-cross --version 330 --no-es test.spv --output test.comp ``` #### Disable prettifying optimizations ``` glslangValidator -H -V -o test.spv shaders/comp/basic.comp ./spirv-cross --version 310 --es test.spv --output test.comp --force-temporary ``` ### Using shaders generated from C++ backend Please see `samples/cpp` where some GLSL shaders are compiled to SPIR-V, decompiled to C++ and run with test data. Reading through the samples should explain how to use the C++ interface. A simple Makefile is included to build all shaders in the directory. ### Implementation notes When using SPIR-V and SPIRV-Cross as an intermediate step for cross-compiling between high level languages there are some considerations to take into account, as not all features used by one high-level language are necessarily supported natively by the target shader language. SPIRV-Cross aims to provide the tools needed to handle these scenarios in a clean and robust way, but some manual action is required to maintain compatibility. #### HLSL source to GLSL ##### HLSL entry points When using SPIR-V shaders compiled from HLSL, there are some extra things you need to take care of. First make sure that the entry point is used correctly. If you forget to set the entry point correctly in glslangValidator (-e MyFancyEntryPoint), you will likely encounter this error message: ``` Cannot end a function before ending the current block. Likely cause: If this SPIR-V was created from glslang HLSL, make sure the entry point is valid. ``` ##### Vertex/Fragment interface linking HLSL relies on semantics in order to effectively link together shader stages. In the SPIR-V generated by glslang, the transformation from HLSL to GLSL ends up looking like ```c++ struct VSOutput { // SV_Position is rerouted to gl_Position float4 position : SV_Position; float4 coord : TEXCOORD0; }; VSOutput main(...) {} ``` ```c++ struct VSOutput { float4 coord; } layout(location = 0) out VSOutput _magicNameGeneratedByGlslang; ``` While this works, be aware of the type of the struct which is used in the vertex stage and the fragment stage. There may be issues if the structure type name differs in vertex stage and fragment stage. You can make use of the reflection interface to force the name of the struct type. ``` // Something like this for both vertex outputs and fragment inputs. compiler.set_name(varying_resource.base_type_id, "VertexFragmentLinkage"); ``` Some platform may require identical variable name for both vertex outputs and fragment inputs. (for example MacOSX) to rename variable base on location, please add ``` --rename-interface-variable ``` #### HLSL source to legacy GLSL/ESSL HLSL tends to emit varying struct types to pass data between vertex and fragment. This is not supported in legacy GL/GLES targets, so to support this, varying structs are flattened. This is done automatically, but the API user might need to be aware that this is happening in order to support all cases. Modern GLES code like this: ```c++ struct Output { vec4 a; vec2 b; }; out Output vout; ``` Is transformed into: ```c++ struct Output { vec4 a; vec2 b; }; varying vec4 Output_a; varying vec2 Output_b; ``` Note that now, both the struct name and the member names will participate in the linking interface between vertex and fragment, so API users might want to ensure that both the struct names and member names match so that vertex outputs and fragment inputs can link properly. #### Separate image samplers (HLSL/Vulkan) for backends which do not support it (GLSL) Another thing you need to remember is when using samplers and textures in HLSL these are separable, and not directly compatible with GLSL. If you need to use this with desktop GL/GLES, you need to call `Compiler::build_combined_image_samplers` first before calling `Compiler::compile`, or you will get an exception. ```c++ // From main.cpp // Builds a mapping for all combinations of images and samplers. compiler->build_combined_image_samplers(); // Give the remapped combined samplers new names. // Here you can also set up decorations if you want (binding = #N). for (auto &remap : compiler->get_combined_image_samplers()) { compiler->set_name(remap.combined_id, join("SPIRV_Cross_Combined", compiler->get_name(remap.image_id), compiler->get_name(remap.sampler_id))); } ``` If your target is Vulkan GLSL, `--vulkan-semantics` will emit separate image samplers as you'd expect. The command line client calls `Compiler::build_combined_image_samplers` automatically, but if you're calling the library, you'll need to do this yourself. #### Descriptor sets (Vulkan GLSL) for backends which do not support them (HLSL/GLSL/Metal) Descriptor sets are unique to Vulkan, so make sure that descriptor set + binding is remapped to a flat binding scheme (set always 0), so that other APIs can make sense of the bindings. This can be done with `Compiler::set_decoration(id, spv::DecorationDescriptorSet)`. #### Linking by name for targets which do not support explicit locations (legacy GLSL/ESSL) Modern GLSL and HLSL sources (and SPIR-V) relies on explicit layout(location) qualifiers to guide the linking process between shader stages, but older GLSL relies on symbol names to perform the linking. When emitting shaders with older versions, these layout statements will be removed, so it is important that the API user ensures that the names of I/O variables are sanitized so that linking will work properly. The reflection API can rename variables, struct types and struct members to deal with these scenarios using `Compiler::set_name` and friends. #### Clip-space conventions SPIRV-Cross can perform some common clip space conversions on gl_Position/SV_Position by enabling `CompilerGLSL::Options.vertex.fixup_clipspace`. While this can be convenient, it is recommended to modify the projection matrices instead as that can achieve the same result. For GLSL targets, enabling this will convert a shader which assumes `[0, w]` depth range (Vulkan / D3D / Metal) into `[-w, w]` range. For MSL and HLSL targets, enabling this will convert a shader in `[-w, w]` depth range (OpenGL) to `[0, w]` depth range. By default, the CLI will not enable `fixup_clipspace`, but in the API you might want to set an explicit value using `CompilerGLSL::set_options()`. Y-flipping of gl_Position and similar is also supported. The use of this is discouraged, because relying on vertex shader Y-flipping tends to get quite messy. To enable this, set `CompilerGLSL::Options.vertex.flip_vert_y` or `--flip-vert-y` in CLI. #### Reserved identifiers When cross-compiling, certain identifiers are considered to be reserved by the implementation. Code generated by SPIRV-Cross cannot emit these identifiers as they are reserved and used for various internal purposes, and such variables will typically show up as `_RESERVED_IDENTIFIER_FIXUP_` or some similar name to make it more obvious that an identifier has been renamed. Reflection output will follow the exact name specified in the SPIR-V module. It might not be a valid identifier in the C sense, as it may contain non-alphanumeric/non-underscore characters. Reserved identifiers currently assumed by the implementation are (in pseudo-regex): - _$digit+, e.g. `_100`, `_2` - _$digit+_.+, e.g. `_100_tmp`, `_2_foobar`. `_2Bar` is **not** reserved. - gl_- prefix - spv- prefix - SPIRV_Cross prefix. This prefix is generally used for interface variables where app needs to provide data for workaround purposes. This identifier will not be rewritten, but be aware of potential collisions. - Double underscores (reserved by all target languages). Members of structs also have a reserved identifier: - _m$digit+$END, e.g. `_m20` and `_m40` are reserved, but not `_m40Foobar`. ## Contributing Contributions to SPIRV-Cross are welcome. See Testing and Licensing sections for details. ### Testing SPIRV-Cross maintains a test suite of shaders with reference output of how the output looks after going through a roundtrip through glslangValidator/spirv-as then back through SPIRV-Cross again. The reference files are stored inside the repository in order to be able to track regressions. All pull requests should ensure that test output does not change unexpectedly. This can be tested with: ``` ./checkout_glslang_spirv_tools.sh # Checks out glslang and SPIRV-Tools at a fixed revision which matches the reference output. # NOTE: Some users have reported problems cloning from git:// paths. To use https:// instead pass in # $ PROTOCOL=https ./checkout_glslang_spirv_tools.sh # instead. ./build_glslang_spirv_tools.sh # Builds glslang and SPIRV-Tools. ./test_shaders.sh # Runs over all changes and makes sure that there are no deltas compared to reference files. ``` `./test_shaders.sh` currently requires a Makefile setup with GCC/Clang to be set up. However, on Windows, this can be rather inconvenient if a MinGW environment is not set up. To use a spirv-cross binary you built with CMake (or otherwise), you can pass in an environment variable as such: ``` SPIRV_CROSS_PATH=path/to/custom/spirv-cross ./test_shaders.sh ``` However, when improving SPIRV-Cross there are of course legitimate cases where reference output should change. In these cases, run: ``` ./update_test_shaders.sh # SPIRV_CROSS_PATH also works here. ``` to update the reference files and include these changes as part of the pull request. Always make sure you are running the correct version of glslangValidator as well as SPIRV-Tools when updating reference files. See `checkout_glslang_spirv_tools.sh` which revisions are currently expected. The revisions change regularly. In short, the master branch should always be able to run `./test_shaders.py shaders` and friends without failure. SPIRV-Cross uses Travis CI to test all pull requests, so it is not strictly needed to perform testing yourself if you have problems running it locally. A pull request which does not pass testing on Travis will not be accepted however. When adding support for new features to SPIRV-Cross, a new shader and reference file should be added which covers usage of the new shader features in question. Travis CI runs the test suite with the CMake, by running `ctest`. This is a more straight-forward alternative to `./test_shaders.sh`. ### Licensing Contributors of new files should add a copyright header at the top of every new source code file with their copyright along with the Apache 2.0 licensing stub. ### Formatting SPIRV-Cross uses `clang-format` to automatically format code. Please use `clang-format` with the style sheet found in `.clang-format` to automatically format code before submitting a pull request. To make things easy, the `format_all.sh` script can be used to format all source files in the library. In this directory, run the following from the command line: ./format_all.sh ## Regression testing In shaders/ a collection of shaders are maintained for purposes of regression testing. The current reference output is contained in reference/. `./test_shaders.py shaders` can be run to perform regression testing. See `./test_shaders.py --help` for more. ### Metal backend To test the roundtrip path GLSL -> SPIR-V -> MSL, `--msl` can be added, e.g. `./test_shaders.py --msl shaders-msl`. ### HLSL backend To test the roundtrip path GLSL -> SPIR-V -> HLSL, `--hlsl` can be added, e.g. `./test_shaders.py --hlsl shaders-hlsl`. ### Updating regression tests When legitimate changes are found, use `--update` flag to update regression files. Otherwise, `./test_shaders.py` will fail with error code. ### Mali Offline Compiler cycle counts To obtain a CSV of static shader cycle counts before and after going through spirv-cross, add `--malisc` flag to `./test_shaders`. This requires the Mali Offline Compiler to be installed in PATH. spirv-cross-2021.01.15/appveyor.yml000066400000000000000000000012541400026215700167640ustar00rootroot00000000000000 environment: matrix: - GENERATOR: "Visual Studio 12 2013 Win64" CONFIG: Debug - GENERATOR: "Visual Studio 12 2013 Win64" CONFIG: Release - GENERATOR: "Visual Studio 14 2015 Win64" CONFIG: Debug - GENERATOR: "Visual Studio 14 2015 Win64" CONFIG: Release - GENERATOR: "Visual Studio 12 2013" CONFIG: Debug - GENERATOR: "Visual Studio 12 2013" CONFIG: Release - GENERATOR: "Visual Studio 14 2015" CONFIG: Debug - GENERATOR: "Visual Studio 14 2015" CONFIG: Release build_script: - git submodule update --init - cmake "-G%GENERATOR%" -H. -B_builds - cmake --build _builds --config "%CONFIG%" spirv-cross-2021.01.15/build_glslang_spirv_tools.sh000077500000000000000000000011361400026215700222030ustar00rootroot00000000000000#!/bin/bash PROFILE=Release if [ ! -z $1 ]; then PROFILE=$1 fi if [ ! -z $2 ]; then NPROC="--parallel $2" fi echo "Building glslang." mkdir -p external/glslang-build cd external/glslang-build cmake ../glslang -DCMAKE_BUILD_TYPE=$PROFILE -DCMAKE_INSTALL_PREFIX=output cmake --build . --config $PROFILE --target install ${NPROC} cd ../.. echo "Building SPIRV-Tools." mkdir -p external/spirv-tools-build cd external/spirv-tools-build cmake ../spirv-tools -DCMAKE_BUILD_TYPE=$PROFILE -DSPIRV_WERROR=OFF -DCMAKE_INSTALL_PREFIX=output cmake --build . --config $PROFILE --target install ${NPROC} cd ../.. spirv-cross-2021.01.15/checkout_glslang_spirv_tools.sh000077500000000000000000000025511400026215700227130ustar00rootroot00000000000000#!/bin/bash GLSLANG_REV=3de5cfe50edecd001e6d703555284d9b10b3dd57 SPIRV_TOOLS_REV=f3ccb633dfd7c5de1f9f0a2d2e9d7a25f2478206 SPIRV_HEADERS_REV=f027d53ded7e230e008d37c8b47ede7cd308e19d if [ -z $PROTOCOL ]; then PROTOCOL=git fi echo "Using protocol \"$PROTOCOL\" for checking out repositories. If this is problematic, try PROTOCOL=https $0." if [ -d external/glslang ]; then echo "Updating glslang to revision $GLSLANG_REV." cd external/glslang git fetch origin git checkout $GLSLANG_REV else echo "Cloning glslang revision $GLSLANG_REV." mkdir -p external cd external git clone $PROTOCOL://github.com/KhronosGroup/glslang.git cd glslang git checkout $GLSLANG_REV fi cd ../.. if [ -d external/spirv-tools ]; then echo "Updating SPIRV-Tools to revision $SPIRV_TOOLS_REV." cd external/spirv-tools git fetch origin git checkout $SPIRV_TOOLS_REV else echo "Cloning SPIRV-Tools revision $SPIRV_TOOLS_REV." mkdir -p external cd external git clone $PROTOCOL://github.com/KhronosGroup/SPIRV-Tools.git spirv-tools cd spirv-tools git checkout $SPIRV_TOOLS_REV fi if [ -d external/spirv-headers ]; then cd external/spirv-headers git pull origin master git checkout $SPIRV_HEADERS_REV cd ../.. else git clone $PROTOCOL://github.com/KhronosGroup/SPIRV-Headers.git external/spirv-headers cd external/spirv-headers git checkout $SPIRV_HEADERS_REV cd ../.. fi cd ../.. spirv-cross-2021.01.15/cmake/000077500000000000000000000000001400026215700154525ustar00rootroot00000000000000spirv-cross-2021.01.15/cmake/gitversion.in.h000066400000000000000000000002751400026215700204250ustar00rootroot00000000000000#ifndef SPIRV_CROSS_GIT_VERSION_H_ #define SPIRV_CROSS_GIT_VERSION_H_ #define SPIRV_CROSS_GIT_REVISION "Git commit: @spirv-cross-build-version@ Timestamp: @spirv-cross-timestamp@" #endif spirv-cross-2021.01.15/format_all.sh000077500000000000000000000003401400026215700170460ustar00rootroot00000000000000#!/bin/bash #for file in spirv_*.{cpp,hpp} include/spirv_cross/*.{hpp,h} samples/cpp/*.cpp main.cpp for file in spirv_*.{cpp,hpp} main.cpp do echo "Formatting file: $file ..." clang-format -style=file -i $file done spirv-cross-2021.01.15/gn/000077500000000000000000000000001400026215700147765ustar00rootroot00000000000000spirv-cross-2021.01.15/gn/BUILD.gn000066400000000000000000000033071400026215700161660ustar00rootroot00000000000000# Copyright (C) 2019 Google, Inc. # # 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. # config("spirv_cross_public") { include_dirs = [ ".." ] defines = [ "SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS" ] } source_set("spirv_cross_sources") { public_configs = [ ":spirv_cross_public" ] sources = [ "../GLSL.std.450.h", "../spirv.hpp", "../spirv_cfg.cpp", "../spirv_cfg.hpp", "../spirv_common.hpp", "../spirv_cross.cpp", "../spirv_cross.hpp", "../spirv_cross_containers.hpp", "../spirv_cross_error_handling.hpp", "../spirv_cross_parsed_ir.cpp", "../spirv_cross_parsed_ir.hpp", "../spirv_cross_util.cpp", "../spirv_cross_util.hpp", "../spirv_glsl.cpp", "../spirv_glsl.hpp", "../spirv_msl.cpp", "../spirv_msl.hpp", "../spirv_parser.cpp", "../spirv_parser.hpp", "../spirv_reflect.cpp", "../spirv_reflect.hpp", ] cflags = [ "-fno-exceptions" ] if (is_clang) { cflags_cc = [ "-Wno-extra-semi", "-Wno-ignored-qualifiers", "-Wno-implicit-fallthrough", "-Wno-inconsistent-missing-override", "-Wno-missing-field-initializers", "-Wno-newline-eof", "-Wno-sign-compare", "-Wno-unused-variable", ] } } spirv-cross-2021.01.15/include/000077500000000000000000000000001400026215700160155ustar00rootroot00000000000000spirv-cross-2021.01.15/include/spirv_cross/000077500000000000000000000000001400026215700203715ustar00rootroot00000000000000spirv-cross-2021.01.15/include/spirv_cross/barrier.hpp000066400000000000000000000034331400026215700225330ustar00rootroot00000000000000/* * Copyright 2015-2017 ARM Limited * * 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 SPIRV_CROSS_BARRIER_HPP #define SPIRV_CROSS_BARRIER_HPP #include #include namespace spirv_cross { class Barrier { public: Barrier() { count.store(0); iteration.store(0); } void set_release_divisor(unsigned divisor) { this->divisor = divisor; } static inline void memoryBarrier() { std::atomic_thread_fence(std::memory_order_seq_cst); } void reset_counter() { count.store(0); iteration.store(0); } void wait() { unsigned target_iteration = iteration.load(std::memory_order_relaxed) + 1; // Overflows cleanly. unsigned target_count = divisor * target_iteration; // Barriers don't enforce memory ordering. // Be as relaxed about the barrier as we possibly can! unsigned c = count.fetch_add(1u, std::memory_order_relaxed); if (c + 1 == target_count) { iteration.store(target_iteration, std::memory_order_relaxed); } else { // If we have more threads than the CPU, don't hog the CPU for very long periods of time. while (iteration.load(std::memory_order_relaxed) != target_iteration) std::this_thread::yield(); } } private: unsigned divisor = 1; std::atomic count; std::atomic iteration; }; } #endif spirv-cross-2021.01.15/include/spirv_cross/external_interface.h000066400000000000000000000065521400026215700244140ustar00rootroot00000000000000/* * Copyright 2015-2017 ARM Limited * * 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 SPIRV_CROSS_EXTERNAL_INTERFACE_H #define SPIRV_CROSS_EXTERNAL_INTERFACE_H #ifdef __cplusplus extern "C" { #endif #include typedef struct spirv_cross_shader spirv_cross_shader_t; struct spirv_cross_interface { spirv_cross_shader_t *(*construct)(void); void (*destruct)(spirv_cross_shader_t *thiz); void (*invoke)(spirv_cross_shader_t *thiz); }; void spirv_cross_set_stage_input(spirv_cross_shader_t *thiz, unsigned location, void *data, size_t size); void spirv_cross_set_stage_output(spirv_cross_shader_t *thiz, unsigned location, void *data, size_t size); void spirv_cross_set_push_constant(spirv_cross_shader_t *thiz, void *data, size_t size); void spirv_cross_set_uniform_constant(spirv_cross_shader_t *thiz, unsigned location, void *data, size_t size); void spirv_cross_set_resource(spirv_cross_shader_t *thiz, unsigned set, unsigned binding, void **data, size_t size); const struct spirv_cross_interface *spirv_cross_get_interface(void); typedef enum spirv_cross_builtin { SPIRV_CROSS_BUILTIN_POSITION = 0, SPIRV_CROSS_BUILTIN_FRAG_COORD = 1, SPIRV_CROSS_BUILTIN_WORK_GROUP_ID = 2, SPIRV_CROSS_BUILTIN_NUM_WORK_GROUPS = 3, SPIRV_CROSS_NUM_BUILTINS } spirv_cross_builtin; void spirv_cross_set_builtin(spirv_cross_shader_t *thiz, spirv_cross_builtin builtin, void *data, size_t size); #define SPIRV_CROSS_NUM_DESCRIPTOR_SETS 4 #define SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS 16 #define SPIRV_CROSS_NUM_STAGE_INPUTS 16 #define SPIRV_CROSS_NUM_STAGE_OUTPUTS 16 #define SPIRV_CROSS_NUM_UNIFORM_CONSTANTS 32 enum spirv_cross_format { SPIRV_CROSS_FORMAT_R8_UNORM = 0, SPIRV_CROSS_FORMAT_R8G8_UNORM = 1, SPIRV_CROSS_FORMAT_R8G8B8_UNORM = 2, SPIRV_CROSS_FORMAT_R8G8B8A8_UNORM = 3, SPIRV_CROSS_NUM_FORMATS }; enum spirv_cross_wrap { SPIRV_CROSS_WRAP_CLAMP_TO_EDGE = 0, SPIRV_CROSS_WRAP_REPEAT = 1, SPIRV_CROSS_NUM_WRAP }; enum spirv_cross_filter { SPIRV_CROSS_FILTER_NEAREST = 0, SPIRV_CROSS_FILTER_LINEAR = 1, SPIRV_CROSS_NUM_FILTER }; enum spirv_cross_mipfilter { SPIRV_CROSS_MIPFILTER_BASE = 0, SPIRV_CROSS_MIPFILTER_NEAREST = 1, SPIRV_CROSS_MIPFILTER_LINEAR = 2, SPIRV_CROSS_NUM_MIPFILTER }; struct spirv_cross_miplevel { const void *data; unsigned width, height; size_t stride; }; struct spirv_cross_sampler_info { const struct spirv_cross_miplevel *mipmaps; unsigned num_mipmaps; enum spirv_cross_format format; enum spirv_cross_wrap wrap_s; enum spirv_cross_wrap wrap_t; enum spirv_cross_filter min_filter; enum spirv_cross_filter mag_filter; enum spirv_cross_mipfilter mip_filter; }; typedef struct spirv_cross_sampler_2d spirv_cross_sampler_2d_t; spirv_cross_sampler_2d_t *spirv_cross_create_sampler_2d(const struct spirv_cross_sampler_info *info); void spirv_cross_destroy_sampler_2d(spirv_cross_sampler_2d_t *samp); #ifdef __cplusplus } #endif #endif spirv-cross-2021.01.15/include/spirv_cross/image.hpp000066400000000000000000000026161400026215700221710ustar00rootroot00000000000000/* * Copyright 2015-2017 ARM Limited * * 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 SPIRV_CROSS_IMAGE_HPP #define SPIRV_CROSS_IMAGE_HPP #ifndef GLM_SWIZZLE #define GLM_SWIZZLE #endif #ifndef GLM_FORCE_RADIANS #define GLM_FORCE_RADIANS #endif #include namespace spirv_cross { template struct image2DBase { virtual ~image2DBase() = default; inline virtual T load(glm::ivec2 coord) const { return T(0, 0, 0, 1); } inline virtual void store(glm::ivec2 coord, const T &v) { } }; typedef image2DBase image2D; typedef image2DBase iimage2D; typedef image2DBase uimage2D; template inline T imageLoad(const image2DBase &image, glm::ivec2 coord) { return image.load(coord); } template void imageStore(image2DBase &image, glm::ivec2 coord, const T &value) { image.store(coord, value); } } #endif spirv-cross-2021.01.15/include/spirv_cross/internal_interface.hpp000066400000000000000000000315351400026215700247450ustar00rootroot00000000000000/* * Copyright 2015-2017 ARM Limited * * 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 SPIRV_CROSS_INTERNAL_INTERFACE_HPP #define SPIRV_CROSS_INTERNAL_INTERFACE_HPP // This file must only be included by the shader generated by spirv-cross! #ifndef GLM_FORCE_SWIZZLE #define GLM_FORCE_SWIZZLE #endif #ifndef GLM_FORCE_RADIANS #define GLM_FORCE_RADIANS #endif #include #include "barrier.hpp" #include "external_interface.h" #include "image.hpp" #include "sampler.hpp" #include "thread_group.hpp" #include #include namespace internal { // Adaptor helpers to adapt GLSL access chain syntax to C++. // Don't bother with arrays of arrays on uniforms ... // Would likely need horribly complex variadic template munging. template struct Interface { enum { ArraySize = 1, Size = sizeof(T) }; Interface() : ptr(0) { } T &get() { assert(ptr); return *ptr; } T *ptr; }; // For array types, return a pointer instead. template struct Interface { enum { ArraySize = U, Size = U * sizeof(T) }; Interface() : ptr(0) { } T *get() { assert(ptr); return ptr; } T *ptr; }; // For case when array size is 1, avoid double dereference. template struct PointerInterface { enum { ArraySize = 1, Size = sizeof(T *) }; enum { PreDereference = true }; PointerInterface() : ptr(0) { } T &get() { assert(ptr); return *ptr; } T *ptr; }; // Automatically converts a pointer down to reference to match GLSL syntax. template struct DereferenceAdaptor { DereferenceAdaptor(T **ptr) : ptr(ptr) { } T &operator[](unsigned index) const { return *(ptr[index]); } T **ptr; }; // We can't have a linear array of T* since T* can be an abstract type in case of samplers. // We also need a list of pointers since we can have run-time length SSBOs. template struct PointerInterface { enum { ArraySize = U, Size = sizeof(T *) * U }; enum { PreDereference = false }; PointerInterface() : ptr(0) { } DereferenceAdaptor get() { assert(ptr); return DereferenceAdaptor(ptr); } T **ptr; }; // Resources can be more abstract and be unsized, // so we need to have an array of pointers for those cases. template struct Resource : PointerInterface { }; // POD with no unknown sizes, so we can express these as flat arrays. template struct UniformConstant : Interface { }; template struct StageInput : Interface { }; template struct StageOutput : Interface { }; template struct PushConstant : Interface { }; } struct spirv_cross_shader { struct PPSize { PPSize() : ptr(0) , size(0) { } void **ptr; size_t size; }; struct PPSizeResource { PPSizeResource() : ptr(0) , size(0) , pre_dereference(false) { } void **ptr; size_t size; bool pre_dereference; }; PPSizeResource resources[SPIRV_CROSS_NUM_DESCRIPTOR_SETS][SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS]; PPSize stage_inputs[SPIRV_CROSS_NUM_STAGE_INPUTS]; PPSize stage_outputs[SPIRV_CROSS_NUM_STAGE_OUTPUTS]; PPSize uniform_constants[SPIRV_CROSS_NUM_UNIFORM_CONSTANTS]; PPSize push_constant; PPSize builtins[SPIRV_CROSS_NUM_BUILTINS]; template void register_builtin(spirv_cross_builtin builtin, const U &value) { assert(!builtins[builtin].ptr); builtins[builtin].ptr = (void **)&value.ptr; builtins[builtin].size = sizeof(*value.ptr) * U::ArraySize; } void set_builtin(spirv_cross_builtin builtin, void *data, size_t size) { assert(builtins[builtin].ptr); assert(size >= builtins[builtin].size); *builtins[builtin].ptr = data; } template void register_resource(const internal::Resource &value, unsigned set, unsigned binding) { assert(set < SPIRV_CROSS_NUM_DESCRIPTOR_SETS); assert(binding < SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS); assert(!resources[set][binding].ptr); resources[set][binding].ptr = (void **)&value.ptr; resources[set][binding].size = internal::Resource::Size; resources[set][binding].pre_dereference = internal::Resource::PreDereference; } template void register_stage_input(const internal::StageInput &value, unsigned location) { assert(location < SPIRV_CROSS_NUM_STAGE_INPUTS); assert(!stage_inputs[location].ptr); stage_inputs[location].ptr = (void **)&value.ptr; stage_inputs[location].size = internal::StageInput::Size; } template void register_stage_output(const internal::StageOutput &value, unsigned location) { assert(location < SPIRV_CROSS_NUM_STAGE_OUTPUTS); assert(!stage_outputs[location].ptr); stage_outputs[location].ptr = (void **)&value.ptr; stage_outputs[location].size = internal::StageOutput::Size; } template void register_uniform_constant(const internal::UniformConstant &value, unsigned location) { assert(location < SPIRV_CROSS_NUM_UNIFORM_CONSTANTS); assert(!uniform_constants[location].ptr); uniform_constants[location].ptr = (void **)&value.ptr; uniform_constants[location].size = internal::UniformConstant::Size; } template void register_push_constant(const internal::PushConstant &value) { assert(!push_constant.ptr); push_constant.ptr = (void **)&value.ptr; push_constant.size = internal::PushConstant::Size; } void set_stage_input(unsigned location, void *data, size_t size) { assert(location < SPIRV_CROSS_NUM_STAGE_INPUTS); assert(stage_inputs[location].ptr); assert(size >= stage_inputs[location].size); *stage_inputs[location].ptr = data; } void set_stage_output(unsigned location, void *data, size_t size) { assert(location < SPIRV_CROSS_NUM_STAGE_OUTPUTS); assert(stage_outputs[location].ptr); assert(size >= stage_outputs[location].size); *stage_outputs[location].ptr = data; } void set_uniform_constant(unsigned location, void *data, size_t size) { assert(location < SPIRV_CROSS_NUM_UNIFORM_CONSTANTS); assert(uniform_constants[location].ptr); assert(size >= uniform_constants[location].size); *uniform_constants[location].ptr = data; } void set_push_constant(void *data, size_t size) { assert(push_constant.ptr); assert(size >= push_constant.size); *push_constant.ptr = data; } void set_resource(unsigned set, unsigned binding, void **data, size_t size) { assert(set < SPIRV_CROSS_NUM_DESCRIPTOR_SETS); assert(binding < SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS); assert(resources[set][binding].ptr); assert(size >= resources[set][binding].size); // We're using the regular PointerInterface, dereference ahead of time. if (resources[set][binding].pre_dereference) *resources[set][binding].ptr = *data; else *resources[set][binding].ptr = data; } }; namespace spirv_cross { template struct BaseShader : spirv_cross_shader { void invoke() { static_cast(this)->main(); } }; struct FragmentResources { internal::StageOutput gl_FragCoord; void init(spirv_cross_shader &s) { s.register_builtin(SPIRV_CROSS_BUILTIN_FRAG_COORD, gl_FragCoord); } #define gl_FragCoord __res->gl_FragCoord.get() }; template struct FragmentShader : BaseShader> { inline void main() { impl.main(); } FragmentShader() { resources.init(*this); impl.__res = &resources; } T impl; Res resources; }; struct VertexResources { internal::StageOutput gl_Position; void init(spirv_cross_shader &s) { s.register_builtin(SPIRV_CROSS_BUILTIN_POSITION, gl_Position); } #define gl_Position __res->gl_Position.get() }; template struct VertexShader : BaseShader> { inline void main() { impl.main(); } VertexShader() { resources.init(*this); impl.__res = &resources; } T impl; Res resources; }; struct TessEvaluationResources { inline void init(spirv_cross_shader &) { } }; template struct TessEvaluationShader : BaseShader> { inline void main() { impl.main(); } TessEvaluationShader() { resources.init(*this); impl.__res = &resources; } T impl; Res resources; }; struct TessControlResources { inline void init(spirv_cross_shader &) { } }; template struct TessControlShader : BaseShader> { inline void main() { impl.main(); } TessControlShader() { resources.init(*this); impl.__res = &resources; } T impl; Res resources; }; struct GeometryResources { inline void init(spirv_cross_shader &) { } }; template struct GeometryShader : BaseShader> { inline void main() { impl.main(); } GeometryShader() { resources.init(*this); impl.__res = &resources; } T impl; Res resources; }; struct ComputeResources { internal::StageInput gl_WorkGroupID__; internal::StageInput gl_NumWorkGroups__; void init(spirv_cross_shader &s) { s.register_builtin(SPIRV_CROSS_BUILTIN_WORK_GROUP_ID, gl_WorkGroupID__); s.register_builtin(SPIRV_CROSS_BUILTIN_NUM_WORK_GROUPS, gl_NumWorkGroups__); } #define gl_WorkGroupID __res->gl_WorkGroupID__.get() #define gl_NumWorkGroups __res->gl_NumWorkGroups__.get() Barrier barrier__; #define barrier() __res->barrier__.wait() }; struct ComputePrivateResources { uint32_t gl_LocalInvocationIndex__; #define gl_LocalInvocationIndex __priv_res.gl_LocalInvocationIndex__ glm::uvec3 gl_LocalInvocationID__; #define gl_LocalInvocationID __priv_res.gl_LocalInvocationID__ glm::uvec3 gl_GlobalInvocationID__; #define gl_GlobalInvocationID __priv_res.gl_GlobalInvocationID__ }; template struct ComputeShader : BaseShader> { inline void main() { resources.barrier__.reset_counter(); for (unsigned z = 0; z < WorkGroupZ; z++) for (unsigned y = 0; y < WorkGroupY; y++) for (unsigned x = 0; x < WorkGroupX; x++) impl[z][y][x].__priv_res.gl_GlobalInvocationID__ = glm::uvec3(WorkGroupX, WorkGroupY, WorkGroupZ) * resources.gl_WorkGroupID__.get() + glm::uvec3(x, y, z); group.run(); group.wait(); } ComputeShader() : group(&impl[0][0][0]) { resources.init(*this); resources.barrier__.set_release_divisor(WorkGroupX * WorkGroupY * WorkGroupZ); unsigned i = 0; for (unsigned z = 0; z < WorkGroupZ; z++) { for (unsigned y = 0; y < WorkGroupY; y++) { for (unsigned x = 0; x < WorkGroupX; x++) { impl[z][y][x].__priv_res.gl_LocalInvocationID__ = glm::uvec3(x, y, z); impl[z][y][x].__priv_res.gl_LocalInvocationIndex__ = i++; impl[z][y][x].__res = &resources; } } } } T impl[WorkGroupZ][WorkGroupY][WorkGroupX]; ThreadGroup group; Res resources; }; inline void memoryBarrierShared() { Barrier::memoryBarrier(); } inline void memoryBarrier() { Barrier::memoryBarrier(); } // TODO: Rest of the barriers. // Atomics template inline T atomicAdd(T &v, T a) { static_assert(sizeof(std::atomic) == sizeof(T), "Cannot cast properly to std::atomic."); // We need explicit memory barriers in GLSL to enfore any ordering. // FIXME: Can we really cast this? There is no other way I think ... return std::atomic_fetch_add_explicit(reinterpret_cast *>(&v), a, std::memory_order_relaxed); } } void spirv_cross_set_stage_input(spirv_cross_shader_t *shader, unsigned location, void *data, size_t size) { shader->set_stage_input(location, data, size); } void spirv_cross_set_stage_output(spirv_cross_shader_t *shader, unsigned location, void *data, size_t size) { shader->set_stage_output(location, data, size); } void spirv_cross_set_uniform_constant(spirv_cross_shader_t *shader, unsigned location, void *data, size_t size) { shader->set_uniform_constant(location, data, size); } void spirv_cross_set_resource(spirv_cross_shader_t *shader, unsigned set, unsigned binding, void **data, size_t size) { shader->set_resource(set, binding, data, size); } void spirv_cross_set_push_constant(spirv_cross_shader_t *shader, void *data, size_t size) { shader->set_push_constant(data, size); } void spirv_cross_set_builtin(spirv_cross_shader_t *shader, spirv_cross_builtin builtin, void *data, size_t size) { shader->set_builtin(builtin, data, size); } #endif spirv-cross-2021.01.15/include/spirv_cross/sampler.hpp000066400000000000000000000046621400026215700225550ustar00rootroot00000000000000/* * Copyright 2015-2017 ARM Limited * * 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 SPIRV_CROSS_SAMPLER_HPP #define SPIRV_CROSS_SAMPLER_HPP #include namespace spirv_cross { struct spirv_cross_sampler_2d { inline virtual ~spirv_cross_sampler_2d() { } }; template struct sampler2DBase : spirv_cross_sampler_2d { sampler2DBase(const spirv_cross_sampler_info *info) { mips.insert(mips.end(), info->mipmaps, info->mipmaps + info->num_mipmaps); format = info->format; wrap_s = info->wrap_s; wrap_t = info->wrap_t; min_filter = info->min_filter; mag_filter = info->mag_filter; mip_filter = info->mip_filter; } inline virtual T sample(glm::vec2 uv, float bias) { return sampleLod(uv, bias); } inline virtual T sampleLod(glm::vec2 uv, float lod) { if (mag_filter == SPIRV_CROSS_FILTER_NEAREST) { uv.x = wrap(uv.x, wrap_s, mips[0].width); uv.y = wrap(uv.y, wrap_t, mips[0].height); glm::vec2 uv_full = uv * glm::vec2(mips[0].width, mips[0].height); int x = int(uv_full.x); int y = int(uv_full.y); return sample(x, y, 0); } else { return T(0, 0, 0, 1); } } inline float wrap(float v, spirv_cross_wrap wrap, unsigned size) { switch (wrap) { case SPIRV_CROSS_WRAP_REPEAT: return v - glm::floor(v); case SPIRV_CROSS_WRAP_CLAMP_TO_EDGE: { float half = 0.5f / size; return glm::clamp(v, half, 1.0f - half); } default: return 0.0f; } } std::vector mips; spirv_cross_format format; spirv_cross_wrap wrap_s; spirv_cross_wrap wrap_t; spirv_cross_filter min_filter; spirv_cross_filter mag_filter; spirv_cross_mipfilter mip_filter; }; typedef sampler2DBase sampler2D; typedef sampler2DBase isampler2D; typedef sampler2DBase usampler2D; template inline T texture(const sampler2DBase &samp, const glm::vec2 &uv, float bias = 0.0f) { return samp.sample(uv, bias); } } #endif spirv-cross-2021.01.15/include/spirv_cross/thread_group.hpp000066400000000000000000000037721400026215700235760ustar00rootroot00000000000000/* * Copyright 2015-2017 ARM Limited * * 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 SPIRV_CROSS_THREAD_GROUP_HPP #define SPIRV_CROSS_THREAD_GROUP_HPP #include #include #include namespace spirv_cross { template class ThreadGroup { public: ThreadGroup(T *impl) { for (unsigned i = 0; i < Size; i++) workers[i].start(&impl[i]); } void run() { for (auto &worker : workers) worker.run(); } void wait() { for (auto &worker : workers) worker.wait(); } private: struct Thread { enum State { Idle, Running, Dying }; State state = Idle; void start(T *impl) { worker = std::thread([impl, this] { for (;;) { { std::unique_lock l{ lock }; cond.wait(l, [this] { return state != Idle; }); if (state == Dying) break; } impl->main(); std::lock_guard l{ lock }; state = Idle; cond.notify_one(); } }); } void wait() { std::unique_lock l{ lock }; cond.wait(l, [this] { return state == Idle; }); } void run() { std::lock_guard l{ lock }; state = Running; cond.notify_one(); } ~Thread() { if (worker.joinable()) { { std::lock_guard l{ lock }; state = Dying; cond.notify_one(); } worker.join(); } } std::thread worker; std::condition_variable cond; std::mutex lock; }; Thread workers[Size]; }; } #endif spirv-cross-2021.01.15/main.cpp000066400000000000000000002042441400026215700160300ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_cpp.hpp" #include "spirv_cross_util.hpp" #include "spirv_glsl.hpp" #include "spirv_hlsl.hpp" #include "spirv_msl.hpp" #include "spirv_parser.hpp" #include "spirv_reflect.hpp" #include #include #include #include #include #include #include #include #include #ifdef _WIN32 #include #include #endif #ifdef HAVE_SPIRV_CROSS_GIT_VERSION #include "gitversion.h" #endif using namespace spv; using namespace SPIRV_CROSS_NAMESPACE; using namespace std; #ifdef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS static inline void THROW(const char *str) { fprintf(stderr, "SPIRV-Cross will abort: %s\n", str); fflush(stderr); abort(); } #else #define THROW(x) throw runtime_error(x) #endif struct CLIParser; struct CLICallbacks { void add(const char *cli, const function &func) { callbacks[cli] = func; } unordered_map> callbacks; function error_handler; function default_handler; }; struct CLIParser { CLIParser(CLICallbacks cbs_, int argc_, char *argv_[]) : cbs(move(cbs_)) , argc(argc_) , argv(argv_) { } bool parse() { #ifndef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS try #endif { while (argc && !ended_state) { const char *next = *argv++; argc--; if (*next != '-' && cbs.default_handler) { cbs.default_handler(next); } else { auto itr = cbs.callbacks.find(next); if (itr == ::end(cbs.callbacks)) { THROW("Invalid argument"); } itr->second(*this); } } return true; } #ifndef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS catch (...) { if (cbs.error_handler) { cbs.error_handler(); } return false; } #endif } void end() { ended_state = true; } uint32_t next_uint() { if (!argc) { THROW("Tried to parse uint, but nothing left in arguments"); } uint64_t val = stoul(*argv); if (val > numeric_limits::max()) { THROW("next_uint() out of range"); } argc--; argv++; return uint32_t(val); } uint32_t next_hex_uint() { if (!argc) { THROW("Tried to parse uint, but nothing left in arguments"); } uint64_t val = stoul(*argv, nullptr, 16); if (val > numeric_limits::max()) { THROW("next_uint() out of range"); } argc--; argv++; return uint32_t(val); } double next_double() { if (!argc) { THROW("Tried to parse double, but nothing left in arguments"); } double val = stod(*argv); argc--; argv++; return val; } // Return a string only if it's not prefixed with `--`, otherwise return the default value const char *next_value_string(const char *default_value) { if (!argc) { return default_value; } if (0 == strncmp("--", *argv, 2)) { return default_value; } return next_string(); } const char *next_string() { if (!argc) { THROW("Tried to parse string, but nothing left in arguments"); } const char *ret = *argv; argc--; argv++; return ret; } CLICallbacks cbs; int argc; char **argv; bool ended_state = false; }; #if defined(__clang__) || defined(__GNUC__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #elif defined(_MSC_VER) #pragma warning(push) #pragma warning(disable : 4996) #endif static vector read_spirv_file_stdin() { #ifdef _WIN32 setmode(fileno(stdin), O_BINARY); #endif vector buffer; uint32_t tmp[256]; size_t ret; while ((ret = fread(tmp, sizeof(uint32_t), 256, stdin))) buffer.insert(buffer.end(), tmp, tmp + ret); return buffer; } static vector read_spirv_file(const char *path) { if (path[0] == '-' && path[1] == '\0') return read_spirv_file_stdin(); FILE *file = fopen(path, "rb"); if (!file) { fprintf(stderr, "Failed to open SPIR-V file: %s\n", path); return {}; } fseek(file, 0, SEEK_END); long len = ftell(file) / sizeof(uint32_t); rewind(file); vector spirv(len); if (fread(spirv.data(), sizeof(uint32_t), len, file) != size_t(len)) spirv.clear(); fclose(file); return spirv; } static bool write_string_to_file(const char *path, const char *string) { FILE *file = fopen(path, "w"); if (!file) { fprintf(stderr, "Failed to write file: %s\n", path); return false; } fprintf(file, "%s", string); fclose(file); return true; } #if defined(__clang__) || defined(__GNUC__) #pragma GCC diagnostic pop #elif defined(_MSC_VER) #pragma warning(pop) #endif static void print_resources(const Compiler &compiler, const char *tag, const SmallVector &resources) { fprintf(stderr, "%s\n", tag); fprintf(stderr, "=============\n\n"); bool print_ssbo = !strcmp(tag, "ssbos"); for (auto &res : resources) { auto &type = compiler.get_type(res.type_id); if (print_ssbo && compiler.buffer_is_hlsl_counter_buffer(res.id)) continue; // If we don't have a name, use the fallback for the type instead of the variable // for SSBOs and UBOs since those are the only meaningful names to use externally. // Push constant blocks are still accessed by name and not block name, even though they are technically Blocks. bool is_push_constant = compiler.get_storage_class(res.id) == StorageClassPushConstant; bool is_block = compiler.get_decoration_bitset(type.self).get(DecorationBlock) || compiler.get_decoration_bitset(type.self).get(DecorationBufferBlock); bool is_sized_block = is_block && (compiler.get_storage_class(res.id) == StorageClassUniform || compiler.get_storage_class(res.id) == StorageClassUniformConstant); ID fallback_id = !is_push_constant && is_block ? ID(res.base_type_id) : ID(res.id); uint32_t block_size = 0; uint32_t runtime_array_stride = 0; if (is_sized_block) { auto &base_type = compiler.get_type(res.base_type_id); block_size = uint32_t(compiler.get_declared_struct_size(base_type)); runtime_array_stride = uint32_t(compiler.get_declared_struct_size_runtime_array(base_type, 1) - compiler.get_declared_struct_size_runtime_array(base_type, 0)); } Bitset mask; if (print_ssbo) mask = compiler.get_buffer_block_flags(res.id); else mask = compiler.get_decoration_bitset(res.id); string array; for (auto arr : type.array) array = join("[", arr ? convert_to_string(arr) : "", "]") + array; fprintf(stderr, " ID %03u : %s%s", uint32_t(res.id), !res.name.empty() ? res.name.c_str() : compiler.get_fallback_name(fallback_id).c_str(), array.c_str()); if (mask.get(DecorationLocation)) fprintf(stderr, " (Location : %u)", compiler.get_decoration(res.id, DecorationLocation)); if (mask.get(DecorationDescriptorSet)) fprintf(stderr, " (Set : %u)", compiler.get_decoration(res.id, DecorationDescriptorSet)); if (mask.get(DecorationBinding)) fprintf(stderr, " (Binding : %u)", compiler.get_decoration(res.id, DecorationBinding)); if (static_cast(compiler).variable_is_depth_or_compare(res.id)) fprintf(stderr, " (comparison)"); if (mask.get(DecorationInputAttachmentIndex)) fprintf(stderr, " (Attachment : %u)", compiler.get_decoration(res.id, DecorationInputAttachmentIndex)); if (mask.get(DecorationNonReadable)) fprintf(stderr, " writeonly"); if (mask.get(DecorationNonWritable)) fprintf(stderr, " readonly"); if (is_sized_block) { fprintf(stderr, " (BlockSize : %u bytes)", block_size); if (runtime_array_stride) fprintf(stderr, " (Unsized array stride: %u bytes)", runtime_array_stride); } uint32_t counter_id = 0; if (print_ssbo && compiler.buffer_get_hlsl_counter_buffer(res.id, counter_id)) fprintf(stderr, " (HLSL counter buffer ID: %u)", counter_id); fprintf(stderr, "\n"); } fprintf(stderr, "=============\n\n"); } static const char *execution_model_to_str(spv::ExecutionModel model) { switch (model) { case spv::ExecutionModelVertex: return "vertex"; case spv::ExecutionModelTessellationControl: return "tessellation control"; case ExecutionModelTessellationEvaluation: return "tessellation evaluation"; case ExecutionModelGeometry: return "geometry"; case ExecutionModelFragment: return "fragment"; case ExecutionModelGLCompute: return "compute"; case ExecutionModelRayGenerationNV: return "raygenNV"; case ExecutionModelIntersectionNV: return "intersectionNV"; case ExecutionModelCallableNV: return "callableNV"; case ExecutionModelAnyHitNV: return "anyhitNV"; case ExecutionModelClosestHitNV: return "closesthitNV"; case ExecutionModelMissNV: return "missNV"; default: return "???"; } } static void print_resources(const Compiler &compiler, const ShaderResources &res) { auto &modes = compiler.get_execution_mode_bitset(); fprintf(stderr, "Entry points:\n"); auto entry_points = compiler.get_entry_points_and_stages(); for (auto &e : entry_points) fprintf(stderr, " %s (%s)\n", e.name.c_str(), execution_model_to_str(e.execution_model)); fprintf(stderr, "\n"); fprintf(stderr, "Execution modes:\n"); modes.for_each_bit([&](uint32_t i) { auto mode = static_cast(i); uint32_t arg0 = compiler.get_execution_mode_argument(mode, 0); uint32_t arg1 = compiler.get_execution_mode_argument(mode, 1); uint32_t arg2 = compiler.get_execution_mode_argument(mode, 2); switch (static_cast(i)) { case ExecutionModeInvocations: fprintf(stderr, " Invocations: %u\n", arg0); break; case ExecutionModeLocalSize: fprintf(stderr, " LocalSize: (%u, %u, %u)\n", arg0, arg1, arg2); break; case ExecutionModeOutputVertices: fprintf(stderr, " OutputVertices: %u\n", arg0); break; #define CHECK_MODE(m) \ case ExecutionMode##m: \ fprintf(stderr, " %s\n", #m); \ break CHECK_MODE(SpacingEqual); CHECK_MODE(SpacingFractionalEven); CHECK_MODE(SpacingFractionalOdd); CHECK_MODE(VertexOrderCw); CHECK_MODE(VertexOrderCcw); CHECK_MODE(PixelCenterInteger); CHECK_MODE(OriginUpperLeft); CHECK_MODE(OriginLowerLeft); CHECK_MODE(EarlyFragmentTests); CHECK_MODE(PointMode); CHECK_MODE(Xfb); CHECK_MODE(DepthReplacing); CHECK_MODE(DepthGreater); CHECK_MODE(DepthLess); CHECK_MODE(DepthUnchanged); CHECK_MODE(LocalSizeHint); CHECK_MODE(InputPoints); CHECK_MODE(InputLines); CHECK_MODE(InputLinesAdjacency); CHECK_MODE(Triangles); CHECK_MODE(InputTrianglesAdjacency); CHECK_MODE(Quads); CHECK_MODE(Isolines); CHECK_MODE(OutputPoints); CHECK_MODE(OutputLineStrip); CHECK_MODE(OutputTriangleStrip); CHECK_MODE(VecTypeHint); CHECK_MODE(ContractionOff); default: break; } }); fprintf(stderr, "\n"); print_resources(compiler, "subpass inputs", res.subpass_inputs); print_resources(compiler, "inputs", res.stage_inputs); print_resources(compiler, "outputs", res.stage_outputs); print_resources(compiler, "textures", res.sampled_images); print_resources(compiler, "separate images", res.separate_images); print_resources(compiler, "separate samplers", res.separate_samplers); print_resources(compiler, "images", res.storage_images); print_resources(compiler, "ssbos", res.storage_buffers); print_resources(compiler, "ubos", res.uniform_buffers); print_resources(compiler, "push", res.push_constant_buffers); print_resources(compiler, "counters", res.atomic_counters); print_resources(compiler, "acceleration structures", res.acceleration_structures); } static void print_push_constant_resources(const Compiler &compiler, const SmallVector &res) { for (auto &block : res) { auto ranges = compiler.get_active_buffer_ranges(block.id); fprintf(stderr, "Active members in buffer: %s\n", !block.name.empty() ? block.name.c_str() : compiler.get_fallback_name(block.id).c_str()); fprintf(stderr, "==================\n\n"); for (auto &range : ranges) { const auto &name = compiler.get_member_name(block.base_type_id, range.index); fprintf(stderr, "Member #%3u (%s): Offset: %4u, Range: %4u\n", range.index, !name.empty() ? name.c_str() : compiler.get_fallback_member_name(range.index).c_str(), unsigned(range.offset), unsigned(range.range)); } fprintf(stderr, "==================\n\n"); } } static void print_spec_constants(const Compiler &compiler) { auto spec_constants = compiler.get_specialization_constants(); fprintf(stderr, "Specialization constants\n"); fprintf(stderr, "==================\n\n"); for (auto &c : spec_constants) fprintf(stderr, "ID: %u, Spec ID: %u\n", uint32_t(c.id), c.constant_id); fprintf(stderr, "==================\n\n"); } static void print_capabilities_and_extensions(const Compiler &compiler) { fprintf(stderr, "Capabilities\n"); fprintf(stderr, "============\n"); for (auto &capability : compiler.get_declared_capabilities()) fprintf(stderr, "Capability: %u\n", static_cast(capability)); fprintf(stderr, "============\n\n"); fprintf(stderr, "Extensions\n"); fprintf(stderr, "============\n"); for (auto &ext : compiler.get_declared_extensions()) fprintf(stderr, "Extension: %s\n", ext.c_str()); fprintf(stderr, "============\n\n"); } struct PLSArg { PlsFormat format; string name; }; struct Remap { string src_name; string dst_name; unsigned components; }; struct VariableTypeRemap { string variable_name; string new_variable_type; }; struct InterfaceVariableRename { StorageClass storageClass; uint32_t location; string variable_name; }; struct CLIArguments { const char *input = nullptr; const char *output = nullptr; const char *cpp_interface_name = nullptr; uint32_t version = 0; uint32_t shader_model = 0; uint32_t msl_version = 0; bool es = false; bool set_version = false; bool set_shader_model = false; bool set_msl_version = false; bool set_es = false; bool dump_resources = false; bool force_temporary = false; bool flatten_ubo = false; bool fixup = false; bool yflip = false; bool sso = false; bool support_nonzero_baseinstance = true; bool msl_capture_output_to_buffer = false; bool msl_swizzle_texture_samples = false; bool msl_ios = false; bool msl_pad_fragment_output = false; bool msl_domain_lower_left = false; bool msl_argument_buffers = false; bool msl_texture_buffer_native = false; bool msl_framebuffer_fetch = false; bool msl_invariant_float_math = false; bool msl_emulate_cube_array = false; bool msl_multiview = false; bool msl_multiview_layered_rendering = true; bool msl_view_index_from_device_index = false; bool msl_dispatch_base = false; bool msl_decoration_binding = false; bool msl_force_active_argument_buffer_resources = false; bool msl_force_native_arrays = false; bool msl_enable_frag_depth_builtin = true; bool msl_enable_frag_stencil_ref_builtin = true; uint32_t msl_enable_frag_output_mask = 0xffffffff; bool msl_enable_clip_distance_user_varying = true; bool msl_multi_patch_workgroup = false; bool msl_vertex_for_tessellation = false; uint32_t msl_additional_fixed_sample_mask = 0xffffffff; bool msl_arrayed_subpass_input = false; uint32_t msl_r32ui_linear_texture_alignment = 4; uint32_t msl_r32ui_alignment_constant_id = 65535; bool msl_texture_1d_as_2d = false; bool msl_ios_use_simdgroup_functions = false; bool msl_emulate_subgroups = false; uint32_t msl_fixed_subgroup_size = 0; bool msl_force_sample_rate_shading = false; bool glsl_emit_push_constant_as_ubo = false; bool glsl_emit_ubo_as_plain_uniforms = false; bool glsl_force_flattened_io_blocks = false; SmallVector> glsl_ext_framebuffer_fetch; bool vulkan_glsl_disable_ext_samplerless_texture_functions = false; bool emit_line_directives = false; bool enable_storage_image_qualifier_deduction = true; bool force_zero_initialized_variables = false; SmallVector msl_discrete_descriptor_sets; SmallVector msl_device_argument_buffers; SmallVector> msl_dynamic_buffers; SmallVector> msl_inline_uniform_blocks; SmallVector msl_shader_inputs; SmallVector pls_in; SmallVector pls_out; SmallVector remaps; SmallVector extensions; SmallVector variable_type_remaps; SmallVector interface_variable_renames; SmallVector hlsl_attr_remap; string entry; string entry_stage; struct Rename { string old_name; string new_name; ExecutionModel execution_model; }; SmallVector entry_point_rename; uint32_t iterations = 1; bool cpp = false; string reflect; bool msl = false; bool hlsl = false; bool hlsl_compat = false; bool hlsl_support_nonzero_base = false; bool hlsl_force_storage_buffer_as_uav = false; bool hlsl_nonwritable_uav_texture_as_srv = false; bool hlsl_enable_16bit_types = false; bool hlsl_flatten_matrix_vertex_input_semantics = false; HLSLBindingFlags hlsl_binding_flags = 0; bool vulkan_semantics = false; bool flatten_multidimensional_arrays = false; bool use_420pack_extension = true; bool remove_unused = false; bool combined_samplers_inherit_bindings = false; }; static void print_version() { #ifdef HAVE_SPIRV_CROSS_GIT_VERSION fprintf(stderr, "%s\n", SPIRV_CROSS_GIT_REVISION); #else fprintf(stderr, "Git revision unknown. Build with CMake to create timestamp and revision info.\n"); #endif } static void print_help_backend() { // clang-format off fprintf(stderr, "\nSelect backend:\n" "\tBy default, OpenGL-style GLSL is the target, with #version and GLSL/ESSL information inherited from the SPIR-V module if present.\n" "\t[--vulkan-semantics] or [-V]:\n\t\tEmit Vulkan GLSL instead of plain GLSL. Makes use of Vulkan-only features to match SPIR-V.\n" "\t[--msl]:\n\t\tEmit Metal Shading Language (MSL).\n" "\t[--hlsl]:\n\t\tEmit HLSL.\n" "\t[--reflect]:\n\t\tEmit JSON reflection.\n" "\t[--cpp]:\n\t\tDEPRECATED. Emits C++ code.\n" ); // clang-format on } static void print_help_glsl() { // clang-format off fprintf(stderr, "\nGLSL options:\n" "\t[--es]:\n\t\tForce ESSL.\n" "\t[--no-es]:\n\t\tForce desktop GLSL.\n" "\t[--version ]:\n\t\tE.g. --version 450 will emit '#version 450' in shader.\n" "\t\tCode generation will depend on the version used.\n" "\t[--flatten-ubo]:\n\t\tEmit UBOs as plain uniform arrays which are suitable for use with glUniform4*v().\n" "\t\tThis can be an optimization on GL implementations where this is faster or works around buggy driver implementations.\n" "\t\tE.g.: uniform MyUBO { vec4 a; float b, c, d, e; }; will be emitted as uniform vec4 MyUBO[2];\n" "\t\tCaveat: You cannot mix and match floating-point and integer in the same UBO with this option.\n" "\t\tLegacy GLSL/ESSL (where this flattening makes sense) does not support bit-casting, which would have been the obvious workaround.\n" "\t[--extension ext]:\n\t\tAdd #extension string of your choosing to GLSL output.\n" "\t\tUseful if you use variable name remapping to something that requires an extension unknown to SPIRV-Cross.\n" "\t[--remove-unused-variables]:\n\t\tDo not emit interface variables which are not statically accessed by the shader.\n" "\t[--separate-shader-objects]:\n\t\tRedeclare gl_PerVertex blocks to be suitable for desktop GL separate shader objects.\n" "\t[--glsl-emit-push-constant-as-ubo]:\n\t\tInstead of a plain uniform of struct for push constants, emit a UBO block instead.\n" "\t[--glsl-emit-ubo-as-plain-uniforms]:\n\t\tInstead of emitting UBOs, emit them as plain uniform structs.\n" "\t[--glsl-remap-ext-framebuffer-fetch input-attachment color-location]:\n\t\tRemaps an input attachment to use GL_EXT_shader_framebuffer_fetch.\n" "\t\tgl_LastFragData[location] is read from. The attachment to read from must be declared as an output in the shader.\n" "\t[--vulkan-glsl-disable-ext-samplerless-texture-functions]:\n\t\tDo not allow use of GL_EXT_samperless_texture_functions, even in Vulkan GLSL.\n" "\t\tUse of texelFetch and similar might have to create dummy samplers to work around it.\n" "\t[--combined-samplers-inherit-bindings]:\n\t\tInherit binding information from the textures when building combined image samplers from separate textures and samplers.\n" "\t[--no-support-nonzero-baseinstance]:\n\t\tWhen using gl_InstanceIndex with desktop GL,\n" "\t\tassume that base instance is always 0, and do not attempt to fix up gl_InstanceID to match Vulkan semantics.\n" "\t[--pls-in format input-name]:\n\t\tRemaps a subpass input with name into a GL_EXT_pixel_local_storage input.\n" "\t\tEntry in PLS block is ordered where first --pls-in marks the first entry. Can be called multiple times.\n" "\t\tFormats allowed: r11f_g11f_b10f, r32f, rg16f, rg16, rgb10_a2, rgba8, rgba8i, rgba8ui, rg16i, rgb10_a2ui, rg16ui, r32ui.\n" "\t\tRequires ESSL.\n" "\t[--pls-out format output-name]:\n\t\tRemaps a color output with name into a GL_EXT_pixel_local_storage output.\n" "\t\tEntry in PLS block is ordered where first --pls-output marks the first entry. Can be called multiple times.\n" "\t\tFormats allowed: r11f_g11f_b10f, r32f, rg16f, rg16, rgb10_a2, rgba8, rgba8i, rgba8ui, rg16i, rgb10_a2ui, rg16ui, r32ui.\n" "\t\tRequires ESSL.\n" "\t[--remap source_name target_name components]:\n\t\tRemaps a variable to a different name with N components.\n" "\t\tMain use case is to remap a subpass input to gl_LastFragDepthARM.\n" "\t\tE.g.:\n" "\t\tuniform subpassInput uDepth;\n" "\t\t--remap uDepth gl_LastFragDepthARM 1 --extension GL_ARM_shader_framebuffer_fetch_depth_stencil\n" "\t[--no-420pack-extension]:\n\t\tDo not make use of GL_ARB_shading_language_420pack in older GL targets to support layout(binding).\n" "\t[--remap-variable-type ]:\n\t\tRemaps a variable type based on name.\n" "\t\tPrimary use case is supporting external samplers in ESSL for video rendering on Android where you could remap a texture to a YUV one.\n" "\t[--glsl-force-flattened-io-blocks]:\n\t\tAlways flatten I/O blocks and structs.\n" ); // clang-format on } static void print_help_hlsl() { // clang-format off fprintf(stderr, "\nHLSL options:\n" "\t[--shader-model]:\n\t\tEnables a specific shader model, e.g. --shader-model 50 for SM 5.0.\n" "\t[--hlsl-enable-compat]:\n\t\tAllow point size and point coord to be used, even if they won't work as expected.\n" "\t\tPointSize is ignored, and PointCoord returns (0.5, 0.5).\n" "\t[--hlsl-support-nonzero-basevertex-baseinstance]:\n\t\tSupport base vertex and base instance by emitting a special cbuffer declared as:\n" "\t\tcbuffer SPIRV_Cross_VertexInfo { int SPIRV_Cross_BaseVertex; int SPIRV_Cross_BaseInstance; };\n" "\t[--hlsl-auto-binding (push, cbv, srv, uav, sampler, all)]\n" "\t\tDo not emit any : register(#) bindings for specific resource types, and rely on HLSL compiler to assign something.\n" "\t[--hlsl-force-storage-buffer-as-uav]:\n\t\tAlways emit SSBOs as UAVs, even when marked as read-only.\n" "\t\tNormally, SSBOs marked with NonWritable will be emitted as SRVs.\n" "\t[--hlsl-nonwritable-uav-texture-as-srv]:\n\t\tEmit NonWritable storage images as SRV textures instead of UAV.\n" "\t\tUsing this option messes with the type system. SPIRV-Cross cannot guarantee that this will work.\n" "\t\tOne major problem area with this feature is function arguments, where we won't know if we're seeing a UAV or SRV.\n" "\t\tShader must ensure that read/write state is consistent at all call sites.\n" "\t[--set-hlsl-vertex-input-semantic ]:\n\t\tEmits a specific vertex input semantic for a given location.\n" "\t\tOtherwise, TEXCOORD# is used as semantics, where # is location.\n" "\t[--hlsl-enable-16bit-types]:\n\t\tEnables native use of half/int16_t/uint16_t and ByteAddressBuffer interaction with these types. Requires SM 6.2.\n" "\t[--hlsl-flatten-matrix-vertex-input-semantics]:\n\t\tEmits matrix vertex inputs with input semantics as if they were independent vectors, e.g. TEXCOORD{2,3,4} rather than matrix form TEXCOORD2_{0,1,2}.\n" ); // clang-format on } static void print_help_msl() { // clang-format off fprintf(stderr, "\nMSL options:\n" "\t[--msl-version ]:\n\t\tUses a specific MSL version, e.g. --msl-version 20100 for MSL 2.1.\n" "\t[--msl-capture-output]:\n\t\tWrites geometry varyings to a buffer instead of as stage-outputs.\n" "\t[--msl-swizzle-texture-samples]:\n\t\tWorks around lack of support for VkImageView component swizzles.\n" "\t\tThis has a massive impact on performance and bloat. Do not use this unless you are absolutely forced to.\n" "\t\tTo use this feature, the API side must pass down swizzle buffers.\n" "\t\tShould only be used by translation layers as a last resort.\n" "\t\tRecent Metal versions do not require this workaround.\n" "\t[--msl-ios]:\n\t\tTarget iOS Metal instead of macOS Metal.\n" "\t[--msl-pad-fragment-output]:\n\t\tAlways emit color outputs as 4-component variables.\n" "\t\tIn Metal, the fragment shader must emit at least as many components as the render target format.\n" "\t[--msl-domain-lower-left]:\n\t\tUse a lower-left tessellation domain.\n" "\t[--msl-argument-buffers]:\n\t\tEmit Indirect Argument buffers instead of plain bindings.\n" "\t\tRequires MSL 2.0 to be enabled.\n" "\t[--msl-texture-buffer-native]:\n\t\tEnable native support for texel buffers. Otherwise, it is emulated as a normal texture.\n" "\t[--msl-framebuffer-fetch]:\n\t\tImplement subpass inputs with frame buffer fetch.\n" "\t\tEmits [[color(N)]] inputs in fragment stage.\n" "\t\tRequires an Apple GPU.\n" "\t[--msl-emulate-cube-array]:\n\t\tEmulate cube arrays with 2D array and manual math.\n" "\t[--msl-discrete-descriptor-set ]:\n\t\tWhen using argument buffers, forces a specific descriptor set to be implemented without argument buffers.\n" "\t\tUseful for implementing push descriptors in emulation layers.\n" "\t\tCan be used multiple times for each descriptor set in question.\n" "\t[--msl-device-argument-buffer ]:\n\t\tUse device address space to hold indirect argument buffers instead of constant.\n" "\t\tComes up when trying to support argument buffers which are larger than 64 KiB.\n" "\t[--msl-multiview]:\n\t\tEnable SPV_KHR_multiview emulation.\n" "\t[--msl-multiview-no-layered-rendering]:\n\t\tDon't set [[render_target_array_index]] in multiview shaders.\n" "\t\tUseful for devices which don't support layered rendering. Only effective when --msl-multiview is enabled.\n" "\t[--msl-view-index-from-device-index]:\n\t\tTreat the view index as the device index instead.\n" "\t\tFor multi-GPU rendering.\n" "\t[--msl-dispatch-base]:\n\t\tAdd support for vkCmdDispatchBase() or similar APIs.\n" "\t\tOffsets the workgroup ID based on a buffer.\n" "\t[--msl-dynamic-buffer ]:\n\t\tMarks a buffer as having dynamic offset.\n" "\t\tThe offset is applied in the shader with pointer arithmetic.\n" "\t\tUseful for argument buffers where it is non-trivial to apply dynamic offset otherwise.\n" "\t[--msl-inline-uniform-block ]:\n\t\tIn argument buffers, mark an UBO as being an inline uniform block which is embedded into the argument buffer itself.\n" "\t[--msl-decoration-binding]:\n\t\tUse SPIR-V bindings directly as MSL bindings.\n" "\t\tThis does not work in the general case as there is no descriptor set support, and combined image samplers are split up.\n" "\t\tHowever, if the shader author knows of binding limitations, this option will avoid the need for reflection on Metal side.\n" "\t[--msl-force-active-argument-buffer-resources]:\n\t\tAlways emit resources which are part of argument buffers.\n" "\t\tThis makes sure that similar shaders with same resource declarations can share the argument buffer as declaring an argument buffer implies an ABI.\n" "\t[--msl-force-native-arrays]:\n\t\tRather than implementing array types as a templated value type ala std::array, use plain, native arrays.\n" "\t\tThis will lead to worse code-gen, but can work around driver bugs on certain driver revisions of certain Intel-based Macbooks where template arrays break.\n" "\t[--msl-disable-frag-depth-builtin]:\n\t\tDisables FragDepth output. Useful if pipeline does not enable depth, as pipeline creation might otherwise fail.\n" "\t[--msl-disable-frag-stencil-ref-builtin]:\n\t\tDisable FragStencilRef output. Useful if pipeline does not enable stencil output, as pipeline creation might otherwise fail.\n" "\t[--msl-enable-frag-output-mask ]:\n\t\tOnly selectively enable fragment outputs. Useful if pipeline does not enable fragment output for certain locations, as pipeline creation might otherwise fail.\n" "\t[--msl-no-clip-distance-user-varying]:\n\t\tDo not emit user varyings to emulate gl_ClipDistance in fragment shaders.\n" "\t[--msl-shader-input ]:\n\t\tSpecify the format of the shader input at .\n" "\t\t can be 'any32', 'any16', 'u16', 'u8', or 'other', to indicate a 32-bit opaque value, 16-bit opaque value, 16-bit unsigned integer, 8-bit unsigned integer, " "or other-typed variable. is the vector length of the variable, which must be greater than or equal to that declared in the shader.\n" "\t\tUseful if shader stage interfaces don't match up, as pipeline creation might otherwise fail.\n" "\t[--msl-multi-patch-workgroup]:\n\t\tUse the new style of tessellation control processing, where multiple patches are processed per workgroup.\n" "\t\tThis should increase throughput by ensuring all the GPU's SIMD lanes are occupied, but it is not compatible with the old style.\n" "\t\tIn addition, this style also passes input variables in buffers directly instead of using vertex attribute processing.\n" "\t\tIn a future version of SPIRV-Cross, this will become the default.\n" "\t[--msl-vertex-for-tessellation]:\n\t\tWhen handling a vertex shader, marks it as one that will be used with a new-style tessellation control shader.\n" "\t\tThe vertex shader is output to MSL as a compute kernel which outputs vertices to the buffer in the order they are received, rather than in index order as with --msl-capture-output normally.\n" "\t[--msl-additional-fixed-sample-mask ]:\n" "\t\tSet an additional fixed sample mask. If the shader outputs a sample mask, then the final sample mask will be a bitwise AND of the two.\n" "\t[--msl-arrayed-subpass-input]:\n\t\tAssume that images of dimension SubpassData have multiple layers. Layered input attachments are accessed relative to BuiltInLayer.\n" "\t\tThis option has no effect if multiview is also enabled.\n" "\t[--msl-r32ui-linear-texture-align ]:\n\t\tThe required alignment of linear textures of format MTLPixelFormatR32Uint.\n" "\t\tThis is used to align the row stride for atomic accesses to such images.\n" "\t[--msl-r32ui-linear-texture-align-constant-id ]:\n\t\tThe function constant ID to use for the linear texture alignment.\n" "\t\tOn MSL 1.2 or later, you can override the alignment by setting this function constant.\n" "\t[--msl-texture-1d-as-2d]:\n\t\tEmit Image variables of dimension Dim1D as texture2d.\n" "\t\tIn Metal, 1D textures do not support all features that 2D textures do. Use this option if your code relies on these features.\n" "\t[--msl-ios-use-simdgroup-functions]:\n\t\tUse simd_*() functions for subgroup ops instead of quad_*().\n" "\t\tRecent Apple GPUs support SIMD-groups larger than a quad. Use this option to take advantage of this support.\n" "\t[--msl-emulate-subgroups]:\n\t\tAssume subgroups of size 1.\n" "\t\tIntended for Vulkan Portability implementations where Metal support for SIMD-groups is insufficient for true subgroups.\n" "\t[--msl-fixed-subgroup-size ]:\n\t\tAssign a constant to the SubgroupSize builtin.\n" "\t\tIntended for Vulkan Portability implementations where VK_EXT_subgroup_size_control is not supported or disabled.\n" "\t\tIf 0, assume variable subgroup size as actually exposed by Metal.\n" "\t[--msl-force-sample-rate-shading]:\n\t\tForce fragment shaders to run per sample.\n" "\t\tThis adds a [[sample_id]] parameter if none is already present.\n"); // clang-format on } static void print_help_common() { // clang-format off fprintf(stderr, "\nCommon options:\n" "\t[--entry name]:\n\t\tUse a specific entry point. By default, the first entry point in the module is used.\n" "\t[--stage ]:\n\t\tForces use of a certain shader stage.\n" "\t\tCan disambiguate the entry point if more than one entry point exists with same name, but different stage.\n" "\t[--emit-line-directives]:\n\t\tIf SPIR-V has OpLine directives, aim to emit those accurately in output code as well.\n" "\t[--rename-entry-point ]:\n\t\tRenames an entry point from what is declared in SPIR-V to code output.\n" "\t\tMostly relevant for HLSL or MSL.\n" "\t[--rename-interface-variable ]:\n\t\tRename an interface variable based on location decoration.\n" "\t[--force-zero-initialized-variables]:\n\t\tForces temporary variables to be initialized to zero.\n" "\t\tCan be useful in environments where compilers do not allow potentially uninitialized variables.\n" "\t\tThis usually comes up with Phi temporaries.\n" "\t[--fixup-clipspace]:\n\t\tFixup Z clip-space at the end of a vertex shader. The behavior is backend-dependent.\n" "\t\tGLSL: Rewrites [0, w] Z range (D3D/Metal/Vulkan) to GL-style [-w, w].\n" "\t\tHLSL/MSL: Rewrites [-w, w] Z range (GL) to D3D/Metal/Vulkan-style [0, w].\n" "\t[--flip-vert-y]:\n\t\tInverts gl_Position.y (or equivalent) at the end of a vertex shader. This is equivalent to using negative viewport height.\n" ); // clang-format on } static void print_help_obscure() { // clang-format off fprintf(stderr, "\nObscure options:\n" "\tThese options are not meant to be used on a regular basis. They have some occasional uses in the test suite.\n" "\t[--force-temporary]:\n\t\tAggressively emit temporary expressions instead of forwarding expressions. Very rarely used and under-tested.\n" "\t[--revision]:\n\t\tPrints build timestamp and Git commit information (updated when cmake is configured).\n" "\t[--iterations iter]:\n\t\tRecompiles the same shader over and over, benchmarking related.\n" "\t[--disable-storage-image-qualifier-deduction]:\n\t\tIf storage images are received without any nonwritable or nonreadable information,\n""" "\t\tdo not attempt to analyze usage, and always emit read/write state.\n" "\t[--flatten-multidimensional-arrays]:\n\t\tDo not support multi-dimensional arrays and flatten them to one dimension.\n" "\t[--cpp-interface-name ]:\n\t\tEmit a specific class name in C++ codegen.\n" ); // clang-format on } static void print_help() { print_version(); // clang-format off fprintf(stderr, "Usage: spirv-cross <...>\n" "\nBasic:\n" "\t[SPIR-V file] (- is stdin)\n" "\t[--output ]: If not provided, prints output to stdout.\n" "\t[--dump-resources]:\n\t\tPrints a basic reflection of the SPIR-V module along with other output.\n" "\t[--help]:\n\t\tPrints this help message.\n" ); // clang-format on print_help_backend(); print_help_common(); print_help_glsl(); print_help_msl(); print_help_hlsl(); print_help_obscure(); } static bool remap_generic(Compiler &compiler, const SmallVector &resources, const Remap &remap) { auto itr = find_if(begin(resources), end(resources), [&remap](const Resource &res) { return res.name == remap.src_name; }); if (itr != end(resources)) { compiler.set_remapped_variable_state(itr->id, true); compiler.set_name(itr->id, remap.dst_name); compiler.set_subpass_input_remapped_components(itr->id, remap.components); return true; } else return false; } static vector remap_pls(const SmallVector &pls_variables, const SmallVector &resources, const SmallVector *secondary_resources) { vector ret; for (auto &pls : pls_variables) { bool found = false; for (auto &res : resources) { if (res.name == pls.name) { ret.push_back({ res.id, pls.format }); found = true; break; } } if (!found && secondary_resources) { for (auto &res : *secondary_resources) { if (res.name == pls.name) { ret.push_back({ res.id, pls.format }); found = true; break; } } } if (!found) fprintf(stderr, "Did not find stage input/output/target with name \"%s\".\n", pls.name.c_str()); } return ret; } static PlsFormat pls_format(const char *str) { if (!strcmp(str, "r11f_g11f_b10f")) return PlsR11FG11FB10F; else if (!strcmp(str, "r32f")) return PlsR32F; else if (!strcmp(str, "rg16f")) return PlsRG16F; else if (!strcmp(str, "rg16")) return PlsRG16; else if (!strcmp(str, "rgb10_a2")) return PlsRGB10A2; else if (!strcmp(str, "rgba8")) return PlsRGBA8; else if (!strcmp(str, "rgba8i")) return PlsRGBA8I; else if (!strcmp(str, "rgba8ui")) return PlsRGBA8UI; else if (!strcmp(str, "rg16i")) return PlsRG16I; else if (!strcmp(str, "rgb10_a2ui")) return PlsRGB10A2UI; else if (!strcmp(str, "rg16ui")) return PlsRG16UI; else if (!strcmp(str, "r32ui")) return PlsR32UI; else return PlsNone; } static ExecutionModel stage_to_execution_model(const std::string &stage) { if (stage == "vert") return ExecutionModelVertex; else if (stage == "frag") return ExecutionModelFragment; else if (stage == "comp") return ExecutionModelGLCompute; else if (stage == "tesc") return ExecutionModelTessellationControl; else if (stage == "tese") return ExecutionModelTessellationEvaluation; else if (stage == "geom") return ExecutionModelGeometry; else SPIRV_CROSS_THROW("Invalid stage."); } static HLSLBindingFlags hlsl_resource_type_to_flag(const std::string &arg) { if (arg == "push") return HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT; else if (arg == "cbv") return HLSL_BINDING_AUTO_CBV_BIT; else if (arg == "srv") return HLSL_BINDING_AUTO_SRV_BIT; else if (arg == "uav") return HLSL_BINDING_AUTO_UAV_BIT; else if (arg == "sampler") return HLSL_BINDING_AUTO_SAMPLER_BIT; else if (arg == "all") return HLSL_BINDING_AUTO_ALL; else { fprintf(stderr, "Invalid resource type for --hlsl-auto-binding: %s\n", arg.c_str()); return 0; } } static string compile_iteration(const CLIArguments &args, std::vector spirv_file) { Parser spirv_parser(move(spirv_file)); spirv_parser.parse(); unique_ptr compiler; bool combined_image_samplers = false; bool build_dummy_sampler = false; if (args.cpp) { compiler.reset(new CompilerCPP(move(spirv_parser.get_parsed_ir()))); if (args.cpp_interface_name) static_cast(compiler.get())->set_interface_name(args.cpp_interface_name); } else if (args.msl) { compiler.reset(new CompilerMSL(move(spirv_parser.get_parsed_ir()))); auto *msl_comp = static_cast(compiler.get()); auto msl_opts = msl_comp->get_msl_options(); if (args.set_msl_version) msl_opts.msl_version = args.msl_version; msl_opts.capture_output_to_buffer = args.msl_capture_output_to_buffer; msl_opts.swizzle_texture_samples = args.msl_swizzle_texture_samples; msl_opts.invariant_float_math = args.msl_invariant_float_math; if (args.msl_ios) { msl_opts.platform = CompilerMSL::Options::iOS; msl_opts.emulate_cube_array = args.msl_emulate_cube_array; } msl_opts.use_framebuffer_fetch_subpasses = args.msl_framebuffer_fetch; msl_opts.pad_fragment_output_components = args.msl_pad_fragment_output; msl_opts.tess_domain_origin_lower_left = args.msl_domain_lower_left; msl_opts.argument_buffers = args.msl_argument_buffers; msl_opts.texture_buffer_native = args.msl_texture_buffer_native; msl_opts.multiview = args.msl_multiview; msl_opts.multiview_layered_rendering = args.msl_multiview_layered_rendering; msl_opts.view_index_from_device_index = args.msl_view_index_from_device_index; msl_opts.dispatch_base = args.msl_dispatch_base; msl_opts.enable_decoration_binding = args.msl_decoration_binding; msl_opts.force_active_argument_buffer_resources = args.msl_force_active_argument_buffer_resources; msl_opts.force_native_arrays = args.msl_force_native_arrays; msl_opts.enable_frag_depth_builtin = args.msl_enable_frag_depth_builtin; msl_opts.enable_frag_stencil_ref_builtin = args.msl_enable_frag_stencil_ref_builtin; msl_opts.enable_frag_output_mask = args.msl_enable_frag_output_mask; msl_opts.enable_clip_distance_user_varying = args.msl_enable_clip_distance_user_varying; msl_opts.multi_patch_workgroup = args.msl_multi_patch_workgroup; msl_opts.vertex_for_tessellation = args.msl_vertex_for_tessellation; msl_opts.additional_fixed_sample_mask = args.msl_additional_fixed_sample_mask; msl_opts.arrayed_subpass_input = args.msl_arrayed_subpass_input; msl_opts.r32ui_linear_texture_alignment = args.msl_r32ui_linear_texture_alignment; msl_opts.r32ui_alignment_constant_id = args.msl_r32ui_alignment_constant_id; msl_opts.texture_1D_as_2D = args.msl_texture_1d_as_2d; msl_opts.ios_use_simdgroup_functions = args.msl_ios_use_simdgroup_functions; msl_opts.emulate_subgroups = args.msl_emulate_subgroups; msl_opts.fixed_subgroup_size = args.msl_fixed_subgroup_size; msl_opts.force_sample_rate_shading = args.msl_force_sample_rate_shading; msl_comp->set_msl_options(msl_opts); for (auto &v : args.msl_discrete_descriptor_sets) msl_comp->add_discrete_descriptor_set(v); for (auto &v : args.msl_device_argument_buffers) msl_comp->set_argument_buffer_device_address_space(v, true); uint32_t i = 0; for (auto &v : args.msl_dynamic_buffers) msl_comp->add_dynamic_buffer(v.first, v.second, i++); for (auto &v : args.msl_inline_uniform_blocks) msl_comp->add_inline_uniform_block(v.first, v.second); for (auto &v : args.msl_shader_inputs) msl_comp->add_msl_shader_input(v); } else if (args.hlsl) compiler.reset(new CompilerHLSL(move(spirv_parser.get_parsed_ir()))); else { combined_image_samplers = !args.vulkan_semantics; if (!args.vulkan_semantics || args.vulkan_glsl_disable_ext_samplerless_texture_functions) build_dummy_sampler = true; compiler.reset(new CompilerGLSL(move(spirv_parser.get_parsed_ir()))); } if (!args.variable_type_remaps.empty()) { auto remap_cb = [&](const SPIRType &, const string &name, string &out) -> void { for (const VariableTypeRemap &remap : args.variable_type_remaps) if (name == remap.variable_name) out = remap.new_variable_type; }; compiler->set_variable_type_remap_callback(move(remap_cb)); } for (auto &rename : args.entry_point_rename) compiler->rename_entry_point(rename.old_name, rename.new_name, rename.execution_model); auto entry_points = compiler->get_entry_points_and_stages(); auto entry_point = args.entry; ExecutionModel model = ExecutionModelMax; if (!args.entry_stage.empty()) { model = stage_to_execution_model(args.entry_stage); if (entry_point.empty()) { // Just use the first entry point with this stage. for (auto &e : entry_points) { if (e.execution_model == model) { entry_point = e.name; break; } } if (entry_point.empty()) { fprintf(stderr, "Could not find an entry point with stage: %s\n", args.entry_stage.c_str()); exit(EXIT_FAILURE); } } else { // Make sure both stage and name exists. bool exists = false; for (auto &e : entry_points) { if (e.execution_model == model && e.name == entry_point) { exists = true; break; } } if (!exists) { fprintf(stderr, "Could not find an entry point %s with stage: %s\n", entry_point.c_str(), args.entry_stage.c_str()); exit(EXIT_FAILURE); } } } else if (!entry_point.empty()) { // Make sure there is just one entry point with this name, or the stage // is ambiguous. uint32_t stage_count = 0; for (auto &e : entry_points) { if (e.name == entry_point) { stage_count++; model = e.execution_model; } } if (stage_count == 0) { fprintf(stderr, "There is no entry point with name: %s\n", entry_point.c_str()); exit(EXIT_FAILURE); } else if (stage_count > 1) { fprintf(stderr, "There is more than one entry point with name: %s. Use --stage.\n", entry_point.c_str()); exit(EXIT_FAILURE); } } if (!entry_point.empty()) compiler->set_entry_point(entry_point, model); if (!args.set_version && !compiler->get_common_options().version) { fprintf(stderr, "Didn't specify GLSL version and SPIR-V did not specify language.\n"); print_help(); exit(EXIT_FAILURE); } CompilerGLSL::Options opts = compiler->get_common_options(); if (args.set_version) opts.version = args.version; if (args.set_es) opts.es = args.es; opts.force_temporary = args.force_temporary; opts.separate_shader_objects = args.sso; opts.flatten_multidimensional_arrays = args.flatten_multidimensional_arrays; opts.enable_420pack_extension = args.use_420pack_extension; opts.vulkan_semantics = args.vulkan_semantics; opts.vertex.fixup_clipspace = args.fixup; opts.vertex.flip_vert_y = args.yflip; opts.vertex.support_nonzero_base_instance = args.support_nonzero_baseinstance; opts.emit_push_constant_as_uniform_buffer = args.glsl_emit_push_constant_as_ubo; opts.emit_uniform_buffer_as_plain_uniforms = args.glsl_emit_ubo_as_plain_uniforms; opts.force_flattened_io_blocks = args.glsl_force_flattened_io_blocks; opts.emit_line_directives = args.emit_line_directives; opts.enable_storage_image_qualifier_deduction = args.enable_storage_image_qualifier_deduction; opts.force_zero_initialized_variables = args.force_zero_initialized_variables; compiler->set_common_options(opts); for (auto &fetch : args.glsl_ext_framebuffer_fetch) compiler->remap_ext_framebuffer_fetch(fetch.first, fetch.second); // Set HLSL specific options. if (args.hlsl) { auto *hlsl = static_cast(compiler.get()); auto hlsl_opts = hlsl->get_hlsl_options(); if (args.set_shader_model) { if (args.shader_model < 30) { fprintf(stderr, "Shader model earlier than 30 (3.0) not supported.\n"); exit(EXIT_FAILURE); } hlsl_opts.shader_model = args.shader_model; } if (args.hlsl_compat) { // Enable all compat options. hlsl_opts.point_size_compat = true; hlsl_opts.point_coord_compat = true; } if (hlsl_opts.shader_model <= 30) { combined_image_samplers = true; build_dummy_sampler = true; } hlsl_opts.support_nonzero_base_vertex_base_instance = args.hlsl_support_nonzero_base; hlsl_opts.force_storage_buffer_as_uav = args.hlsl_force_storage_buffer_as_uav; hlsl_opts.nonwritable_uav_texture_as_srv = args.hlsl_nonwritable_uav_texture_as_srv; hlsl_opts.enable_16bit_types = args.hlsl_enable_16bit_types; hlsl_opts.flatten_matrix_vertex_input_semantics = args.hlsl_flatten_matrix_vertex_input_semantics; hlsl->set_hlsl_options(hlsl_opts); hlsl->set_resource_binding_flags(args.hlsl_binding_flags); } if (build_dummy_sampler) { uint32_t sampler = compiler->build_dummy_sampler_for_combined_images(); if (sampler != 0) { // Set some defaults to make validation happy. compiler->set_decoration(sampler, DecorationDescriptorSet, 0); compiler->set_decoration(sampler, DecorationBinding, 0); } } ShaderResources res; if (args.remove_unused) { auto active = compiler->get_active_interface_variables(); res = compiler->get_shader_resources(active); compiler->set_enabled_interface_variables(move(active)); } else res = compiler->get_shader_resources(); if (args.flatten_ubo) { for (auto &ubo : res.uniform_buffers) compiler->flatten_buffer_block(ubo.id); for (auto &ubo : res.push_constant_buffers) compiler->flatten_buffer_block(ubo.id); } auto pls_inputs = remap_pls(args.pls_in, res.stage_inputs, &res.subpass_inputs); auto pls_outputs = remap_pls(args.pls_out, res.stage_outputs, nullptr); compiler->remap_pixel_local_storage(move(pls_inputs), move(pls_outputs)); for (auto &ext : args.extensions) compiler->require_extension(ext); for (auto &remap : args.remaps) { if (remap_generic(*compiler, res.stage_inputs, remap)) continue; if (remap_generic(*compiler, res.stage_outputs, remap)) continue; if (remap_generic(*compiler, res.subpass_inputs, remap)) continue; } for (auto &rename : args.interface_variable_renames) { if (rename.storageClass == StorageClassInput) spirv_cross_util::rename_interface_variable(*compiler, res.stage_inputs, rename.location, rename.variable_name); else if (rename.storageClass == StorageClassOutput) spirv_cross_util::rename_interface_variable(*compiler, res.stage_outputs, rename.location, rename.variable_name); else { fprintf(stderr, "error at --rename-interface-variable ...\n"); exit(EXIT_FAILURE); } } if (combined_image_samplers) { compiler->build_combined_image_samplers(); if (args.combined_samplers_inherit_bindings) spirv_cross_util::inherit_combined_sampler_bindings(*compiler); // Give the remapped combined samplers new names. for (auto &remap : compiler->get_combined_image_samplers()) { compiler->set_name(remap.combined_id, join("SPIRV_Cross_Combined", compiler->get_name(remap.image_id), compiler->get_name(remap.sampler_id))); } } if (args.hlsl) { auto *hlsl_compiler = static_cast(compiler.get()); uint32_t new_builtin = hlsl_compiler->remap_num_workgroups_builtin(); if (new_builtin) { hlsl_compiler->set_decoration(new_builtin, DecorationDescriptorSet, 0); hlsl_compiler->set_decoration(new_builtin, DecorationBinding, 0); } } if (args.hlsl) { for (auto &remap : args.hlsl_attr_remap) static_cast(compiler.get())->add_vertex_attribute_remap(remap); } auto ret = compiler->compile(); if (args.dump_resources) { print_resources(*compiler, res); print_push_constant_resources(*compiler, res.push_constant_buffers); print_spec_constants(*compiler); print_capabilities_and_extensions(*compiler); } return ret; } static int main_inner(int argc, char *argv[]) { CLIArguments args; CLICallbacks cbs; cbs.add("--help", [](CLIParser &parser) { print_help(); parser.end(); }); cbs.add("--revision", [](CLIParser &parser) { print_version(); parser.end(); }); cbs.add("--output", [&args](CLIParser &parser) { args.output = parser.next_string(); }); cbs.add("--es", [&args](CLIParser &) { args.es = true; args.set_es = true; }); cbs.add("--no-es", [&args](CLIParser &) { args.es = false; args.set_es = true; }); cbs.add("--version", [&args](CLIParser &parser) { args.version = parser.next_uint(); args.set_version = true; }); cbs.add("--dump-resources", [&args](CLIParser &) { args.dump_resources = true; }); cbs.add("--force-temporary", [&args](CLIParser &) { args.force_temporary = true; }); cbs.add("--flatten-ubo", [&args](CLIParser &) { args.flatten_ubo = true; }); cbs.add("--fixup-clipspace", [&args](CLIParser &) { args.fixup = true; }); cbs.add("--flip-vert-y", [&args](CLIParser &) { args.yflip = true; }); cbs.add("--iterations", [&args](CLIParser &parser) { args.iterations = parser.next_uint(); }); cbs.add("--cpp", [&args](CLIParser &) { args.cpp = true; }); cbs.add("--reflect", [&args](CLIParser &parser) { args.reflect = parser.next_value_string("json"); }); cbs.add("--cpp-interface-name", [&args](CLIParser &parser) { args.cpp_interface_name = parser.next_string(); }); cbs.add("--metal", [&args](CLIParser &) { args.msl = true; }); // Legacy compatibility cbs.add("--glsl-emit-push-constant-as-ubo", [&args](CLIParser &) { args.glsl_emit_push_constant_as_ubo = true; }); cbs.add("--glsl-emit-ubo-as-plain-uniforms", [&args](CLIParser &) { args.glsl_emit_ubo_as_plain_uniforms = true; }); cbs.add("--glsl-force-flattened-io-blocks", [&args](CLIParser &) { args.glsl_force_flattened_io_blocks = true; }); cbs.add("--glsl-remap-ext-framebuffer-fetch", [&args](CLIParser &parser) { uint32_t input_index = parser.next_uint(); uint32_t color_attachment = parser.next_uint(); args.glsl_ext_framebuffer_fetch.push_back({ input_index, color_attachment }); }); cbs.add("--vulkan-glsl-disable-ext-samplerless-texture-functions", [&args](CLIParser &) { args.vulkan_glsl_disable_ext_samplerless_texture_functions = true; }); cbs.add("--disable-storage-image-qualifier-deduction", [&args](CLIParser &) { args.enable_storage_image_qualifier_deduction = false; }); cbs.add("--force-zero-initialized-variables", [&args](CLIParser &) { args.force_zero_initialized_variables = true; }); cbs.add("--msl", [&args](CLIParser &) { args.msl = true; }); cbs.add("--hlsl", [&args](CLIParser &) { args.hlsl = true; }); cbs.add("--hlsl-enable-compat", [&args](CLIParser &) { args.hlsl_compat = true; }); cbs.add("--hlsl-support-nonzero-basevertex-baseinstance", [&args](CLIParser &) { args.hlsl_support_nonzero_base = true; }); cbs.add("--hlsl-auto-binding", [&args](CLIParser &parser) { args.hlsl_binding_flags |= hlsl_resource_type_to_flag(parser.next_string()); }); cbs.add("--hlsl-force-storage-buffer-as-uav", [&args](CLIParser &) { args.hlsl_force_storage_buffer_as_uav = true; }); cbs.add("--hlsl-nonwritable-uav-texture-as-srv", [&args](CLIParser &) { args.hlsl_nonwritable_uav_texture_as_srv = true; }); cbs.add("--hlsl-enable-16bit-types", [&args](CLIParser &) { args.hlsl_enable_16bit_types = true; }); cbs.add("--hlsl-flatten-matrix-vertex-input-semantics", [&args](CLIParser &) { args.hlsl_flatten_matrix_vertex_input_semantics = true; }); cbs.add("--vulkan-semantics", [&args](CLIParser &) { args.vulkan_semantics = true; }); cbs.add("-V", [&args](CLIParser &) { args.vulkan_semantics = true; }); cbs.add("--flatten-multidimensional-arrays", [&args](CLIParser &) { args.flatten_multidimensional_arrays = true; }); cbs.add("--no-420pack-extension", [&args](CLIParser &) { args.use_420pack_extension = false; }); cbs.add("--msl-capture-output", [&args](CLIParser &) { args.msl_capture_output_to_buffer = true; }); cbs.add("--msl-swizzle-texture-samples", [&args](CLIParser &) { args.msl_swizzle_texture_samples = true; }); cbs.add("--msl-ios", [&args](CLIParser &) { args.msl_ios = true; }); cbs.add("--msl-pad-fragment-output", [&args](CLIParser &) { args.msl_pad_fragment_output = true; }); cbs.add("--msl-domain-lower-left", [&args](CLIParser &) { args.msl_domain_lower_left = true; }); cbs.add("--msl-argument-buffers", [&args](CLIParser &) { args.msl_argument_buffers = true; }); cbs.add("--msl-discrete-descriptor-set", [&args](CLIParser &parser) { args.msl_discrete_descriptor_sets.push_back(parser.next_uint()); }); cbs.add("--msl-device-argument-buffer", [&args](CLIParser &parser) { args.msl_device_argument_buffers.push_back(parser.next_uint()); }); cbs.add("--msl-texture-buffer-native", [&args](CLIParser &) { args.msl_texture_buffer_native = true; }); cbs.add("--msl-framebuffer-fetch", [&args](CLIParser &) { args.msl_framebuffer_fetch = true; }); cbs.add("--msl-invariant-float-math", [&args](CLIParser &) { args.msl_invariant_float_math = true; }); cbs.add("--msl-emulate-cube-array", [&args](CLIParser &) { args.msl_emulate_cube_array = true; }); cbs.add("--msl-multiview", [&args](CLIParser &) { args.msl_multiview = true; }); cbs.add("--msl-multiview-no-layered-rendering", [&args](CLIParser &) { args.msl_multiview_layered_rendering = false; }); cbs.add("--msl-view-index-from-device-index", [&args](CLIParser &) { args.msl_view_index_from_device_index = true; }); cbs.add("--msl-dispatch-base", [&args](CLIParser &) { args.msl_dispatch_base = true; }); cbs.add("--msl-dynamic-buffer", [&args](CLIParser &parser) { args.msl_argument_buffers = true; // Make sure next_uint() is called in-order. uint32_t desc_set = parser.next_uint(); uint32_t binding = parser.next_uint(); args.msl_dynamic_buffers.push_back(make_pair(desc_set, binding)); }); cbs.add("--msl-decoration-binding", [&args](CLIParser &) { args.msl_decoration_binding = true; }); cbs.add("--msl-force-active-argument-buffer-resources", [&args](CLIParser &) { args.msl_force_active_argument_buffer_resources = true; }); cbs.add("--msl-inline-uniform-block", [&args](CLIParser &parser) { args.msl_argument_buffers = true; // Make sure next_uint() is called in-order. uint32_t desc_set = parser.next_uint(); uint32_t binding = parser.next_uint(); args.msl_inline_uniform_blocks.push_back(make_pair(desc_set, binding)); }); cbs.add("--msl-force-native-arrays", [&args](CLIParser &) { args.msl_force_native_arrays = true; }); cbs.add("--msl-disable-frag-depth-builtin", [&args](CLIParser &) { args.msl_enable_frag_depth_builtin = false; }); cbs.add("--msl-disable-frag-stencil-ref-builtin", [&args](CLIParser &) { args.msl_enable_frag_stencil_ref_builtin = false; }); cbs.add("--msl-enable-frag-output-mask", [&args](CLIParser &parser) { args.msl_enable_frag_output_mask = parser.next_hex_uint(); }); cbs.add("--msl-no-clip-distance-user-varying", [&args](CLIParser &) { args.msl_enable_clip_distance_user_varying = false; }); cbs.add("--msl-shader-input", [&args](CLIParser &parser) { MSLShaderInput input; // Make sure next_uint() is called in-order. input.location = parser.next_uint(); const char *format = parser.next_value_string("other"); if (strcmp(format, "any32") == 0) input.format = MSL_SHADER_INPUT_FORMAT_ANY32; else if (strcmp(format, "any16") == 0) input.format = MSL_SHADER_INPUT_FORMAT_ANY16; else if (strcmp(format, "u16") == 0) input.format = MSL_SHADER_INPUT_FORMAT_UINT16; else if (strcmp(format, "u8") == 0) input.format = MSL_SHADER_INPUT_FORMAT_UINT8; else input.format = MSL_SHADER_INPUT_FORMAT_OTHER; input.vecsize = parser.next_uint(); args.msl_shader_inputs.push_back(input); }); cbs.add("--msl-multi-patch-workgroup", [&args](CLIParser &) { args.msl_multi_patch_workgroup = true; }); cbs.add("--msl-vertex-for-tessellation", [&args](CLIParser &) { args.msl_vertex_for_tessellation = true; }); cbs.add("--msl-additional-fixed-sample-mask", [&args](CLIParser &parser) { args.msl_additional_fixed_sample_mask = parser.next_hex_uint(); }); cbs.add("--msl-arrayed-subpass-input", [&args](CLIParser &) { args.msl_arrayed_subpass_input = true; }); cbs.add("--msl-r32ui-linear-texture-align", [&args](CLIParser &parser) { args.msl_r32ui_linear_texture_alignment = parser.next_uint(); }); cbs.add("--msl-r32ui-linear-texture-align-constant-id", [&args](CLIParser &parser) { args.msl_r32ui_alignment_constant_id = parser.next_uint(); }); cbs.add("--msl-texture-1d-as-2d", [&args](CLIParser &) { args.msl_texture_1d_as_2d = true; }); cbs.add("--msl-ios-use-simdgroup-functions", [&args](CLIParser &) { args.msl_ios_use_simdgroup_functions = true; }); cbs.add("--msl-emulate-subgroups", [&args](CLIParser &) { args.msl_emulate_subgroups = true; }); cbs.add("--msl-fixed-subgroup-size", [&args](CLIParser &parser) { args.msl_fixed_subgroup_size = parser.next_uint(); }); cbs.add("--msl-force-sample-rate-shading", [&args](CLIParser &) { args.msl_force_sample_rate_shading = true; }); cbs.add("--extension", [&args](CLIParser &parser) { args.extensions.push_back(parser.next_string()); }); cbs.add("--rename-entry-point", [&args](CLIParser &parser) { auto old_name = parser.next_string(); auto new_name = parser.next_string(); auto model = stage_to_execution_model(parser.next_string()); args.entry_point_rename.push_back({ old_name, new_name, move(model) }); }); cbs.add("--entry", [&args](CLIParser &parser) { args.entry = parser.next_string(); }); cbs.add("--stage", [&args](CLIParser &parser) { args.entry_stage = parser.next_string(); }); cbs.add("--separate-shader-objects", [&args](CLIParser &) { args.sso = true; }); cbs.add("--set-hlsl-vertex-input-semantic", [&args](CLIParser &parser) { HLSLVertexAttributeRemap remap; remap.location = parser.next_uint(); remap.semantic = parser.next_string(); args.hlsl_attr_remap.push_back(move(remap)); }); cbs.add("--remap", [&args](CLIParser &parser) { string src = parser.next_string(); string dst = parser.next_string(); uint32_t components = parser.next_uint(); args.remaps.push_back({ move(src), move(dst), components }); }); cbs.add("--remap-variable-type", [&args](CLIParser &parser) { string var_name = parser.next_string(); string new_type = parser.next_string(); args.variable_type_remaps.push_back({ move(var_name), move(new_type) }); }); cbs.add("--rename-interface-variable", [&args](CLIParser &parser) { StorageClass cls = StorageClassMax; string clsStr = parser.next_string(); if (clsStr == "in") cls = StorageClassInput; else if (clsStr == "out") cls = StorageClassOutput; uint32_t loc = parser.next_uint(); string var_name = parser.next_string(); args.interface_variable_renames.push_back({ cls, loc, move(var_name) }); }); cbs.add("--pls-in", [&args](CLIParser &parser) { auto fmt = pls_format(parser.next_string()); auto name = parser.next_string(); args.pls_in.push_back({ move(fmt), move(name) }); }); cbs.add("--pls-out", [&args](CLIParser &parser) { auto fmt = pls_format(parser.next_string()); auto name = parser.next_string(); args.pls_out.push_back({ move(fmt), move(name) }); }); cbs.add("--shader-model", [&args](CLIParser &parser) { args.shader_model = parser.next_uint(); args.set_shader_model = true; }); cbs.add("--msl-version", [&args](CLIParser &parser) { args.msl_version = parser.next_uint(); args.set_msl_version = true; }); cbs.add("--remove-unused-variables", [&args](CLIParser &) { args.remove_unused = true; }); cbs.add("--combined-samplers-inherit-bindings", [&args](CLIParser &) { args.combined_samplers_inherit_bindings = true; }); cbs.add("--no-support-nonzero-baseinstance", [&](CLIParser &) { args.support_nonzero_baseinstance = false; }); cbs.add("--emit-line-directives", [&args](CLIParser &) { args.emit_line_directives = true; }); cbs.default_handler = [&args](const char *value) { args.input = value; }; cbs.add("-", [&args](CLIParser &) { args.input = "-"; }); cbs.error_handler = [] { print_help(); }; CLIParser parser{ move(cbs), argc - 1, argv + 1 }; if (!parser.parse()) return EXIT_FAILURE; else if (parser.ended_state) return EXIT_SUCCESS; if (!args.input) { fprintf(stderr, "Didn't specify input file.\n"); print_help(); return EXIT_FAILURE; } auto spirv_file = read_spirv_file(args.input); if (spirv_file.empty()) return EXIT_FAILURE; // Special case reflection because it has little to do with the path followed by code-outputting compilers if (!args.reflect.empty()) { Parser spirv_parser(move(spirv_file)); spirv_parser.parse(); CompilerReflection compiler(move(spirv_parser.get_parsed_ir())); compiler.set_format(args.reflect); auto json = compiler.compile(); if (args.output) write_string_to_file(args.output, json.c_str()); else printf("%s", json.c_str()); return EXIT_SUCCESS; } string compiled_output; if (args.iterations == 1) compiled_output = compile_iteration(args, move(spirv_file)); else { for (unsigned i = 0; i < args.iterations; i++) compiled_output = compile_iteration(args, spirv_file); } if (args.output) write_string_to_file(args.output, compiled_output.c_str()); else printf("%s", compiled_output.c_str()); return EXIT_SUCCESS; } int main(int argc, char *argv[]) { #ifdef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS return main_inner(argc, argv); #else // Make sure we catch the exception or it just disappears into the aether on Windows. try { return main_inner(argc, argv); } catch (const std::exception &e) { fprintf(stderr, "SPIRV-Cross threw an exception: %s\n", e.what()); return EXIT_FAILURE; } #endif } spirv-cross-2021.01.15/pkg-config/000077500000000000000000000000001400026215700164165ustar00rootroot00000000000000spirv-cross-2021.01.15/pkg-config/spirv-cross-c-shared.pc.in000066400000000000000000000006021400026215700233230ustar00rootroot00000000000000prefix=@CMAKE_INSTALL_PREFIX@ exec_prefix=${prefix} libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ sharedlibdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@/spirv_cross Name: spirv-cross-c-shared Description: C API for SPIRV-Cross Version: @SPIRV_CROSS_VERSION@ Requires: Libs: -L${libdir} -L${sharedlibdir} -lspirv-cross-c-shared Cflags: -I${includedir} spirv-cross-2021.01.15/reference/000077500000000000000000000000001400026215700163305ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/000077500000000000000000000000001400026215700171325ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/000077500000000000000000000000001400026215700215235ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/000077500000000000000000000000001400026215700223035ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/comp/000077500000000000000000000000001400026215700232415ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/comp/access-chain-invalidate.asm.comp000066400000000000000000000004751400026215700313450ustar00rootroot00000000000000RWByteAddressBuffer _4 : register(u0); void comp_main() { uint _21 = _4.Load(_4.Load(0) * 4 + 4); for (uint _23 = 0u; _23 < 64u; ) { _4.Store(_23 * 4 + 4, 0u); _23++; continue; } _4.Store(_4.Load(0) * 4 + 4, _21); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/comp/atomic-decrement.asm.comp000066400000000000000000000007621400026215700301250ustar00rootroot00000000000000RWByteAddressBuffer u0_counter : register(u1); RWBuffer u0 : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { uint _29; u0_counter.InterlockedAdd(0, -1, _29); u0[asint(asfloat(_29))] = uint(int(gl_GlobalInvocationID.x)).x; } [numthreads(4, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/comp/atomic-increment.asm.comp000066400000000000000000000007611400026215700301420ustar00rootroot00000000000000RWByteAddressBuffer u0_counter : register(u1); RWBuffer u0 : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { uint _29; u0_counter.InterlockedAdd(0, 1, _29); u0[asint(asfloat(_29))] = uint(int(gl_GlobalInvocationID.x)).x; } [numthreads(4, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/comp/bitcast_icmp.asm.comp000066400000000000000000000073741400026215700273540ustar00rootroot00000000000000RWByteAddressBuffer _5 : register(u0); RWByteAddressBuffer _6 : register(u1); void comp_main() { bool4 _31 = bool4(int(_5.Load4(16).x) < int4(_5.Load4(0)).x, int(_5.Load4(16).y) < int4(_5.Load4(0)).y, int(_5.Load4(16).z) < int4(_5.Load4(0)).z, int(_5.Load4(16).w) < int4(_5.Load4(0)).w); bool4 _32 = bool4(int(_5.Load4(16).x) <= int4(_5.Load4(0)).x, int(_5.Load4(16).y) <= int4(_5.Load4(0)).y, int(_5.Load4(16).z) <= int4(_5.Load4(0)).z, int(_5.Load4(16).w) <= int4(_5.Load4(0)).w); bool4 _33 = bool4(_5.Load4(16).x < uint(int4(_5.Load4(0)).x), _5.Load4(16).y < uint(int4(_5.Load4(0)).y), _5.Load4(16).z < uint(int4(_5.Load4(0)).z), _5.Load4(16).w < uint(int4(_5.Load4(0)).w)); bool4 _34 = bool4(_5.Load4(16).x <= uint(int4(_5.Load4(0)).x), _5.Load4(16).y <= uint(int4(_5.Load4(0)).y), _5.Load4(16).z <= uint(int4(_5.Load4(0)).z), _5.Load4(16).w <= uint(int4(_5.Load4(0)).w)); bool4 _35 = bool4(int(_5.Load4(16).x) > int4(_5.Load4(0)).x, int(_5.Load4(16).y) > int4(_5.Load4(0)).y, int(_5.Load4(16).z) > int4(_5.Load4(0)).z, int(_5.Load4(16).w) > int4(_5.Load4(0)).w); bool4 _36 = bool4(int(_5.Load4(16).x) >= int4(_5.Load4(0)).x, int(_5.Load4(16).y) >= int4(_5.Load4(0)).y, int(_5.Load4(16).z) >= int4(_5.Load4(0)).z, int(_5.Load4(16).w) >= int4(_5.Load4(0)).w); bool4 _37 = bool4(_5.Load4(16).x > uint(int4(_5.Load4(0)).x), _5.Load4(16).y > uint(int4(_5.Load4(0)).y), _5.Load4(16).z > uint(int4(_5.Load4(0)).z), _5.Load4(16).w > uint(int4(_5.Load4(0)).w)); bool4 _38 = bool4(_5.Load4(16).x >= uint(int4(_5.Load4(0)).x), _5.Load4(16).y >= uint(int4(_5.Load4(0)).y), _5.Load4(16).z >= uint(int4(_5.Load4(0)).z), _5.Load4(16).w >= uint(int4(_5.Load4(0)).w)); _6.Store4(0, uint4(_31.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _31.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _31.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _31.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_32.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _32.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _32.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _32.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_33.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _33.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _33.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _33.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_34.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _34.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _34.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _34.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_35.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _35.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _35.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _35.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_36.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _36.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _36.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _36.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_37.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _37.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _37.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _37.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_38.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _38.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _38.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _38.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/comp/block-name-alias-global.asm.comp000066400000000000000000000016141400026215700312370ustar00rootroot00000000000000struct A { int a; int b; }; RWByteAddressBuffer C1 : register(u1); cbuffer C2 : register(b2) { A C2_1_Data[1024] : packoffset(c0); }; RWByteAddressBuffer C3 : register(u0); cbuffer B : register(b3) { A C4_Data[1024] : packoffset(c0); }; static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { C1.Store(gl_GlobalInvocationID.x * 8 + 0, uint(C2_1_Data[gl_GlobalInvocationID.x].a)); C1.Store(gl_GlobalInvocationID.x * 8 + 4, uint(C2_1_Data[gl_GlobalInvocationID.x].b)); C3.Store(gl_GlobalInvocationID.x * 8 + 0, uint(C4_Data[gl_GlobalInvocationID.x].a)); C3.Store(gl_GlobalInvocationID.x * 8 + 4, uint(C4_Data[gl_GlobalInvocationID.x].b)); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/comp/control-flow-hints.asm.comp000066400000000000000000000024661400026215700304600ustar00rootroot00000000000000RWByteAddressBuffer bar : register(u0); RWByteAddressBuffer foo : register(u1); void comp_main() { bar.Store4(0, asuint(asfloat(foo.Load4(0)))); bar.Store4(16, asuint(asfloat(foo.Load4(16)))); bar.Store4(32, asuint(asfloat(foo.Load4(32)))); bar.Store4(48, asuint(asfloat(foo.Load4(48)))); bar.Store4(64, asuint(asfloat(foo.Load4(64)))); bar.Store4(80, asuint(asfloat(foo.Load4(80)))); bar.Store4(96, asuint(asfloat(foo.Load4(96)))); bar.Store4(112, asuint(asfloat(foo.Load4(112)))); bar.Store4(128, asuint(asfloat(foo.Load4(128)))); bar.Store4(144, asuint(asfloat(foo.Load4(144)))); bar.Store4(160, asuint(asfloat(foo.Load4(160)))); bar.Store4(176, asuint(asfloat(foo.Load4(176)))); bar.Store4(192, asuint(asfloat(foo.Load4(192)))); bar.Store4(208, asuint(asfloat(foo.Load4(208)))); bar.Store4(224, asuint(asfloat(foo.Load4(224)))); bar.Store4(240, asuint(asfloat(foo.Load4(240)))); [loop] for (int _137 = 0; _137 < 16; ) { bar.Store4((15 - _137) * 16 + 0, asuint(asfloat(foo.Load4(_137 * 16 + 0)))); _137++; continue; } [branch] if (asfloat(bar.Load(160)) > 10.0f) { foo.Store4(320, asuint(5.0f.xxxx)); } foo.Store4(320, asuint(20.0f.xxxx)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/comp/global-parameter-name-alias.asm.comp000066400000000000000000000001151400026215700321200ustar00rootroot00000000000000void comp_main() { } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/comp/nmin-max-clamp.asm.comp000066400000000000000000000157431400026215700275300ustar00rootroot00000000000000RWByteAddressBuffer _4 : register(u0); void comp_main() { _4.Store(0, asuint(isnan(asfloat(_4.Load(96))) ? asfloat(_4.Load(48)) : (isnan(asfloat(_4.Load(48))) ? asfloat(_4.Load(96)) : min(asfloat(_4.Load(48)), asfloat(_4.Load(96)))))); bool2 _146 = isnan(asfloat(_4.Load2(56))); bool2 _147 = isnan(asfloat(_4.Load2(104))); float2 _148 = min(asfloat(_4.Load2(56)), asfloat(_4.Load2(104))); float2 _149 = float2(_146.x ? asfloat(_4.Load2(104)).x : _148.x, _146.y ? asfloat(_4.Load2(104)).y : _148.y); _4.Store2(8, asuint(float2(_147.x ? asfloat(_4.Load2(56)).x : _149.x, _147.y ? asfloat(_4.Load2(56)).y : _149.y))); bool3 _151 = isnan(asfloat(_4.Load3(64))); bool3 _152 = isnan(asfloat(_4.Load3(112))); float3 _153 = min(asfloat(_4.Load3(64)), asfloat(_4.Load3(112))); float3 _154 = float3(_151.x ? asfloat(_4.Load3(112)).x : _153.x, _151.y ? asfloat(_4.Load3(112)).y : _153.y, _151.z ? asfloat(_4.Load3(112)).z : _153.z); _4.Store3(16, asuint(float3(_152.x ? asfloat(_4.Load3(64)).x : _154.x, _152.y ? asfloat(_4.Load3(64)).y : _154.y, _152.z ? asfloat(_4.Load3(64)).z : _154.z))); bool4 _156 = isnan(asfloat(_4.Load4(80))); bool4 _157 = isnan(asfloat(_4.Load4(128))); float4 _158 = min(asfloat(_4.Load4(80)), asfloat(_4.Load4(128))); float4 _159 = float4(_156.x ? asfloat(_4.Load4(128)).x : _158.x, _156.y ? asfloat(_4.Load4(128)).y : _158.y, _156.z ? asfloat(_4.Load4(128)).z : _158.z, _156.w ? asfloat(_4.Load4(128)).w : _158.w); _4.Store4(32, asuint(float4(_157.x ? asfloat(_4.Load4(80)).x : _159.x, _157.y ? asfloat(_4.Load4(80)).y : _159.y, _157.z ? asfloat(_4.Load4(80)).z : _159.z, _157.w ? asfloat(_4.Load4(80)).w : _159.w))); _4.Store(0, asuint(isnan(asfloat(_4.Load(96))) ? asfloat(_4.Load(48)) : (isnan(asfloat(_4.Load(48))) ? asfloat(_4.Load(96)) : max(asfloat(_4.Load(48)), asfloat(_4.Load(96)))))); bool2 _166 = isnan(asfloat(_4.Load2(56))); bool2 _167 = isnan(asfloat(_4.Load2(104))); float2 _168 = max(asfloat(_4.Load2(56)), asfloat(_4.Load2(104))); float2 _169 = float2(_166.x ? asfloat(_4.Load2(104)).x : _168.x, _166.y ? asfloat(_4.Load2(104)).y : _168.y); _4.Store2(8, asuint(float2(_167.x ? asfloat(_4.Load2(56)).x : _169.x, _167.y ? asfloat(_4.Load2(56)).y : _169.y))); bool3 _171 = isnan(asfloat(_4.Load3(64))); bool3 _172 = isnan(asfloat(_4.Load3(112))); float3 _173 = max(asfloat(_4.Load3(64)), asfloat(_4.Load3(112))); float3 _174 = float3(_171.x ? asfloat(_4.Load3(112)).x : _173.x, _171.y ? asfloat(_4.Load3(112)).y : _173.y, _171.z ? asfloat(_4.Load3(112)).z : _173.z); _4.Store3(16, asuint(float3(_172.x ? asfloat(_4.Load3(64)).x : _174.x, _172.y ? asfloat(_4.Load3(64)).y : _174.y, _172.z ? asfloat(_4.Load3(64)).z : _174.z))); bool4 _176 = isnan(asfloat(_4.Load4(80))); bool4 _177 = isnan(asfloat(_4.Load4(128))); float4 _178 = max(asfloat(_4.Load4(80)), asfloat(_4.Load4(128))); float4 _179 = float4(_176.x ? asfloat(_4.Load4(128)).x : _178.x, _176.y ? asfloat(_4.Load4(128)).y : _178.y, _176.z ? asfloat(_4.Load4(128)).z : _178.z, _176.w ? asfloat(_4.Load4(128)).w : _178.w); _4.Store4(32, asuint(float4(_177.x ? asfloat(_4.Load4(80)).x : _179.x, _177.y ? asfloat(_4.Load4(80)).y : _179.y, _177.z ? asfloat(_4.Load4(80)).z : _179.z, _177.w ? asfloat(_4.Load4(80)).w : _179.w))); float _180 = isnan(asfloat(_4.Load(48))) ? asfloat(_4.Load(0)) : (isnan(asfloat(_4.Load(0))) ? asfloat(_4.Load(48)) : max(asfloat(_4.Load(0)), asfloat(_4.Load(48)))); _4.Store(0, asuint(isnan(asfloat(_4.Load(96))) ? _180 : (isnan(_180) ? asfloat(_4.Load(96)) : min(_180, asfloat(_4.Load(96)))))); bool2 _193 = isnan(asfloat(_4.Load2(8))); bool2 _194 = isnan(asfloat(_4.Load2(56))); float2 _195 = max(asfloat(_4.Load2(8)), asfloat(_4.Load2(56))); float2 _196 = float2(_193.x ? asfloat(_4.Load2(56)).x : _195.x, _193.y ? asfloat(_4.Load2(56)).y : _195.y); float2 _191 = float2(_194.x ? asfloat(_4.Load2(8)).x : _196.x, _194.y ? asfloat(_4.Load2(8)).y : _196.y); bool2 _198 = isnan(_191); bool2 _199 = isnan(asfloat(_4.Load2(104))); float2 _200 = min(_191, asfloat(_4.Load2(104))); float2 _201 = float2(_198.x ? asfloat(_4.Load2(104)).x : _200.x, _198.y ? asfloat(_4.Load2(104)).y : _200.y); _4.Store2(8, asuint(float2(_199.x ? _191.x : _201.x, _199.y ? _191.y : _201.y))); bool3 _204 = isnan(asfloat(_4.Load3(16))); bool3 _205 = isnan(asfloat(_4.Load3(64))); float3 _206 = max(asfloat(_4.Load3(16)), asfloat(_4.Load3(64))); float3 _207 = float3(_204.x ? asfloat(_4.Load3(64)).x : _206.x, _204.y ? asfloat(_4.Load3(64)).y : _206.y, _204.z ? asfloat(_4.Load3(64)).z : _206.z); float3 _202 = float3(_205.x ? asfloat(_4.Load3(16)).x : _207.x, _205.y ? asfloat(_4.Load3(16)).y : _207.y, _205.z ? asfloat(_4.Load3(16)).z : _207.z); bool3 _209 = isnan(_202); bool3 _210 = isnan(asfloat(_4.Load3(112))); float3 _211 = min(_202, asfloat(_4.Load3(112))); float3 _212 = float3(_209.x ? asfloat(_4.Load3(112)).x : _211.x, _209.y ? asfloat(_4.Load3(112)).y : _211.y, _209.z ? asfloat(_4.Load3(112)).z : _211.z); _4.Store3(16, asuint(float3(_210.x ? _202.x : _212.x, _210.y ? _202.y : _212.y, _210.z ? _202.z : _212.z))); bool4 _215 = isnan(asfloat(_4.Load4(32))); bool4 _216 = isnan(asfloat(_4.Load4(80))); float4 _217 = max(asfloat(_4.Load4(32)), asfloat(_4.Load4(80))); float4 _218 = float4(_215.x ? asfloat(_4.Load4(80)).x : _217.x, _215.y ? asfloat(_4.Load4(80)).y : _217.y, _215.z ? asfloat(_4.Load4(80)).z : _217.z, _215.w ? asfloat(_4.Load4(80)).w : _217.w); float4 _213 = float4(_216.x ? asfloat(_4.Load4(32)).x : _218.x, _216.y ? asfloat(_4.Load4(32)).y : _218.y, _216.z ? asfloat(_4.Load4(32)).z : _218.z, _216.w ? asfloat(_4.Load4(32)).w : _218.w); bool4 _220 = isnan(_213); bool4 _221 = isnan(asfloat(_4.Load4(128))); float4 _222 = min(_213, asfloat(_4.Load4(128))); float4 _223 = float4(_220.x ? asfloat(_4.Load4(128)).x : _222.x, _220.y ? asfloat(_4.Load4(128)).y : _222.y, _220.z ? asfloat(_4.Load4(128)).z : _222.z, _220.w ? asfloat(_4.Load4(128)).w : _222.w); _4.Store4(32, asuint(float4(_221.x ? _213.x : _223.x, _221.y ? _213.y : _223.y, _221.z ? _213.z : _223.z, _221.w ? _213.w : _223.w))); for (int _139 = 0; _139 < 2; ) { bool2 _225 = isnan(asfloat(_4.Load2(56))); bool2 _226 = isnan(asfloat(_4.Load2(104))); float2 _227 = min(asfloat(_4.Load2(56)), asfloat(_4.Load2(104))); float2 _228 = float2(_225.x ? asfloat(_4.Load2(104)).x : _227.x, _225.y ? asfloat(_4.Load2(104)).y : _227.y); _4.Store2(8, asuint(float2(_226.x ? asfloat(_4.Load2(56)).x : _228.x, _226.y ? asfloat(_4.Load2(56)).y : _228.y))); float _229 = isnan(asfloat(_4.Load(56))) ? asfloat(_4.Load(0)) : (isnan(asfloat(_4.Load(0))) ? asfloat(_4.Load(56)) : max(asfloat(_4.Load(0)), asfloat(_4.Load(56)))); _4.Store(0, asuint(isnan(asfloat(_4.Load(60))) ? _229 : (isnan(_229) ? asfloat(_4.Load(60)) : min(_229, asfloat(_4.Load(60)))))); _139++; continue; } } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/000077500000000000000000000000001400026215700232225ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/cbuffer-stripped.asm.frag000066400000000000000000000006001400026215700301020ustar00rootroot00000000000000cbuffer _4_5 : register(b0) { column_major float2x4 _5_m0 : packoffset(c0); float4 _5_m1 : packoffset(c4); }; static float2 _3; struct SPIRV_Cross_Output { float2 _3 : SV_Target0; }; void frag_main() { _3 = mul(_5_m0, _5_m1); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output._3 = _3; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/combined-sampler-reuse.asm.frag000066400000000000000000000011011400026215700311750ustar00rootroot00000000000000Texture2D uTex : register(t1); SamplerState uSampler : register(s0); static float4 FragColor; static float2 vUV; struct SPIRV_Cross_Input { float2 vUV : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = uTex.Sample(uSampler, vUV); FragColor += uTex.Sample(uSampler, vUV, int2(1, 1)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/empty-struct.asm.frag000066400000000000000000000000671400026215700273250ustar00rootroot00000000000000void frag_main() { } void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/frem.asm.frag000066400000000000000000000007561400026215700256030ustar00rootroot00000000000000static float4 FragColor; static float4 vA; static float4 vB; struct SPIRV_Cross_Input { float4 vA : TEXCOORD0; float4 vB : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = fmod(vA, vB); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vA = stage_input.vA; vB = stage_input.vB; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/function-overload-alias.asm.frag000066400000000000000000000004441400026215700313710ustar00rootroot00000000000000static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = 10.0f.xxxx; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/image-extract-reuse.asm.frag000066400000000000000000000012561400026215700305210ustar00rootroot00000000000000Texture2D uTexture : register(t0); SamplerState _uTexture_sampler : register(s0); static int2 Size; struct SPIRV_Cross_Output { int2 Size : SV_Target0; }; uint2 spvTextureSize(Texture2D Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(Level, ret.x, ret.y, Param); return ret; } void frag_main() { uint _19_dummy_parameter; uint _20_dummy_parameter; Size = int2(spvTextureSize(uTexture, uint(0), _19_dummy_parameter)) + int2(spvTextureSize(uTexture, uint(1), _20_dummy_parameter)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.Size = Size; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/implicit-read-dep-phi.asm.frag000066400000000000000000000020341400026215700307100ustar00rootroot00000000000000Texture2D uImage : register(t0); SamplerState _uImage_sampler : register(s0); static float4 v0; static float4 FragColor; struct SPIRV_Cross_Input { float4 v0 : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { float phi; float4 _36; int _51; _51 = 0; phi = 1.0f; _36 = float4(1.0f, 2.0f, 1.0f, 2.0f); for (;;) { FragColor = _36; if (_51 < 4) { if (v0[_51] > 0.0f) { float2 _48 = phi.xx; _51++; phi += 2.0f; _36 = uImage.SampleLevel(_uImage_sampler, _48, 0.0f); continue; } else { break; } } else { break; } } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { v0 = stage_input.v0; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/inf-nan-constant.asm.frag000066400000000000000000000005421400026215700300200ustar00rootroot00000000000000static float3 FragColor; struct SPIRV_Cross_Output { float3 FragColor : SV_Target0; }; void frag_main() { FragColor = float3(asfloat(0x7f800000u), asfloat(0xff800000u), asfloat(0x7fc00000u)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/line-directive.line.asm.frag000066400000000000000000000033611400026215700304760ustar00rootroot00000000000000static float FragColor; static float vColor; struct SPIRV_Cross_Input { float vColor : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; #line 8 "test.frag" void frag_main() { #line 8 "test.frag" FragColor = 1.0f; #line 9 "test.frag" FragColor = 2.0f; #line 10 "test.frag" if (vColor < 0.0f) { #line 12 "test.frag" FragColor = 3.0f; } else { #line 16 "test.frag" FragColor = 4.0f; } #line 19 "test.frag" for (int _127 = 0; float(_127) < (40.0f + vColor); ) { #line 21 "test.frag" FragColor += 0.20000000298023223876953125f; #line 22 "test.frag" FragColor += 0.300000011920928955078125f; #line 19 "test.frag" _127 += (int(vColor) + 5); continue; } #line 25 "test.frag" switch (int(vColor)) { case 0: { #line 28 "test.frag" FragColor += 0.20000000298023223876953125f; #line 29 "test.frag" break; } case 1: { #line 32 "test.frag" FragColor += 0.4000000059604644775390625f; #line 33 "test.frag" break; } default: { #line 36 "test.frag" FragColor += 0.800000011920928955078125f; #line 37 "test.frag" break; } } for (;;) { #line 42 "test.frag" FragColor += (10.0f + vColor); #line 43 "test.frag" #line 42 "test.frag" #line 43 "test.frag" if (FragColor < 100.0f) { } else { break; } } #line 48 "test.frag" } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/lut-promotion-initializer.asm.frag000066400000000000000000000023001400026215700320060ustar00rootroot00000000000000static const float _46[16] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f }; static const float4 _76[4] = { 0.0f.xxxx, 1.0f.xxxx, 8.0f.xxxx, 5.0f.xxxx }; static const float4 _90[4] = { 20.0f.xxxx, 30.0f.xxxx, 50.0f.xxxx, 60.0f.xxxx }; static float FragColor; static int index; struct SPIRV_Cross_Input { nointerpolation int index : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { float4 foobar[4] = _76; float4 baz[4] = _76; FragColor = _46[index]; if (index < 10) { FragColor += _46[index ^ 1]; } else { FragColor += _46[index & 1]; } bool _99 = index > 30; if (_99) { FragColor += _76[index & 3].y; } else { FragColor += _76[index & 1].x; } if (_99) { foobar[1].z = 20.0f; } int _37 = index & 3; FragColor += foobar[_37].z; baz = _90; FragColor += baz[_37].z; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { index = stage_input.index; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } pack-and-unpack-uint2.fxconly.nofxc.sm60.asm.frag000066400000000000000000000012461400026215700341430ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/fragstatic float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; uint64_t spvPackUint2x32(uint2 value) { return (uint64_t(value.y) << 32) | uint64_t(value.x); } uint2 spvUnpackUint2x32(uint64_t value) { uint2 Unpacked; Unpacked.x = uint(value & 0xffffffff); Unpacked.y = uint(value >> 32); return Unpacked; } void frag_main() { uint2 unpacked = spvUnpackUint2x32(spvPackUint2x32(uint2(18u, 52u))); FragColor = float4(float(unpacked.x), float(unpacked.y), 1.0f, 1.0f); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/pass-by-value.asm.frag000066400000000000000000000005601400026215700273330ustar00rootroot00000000000000cbuffer Registers { float registers_foo : packoffset(c0); }; static float FragColor; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = 10.0f + registers_foo; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/sample-and-compare.asm.frag000066400000000000000000000013761400026215700303160ustar00rootroot00000000000000Texture2D g_Texture : register(t0); SamplerState g_Sampler : register(s0); SamplerComparisonState g_CompareSampler : register(s1); static float2 in_var_TEXCOORD0; static float out_var_SV_Target; struct SPIRV_Cross_Input { float2 in_var_TEXCOORD0 : TEXCOORD0; }; struct SPIRV_Cross_Output { float out_var_SV_Target : SV_Target0; }; void frag_main() { out_var_SV_Target = g_Texture.Sample(g_Sampler, in_var_TEXCOORD0).x + g_Texture.SampleCmpLevelZero(g_CompareSampler, in_var_TEXCOORD0, 0.5f); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { in_var_TEXCOORD0 = stage_input.in_var_TEXCOORD0; frag_main(); SPIRV_Cross_Output stage_output; stage_output.out_var_SV_Target = out_var_SV_Target; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/single-function-private-lut.asm.frag000066400000000000000000000021461400026215700322230ustar00rootroot00000000000000struct myType { float data; }; static const myType _18 = { 0.0f }; static const myType _20 = { 1.0f }; static const myType _21[5] = { { 0.0f }, { 1.0f }, { 0.0f }, { 1.0f }, { 0.0f } }; static float4 gl_FragCoord; static float4 o_color; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 o_color : SV_Target0; }; float mod(float x, float y) { return x - y * floor(x / y); } float2 mod(float2 x, float2 y) { return x - y * floor(x / y); } float3 mod(float3 x, float3 y) { return x - y * floor(x / y); } float4 mod(float4 x, float4 y) { return x - y * floor(x / y); } void frag_main() { if (_21[int(mod(gl_FragCoord.x, 4.0f))].data > 0.0f) { o_color = float4(0.0f, 1.0f, 0.0f, 1.0f); } else { o_color = float4(1.0f, 0.0f, 0.0f, 1.0f); } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.o_color = o_color; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/srem.asm.frag000066400000000000000000000010251400026215700256060ustar00rootroot00000000000000static float4 FragColor; static int4 vA; static int4 vB; struct SPIRV_Cross_Input { nointerpolation int4 vA : TEXCOORD0; nointerpolation int4 vB : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = float4(vA - vB * (vA / vB)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vA = stage_input.vA; vB = stage_input.vB; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/storage-class-output-initializer.asm.frag000066400000000000000000000007261400026215700332750ustar00rootroot00000000000000static const float4 _20[2] = { float4(1.0f, 2.0f, 3.0f, 4.0f), 10.0f.xxxx }; static float4 FragColors[2] = _20; static float4 FragColor = 5.0f.xxxx; struct SPIRV_Cross_Output { float4 FragColors[2] : SV_Target0; float4 FragColor : SV_Target2; }; void frag_main() { } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColors = FragColors; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/texel-fetch-no-lod.asm.frag000066400000000000000000000011711400026215700302400ustar00rootroot00000000000000Texture2D uTexture : register(t0); SamplerState _uTexture_sampler : register(s0); static float4 gl_FragCoord; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = uTexture.Load(int3(int2(gl_FragCoord.xy), 0)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/texture-sampling-fp16.asm.frag000066400000000000000000000010761400026215700307300ustar00rootroot00000000000000Texture2D uTexture : register(t0); SamplerState _uTexture_sampler : register(s0); static min16float4 FragColor; static min16float2 UV; struct SPIRV_Cross_Input { min16float2 UV : TEXCOORD0; }; struct SPIRV_Cross_Output { min16float4 FragColor : SV_Target0; }; void frag_main() { FragColor = min16float4(uTexture.Sample(_uTexture_sampler, UV)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { UV = stage_input.UV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/unknown-depth-state.asm.frag000066400000000000000000000012741400026215700305650ustar00rootroot00000000000000Texture2D uShadow : register(t0); SamplerComparisonState _uShadow_sampler : register(s0); Texture2D uTexture : register(t1); SamplerComparisonState uSampler : register(s2); static float3 vUV; static float FragColor; struct SPIRV_Cross_Input { float3 vUV : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = uShadow.SampleCmp(_uShadow_sampler, vUV.xy, vUV.z) + uTexture.SampleCmp(uSampler, vUV.xy, vUV.z); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/frag/unreachable.asm.frag000066400000000000000000000012301400026215700271070ustar00rootroot00000000000000static int counter; static float4 FragColor; struct SPIRV_Cross_Input { nointerpolation int counter : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { float4 _33; for (;;) { if (counter == 10) { _33 = 10.0f.xxxx; break; } else { _33 = 30.0f.xxxx; break; } } FragColor = _33; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { counter = stage_input.counter; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/vert/000077500000000000000000000000001400026215700232635ustar00rootroot00000000000000extract-transposed-matrix-from-struct.asm.vert000066400000000000000000000020501400026215700343010ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/vertstruct InstanceData { column_major float4x4 MATRIX_MVP; float4 Color; }; cbuffer gInstanceData : register(b0) { InstanceData gInstanceData_1_data[32] : packoffset(c0); }; static float4 gl_Position; static int gl_InstanceIndex; static float3 PosL; static float4 _entryPointOutput_Color; struct SPIRV_Cross_Input { float3 PosL : TEXCOORD0; uint gl_InstanceIndex : SV_InstanceID; }; struct SPIRV_Cross_Output { float4 _entryPointOutput_Color : TEXCOORD0; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = mul(float4(PosL, 1.0f), gInstanceData_1_data[uint(gl_InstanceIndex)].MATRIX_MVP); _entryPointOutput_Color = gInstanceData_1_data[uint(gl_InstanceIndex)].Color; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_InstanceIndex = int(stage_input.gl_InstanceIndex); PosL = stage_input.PosL; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output._entryPointOutput_Color = _entryPointOutput_Color; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/vert/spec-constant-op-composite.asm.vert000066400000000000000000000022051400026215700321400ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_201 #define SPIRV_CROSS_CONSTANT_ID_201 -10 #endif static const int _7 = SPIRV_CROSS_CONSTANT_ID_201; static const int _20 = (_7 + 2); #ifndef SPIRV_CROSS_CONSTANT_ID_202 #define SPIRV_CROSS_CONSTANT_ID_202 100u #endif static const uint _8 = SPIRV_CROSS_CONSTANT_ID_202; static const uint _25 = (_8 % 5u); #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 int4(20, 30, _20, _20) #endif static const int4 _30 = SPIRV_CROSS_CONSTANT_ID_0; static const int2 _32 = int2(_30.y, _30.x); static const int _33 = _30.y; static float4 gl_Position; static int _4; struct SPIRV_Cross_Output { nointerpolation int _4 : TEXCOORD0; float4 gl_Position : SV_Position; }; void vert_main() { float4 _63 = 0.0f.xxxx; _63.y = float(_20); float4 _66 = _63; _66.z = float(_25); float4 _52 = _66 + float4(_30); float2 _56 = _52.xy + float2(_32); gl_Position = float4(_56.x, _56.y, _52.z, _52.w); _4 = _33; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output._4 = _4; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/vert/uint-vertex-id-instance-id.asm.vert000066400000000000000000000012231400026215700320220ustar00rootroot00000000000000static float4 gl_Position; static int gl_VertexIndex; static int gl_InstanceIndex; struct SPIRV_Cross_Input { uint gl_VertexIndex : SV_VertexID; uint gl_InstanceIndex : SV_InstanceID; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = float(uint(gl_VertexIndex) + uint(gl_InstanceIndex)).xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_VertexIndex = int(stage_input.gl_VertexIndex); gl_InstanceIndex = int(stage_input.gl_InstanceIndex); vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/asm/vert/vertex-id-instance-id.asm.vert000066400000000000000000000012071400026215700310470ustar00rootroot00000000000000static float4 gl_Position; static int gl_VertexIndex; static int gl_InstanceIndex; struct SPIRV_Cross_Input { uint gl_VertexIndex : SV_VertexID; uint gl_InstanceIndex : SV_InstanceID; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = float(gl_VertexIndex + gl_InstanceIndex).xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_VertexIndex = int(stage_input.gl_VertexIndex); gl_InstanceIndex = int(stage_input.gl_InstanceIndex); vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/000077500000000000000000000000001400026215700224615ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/access-chain-load-composite.comp000066400000000000000000000070611400026215700306030ustar00rootroot00000000000000struct Baz { float c; }; struct Bar { float d[2][4]; Baz baz[2]; }; struct Foo { column_major float2x2 a; float2 b; Bar c[5]; }; static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _31 : register(u0); void comp_main() { Foo _36; _36.a = asfloat(uint2x2(_31.Load(0), _31.Load(8), _31.Load(4), _31.Load(12))); _36.b = asfloat(_31.Load2(16)); [unroll] for (int _4ident = 0; _4ident < 5; _4ident++) { [unroll] for (int _5ident = 0; _5ident < 2; _5ident++) { [unroll] for (int _6ident = 0; _6ident < 4; _6ident++) { _36.c[_4ident].d[_5ident][_6ident] = asfloat(_31.Load(_6ident * 4 + _5ident * 16 + _4ident * 40 + 24)); } } [unroll] for (int _7ident = 0; _7ident < 2; _7ident++) { _36.c[_4ident].baz[_7ident].c = asfloat(_31.Load(_7ident * 4 + _4ident * 40 + 56)); } } float2x2 _234 = float2x2(_36.a[0] + 1.0f.xx, _36.a[1] + 1.0f.xx); _31.Store(224, asuint(_234[0].x)); _31.Store(228, asuint(_234[1].x)); _31.Store(232, asuint(_234[0].y)); _31.Store(236, asuint(_234[1].y)); _31.Store2(240, asuint(_36.b + 2.0f.xx)); _31.Store(248, asuint(_36.c[0].d[0][0])); _31.Store(252, asuint(_36.c[0].d[0][1])); _31.Store(256, asuint(_36.c[0].d[0][2])); _31.Store(260, asuint(_36.c[0].d[0][3])); _31.Store(264, asuint(_36.c[0].d[1][0])); _31.Store(268, asuint(_36.c[0].d[1][1])); _31.Store(272, asuint(_36.c[0].d[1][2])); _31.Store(276, asuint(_36.c[0].d[1][3])); _31.Store(280, asuint(_36.c[0].baz[0].c)); _31.Store(284, asuint(_36.c[0].baz[1].c)); _31.Store(288, asuint(_36.c[1].d[0][0])); _31.Store(292, asuint(_36.c[1].d[0][1])); _31.Store(296, asuint(_36.c[1].d[0][2])); _31.Store(300, asuint(_36.c[1].d[0][3])); _31.Store(304, asuint(_36.c[1].d[1][0])); _31.Store(308, asuint(_36.c[1].d[1][1])); _31.Store(312, asuint(_36.c[1].d[1][2])); _31.Store(316, asuint(_36.c[1].d[1][3])); _31.Store(320, asuint(_36.c[1].baz[0].c)); _31.Store(324, asuint(_36.c[1].baz[1].c)); _31.Store(328, asuint(_36.c[2].d[0][0])); _31.Store(332, asuint(_36.c[2].d[0][1])); _31.Store(336, asuint(_36.c[2].d[0][2])); _31.Store(340, asuint(_36.c[2].d[0][3])); _31.Store(344, asuint(_36.c[2].d[1][0])); _31.Store(348, asuint(_36.c[2].d[1][1])); _31.Store(352, asuint(_36.c[2].d[1][2])); _31.Store(356, asuint(_36.c[2].d[1][3])); _31.Store(360, asuint(_36.c[2].baz[0].c)); _31.Store(364, asuint(_36.c[2].baz[1].c)); _31.Store(368, asuint(_36.c[3].d[0][0])); _31.Store(372, asuint(_36.c[3].d[0][1])); _31.Store(376, asuint(_36.c[3].d[0][2])); _31.Store(380, asuint(_36.c[3].d[0][3])); _31.Store(384, asuint(_36.c[3].d[1][0])); _31.Store(388, asuint(_36.c[3].d[1][1] + 5.0f)); _31.Store(392, asuint(_36.c[3].d[1][2])); _31.Store(396, asuint(_36.c[3].d[1][3])); _31.Store(400, asuint(_36.c[3].baz[0].c)); _31.Store(404, asuint(_36.c[3].baz[1].c)); _31.Store(408, asuint(_36.c[4].d[0][0])); _31.Store(412, asuint(_36.c[4].d[0][1])); _31.Store(416, asuint(_36.c[4].d[0][2])); _31.Store(420, asuint(_36.c[4].d[0][3])); _31.Store(424, asuint(_36.c[4].d[1][0])); _31.Store(428, asuint(_36.c[4].d[1][1])); _31.Store(432, asuint(_36.c[4].d[1][2])); _31.Store(436, asuint(_36.c[4].d[1][3])); _31.Store(440, asuint(_36.c[4].baz[0].c)); _31.Store(444, asuint(_36.c[4].baz[1].c)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/access-chains.comp000066400000000000000000000012161400026215700260450ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer wo : register(u1); ByteAddressBuffer ro : register(t0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { wo.Store4(gl_GlobalInvocationID.x * 64 + 272, asuint(asfloat(ro.Load4(gl_GlobalInvocationID.x * 64 + 160)))); wo.Store4(gl_GlobalInvocationID.x * 16 + 480, asuint(asfloat(ro.Load4(gl_GlobalInvocationID.x * 16 + 480)))); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/access-chains.force-uav.comp000066400000000000000000000012201400026215700277260ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer wo : register(u1); RWByteAddressBuffer ro : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { wo.Store4(gl_GlobalInvocationID.x * 64 + 272, asuint(asfloat(ro.Load4(gl_GlobalInvocationID.x * 64 + 160)))); wo.Store4(gl_GlobalInvocationID.x * 16 + 480, asuint(asfloat(ro.Load4(gl_GlobalInvocationID.x * 16 + 480)))); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/address-buffers.comp000066400000000000000000000006271400026215700264250ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer WriteOnly : register(u2); ByteAddressBuffer ReadOnly : register(t0); RWByteAddressBuffer ReadWrite : register(u1); void comp_main() { WriteOnly.Store4(0, asuint(asfloat(ReadOnly.Load4(0)))); ReadWrite.Store4(0, asuint(asfloat(ReadWrite.Load4(0)) + 10.0f.xxxx)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/atomic.comp000066400000000000000000000046611400026215700246240ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer ssbo : register(u2); RWTexture2D uImage : register(u0); RWTexture2D iImage : register(u1); groupshared int int_atomic; groupshared uint uint_atomic; groupshared int int_atomic_array[1]; groupshared uint uint_atomic_array[1]; void comp_main() { uint _19; InterlockedAdd(uImage[int2(1, 5)], 1u, _19); uint _27; InterlockedAdd(uImage[int2(1, 5)], 1u, _27); iImage[int2(1, 6)] = int(_27).x; uint _32; InterlockedOr(uImage[int2(1, 5)], 1u, _32); uint _34; InterlockedXor(uImage[int2(1, 5)], 1u, _34); uint _36; InterlockedAnd(uImage[int2(1, 5)], 1u, _36); uint _38; InterlockedMin(uImage[int2(1, 5)], 1u, _38); uint _40; InterlockedMax(uImage[int2(1, 5)], 1u, _40); uint _44; InterlockedCompareExchange(uImage[int2(1, 5)], 10u, 2u, _44); int _47; InterlockedAdd(iImage[int2(1, 6)], 1, _47); int _49; InterlockedOr(iImage[int2(1, 6)], 1, _49); int _51; InterlockedXor(iImage[int2(1, 6)], 1, _51); int _53; InterlockedAnd(iImage[int2(1, 6)], 1, _53); int _55; InterlockedMin(iImage[int2(1, 6)], 1, _55); int _57; InterlockedMax(iImage[int2(1, 6)], 1, _57); int _61; InterlockedCompareExchange(iImage[int2(1, 5)], 10, 2, _61); uint _68; ssbo.InterlockedAdd(0, 1u, _68); uint _70; ssbo.InterlockedOr(0, 1u, _70); uint _72; ssbo.InterlockedXor(0, 1u, _72); uint _74; ssbo.InterlockedAnd(0, 1u, _74); uint _76; ssbo.InterlockedMin(0, 1u, _76); uint _78; ssbo.InterlockedMax(0, 1u, _78); uint _80; ssbo.InterlockedExchange(0, 1u, _80); uint _82; ssbo.InterlockedCompareExchange(0, 10u, 2u, _82); int _85; ssbo.InterlockedAdd(4, 1, _85); int _87; ssbo.InterlockedOr(4, 1, _87); int _89; ssbo.InterlockedXor(4, 1, _89); int _91; ssbo.InterlockedAnd(4, 1, _91); int _93; ssbo.InterlockedMin(4, 1, _93); int _95; ssbo.InterlockedMax(4, 1, _95); int _97; ssbo.InterlockedExchange(4, 1, _97); int _99; ssbo.InterlockedCompareExchange(4, 10, 2, _99); int _102; InterlockedAdd(int_atomic, 10, _102); uint _105; InterlockedAdd(uint_atomic, 10u, _105); int _110; InterlockedAdd(int_atomic_array[0], 10, _110); uint _115; InterlockedAdd(uint_atomic_array[0], 10u, _115); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/barriers.comp000066400000000000000000000011271400026215700251530ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(4u, 1u, 1u); void comp_main() { GroupMemoryBarrier(); AllMemoryBarrier(); DeviceMemoryBarrier(); DeviceMemoryBarrier(); AllMemoryBarrier(); GroupMemoryBarrierWithGroupSync(); AllMemoryBarrier(); GroupMemoryBarrierWithGroupSync(); DeviceMemoryBarrier(); GroupMemoryBarrierWithGroupSync(); DeviceMemoryBarrier(); GroupMemoryBarrierWithGroupSync(); AllMemoryBarrier(); GroupMemoryBarrierWithGroupSync(); GroupMemoryBarrierWithGroupSync(); } [numthreads(4, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/builtins.comp000066400000000000000000000002071400026215700251710ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(8u, 4u, 2u); void comp_main() { } [numthreads(8, 4, 2)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/composite-array-initialization.comp000066400000000000000000000025511400026215700315070ustar00rootroot00000000000000struct Data { float a; float b; }; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 4.0f #endif static const float X = SPIRV_CROSS_CONSTANT_ID_0; static const uint3 gl_WorkGroupSize = uint3(2u, 1u, 1u); static const Data _21 = { 1.0f, 2.0f }; static const Data _24 = { 3.0f, 4.0f }; static const Data _25[2] = { { 1.0f, 2.0f }, { 3.0f, 4.0f } }; static const Data _30 = { 3.0f, 5.0f }; RWByteAddressBuffer _61 : register(u0); static uint3 gl_WorkGroupID; static uint3 gl_LocalInvocationID; static uint gl_LocalInvocationIndex; struct SPIRV_Cross_Input { uint3 gl_WorkGroupID : SV_GroupID; uint3 gl_LocalInvocationID : SV_GroupThreadID; uint gl_LocalInvocationIndex : SV_GroupIndex; }; void comp_main() { Data _28 = { X, 2.0f }; Data _31[2] = { _28, _30 }; Data data2[2] = _31; if (gl_LocalInvocationIndex == 0u) { _61.Store(gl_WorkGroupID.x * 8 + 0, asuint(_25[gl_LocalInvocationID.x].a + data2[gl_LocalInvocationID.x].a)); _61.Store(gl_WorkGroupID.x * 8 + 4, asuint(_25[gl_LocalInvocationID.x].b + data2[gl_LocalInvocationID.x].b)); } } [numthreads(2, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_WorkGroupID = stage_input.gl_WorkGroupID; gl_LocalInvocationID = stage_input.gl_LocalInvocationID; gl_LocalInvocationIndex = stage_input.gl_LocalInvocationIndex; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/globallycoherent.comp000066400000000000000000000006651400026215700267050ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); globallycoherent RWByteAddressBuffer _29 : register(u3); ByteAddressBuffer _33 : register(t2); RWTexture2D uImageIn : register(u0); globallycoherent RWTexture2D uImageOut : register(u1); void comp_main() { uImageOut[int2(9, 7)] = uImageIn[int2(9, 7)].x; _29.Store(0, asuint(asfloat(_33.Load(0)))); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/image.comp000066400000000000000000000045461400026215700244340ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWTexture2D uImageInF : register(u0); RWTexture2D uImageOutF : register(u1); RWTexture2D uImageInI : register(u2); RWTexture2D uImageOutI : register(u3); RWTexture2D uImageInU : register(u4); RWTexture2D uImageOutU : register(u5); RWBuffer uImageInBuffer : register(u6); RWBuffer uImageOutBuffer : register(u7); RWTexture2D uImageInF2 : register(u8); RWTexture2D uImageOutF2 : register(u9); RWTexture2D uImageInI2 : register(u10); RWTexture2D uImageOutI2 : register(u11); RWTexture2D uImageInU2 : register(u12); RWTexture2D uImageOutU2 : register(u13); RWBuffer uImageInBuffer2 : register(u14); RWBuffer uImageOutBuffer2 : register(u15); RWTexture2D uImageInF4 : register(u16); RWTexture2D uImageOutF4 : register(u17); RWTexture2D uImageInI4 : register(u18); RWTexture2D uImageOutI4 : register(u19); RWTexture2D uImageInU4 : register(u20); RWTexture2D uImageOutU4 : register(u21); RWBuffer uImageInBuffer4 : register(u22); RWBuffer uImageOutBuffer4 : register(u23); RWTexture2D uImageNoFmtF : register(u24); RWTexture2D uImageNoFmtU : register(u25); RWTexture2D uImageNoFmtI : register(u26); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { int2 _23 = int2(gl_GlobalInvocationID.xy); uImageOutF[_23] = uImageInF[_23].x; uImageOutI[_23] = uImageInI[_23].x; uImageOutU[_23] = uImageInU[_23].x; int _74 = int(gl_GlobalInvocationID.x); uImageOutBuffer[_74] = uImageInBuffer[_74].x; uImageOutF2[_23] = uImageInF2[_23].xy; uImageOutI2[_23] = uImageInI2[_23].xy; uImageOutU2[_23] = uImageInU2[_23].xy; float4 _135 = uImageInBuffer2[_74].xyyy; uImageOutBuffer2[_74] = _135.xy; uImageOutF4[_23] = uImageInF4[_23]; int4 _165 = uImageInI4[_23]; uImageOutI4[_23] = _165; uint4 _180 = uImageInU4[_23]; uImageOutU4[_23] = _180; uImageOutBuffer4[_74] = uImageInBuffer4[_74]; uImageNoFmtF[_23] = _135; uImageNoFmtU[_23] = _180; uImageNoFmtI[_23] = _165; } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/image.nonwritable-uav-texture.comp000066400000000000000000000045151400026215700312420ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); Texture2D uImageInF : register(t0); RWTexture2D uImageOutF : register(u1); Texture2D uImageInI : register(t2); RWTexture2D uImageOutI : register(u3); Texture2D uImageInU : register(t4); RWTexture2D uImageOutU : register(u5); Buffer uImageInBuffer : register(t6); RWBuffer uImageOutBuffer : register(u7); Texture2D uImageInF2 : register(t8); RWTexture2D uImageOutF2 : register(u9); Texture2D uImageInI2 : register(t10); RWTexture2D uImageOutI2 : register(u11); Texture2D uImageInU2 : register(t12); RWTexture2D uImageOutU2 : register(u13); Buffer uImageInBuffer2 : register(t14); RWBuffer uImageOutBuffer2 : register(u15); Texture2D uImageInF4 : register(t16); RWTexture2D uImageOutF4 : register(u17); Texture2D uImageInI4 : register(t18); RWTexture2D uImageOutI4 : register(u19); Texture2D uImageInU4 : register(t20); RWTexture2D uImageOutU4 : register(u21); Buffer uImageInBuffer4 : register(t22); RWBuffer uImageOutBuffer4 : register(u23); RWTexture2D uImageNoFmtF : register(u24); RWTexture2D uImageNoFmtU : register(u25); RWTexture2D uImageNoFmtI : register(u26); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { int2 _23 = int2(gl_GlobalInvocationID.xy); uImageOutF[_23] = uImageInF[_23].x; uImageOutI[_23] = uImageInI[_23].x; uImageOutU[_23] = uImageInU[_23].x; int _74 = int(gl_GlobalInvocationID.x); uImageOutBuffer[_74] = uImageInBuffer[_74].x; uImageOutF2[_23] = uImageInF2[_23].xy; uImageOutI2[_23] = uImageInI2[_23].xy; uImageOutU2[_23] = uImageInU2[_23].xy; float4 _135 = uImageInBuffer2[_74]; uImageOutBuffer2[_74] = _135.xy; uImageOutF4[_23] = uImageInF4[_23]; int4 _165 = uImageInI4[_23]; uImageOutI4[_23] = _165; uint4 _180 = uImageInU4[_23]; uImageOutU4[_23] = _180; uImageOutBuffer4[_74] = uImageInBuffer4[_74]; uImageNoFmtF[_23] = _135; uImageNoFmtU[_23] = _180; uImageNoFmtI[_23] = _165; } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/inverse.comp000066400000000000000000000135051400026215700250200ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _15 : register(u0); ByteAddressBuffer _20 : register(t1); // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. float2x2 spvInverse(float2x2 m) { float2x2 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = m[1][1]; adj[0][1] = -m[0][1]; adj[1][0] = -m[1][0]; adj[1][1] = m[0][0]; // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the determinant of a 2x2 matrix. float spvDet2x2(float a1, float a2, float b1, float b2) { return a1 * b2 - b1 * a2; } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. float3x3 spvInverse(float3x3 m) { float3x3 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]); adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]); adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]); adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]); adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]); adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]); adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]); adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]); adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the determinant of a 3x3 matrix. float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) { return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3); } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. float4x4 spvInverse(float4x4 m) { float4x4 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]); adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]); adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]); adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]); adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]); adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]); adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]); adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] * m[3][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } void comp_main() { float2x2 _23 = asfloat(uint2x2(_20.Load2(0), _20.Load2(8))); float2x2 _24 = spvInverse(_23); _15.Store2(0, asuint(_24[0])); _15.Store2(8, asuint(_24[1])); float3x3 _29 = asfloat(uint3x3(_20.Load3(16), _20.Load3(32), _20.Load3(48))); float3x3 _30 = spvInverse(_29); _15.Store3(16, asuint(_30[0])); _15.Store3(32, asuint(_30[1])); _15.Store3(48, asuint(_30[2])); float4x4 _35 = asfloat(uint4x4(_20.Load4(64), _20.Load4(80), _20.Load4(96), _20.Load4(112))); float4x4 _36 = spvInverse(_35); _15.Store4(64, asuint(_36[0])); _15.Store4(80, asuint(_36[1])); _15.Store4(96, asuint(_36[2])); _15.Store4(112, asuint(_36[3])); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/num-workgroups-alone.comp000066400000000000000000000005331400026215700274550ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _10 : register(u0); cbuffer SPIRV_Cross_NumWorkgroups : register(b0) { uint3 SPIRV_Cross_NumWorkgroups_1_count : packoffset(c0); }; void comp_main() { _10.Store3(0, SPIRV_Cross_NumWorkgroups_1_count); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/num-workgroups-with-builtins.comp000066400000000000000000000010351400026215700311570ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _10 : register(u0); cbuffer SPIRV_Cross_NumWorkgroups : register(b0) { uint3 SPIRV_Cross_NumWorkgroups_1_count : packoffset(c0); }; static uint3 gl_WorkGroupID; struct SPIRV_Cross_Input { uint3 gl_WorkGroupID : SV_GroupID; }; void comp_main() { _10.Store3(0, SPIRV_Cross_NumWorkgroups_1_count + gl_WorkGroupID); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_WorkGroupID = stage_input.gl_WorkGroupID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/outer-product.comp000066400000000000000000000054111400026215700261560ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _21 : register(u0); ByteAddressBuffer _26 : register(t1); void comp_main() { float2x2 _32 = float2x2(asfloat(_26.Load2(0)) * asfloat(_26.Load2(0)).x, asfloat(_26.Load2(0)) * asfloat(_26.Load2(0)).y); _21.Store2(0, asuint(_32[0])); _21.Store2(8, asuint(_32[1])); float2x3 _41 = float2x3(asfloat(_26.Load3(16)) * asfloat(_26.Load2(0)).x, asfloat(_26.Load3(16)) * asfloat(_26.Load2(0)).y); _21.Store3(16, asuint(_41[0])); _21.Store3(32, asuint(_41[1])); float2x4 _50 = float2x4(asfloat(_26.Load4(32)) * asfloat(_26.Load2(0)).x, asfloat(_26.Load4(32)) * asfloat(_26.Load2(0)).y); _21.Store4(48, asuint(_50[0])); _21.Store4(64, asuint(_50[1])); float3x2 _58 = float3x2(asfloat(_26.Load2(0)) * asfloat(_26.Load3(16)).x, asfloat(_26.Load2(0)) * asfloat(_26.Load3(16)).y, asfloat(_26.Load2(0)) * asfloat(_26.Load3(16)).z); _21.Store2(80, asuint(_58[0])); _21.Store2(88, asuint(_58[1])); _21.Store2(96, asuint(_58[2])); float3x3 _66 = float3x3(asfloat(_26.Load3(16)) * asfloat(_26.Load3(16)).x, asfloat(_26.Load3(16)) * asfloat(_26.Load3(16)).y, asfloat(_26.Load3(16)) * asfloat(_26.Load3(16)).z); _21.Store3(112, asuint(_66[0])); _21.Store3(128, asuint(_66[1])); _21.Store3(144, asuint(_66[2])); float3x4 _74 = float3x4(asfloat(_26.Load4(32)) * asfloat(_26.Load3(16)).x, asfloat(_26.Load4(32)) * asfloat(_26.Load3(16)).y, asfloat(_26.Load4(32)) * asfloat(_26.Load3(16)).z); _21.Store4(160, asuint(_74[0])); _21.Store4(176, asuint(_74[1])); _21.Store4(192, asuint(_74[2])); float4x2 _82 = float4x2(asfloat(_26.Load2(0)) * asfloat(_26.Load4(32)).x, asfloat(_26.Load2(0)) * asfloat(_26.Load4(32)).y, asfloat(_26.Load2(0)) * asfloat(_26.Load4(32)).z, asfloat(_26.Load2(0)) * asfloat(_26.Load4(32)).w); _21.Store2(208, asuint(_82[0])); _21.Store2(216, asuint(_82[1])); _21.Store2(224, asuint(_82[2])); _21.Store2(232, asuint(_82[3])); float4x3 _90 = float4x3(asfloat(_26.Load3(16)) * asfloat(_26.Load4(32)).x, asfloat(_26.Load3(16)) * asfloat(_26.Load4(32)).y, asfloat(_26.Load3(16)) * asfloat(_26.Load4(32)).z, asfloat(_26.Load3(16)) * asfloat(_26.Load4(32)).w); _21.Store3(240, asuint(_90[0])); _21.Store3(256, asuint(_90[1])); _21.Store3(272, asuint(_90[2])); _21.Store3(288, asuint(_90[3])); float4x4 _98 = float4x4(asfloat(_26.Load4(32)) * asfloat(_26.Load4(32)).x, asfloat(_26.Load4(32)) * asfloat(_26.Load4(32)).y, asfloat(_26.Load4(32)) * asfloat(_26.Load4(32)).z, asfloat(_26.Load4(32)) * asfloat(_26.Load4(32)).w); _21.Store4(304, asuint(_98[0])); _21.Store4(320, asuint(_98[1])); _21.Store4(336, asuint(_98[2])); _21.Store4(352, asuint(_98[3])); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/rmw-matrix.comp000066400000000000000000000012761400026215700254560ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _11 : register(u0); void comp_main() { _11.Store(0, asuint(asfloat(_11.Load(0)) * asfloat(_11.Load(96)))); _11.Store4(16, asuint(asfloat(_11.Load4(16)) * asfloat(_11.Load4(112)))); float4x4 _35 = asfloat(uint4x4(_11.Load4(128), _11.Load4(144), _11.Load4(160), _11.Load4(176))); float4x4 _37 = asfloat(uint4x4(_11.Load4(32), _11.Load4(48), _11.Load4(64), _11.Load4(80))); float4x4 _38 = mul(_35, _37); _11.Store4(32, asuint(_38[0])); _11.Store4(48, asuint(_38[1])); _11.Store4(64, asuint(_38[2])); _11.Store4(80, asuint(_38[3])); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/rwbuffer-matrix.comp000066400000000000000000000102441400026215700264660ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _28 : register(u0); cbuffer UBO : register(b1) { int _68_index0 : packoffset(c0); int _68_index1 : packoffset(c0.y); }; void comp_main() { float4x4 _258 = asfloat(uint4x4(_28.Load(64), _28.Load(80), _28.Load(96), _28.Load(112), _28.Load(68), _28.Load(84), _28.Load(100), _28.Load(116), _28.Load(72), _28.Load(88), _28.Load(104), _28.Load(120), _28.Load(76), _28.Load(92), _28.Load(108), _28.Load(124))); _28.Store4(0, asuint(_258[0])); _28.Store4(16, asuint(_258[1])); _28.Store4(32, asuint(_258[2])); _28.Store4(48, asuint(_258[3])); float2x2 _261 = asfloat(uint2x2(_28.Load(144), _28.Load(152), _28.Load(148), _28.Load(156))); _28.Store2(128, asuint(_261[0])); _28.Store2(136, asuint(_261[1])); float2x3 _264 = asfloat(uint2x3(_28.Load(192), _28.Load(200), _28.Load(208), _28.Load(196), _28.Load(204), _28.Load(212))); _28.Store3(160, asuint(_264[0])); _28.Store3(176, asuint(_264[1])); float3x2 _267 = asfloat(uint3x2(_28.Load(240), _28.Load(256), _28.Load(244), _28.Load(260), _28.Load(248), _28.Load(264))); _28.Store2(216, asuint(_267[0])); _28.Store2(224, asuint(_267[1])); _28.Store2(232, asuint(_267[2])); float4x4 _271 = asfloat(uint4x4(_28.Load4(0), _28.Load4(16), _28.Load4(32), _28.Load4(48))); _28.Store(64, asuint(_271[0].x)); _28.Store(68, asuint(_271[1].x)); _28.Store(72, asuint(_271[2].x)); _28.Store(76, asuint(_271[3].x)); _28.Store(80, asuint(_271[0].y)); _28.Store(84, asuint(_271[1].y)); _28.Store(88, asuint(_271[2].y)); _28.Store(92, asuint(_271[3].y)); _28.Store(96, asuint(_271[0].z)); _28.Store(100, asuint(_271[1].z)); _28.Store(104, asuint(_271[2].z)); _28.Store(108, asuint(_271[3].z)); _28.Store(112, asuint(_271[0].w)); _28.Store(116, asuint(_271[1].w)); _28.Store(120, asuint(_271[2].w)); _28.Store(124, asuint(_271[3].w)); float2x2 _274 = asfloat(uint2x2(_28.Load2(128), _28.Load2(136))); _28.Store(144, asuint(_274[0].x)); _28.Store(148, asuint(_274[1].x)); _28.Store(152, asuint(_274[0].y)); _28.Store(156, asuint(_274[1].y)); float2x3 _277 = asfloat(uint2x3(_28.Load3(160), _28.Load3(176))); _28.Store(192, asuint(_277[0].x)); _28.Store(196, asuint(_277[1].x)); _28.Store(200, asuint(_277[0].y)); _28.Store(204, asuint(_277[1].y)); _28.Store(208, asuint(_277[0].z)); _28.Store(212, asuint(_277[1].z)); float3x2 _280 = asfloat(uint3x2(_28.Load2(216), _28.Load2(224), _28.Load2(232))); _28.Store(240, asuint(_280[0].x)); _28.Store(244, asuint(_280[1].x)); _28.Store(248, asuint(_280[2].x)); _28.Store(256, asuint(_280[0].y)); _28.Store(260, asuint(_280[1].y)); _28.Store(264, asuint(_280[2].y)); _28.Store(_68_index0 * 4 + _68_index1 * 16 + 64, asuint(1.0f)); _28.Store(_68_index0 * 4 + _68_index1 * 8 + 144, asuint(2.0f)); _28.Store(_68_index0 * 4 + _68_index1 * 8 + 192, asuint(3.0f)); _28.Store(_68_index0 * 4 + _68_index1 * 16 + 240, asuint(4.0f)); _28.Store(_68_index0 * 4 + 64, asuint(1.0f.x)); _28.Store(_68_index0 * 4 + 80, asuint(1.0f.xxxx.y)); _28.Store(_68_index0 * 4 + 96, asuint(1.0f.xxxx.z)); _28.Store(_68_index0 * 4 + 112, asuint(1.0f.xxxx.w)); _28.Store(_68_index0 * 4 + 144, asuint(2.0f.x)); _28.Store(_68_index0 * 4 + 152, asuint(2.0f.xx.y)); _28.Store(_68_index0 * 4 + 192, asuint(3.0f.x)); _28.Store(_68_index0 * 4 + 200, asuint(3.0f.xxx.y)); _28.Store(_68_index0 * 4 + 208, asuint(3.0f.xxx.z)); _28.Store(_68_index0 * 4 + 240, asuint(4.0f.x)); _28.Store(_68_index0 * 4 + 256, asuint(4.0f.xx.y)); _28.Store(_68_index0 * 16 + _68_index1 * 4 + 0, asuint(1.0f)); _28.Store(_68_index0 * 8 + _68_index1 * 4 + 128, asuint(2.0f)); _28.Store(_68_index0 * 16 + _68_index1 * 4 + 160, asuint(3.0f)); _28.Store(_68_index0 * 8 + _68_index1 * 4 + 216, asuint(4.0f)); _28.Store4(_68_index0 * 16 + 0, asuint(1.0f.xxxx)); _28.Store2(_68_index0 * 8 + 128, asuint(2.0f.xx)); _28.Store3(_68_index0 * 16 + 160, asuint(3.0f.xxx)); _28.Store2(_68_index0 * 8 + 216, asuint(4.0f.xx)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/scalar-std450-distance-length-normalize.comp000066400000000000000000000005501400026215700326740ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _9 : register(u0); void comp_main() { _9.Store(8, asuint(distance(asfloat(_9.Load(0)), asfloat(_9.Load(4))))); _9.Store(12, asuint(length(asfloat(_9.Load(0))))); _9.Store(16, asuint(sign(asfloat(_9.Load(0))))); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/shared.comp000066400000000000000000000015061400026215700246110ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(4u, 1u, 1u); ByteAddressBuffer _22 : register(t0); RWByteAddressBuffer _44 : register(u1); static uint3 gl_GlobalInvocationID; static uint gl_LocalInvocationIndex; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; uint gl_LocalInvocationIndex : SV_GroupIndex; }; groupshared float sShared[4]; void comp_main() { sShared[gl_LocalInvocationIndex] = asfloat(_22.Load(gl_GlobalInvocationID.x * 4 + 0)); GroupMemoryBarrierWithGroupSync(); _44.Store(gl_GlobalInvocationID.x * 4 + 0, asuint(sShared[3u - gl_LocalInvocationIndex])); } [numthreads(4, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; gl_LocalInvocationIndex = stage_input.gl_LocalInvocationIndex; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/spec-constant-op-member-array.comp000066400000000000000000000022661400026215700311250ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 100 #endif static const int a = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 200 #endif static const int b = SPIRV_CROSS_CONSTANT_ID_1; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 300 #endif static const int c = SPIRV_CROSS_CONSTANT_ID_2; static const int d = (c + 50); #ifndef SPIRV_CROSS_CONSTANT_ID_3 #define SPIRV_CROSS_CONSTANT_ID_3 400 #endif static const int e = SPIRV_CROSS_CONSTANT_ID_3; static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _22 : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { _22.Store(gl_GlobalInvocationID.x * 4 + 2800, uint(int(_22.Load(gl_GlobalInvocationID.x * 4 + 2800)) + (int(_22.Load(gl_GlobalInvocationID.x * 4 + 2400)) + e))); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/spec-constant-work-group-size.comp000066400000000000000000000023621400026215700312070ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 2 #endif static const int b = SPIRV_CROSS_CONSTANT_ID_1; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 1 #endif static const int a = SPIRV_CROSS_CONSTANT_ID_0; static const uint _26 = (uint(a) + 0u); #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 1u #endif static const uint _27 = SPIRV_CROSS_CONSTANT_ID_10; static const uint3 gl_WorkGroupSize = uint3(_27, 20u, 1u); static const uint _32 = gl_WorkGroupSize.x; static const uint _33 = (_26 + _32); static const uint _34 = gl_WorkGroupSize.y; static const uint _35 = (_33 + _34); static const int _42 = (1 - a); RWByteAddressBuffer _23 : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { int spec_const_array_size[b]; spec_const_array_size[0] = 10; spec_const_array_size[1] = 40; spec_const_array_size[a] = a; _23.Store((_35 + gl_GlobalInvocationID.x) * 4 + 0, uint(b + spec_const_array_size[_42])); } [numthreads(SPIRV_CROSS_CONSTANT_ID_10, 20, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/ssbo-array-length.comp000066400000000000000000000004271400026215700267050ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _11 : register(u1); void comp_main() { uint _14; _11.GetDimensions(_14); _14 = (_14 - 16) / 16; _11.Store(0, uint(int(_14))); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/comp/ssbo-array.comp000066400000000000000000000002071400026215700254220ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); void comp_main() { } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/000077500000000000000000000000001400026215700224425ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/array-lut-no-loop-variable.frag000066400000000000000000000011321400026215700303640ustar00rootroot00000000000000static const float _17[5] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; static float4 FragColor; static float4 v0; struct SPIRV_Cross_Input { float4 v0 : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { for (int _46 = 0; _46 < 4; ) { int _33 = _46 + 1; FragColor += _17[_33].xxxx; _46 = _33; continue; } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { v0 = stage_input.v0; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/basic-color-3comp.sm30.frag000066400000000000000000000006771400026215700273120ustar00rootroot00000000000000static float3 FragColor; static float4 vColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : COLOR0; }; void frag_main() { FragColor = vColor.xyz; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = float4(FragColor, 0.0); return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/basic-color-3comp.sm50.frag000066400000000000000000000006661400026215700273120ustar00rootroot00000000000000static float3 FragColor; static float4 vColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; }; struct SPIRV_Cross_Output { float3 FragColor : SV_Target0; }; void frag_main() { FragColor = vColor.xyz; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/basic.frag000066400000000000000000000011661400026215700243700ustar00rootroot00000000000000Texture2D uTex : register(t0); SamplerState _uTex_sampler : register(s0); static float4 FragColor; static float4 vColor; static float2 vTex; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; float2 vTex : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = vColor * uTex.Sample(_uTex_sampler, vTex); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; vTex = stage_input.vTex; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/bit-conversions.frag000066400000000000000000000007311400026215700264300ustar00rootroot00000000000000static float2 value; static float4 FragColor; struct SPIRV_Cross_Input { float2 value : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = float4(1.0f, 0.0f, asfloat(asint(value.x)), 1.0f); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { value = stage_input.value; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/boolean-mix.frag000066400000000000000000000010561400026215700255170ustar00rootroot00000000000000static float2 FragColor; static float2 x0; struct SPIRV_Cross_Input { float2 x0 : TEXCOORD0; }; struct SPIRV_Cross_Output { float2 FragColor : SV_Target0; }; void frag_main() { bool2 _27 = (x0.x > x0.y).xx; FragColor = float2(_27.x ? float2(1.0f, 0.0f).x : float2(0.0f, 1.0f).x, _27.y ? float2(1.0f, 0.0f).y : float2(0.0f, 1.0f).y); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { x0 = stage_input.x0; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/builtins.frag000066400000000000000000000013411400026215700251330ustar00rootroot00000000000000static float4 gl_FragCoord; static float gl_FragDepth; static float4 FragColor; static float4 vColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; float gl_FragDepth : SV_Depth; }; void frag_main() { FragColor = gl_FragCoord + vColor; gl_FragDepth = 0.5f; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_FragDepth = gl_FragDepth; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/bvec-operations.frag000066400000000000000000000011531400026215700264030ustar00rootroot00000000000000static float2 value; static float4 FragColor; struct SPIRV_Cross_Input { float2 value : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; static bool _47; void frag_main() { bool2 _25 = bool2(value.x == 0.0f, _47); FragColor = float4(1.0f, 0.0f, float(bool2(!_25.x, !_25.y).x), float(bool2(value.x <= float2(1.5f, 0.5f).x, value.y <= float2(1.5f, 0.5f).y).x)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { value = stage_input.value; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/clip-cull-distance.frag000066400000000000000000000013361400026215700267620ustar00rootroot00000000000000static float gl_ClipDistance[2]; static float gl_CullDistance[1]; static float FragColor; struct SPIRV_Cross_Input { float2 gl_ClipDistance0 : SV_ClipDistance0; float gl_CullDistance0 : SV_CullDistance0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = (gl_ClipDistance[0] + gl_CullDistance[0]) + gl_ClipDistance[1]; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_ClipDistance[0] = stage_input.gl_ClipDistance0.x; gl_ClipDistance[1] = stage_input.gl_ClipDistance0.y; gl_CullDistance[0] = stage_input.gl_CullDistance0.x; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/combined-texture-sampler-parameter.frag000066400000000000000000000012001400026215700321710ustar00rootroot00000000000000Texture2D uSampler : register(t0); SamplerState _uSampler_sampler : register(s0); Texture2D uSamplerShadow : register(t1); SamplerComparisonState _uSamplerShadow_sampler : register(s1); static float FragColor; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = (uSampler.Sample(_uSampler_sampler, 1.0f.xx) + uSampler.Load(int3(int2(10, 10), 0))).x + uSamplerShadow.SampleCmp(_uSamplerShadow_sampler, 1.0f.xxx.xy, 1.0f); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/combined-texture-sampler-shadow.frag000066400000000000000000000007541400026215700315130ustar00rootroot00000000000000Texture2D uDepth : register(t2); SamplerComparisonState uSampler : register(s0); SamplerState uSampler1 : register(s1); static float FragColor; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = uDepth.SampleCmp(uSampler, 1.0f.xxx.xy, 1.0f) + uDepth.Sample(uSampler1, 1.0f.xx).x; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/complex-expression-in-access-chain.frag000066400000000000000000000017251400026215700320770ustar00rootroot00000000000000RWByteAddressBuffer _34 : register(u0); Texture2D Buf : register(t1); SamplerState _Buf_sampler : register(s1); static float4 gl_FragCoord; static int vIn; static int vIn2; static float4 FragColor; struct SPIRV_Cross_Input { nointerpolation int vIn : TEXCOORD0; nointerpolation int vIn2 : TEXCOORD1; float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int _40 = Buf.Load(int3(int2(gl_FragCoord.xy), 0)).x % 16; FragColor = (asfloat(_34.Load4(_40 * 16 + 0)) + asfloat(_34.Load4(_40 * 16 + 0))) + asfloat(_34.Load4(((vIn * vIn) + (vIn2 * vIn2)) * 16 + 0)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; vIn = stage_input.vIn; vIn2 = stage_input.vIn2; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/constant-composites.frag000066400000000000000000000013621400026215700273210ustar00rootroot00000000000000struct Foo { float a; float b; }; static const float _16[4] = { 1.0f, 4.0f, 3.0f, 2.0f }; static const Foo _24 = { 10.0f, 20.0f }; static const Foo _27 = { 30.0f, 40.0f }; static const Foo _28[2] = { { 10.0f, 20.0f }, { 30.0f, 40.0f } }; static float4 FragColor; static int _line; struct SPIRV_Cross_Input { nointerpolation int _line : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = _16[_line].xxxx; FragColor += (_28[_line].a * _28[1 - _line].a).xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { _line = stage_input._line; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/control-dependent-in-branch.desktop.frag000066400000000000000000000024651400026215700322450ustar00rootroot00000000000000Texture2D uSampler : register(t0); SamplerState _uSampler_sampler : register(s0); static float4 FragColor; static float4 vInput; struct SPIRV_Cross_Input { float4 vInput : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = vInput; float4 _23 = uSampler.Sample(_uSampler_sampler, vInput.xy); float4 _26 = ddx(vInput); float4 _29 = ddy(vInput); float4 _32 = fwidth(vInput); float4 _35 = ddx_coarse(vInput); float4 _38 = ddy_coarse(vInput); float4 _41 = fwidth(vInput); float4 _44 = ddx_fine(vInput); float4 _47 = ddy_fine(vInput); float4 _50 = fwidth(vInput); float _56_tmp = uSampler.CalculateLevelOfDetail(_uSampler_sampler, vInput.zw); float2 _56 = _56_tmp.xx; if (vInput.y > 10.0f) { FragColor += _23; FragColor += _26; FragColor += _29; FragColor += _32; FragColor += _35; FragColor += _38; FragColor += _41; FragColor += _44; FragColor += _47; FragColor += _50; FragColor += _56.xyxy; } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vInput = stage_input.vInput; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/demote-to-helper.frag000066400000000000000000000001041400026215700264500ustar00rootroot00000000000000void frag_main() { discard; } void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/depth-greater-than.frag000066400000000000000000000005101400026215700267620ustar00rootroot00000000000000static float gl_FragDepth; struct SPIRV_Cross_Output { float gl_FragDepth : SV_DepthGreaterEqual; }; void frag_main() { gl_FragDepth = 0.5f; } [earlydepthstencil] SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_FragDepth = gl_FragDepth; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/depth-less-than.frag000066400000000000000000000005051400026215700263030ustar00rootroot00000000000000static float gl_FragDepth; struct SPIRV_Cross_Output { float gl_FragDepth : SV_DepthLessEqual; }; void frag_main() { gl_FragDepth = 0.5f; } [earlydepthstencil] SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_FragDepth = gl_FragDepth; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/dual-source-blending.frag000066400000000000000000000006541400026215700273130ustar00rootroot00000000000000static float4 FragColor0; static float4 FragColor1; struct SPIRV_Cross_Output { float4 FragColor0 : SV_Target0; float4 FragColor1 : SV_Target1; }; void frag_main() { FragColor0 = 1.0f.xxxx; FragColor1 = 2.0f.xxxx; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor0 = FragColor0; stage_output.FragColor1 = FragColor1; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/early-fragment-test.frag000066400000000000000000000001131400026215700271700ustar00rootroot00000000000000void frag_main() { } [earlydepthstencil] void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/for-loop-continue-control-flow.frag000066400000000000000000000006271400026215700313120ustar00rootroot00000000000000static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = 0.0f.xxxx; for (int _43 = 0; _43 < 3; ) { FragColor[_43] += float(_43); _43++; continue; } } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/fp16-packing.frag000066400000000000000000000015571400026215700255010ustar00rootroot00000000000000static float2 FP32Out; static uint FP16; static uint FP16Out; static float2 FP32; struct SPIRV_Cross_Input { nointerpolation uint FP16 : TEXCOORD0; nointerpolation float2 FP32 : TEXCOORD1; }; struct SPIRV_Cross_Output { float2 FP32Out : SV_Target0; uint FP16Out : SV_Target1; }; uint spvPackHalf2x16(float2 value) { uint2 Packed = f32tof16(value); return Packed.x | (Packed.y << 16); } float2 spvUnpackHalf2x16(uint value) { return f16tof32(uint2(value & 0xffff, value >> 16)); } void frag_main() { FP32Out = spvUnpackHalf2x16(FP16); FP16Out = spvPackHalf2x16(FP32); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { FP16 = stage_input.FP16; FP32 = stage_input.FP32; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FP32Out = FP32Out; stage_output.FP16Out = FP16Out; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/front-facing.frag000066400000000000000000000012601400026215700256570ustar00rootroot00000000000000static bool gl_FrontFacing; static float4 FragColor; static float4 vA; static float4 vB; struct SPIRV_Cross_Input { float4 vA : TEXCOORD0; float4 vB : TEXCOORD1; bool gl_FrontFacing : SV_IsFrontFace; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { if (gl_FrontFacing) { FragColor = vA; } else { FragColor = vB; } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FrontFacing = stage_input.gl_FrontFacing; vA = stage_input.vA; vB = stage_input.vB; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/image-query-selective.frag000066400000000000000000000000671400026215700275140ustar00rootroot00000000000000void frag_main() { } void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/image-query-uav.frag000066400000000000000000000000671400026215700263240ustar00rootroot00000000000000void frag_main() { } void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/image-query-uav.nonwritable-uav-texture.frag000066400000000000000000000000671400026215700331360ustar00rootroot00000000000000void frag_main() { } void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/image-query.frag000066400000000000000000000000671400026215700255330ustar00rootroot00000000000000void frag_main() { } void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/input-attachment-ms.frag000066400000000000000000000015021400026215700272030ustar00rootroot00000000000000Texture2DMS uSubpass0 : register(t0); Texture2DMS uSubpass1 : register(t1); static float4 gl_FragCoord; static int gl_SampleID; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; uint gl_SampleID : SV_SampleIndex; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = (uSubpass0.Load(int2(gl_FragCoord.xy), 1) + uSubpass1.Load(int2(gl_FragCoord.xy), 2)) + uSubpass0.Load(int2(gl_FragCoord.xy), gl_SampleID); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; gl_SampleID = stage_input.gl_SampleID; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/input-attachment.frag000066400000000000000000000012511400026215700265670ustar00rootroot00000000000000Texture2D uSubpass0 : register(t0); Texture2D uSubpass1 : register(t1); static float4 gl_FragCoord; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = uSubpass0.Load(int3(int2(gl_FragCoord.xy), 0)) + uSubpass1.Load(int3(int2(gl_FragCoord.xy), 0)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/io-block.frag000066400000000000000000000006761400026215700250130ustar00rootroot00000000000000static float4 FragColor; struct VertexOut { float4 a : TEXCOORD1; float4 b : TEXCOORD2; }; static VertexOut _12; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = _12.a + _12.b; } SPIRV_Cross_Output main(in VertexOut stage_input_12) { _12 = stage_input_12; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/legacy-tex-modifiers.sm30.frag000066400000000000000000000013141400026215700301040ustar00rootroot00000000000000uniform sampler2D uSampler; static float4 FragColor; static float2 vUV; struct SPIRV_Cross_Input { float2 vUV : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : COLOR0; }; void frag_main() { float3 _23 = float3(vUV, 5.0f); FragColor = tex2Dproj(uSampler, float4(_23.xy, 0.0, _23.z)); FragColor += tex2Dbias(uSampler, float4(vUV, 0.0, 3.0f)); FragColor += tex2Dlod(uSampler, float4(vUV, 0.0, 2.0f)); FragColor += tex2Dgrad(uSampler, vUV, 4.0f.xx, 5.0f.xx); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = float4(FragColor); return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/lut-promotion.frag000066400000000000000000000022321400026215700261320ustar00rootroot00000000000000static const float _16[16] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f }; static const float4 _60[4] = { 0.0f.xxxx, 1.0f.xxxx, 8.0f.xxxx, 5.0f.xxxx }; static const float4 _104[4] = { 20.0f.xxxx, 30.0f.xxxx, 50.0f.xxxx, 60.0f.xxxx }; static float FragColor; static int index; struct SPIRV_Cross_Input { nointerpolation int index : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = _16[index]; if (index < 10) { FragColor += _16[index ^ 1]; } else { FragColor += _16[index & 1]; } bool _63 = index > 30; if (_63) { FragColor += _60[index & 3].y; } else { FragColor += _60[index & 1].x; } float4 foobar[4] = _60; if (_63) { foobar[1].z = 20.0f; } int _91 = index & 3; FragColor += foobar[_91].z; FragColor += _104[_91].z; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { index = stage_input.index; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/matrix-input.frag000066400000000000000000000006711400026215700257500ustar00rootroot00000000000000static float4 FragColor; static float4x4 m; struct SPIRV_Cross_Input { float4x4 m : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = ((m[0] + m[1]) + m[2]) + m[3]; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { m = stage_input.m; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/mod.frag000066400000000000000000000023331400026215700240630ustar00rootroot00000000000000static float4 a4; static float4 b4; static float3 a3; static float3 b3; static float2 a2; static float2 b2; static float a1; static float b1; static float4 FragColor; struct SPIRV_Cross_Input { float4 a4 : TEXCOORD0; float3 a3 : TEXCOORD1; float2 a2 : TEXCOORD2; float a1 : TEXCOORD3; float4 b4 : TEXCOORD4; float3 b3 : TEXCOORD5; float2 b2 : TEXCOORD6; float b1 : TEXCOORD7; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; float mod(float x, float y) { return x - y * floor(x / y); } float2 mod(float2 x, float2 y) { return x - y * floor(x / y); } float3 mod(float3 x, float3 y) { return x - y * floor(x / y); } float4 mod(float4 x, float4 y) { return x - y * floor(x / y); } void frag_main() { FragColor = ((mod(a4, b4) + mod(a3, b3).xyzx) + mod(a2, b2).xyxy) + mod(a1, b1).xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { a4 = stage_input.a4; b4 = stage_input.b4; a3 = stage_input.a3; b3 = stage_input.b3; a2 = stage_input.a2; b2 = stage_input.b2; a1 = stage_input.a1; b1 = stage_input.b1; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/mrt.frag000066400000000000000000000010501400026215700241010ustar00rootroot00000000000000static float4 RT0; static float4 RT1; static float4 RT2; static float4 RT3; struct SPIRV_Cross_Output { float4 RT0 : SV_Target0; float4 RT1 : SV_Target1; float4 RT2 : SV_Target2; float4 RT3 : SV_Target3; }; void frag_main() { RT0 = 1.0f.xxxx; RT1 = 2.0f.xxxx; RT2 = 3.0f.xxxx; RT3 = 4.0f.xxxx; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.RT0 = RT0; stage_output.RT1 = RT1; stage_output.RT2 = RT2; stage_output.RT3 = RT3; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/no-return.frag000066400000000000000000000000671400026215700252370ustar00rootroot00000000000000void frag_main() { } void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/no-return2.frag000066400000000000000000000003121400026215700253120ustar00rootroot00000000000000static float4 vColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; }; void frag_main() { } void main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); } nonuniform-qualifier.nonuniformresource.sm51.frag000066400000000000000000000025531400026215700341270ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/fragstruct UBO_1_1 { float4 v[64]; }; ConstantBuffer ubos[] : register(b0, space3); ByteAddressBuffer ssbos[] : register(t0, space4); Texture2D uSamplers[] : register(t0, space0); SamplerState uSamps[] : register(s0, space2); Texture2D uCombinedSamplers[] : register(t0, space1); SamplerState _uCombinedSamplers_sampler[] : register(s0, space1); static int vIndex; static float4 FragColor; static float2 vUV; struct SPIRV_Cross_Input { nointerpolation int vIndex : TEXCOORD0; float2 vUV : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int _23 = vIndex + 10; int _34 = vIndex + 40; FragColor = uSamplers[NonUniformResourceIndex(_23)].Sample(uSamps[NonUniformResourceIndex(_34)], vUV); FragColor = uCombinedSamplers[NonUniformResourceIndex(_23)].Sample(_uCombinedSamplers_sampler[NonUniformResourceIndex(_23)], vUV); int _66 = vIndex + 20; FragColor += ubos[NonUniformResourceIndex(_66)].v[_34]; int _84 = vIndex + 50; int _88 = vIndex + 60; FragColor += asfloat(ssbos[NonUniformResourceIndex(_84)].Load4(_88 * 16 + 0)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vIndex = stage_input.vIndex; vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/partial-write-preserve.frag000066400000000000000000000000671400026215700277230ustar00rootroot00000000000000void frag_main() { } void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/pixel-interlock-ordered.sm51.fxconly.frag000066400000000000000000000014261400026215700323060ustar00rootroot00000000000000RWByteAddressBuffer _9 : register(u6, space0); globallycoherent RasterizerOrderedByteAddressBuffer _42 : register(u3, space0); RasterizerOrderedByteAddressBuffer _52 : register(u4, space0); RWTexture2D img4 : register(u5, space0); RasterizerOrderedTexture2D img : register(u0, space0); RasterizerOrderedTexture2D img3 : register(u2, space0); RasterizerOrderedTexture2D img2 : register(u1, space0); void frag_main() { _9.Store(0, uint(0)); img4[int2(1, 1)] = float4(1.0f, 0.0f, 0.0f, 1.0f); img[int2(0, 0)] = img3[int2(0, 0)]; uint _39; InterlockedAdd(img2[int2(0, 0)], 1u, _39); _42.Store(0, uint(int(_42.Load(0)) + 42)); uint _55; _42.InterlockedAnd(4, _52.Load(0), _55); } void main() { frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/point-coord-compat.frag000066400000000000000000000004541400026215700270240ustar00rootroot00000000000000static float2 FragColor; struct SPIRV_Cross_Output { float2 FragColor : SV_Target0; }; void frag_main() { FragColor = float2(0.5f, 0.5f); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/query-lod.desktop.frag000066400000000000000000000012131400026215700266710ustar00rootroot00000000000000Texture2D uSampler : register(t0); SamplerState _uSampler_sampler : register(s0); static float4 FragColor; static float2 vTexCoord; struct SPIRV_Cross_Input { float2 vTexCoord : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { float _19_tmp = uSampler.CalculateLevelOfDetail(_uSampler_sampler, vTexCoord); float2 _19 = _19_tmp.xx; FragColor = _19.xyxy; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vTexCoord = stage_input.vTexCoord; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/readonly-coherent-ssbo.force-uav.frag000066400000000000000000000005511400026215700315600ustar00rootroot00000000000000globallycoherent RWByteAddressBuffer _12 : register(u0); static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = asfloat(_12.Load4(0)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/readonly-coherent-ssbo.frag000066400000000000000000000005261400026215700276740ustar00rootroot00000000000000ByteAddressBuffer _12 : register(t0); static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = asfloat(_12.Load4(0)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/resources.frag000066400000000000000000000015201400026215700253130ustar00rootroot00000000000000cbuffer CBuffer : register(b3) { float4 cbuf_a : packoffset(c0); }; cbuffer PushMe { float4 registers_d : packoffset(c0); }; Texture2D uSampledImage : register(t4); SamplerState _uSampledImage_sampler : register(s4); Texture2D uTexture : register(t5); SamplerState uSampler : register(s6); static float2 vTex; static float4 FragColor; struct SPIRV_Cross_Input { float2 vTex : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = (uSampledImage.Sample(_uSampledImage_sampler, vTex) + uTexture.Sample(uSampler, vTex)) + (cbuf_a + registers_d); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vTex = stage_input.vTex; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/row-major-layout-in-struct.frag000066400000000000000000000011141400026215700304560ustar00rootroot00000000000000struct Foo { row_major float4x4 v; row_major float4x4 w; }; cbuffer UBO : register(b0) { Foo _17_foo : packoffset(c0); }; static float4 FragColor; static float4 vUV; struct SPIRV_Cross_Input { float4 vUV : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = mul(mul(vUV, _17_foo.w), _17_foo.v); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/sample-cmp-level-zero.frag000066400000000000000000000034241400026215700274260ustar00rootroot00000000000000Texture2D uSampler2D : register(t0); SamplerComparisonState _uSampler2D_sampler : register(s0); Texture2DArray uSampler2DArray : register(t1); SamplerComparisonState _uSampler2DArray_sampler : register(s1); TextureCube uSamplerCube : register(t2); SamplerComparisonState _uSamplerCube_sampler : register(s2); TextureCubeArray uSamplerCubeArray : register(t3); SamplerComparisonState _uSamplerCubeArray_sampler : register(s3); static float3 vUVRef; static float4 vDirRef; static float FragColor; struct SPIRV_Cross_Input { float3 vUVRef : TEXCOORD0; float4 vDirRef : TEXCOORD1; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { float4 _80 = vDirRef; _80.z = vDirRef.w; FragColor = (((((((uSampler2D.SampleCmp(_uSampler2D_sampler, vUVRef.xy, vUVRef.z, int2(-1, -1)) + uSampler2DArray.SampleCmp(_uSampler2DArray_sampler, vDirRef.xyz, vDirRef.w, int2(-1, -1))) + uSamplerCube.SampleCmp(_uSamplerCube_sampler, vDirRef.xyz, vDirRef.w)) + uSamplerCubeArray.SampleCmp(_uSamplerCubeArray_sampler, vDirRef, 0.5f)) + uSampler2D.SampleCmpLevelZero(_uSampler2D_sampler, vUVRef.xy, vUVRef.z, int2(-1, -1))) + uSampler2DArray.SampleCmpLevelZero(_uSampler2DArray_sampler, vDirRef.xyz, vDirRef.w, int2(-1, -1))) + uSamplerCube.SampleCmpLevelZero(_uSamplerCube_sampler, vDirRef.xyz, vDirRef.w)) + uSampler2D.SampleCmp(_uSampler2D_sampler, _80.xy / _80.z, vDirRef.z / _80.z, int2(1, 1))) + uSampler2D.SampleCmpLevelZero(_uSampler2D_sampler, _80.xy / _80.z, vDirRef.z / _80.z, int2(1, 1)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUVRef = stage_input.vUVRef; vDirRef = stage_input.vDirRef; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/sample-mask-in-and-out.frag000066400000000000000000000011531400026215700274660ustar00rootroot00000000000000static int gl_SampleMaskIn; static int gl_SampleMask; static float4 FragColor; struct SPIRV_Cross_Input { uint gl_SampleMaskIn : SV_Coverage; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; uint gl_SampleMask : SV_Coverage; }; void frag_main() { FragColor = 1.0f.xxxx; gl_SampleMask = gl_SampleMaskIn; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_SampleMaskIn = stage_input.gl_SampleMaskIn; frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_SampleMask = gl_SampleMask; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/sample-mask-in.frag000066400000000000000000000012051400026215700261170ustar00rootroot00000000000000static int gl_SampleID; static int gl_SampleMaskIn; static float4 FragColor; struct SPIRV_Cross_Input { uint gl_SampleID : SV_SampleIndex; uint gl_SampleMaskIn : SV_Coverage; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { if ((gl_SampleMaskIn & (1 << gl_SampleID)) != 0) { FragColor = 1.0f.xxxx; } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_SampleID = stage_input.gl_SampleID; gl_SampleMaskIn = stage_input.gl_SampleMaskIn; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/sample-mask-out.frag000066400000000000000000000006521400026215700263250ustar00rootroot00000000000000static int gl_SampleMask; static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; uint gl_SampleMask : SV_Coverage; }; void frag_main() { FragColor = 1.0f.xxxx; gl_SampleMask = 0; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_SampleMask = gl_SampleMask; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/sampler-array.frag000066400000000000000000000016651400026215700260720ustar00rootroot00000000000000Texture2D uCombined[4] : register(t0); SamplerState _uCombined_sampler[4] : register(s0); Texture2D uTex[4] : register(t4); SamplerState uSampler[4] : register(s8); RWTexture2D uImage[8] : register(u12); static float4 gl_FragCoord; static float2 vTex; static int vIndex; struct SPIRV_Cross_Input { float2 vTex : TEXCOORD0; nointerpolation int vIndex : TEXCOORD1; float4 gl_FragCoord : SV_Position; }; void frag_main() { int _72 = vIndex + 1; uImage[vIndex][int2(gl_FragCoord.xy)] = ((uCombined[vIndex].Sample(_uCombined_sampler[vIndex], vTex) + uTex[vIndex].Sample(uSampler[vIndex], vTex)) + uCombined[_72].Sample(_uCombined_sampler[_72], vTex)) + uTex[_72].Sample(uSampler[_72], vTex); } void main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; vTex = stage_input.vTex; vIndex = stage_input.vIndex; frag_main(); } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/sampler-image-arrays.frag000066400000000000000000000022331400026215700273250ustar00rootroot00000000000000Texture2D uSampler[4] : register(t0); SamplerState _uSampler_sampler[4] : register(s0); Texture2D uTextures[4] : register(t8); SamplerState uSamplers[4] : register(s4); static int vIndex; static float2 vTex; static float4 FragColor; struct SPIRV_Cross_Input { nointerpolation float2 vTex : TEXCOORD0; nointerpolation int vIndex : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = 0.0f.xxxx; FragColor += uTextures[2].Sample(uSamplers[1], vTex); FragColor += uSampler[vIndex].Sample(_uSampler_sampler[vIndex], vTex); FragColor += uSampler[vIndex].Sample(_uSampler_sampler[vIndex], vTex + 0.100000001490116119384765625f.xx); FragColor += uSampler[vIndex].Sample(_uSampler_sampler[vIndex], vTex + 0.20000000298023223876953125f.xx); FragColor += uSampler[3].Sample(_uSampler_sampler[3], vTex + 0.300000011920928955078125f.xx); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vIndex = stage_input.vIndex; vTex = stage_input.vTex; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/scalar-refract-reflect.frag000066400000000000000000000017471400026215700276270ustar00rootroot00000000000000static float FragColor; static float3 vRefract; struct SPIRV_Cross_Input { float3 vRefract : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; float spvReflect(float i, float n) { return i - 2.0 * dot(n, i) * n; } float spvRefract(float i, float n, float eta) { float NoI = n * i; float NoI2 = NoI * NoI; float k = 1.0 - eta * eta * (1.0 - NoI2); if (k < 0.0) { return 0.0; } else { return eta * i - (eta * NoI + sqrt(k)) * n; } } void frag_main() { FragColor = spvRefract(vRefract.x, vRefract.y, vRefract.z); FragColor += spvReflect(vRefract.x, vRefract.y); FragColor += refract(vRefract.xy, vRefract.yz, vRefract.z).y; FragColor += reflect(vRefract.xy, vRefract.zy).y; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vRefract = stage_input.vRefract; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/separate-combined-fake-overload.sm30.frag000066400000000000000000000006441400026215700321670ustar00rootroot00000000000000uniform sampler2D uSamp; uniform sampler2D SPIRV_Cross_CombineduTuS; static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : COLOR0; }; void frag_main() { FragColor = tex2D(uSamp, 0.5f.xx) + tex2D(SPIRV_Cross_CombineduTuS, 0.5f.xx); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = float4(FragColor); return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/spec-constant-block-size.frag000066400000000000000000000012461400026215700301270ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 2 #endif static const int Value = SPIRV_CROSS_CONSTANT_ID_10; cbuffer SpecConstArray : register(b0) { float4 _15_samples[Value] : packoffset(c0); }; static float4 FragColor; static int Index; struct SPIRV_Cross_Input { nointerpolation int Index : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = _15_samples[Index]; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { Index = stage_input.Index; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/spec-constant-ternary.frag000066400000000000000000000007531400026215700275530ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 10u #endif static const uint s = SPIRV_CROSS_CONSTANT_ID_0; static const bool _13 = (s > 20u); static const uint f = _13 ? 30u : 50u; static float FragColor; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = float(f); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/switch-unsigned-case.frag000066400000000000000000000012111400026215700273220ustar00rootroot00000000000000cbuffer Buff : register(b0) { uint _15_TestVal : packoffset(c0); }; static float4 fsout_Color; struct SPIRV_Cross_Output { float4 fsout_Color : SV_Target0; }; void frag_main() { fsout_Color = 1.0f.xxxx; switch (_15_TestVal) { case 0u: { fsout_Color = 0.100000001490116119384765625f.xxxx; break; } case 1u: { fsout_Color = 0.20000000298023223876953125f.xxxx; break; } } } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.fsout_Color = fsout_Color; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/swizzle-scalar.frag000066400000000000000000000015361400026215700262620ustar00rootroot00000000000000static float4 Float; static float vFloat; static int4 Int; static int vInt; static float4 Float2; static int4 Int2; struct SPIRV_Cross_Input { nointerpolation float vFloat : TEXCOORD0; nointerpolation int vInt : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 Float : SV_Target0; int4 Int : SV_Target1; float4 Float2 : SV_Target2; int4 Int2 : SV_Target3; }; void frag_main() { Float = vFloat.xxxx * 2.0f; Int = vInt.xxxx * int4(2, 2, 2, 2); Float2 = 10.0f.xxxx; Int2 = int4(10, 10, 10, 10); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vFloat = stage_input.vFloat; vInt = stage_input.vInt; frag_main(); SPIRV_Cross_Output stage_output; stage_output.Float = Float; stage_output.Int = Int; stage_output.Float2 = Float2; stage_output.Int2 = Int2; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/tex-sampling-ms.frag000066400000000000000000000013511400026215700263300ustar00rootroot00000000000000Texture2DMS uTex : register(t0); SamplerState _uTex_sampler : register(s0); static float4 gl_FragCoord; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int2 _22 = int2(gl_FragCoord.xy); FragColor = uTex.Load(_22, 0); FragColor += uTex.Load(_22, 1); FragColor += uTex.Load(_22, 2); FragColor += uTex.Load(_22, 3); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/tex-sampling.frag000066400000000000000000000105761400026215700257240ustar00rootroot00000000000000Texture1D tex1d : register(t0); SamplerState _tex1d_sampler : register(s0); Texture2D tex2d : register(t1); SamplerState _tex2d_sampler : register(s1); Texture3D tex3d : register(t2); SamplerState _tex3d_sampler : register(s2); TextureCube texCube : register(t3); SamplerState _texCube_sampler : register(s3); Texture1D tex1dShadow : register(t4); SamplerComparisonState _tex1dShadow_sampler : register(s4); Texture2D tex2dShadow : register(t5); SamplerComparisonState _tex2dShadow_sampler : register(s5); TextureCube texCubeShadow : register(t6); SamplerComparisonState _texCubeShadow_sampler : register(s6); Texture1DArray tex1dArray : register(t7); SamplerState _tex1dArray_sampler : register(s7); Texture2DArray tex2dArray : register(t8); SamplerState _tex2dArray_sampler : register(s8); TextureCubeArray texCubeArray : register(t9); SamplerState _texCubeArray_sampler : register(s9); Texture2D separateTex2d : register(t12); SamplerState samplerNonDepth : register(s11); Texture2D separateTex2dDepth : register(t13); SamplerComparisonState samplerDepth : register(s10); static float texCoord1d; static float2 texCoord2d; static float3 texCoord3d; static float4 texCoord4d; static float4 FragColor; struct SPIRV_Cross_Input { float texCoord1d : TEXCOORD0; float2 texCoord2d : TEXCOORD1; float3 texCoord3d : TEXCOORD2; float4 texCoord4d : TEXCOORD3; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { float2 _41 = float2(texCoord1d, 2.0f); float3 _88 = float3(texCoord2d, 2.0f); float4 _135 = float4(texCoord3d, 2.0f); float4 _162 = (((((((((((((((((((tex1d.Sample(_tex1d_sampler, texCoord1d) + tex1d.Sample(_tex1d_sampler, texCoord1d, 1)) + tex1d.SampleLevel(_tex1d_sampler, texCoord1d, 2.0f)) + tex1d.SampleGrad(_tex1d_sampler, texCoord1d, 1.0f, 2.0f)) + tex1d.Sample(_tex1d_sampler, _41.x / _41.y)) + tex1d.SampleBias(_tex1d_sampler, texCoord1d, 1.0f)) + tex2d.Sample(_tex2d_sampler, texCoord2d)) + tex2d.Sample(_tex2d_sampler, texCoord2d, int2(1, 2))) + tex2d.SampleLevel(_tex2d_sampler, texCoord2d, 2.0f)) + tex2d.SampleGrad(_tex2d_sampler, texCoord2d, float2(1.0f, 2.0f), float2(3.0f, 4.0f))) + tex2d.Sample(_tex2d_sampler, _88.xy / _88.z)) + tex2d.SampleBias(_tex2d_sampler, texCoord2d, 1.0f)) + tex3d.Sample(_tex3d_sampler, texCoord3d)) + tex3d.Sample(_tex3d_sampler, texCoord3d, int3(1, 2, 3))) + tex3d.SampleLevel(_tex3d_sampler, texCoord3d, 2.0f)) + tex3d.SampleGrad(_tex3d_sampler, texCoord3d, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f))) + tex3d.Sample(_tex3d_sampler, _135.xyz / _135.w)) + tex3d.SampleBias(_tex3d_sampler, texCoord3d, 1.0f)) + texCube.Sample(_texCube_sampler, texCoord3d)) + texCube.SampleLevel(_texCube_sampler, texCoord3d, 2.0f)) + texCube.SampleBias(_texCube_sampler, texCoord3d, 1.0f); float4 _333 = _162; _333.w = ((_162.w + tex1dShadow.SampleCmp(_tex1dShadow_sampler, float3(texCoord1d, 0.0f, 0.0f).x, 0.0f)) + tex2dShadow.SampleCmp(_tex2dShadow_sampler, float3(texCoord2d, 0.0f).xy, 0.0f)) + texCubeShadow.SampleCmp(_texCubeShadow_sampler, float4(texCoord3d, 0.0f).xyz, 0.0f); float4 _243 = tex2d.GatherRed(_tex2d_sampler, texCoord2d); float4 _269 = tex2d.GatherRed(_tex2d_sampler, texCoord2d, int2(1, 1)); float4 _308 = ((((((((((((((_333 + tex1dArray.Sample(_tex1dArray_sampler, texCoord2d)) + tex2dArray.Sample(_tex2dArray_sampler, texCoord3d)) + texCubeArray.Sample(_texCubeArray_sampler, texCoord4d)) + _243) + _243) + tex2d.GatherGreen(_tex2d_sampler, texCoord2d)) + tex2d.GatherBlue(_tex2d_sampler, texCoord2d)) + tex2d.GatherAlpha(_tex2d_sampler, texCoord2d)) + _269) + _269) + tex2d.GatherGreen(_tex2d_sampler, texCoord2d, int2(1, 1))) + tex2d.GatherBlue(_tex2d_sampler, texCoord2d, int2(1, 1))) + tex2d.GatherAlpha(_tex2d_sampler, texCoord2d, int2(1, 1))) + tex2d.Load(int3(int2(1, 2), 0))) + separateTex2d.Sample(samplerNonDepth, texCoord2d); float4 _336 = _308; _336.w = _308.w + separateTex2dDepth.SampleCmp(samplerDepth, texCoord3d.xy, texCoord3d.z); FragColor = _336; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { texCoord1d = stage_input.texCoord1d; texCoord2d = stage_input.texCoord2d; texCoord3d = stage_input.texCoord3d; texCoord4d = stage_input.texCoord4d; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/tex-sampling.sm30.frag000066400000000000000000000052251400026215700265000ustar00rootroot00000000000000uniform sampler1D tex1d; uniform sampler2D tex2d; uniform sampler3D tex3d; uniform samplerCUBE texCube; uniform sampler1D tex1dShadow; uniform sampler2D tex2dShadow; static float texCoord1d; static float2 texCoord2d; static float3 texCoord3d; static float4 FragColor; static float4 texCoord4d; struct SPIRV_Cross_Input { float texCoord1d : TEXCOORD0; float2 texCoord2d : TEXCOORD1; float3 texCoord3d : TEXCOORD2; float4 texCoord4d : TEXCOORD3; }; struct SPIRV_Cross_Output { float4 FragColor : COLOR0; }; void frag_main() { float2 _34 = float2(texCoord1d, 2.0f); float3 _73 = float3(texCoord2d, 2.0f); float4 _112 = float4(texCoord3d, 2.0f); float4 _139 = ((((((((((((((((tex1D(tex1d, texCoord1d) + tex1Dlod(tex1d, float4(texCoord1d, 0.0, 0.0, 2.0f))) + tex1Dgrad(tex1d, texCoord1d, 1.0f, 2.0f)) + tex1Dproj(tex1d, float4(_34.x, 0.0, 0.0, _34.y))) + tex1Dbias(tex1d, float4(texCoord1d, 0.0, 0.0, 1.0f))) + tex2D(tex2d, texCoord2d)) + tex2Dlod(tex2d, float4(texCoord2d, 0.0, 2.0f))) + tex2Dgrad(tex2d, texCoord2d, float2(1.0f, 2.0f), float2(3.0f, 4.0f))) + tex2Dproj(tex2d, float4(_73.xy, 0.0, _73.z))) + tex2Dbias(tex2d, float4(texCoord2d, 0.0, 1.0f))) + tex3D(tex3d, texCoord3d)) + tex3Dlod(tex3d, float4(texCoord3d, 2.0f))) + tex3Dgrad(tex3d, texCoord3d, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f))) + tex3Dproj(tex3d, float4(_112.xyz, _112.w))) + tex3Dbias(tex3d, float4(texCoord3d, 1.0f))) + texCUBE(texCube, texCoord3d)) + texCUBElod(texCube, float4(texCoord3d, 2.0f))) + texCUBEbias(texCube, float4(texCoord3d, 1.0f)); float3 _147 = float3(texCoord1d, 0.0f, 0.0f); float4 _171 = float4(texCoord1d, 0.0f, 0.0f, 2.0f); _171.y = 2.0f; float3 _194 = float3(texCoord2d, 0.0f); float4 _219 = float4(texCoord2d, 0.0f, 2.0f); _219.z = 2.0f; float4 _264 = _139; _264.w = (((((((_139.w + tex1Dproj(tex1dShadow, float4(_147.x, 0.0, 0.0f, 1.0)).x) + tex1Dlod(tex1dShadow, float4(_147.x, 0.0, 0.0f, 2.0f)).x) + tex1Dproj(tex1dShadow, float4(_171.x, 0.0, 0.0f, _171.y)).x) + tex1Dbias(tex1dShadow, float4(_147.x, 0.0, 0.0f, 1.0f)).x) + tex2Dproj(tex2dShadow, float4(_194.xy, 0.0f, 1.0)).x) + tex2Dlod(tex2dShadow, float4(_194.xy, 0.0f, 2.0f)).x) + tex2Dproj(tex2dShadow, float4(_219.xy, 0.0f, _219.z)).x) + tex2Dbias(tex2dShadow, float4(_194.xy, 0.0f, 1.0f)).x; FragColor = _264; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { texCoord1d = stage_input.texCoord1d; texCoord2d = stage_input.texCoord2d; texCoord3d = stage_input.texCoord3d; texCoord4d = stage_input.texCoord4d; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = float4(FragColor); return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/texel-fetch-offset.frag000066400000000000000000000013241400026215700267770ustar00rootroot00000000000000Texture2D uTexture : register(t0); SamplerState _uTexture_sampler : register(s0); static float4 gl_FragCoord; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int2 _22 = int2(gl_FragCoord.xy); FragColor = uTexture.Load(int3(_22, 0), int2(1, 1)); FragColor += uTexture.Load(int3(_22, 0), int2(-1, 1)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/texture-proj-shadow.frag000066400000000000000000000030561400026215700272420ustar00rootroot00000000000000Texture1D uShadow1D : register(t0); SamplerComparisonState _uShadow1D_sampler : register(s0); Texture2D uShadow2D : register(t1); SamplerComparisonState _uShadow2D_sampler : register(s1); Texture1D uSampler1D : register(t2); SamplerState _uSampler1D_sampler : register(s2); Texture2D uSampler2D : register(t3); SamplerState _uSampler2D_sampler : register(s3); Texture3D uSampler3D : register(t4); SamplerState _uSampler3D_sampler : register(s4); static float FragColor; static float4 vClip4; static float2 vClip2; static float3 vClip3; struct SPIRV_Cross_Input { float3 vClip3 : TEXCOORD0; float4 vClip4 : TEXCOORD1; float2 vClip2 : TEXCOORD2; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { float4 _20 = vClip4; _20.y = vClip4.w; FragColor = uShadow1D.SampleCmp(_uShadow1D_sampler, _20.x / _20.y, vClip4.z / _20.y); float4 _30 = vClip4; _30.z = vClip4.w; FragColor = uShadow2D.SampleCmp(_uShadow2D_sampler, _30.xy / _30.z, vClip4.z / _30.z); FragColor = uSampler1D.Sample(_uSampler1D_sampler, vClip2.x / vClip2.y).x; FragColor = uSampler2D.Sample(_uSampler2D_sampler, vClip3.xy / vClip3.z).x; FragColor = uSampler3D.Sample(_uSampler3D_sampler, vClip4.xyz / vClip4.w).x; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vClip4 = stage_input.vClip4; vClip2 = stage_input.vClip2; vClip3 = stage_input.vClip3; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/texture-size-combined-image-sampler.frag000066400000000000000000000011121400026215700322450ustar00rootroot00000000000000Texture2D uTex : register(t0); SamplerState uSampler : register(s1); static int2 FooOut; struct SPIRV_Cross_Output { int2 FooOut : SV_Target0; }; uint2 spvTextureSize(Texture2D Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(Level, ret.x, ret.y, Param); return ret; } void frag_main() { uint _23_dummy_parameter; FooOut = int2(spvTextureSize(uTex, uint(0), _23_dummy_parameter)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FooOut = FooOut; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/unary-enclose.frag000066400000000000000000000007751400026215700261000ustar00rootroot00000000000000static float4 FragColor; static float4 vIn; static int4 vIn1; struct SPIRV_Cross_Input { float4 vIn : TEXCOORD0; nointerpolation int4 vIn1 : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = vIn; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vIn = stage_input.vIn; vIn1 = stage_input.vIn1; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/unorm-snorm-packing.frag000066400000000000000000000057641400026215700272250ustar00rootroot00000000000000static float4 FP32Out; static uint UNORM8; static uint SNORM8; static uint UNORM16; static uint SNORM16; static uint UNORM8Out; static float4 FP32; static uint SNORM8Out; static uint UNORM16Out; static uint SNORM16Out; struct SPIRV_Cross_Input { nointerpolation uint SNORM8 : TEXCOORD0; nointerpolation uint UNORM8 : TEXCOORD1; nointerpolation uint SNORM16 : TEXCOORD2; nointerpolation uint UNORM16 : TEXCOORD3; nointerpolation float4 FP32 : TEXCOORD4; }; struct SPIRV_Cross_Output { float4 FP32Out : SV_Target0; uint UNORM8Out : SV_Target1; uint SNORM8Out : SV_Target2; uint UNORM16Out : SV_Target3; uint SNORM16Out : SV_Target4; }; uint spvPackUnorm4x8(float4 value) { uint4 Packed = uint4(round(saturate(value) * 255.0)); return Packed.x | (Packed.y << 8) | (Packed.z << 16) | (Packed.w << 24); } float4 spvUnpackUnorm4x8(uint value) { uint4 Packed = uint4(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, value >> 24); return float4(Packed) / 255.0; } uint spvPackSnorm4x8(float4 value) { int4 Packed = int4(round(clamp(value, -1.0, 1.0) * 127.0)) & 0xff; return uint(Packed.x | (Packed.y << 8) | (Packed.z << 16) | (Packed.w << 24)); } float4 spvUnpackSnorm4x8(uint value) { int SignedValue = int(value); int4 Packed = int4(SignedValue << 24, SignedValue << 16, SignedValue << 8, SignedValue) >> 24; return clamp(float4(Packed) / 127.0, -1.0, 1.0); } uint spvPackUnorm2x16(float2 value) { uint2 Packed = uint2(round(saturate(value) * 65535.0)); return Packed.x | (Packed.y << 16); } float2 spvUnpackUnorm2x16(uint value) { uint2 Packed = uint2(value & 0xffff, value >> 16); return float2(Packed) / 65535.0; } uint spvPackSnorm2x16(float2 value) { int2 Packed = int2(round(clamp(value, -1.0, 1.0) * 32767.0)) & 0xffff; return uint(Packed.x | (Packed.y << 16)); } float2 spvUnpackSnorm2x16(uint value) { int SignedValue = int(value); int2 Packed = int2(SignedValue << 16, SignedValue) >> 16; return clamp(float2(Packed) / 32767.0, -1.0, 1.0); } void frag_main() { FP32Out = spvUnpackUnorm4x8(UNORM8); FP32Out = spvUnpackSnorm4x8(SNORM8); float2 _21 = spvUnpackUnorm2x16(UNORM16); FP32Out = float4(_21.x, _21.y, FP32Out.z, FP32Out.w); float2 _26 = spvUnpackSnorm2x16(SNORM16); FP32Out = float4(_26.x, _26.y, FP32Out.z, FP32Out.w); UNORM8Out = spvPackUnorm4x8(FP32); SNORM8Out = spvPackSnorm4x8(FP32); UNORM16Out = spvPackUnorm2x16(FP32.xy); SNORM16Out = spvPackSnorm2x16(FP32.zw); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { UNORM8 = stage_input.UNORM8; SNORM8 = stage_input.SNORM8; UNORM16 = stage_input.UNORM16; SNORM16 = stage_input.SNORM16; FP32 = stage_input.FP32; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FP32Out = FP32Out; stage_output.UNORM8Out = UNORM8Out; stage_output.SNORM8Out = SNORM8Out; stage_output.UNORM16Out = UNORM16Out; stage_output.SNORM16Out = SNORM16Out; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/frag/various-glsl-ops.frag000066400000000000000000000011321400026215700265260ustar00rootroot00000000000000static float2 interpolant; static float4 FragColor; struct SPIRV_Cross_Input { float2 interpolant : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = float4(0.0f, 0.0f, 0.0f, EvaluateAttributeSnapped(interpolant, 0.100000001490116119384765625f.xx).x) + float4(0.0f, 0.0f, 0.0f, ddx_coarse(interpolant.x)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { interpolant = stage_input.interpolant; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/000077500000000000000000000000001400026215700225035ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/basic.vert000066400000000000000000000013611400026215700244670ustar00rootroot00000000000000cbuffer UBO : register(b0) { row_major float4x4 _16_uMVP : packoffset(c0); }; static float4 gl_Position; static float4 aVertex; static float3 vNormal; static float3 aNormal; struct SPIRV_Cross_Input { float4 aVertex : TEXCOORD0; float3 aNormal : TEXCOORD1; }; struct SPIRV_Cross_Output { float3 vNormal : TEXCOORD0; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = mul(aVertex, _16_uMVP); vNormal = aNormal; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { aVertex = stage_input.aVertex; aNormal = stage_input.aNormal; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.vNormal = vNormal; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/clip-cull-distance.vert000066400000000000000000000013311400026215700270570ustar00rootroot00000000000000static float4 gl_Position; static float gl_ClipDistance[2]; static float gl_CullDistance[1]; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; float2 gl_ClipDistance0 : SV_ClipDistance0; float gl_CullDistance0 : SV_CullDistance0; }; void vert_main() { gl_Position = 1.0f.xxxx; gl_ClipDistance[0] = 0.0f; gl_ClipDistance[1] = 0.0f; gl_CullDistance[0] = 4.0f; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.gl_ClipDistance0.x = gl_ClipDistance[0]; stage_output.gl_ClipDistance0.y = gl_ClipDistance[1]; stage_output.gl_CullDistance0.x = gl_CullDistance[0]; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/instancing.vert000066400000000000000000000012071400026215700255420ustar00rootroot00000000000000static float4 gl_Position; static int gl_VertexIndex; static int gl_InstanceIndex; struct SPIRV_Cross_Input { uint gl_VertexIndex : SV_VertexID; uint gl_InstanceIndex : SV_InstanceID; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = float(gl_VertexIndex + gl_InstanceIndex).xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_VertexIndex = int(stage_input.gl_VertexIndex); gl_InstanceIndex = int(stage_input.gl_InstanceIndex); vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/locations.vert000066400000000000000000000031441400026215700254020ustar00rootroot00000000000000struct Foo { float3 a; float3 b; float3 c; }; static const Foo _71 = { 1.0f.xxx, 1.0f.xxx, 1.0f.xxx }; static float4 gl_Position; static float4 Input2; static float4 Input4; static float4 Input0; static float vLocation0; static float vLocation1; static float vLocation2[2]; static Foo vLocation4; static float vLocation9; struct VertexOut { float3 color : TEXCOORD7; float3 foo : TEXCOORD8; }; static VertexOut vout; struct SPIRV_Cross_Input { float4 Input0 : TEXCOORD0; float4 Input2 : TEXCOORD2; float4 Input4 : TEXCOORD4; }; struct SPIRV_Cross_Output { float vLocation0 : TEXCOORD0; float vLocation1 : TEXCOORD1; float vLocation2[2] : TEXCOORD2; Foo vLocation4 : TEXCOORD4; float vLocation9 : TEXCOORD9; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = ((1.0f.xxxx + Input2) + Input4) + Input0; vLocation0 = 0.0f; vLocation1 = 1.0f; vLocation2[0] = 2.0f; vLocation2[1] = 2.0f; vLocation4 = _71; vLocation9 = 9.0f; vout.color = 2.0f.xxx; vout.foo = 4.0f.xxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input, out VertexOut stage_outputvout) { Input2 = stage_input.Input2; Input4 = stage_input.Input4; Input0 = stage_input.Input0; vert_main(); stage_outputvout = vout; SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.vLocation0 = vLocation0; stage_output.vLocation1 = vLocation1; stage_output.vLocation2 = vLocation2; stage_output.vLocation4 = vLocation4; stage_output.vLocation9 = vLocation9; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/matrix-attribute.vert000066400000000000000000000012771400026215700267210ustar00rootroot00000000000000static float4 gl_Position; static float4x4 m; static float3 pos; struct SPIRV_Cross_Input { float3 pos : TEXCOORD0; float4 m_0 : TEXCOORD1_0; float4 m_1 : TEXCOORD1_1; float4 m_2 : TEXCOORD1_2; float4 m_3 : TEXCOORD1_3; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = mul(float4(pos, 1.0f), m); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { m[0] = stage_input.m_0; m[1] = stage_input.m_1; m[2] = stage_input.m_2; m[3] = stage_input.m_3; pos = stage_input.pos; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/matrix-output.vert000066400000000000000000000010071400026215700262450ustar00rootroot00000000000000static float4 gl_Position; static float4x4 m; struct SPIRV_Cross_Output { float4x4 m : TEXCOORD0; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = 1.0f.xxxx; m = float4x4(float4(1.0f, 0.0f, 0.0f, 0.0f), float4(0.0f, 1.0f, 0.0f, 0.0f), float4(0.0f, 0.0f, 1.0f, 0.0f), float4(0.0f, 0.0f, 0.0f, 1.0f)); } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.m = m; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/no-input.vert000066400000000000000000000004551400026215700251620ustar00rootroot00000000000000static float4 gl_Position; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = 1.0f.xxxx; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/point-size-compat.vert000066400000000000000000000005411400026215700267670ustar00rootroot00000000000000static float4 gl_Position; static float gl_PointSize; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = 1.0f.xxxx; gl_PointSize = 1.0f; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/qualifiers.vert000066400000000000000000000022551400026215700255550ustar00rootroot00000000000000static float4 gl_Position; static float vFlat; static float vCentroid; static float vSample; static float vNoperspective; struct Block { nointerpolation float vFlat : TEXCOORD4; centroid float vCentroid : TEXCOORD5; sample float vSample : TEXCOORD6; noperspective float vNoperspective : TEXCOORD7; }; static Block vout; struct SPIRV_Cross_Output { nointerpolation float vFlat : TEXCOORD0; centroid float vCentroid : TEXCOORD1; sample float vSample : TEXCOORD2; noperspective float vNoperspective : TEXCOORD3; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = 1.0f.xxxx; vFlat = 0.0f; vCentroid = 1.0f; vSample = 2.0f; vNoperspective = 3.0f; vout.vFlat = 0.0f; vout.vCentroid = 1.0f; vout.vSample = 2.0f; vout.vNoperspective = 3.0f; } SPIRV_Cross_Output main(out Block stage_outputvout) { vert_main(); stage_outputvout = vout; SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.vFlat = vFlat; stage_output.vCentroid = vCentroid; stage_output.vSample = vSample; stage_output.vNoperspective = vNoperspective; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/read-from-row-major-array.vert000066400000000000000000000021601400026215700303070ustar00rootroot00000000000000cbuffer Block : register(b0) { column_major float2x3 _104_var[3][4] : packoffset(c0); }; static float4 gl_Position; static float4 a_position; static float v_vtxResult; struct SPIRV_Cross_Input { float4 a_position : TEXCOORD0; }; struct SPIRV_Cross_Output { float v_vtxResult : TEXCOORD0; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = a_position; v_vtxResult = ((float(abs(_104_var[0][0][0].x - 2.0f) < 0.0500000007450580596923828125f) * float(abs(_104_var[0][0][0].y - 6.0f) < 0.0500000007450580596923828125f)) * float(abs(_104_var[0][0][0].z - (-6.0f)) < 0.0500000007450580596923828125f)) * ((float(abs(_104_var[0][0][1].x) < 0.0500000007450580596923828125f) * float(abs(_104_var[0][0][1].y - 5.0f) < 0.0500000007450580596923828125f)) * float(abs(_104_var[0][0][1].z - 5.0f) < 0.0500000007450580596923828125f)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { a_position = stage_input.a_position; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.v_vtxResult = v_vtxResult; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/return-array.vert000066400000000000000000000010511400026215700260350ustar00rootroot00000000000000static float4 gl_Position; static float4 vInput0; static float4 vInput1; struct SPIRV_Cross_Input { float4 vInput0 : TEXCOORD0; float4 vInput1 : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = 10.0f.xxxx + vInput1; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vInput0 = stage_input.vInput0; vInput1 = stage_input.vInput1; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/sampler-buffers.vert000066400000000000000000000007771400026215700265150ustar00rootroot00000000000000Buffer uFloatSampler : register(t1); Buffer uIntSampler : register(t2); Buffer uUintSampler : register(t3); static float4 gl_Position; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = (uFloatSampler.Load(20) + asfloat(uIntSampler.Load(40))) + asfloat(uUintSampler.Load(60)); } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/struct-composite-decl.vert000066400000000000000000000012541400026215700276400ustar00rootroot00000000000000struct VOut { float4 a; float4 b; float4 c; float4 d; }; static VOut vout; static float4 a; static float4 b; static float4 c; static float4 d; struct SPIRV_Cross_Input { float4 a : TEXCOORD0; float4 b : TEXCOORD1; float4 c : TEXCOORD2; float4 d : TEXCOORD3; }; struct SPIRV_Cross_Output { VOut vout : TEXCOORD0; }; void vert_main() { VOut _26 = { a, b, c, d }; vout = _26; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { a = stage_input.a; b = stage_input.b; c = stage_input.c; d = stage_input.d; vert_main(); SPIRV_Cross_Output stage_output; stage_output.vout = vout; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-hlsl/vert/texture_buffer.vert000066400000000000000000000006161400026215700264410ustar00rootroot00000000000000Buffer uSamp : register(t4); RWBuffer uSampo : register(u5); static float4 gl_Position; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = uSamp.Load(10) + uSampo[100]; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/opt/shaders-msl/000077500000000000000000000000001400026215700213545ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/amd/000077500000000000000000000000001400026215700221155ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/amd/shader_trinary_minmax.msl21.comp000066400000000000000000000002511400026215700303170ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(64u, 1u, 1u); kernel void main0() { } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/000077500000000000000000000000001400026215700221345ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/000077500000000000000000000000001400026215700230725ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/atomic-decrement.asm.comp000066400000000000000000000014751400026215700277600ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct u0_counters { uint c; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } kernel void main0(device u0_counters& u0_counter [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint _29 = atomic_fetch_sub_explicit((device atomic_uint*)&u0_counter.c, 1, memory_order_relaxed); u0.write(uint4(uint(int(gl_GlobalInvocationID.x))), spvTexelBufferCoord(as_type(as_type(_29)))); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/atomic-increment.asm.comp000066400000000000000000000014751400026215700277760ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct u0_counters { uint c; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } kernel void main0(device u0_counters& u0_counter [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint _29 = atomic_fetch_add_explicit((device atomic_uint*)&u0_counter.c, 1, memory_order_relaxed); u0.write(uint4(uint(int(gl_GlobalInvocationID.x))), spvTexelBufferCoord(as_type(as_type(_29)))); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/bitcast_iadd.asm.comp000066400000000000000000000010341400026215700271410ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& restrict _5 [[buffer(0)]], device _4& restrict _6 [[buffer(1)]]) { _6._m0 = _5._m1 + uint4(_5._m0); _6._m0 = uint4(_5._m0) + _5._m1; _6._m0 = _5._m1 + _5._m1; _6._m0 = uint4(_5._m0 + _5._m0); _6._m1 = int4(_5._m1 + _5._m1); _6._m1 = _5._m0 + _5._m0; _6._m1 = int4(_5._m1) + _5._m0; _6._m1 = _5._m0 + int4(_5._m1); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/bitcast_icmp.asm.comp000066400000000000000000000014351400026215700271750ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& restrict _5 [[buffer(0)]], device _4& restrict _6 [[buffer(1)]]) { _6._m0 = select(uint4(0u), uint4(1u), int4(_5._m1) < _5._m0); _6._m0 = select(uint4(0u), uint4(1u), int4(_5._m1) <= _5._m0); _6._m0 = select(uint4(0u), uint4(1u), _5._m1 < uint4(_5._m0)); _6._m0 = select(uint4(0u), uint4(1u), _5._m1 <= uint4(_5._m0)); _6._m0 = select(uint4(0u), uint4(1u), int4(_5._m1) > _5._m0); _6._m0 = select(uint4(0u), uint4(1u), int4(_5._m1) >= _5._m0); _6._m0 = select(uint4(0u), uint4(1u), _5._m1 > uint4(_5._m0)); _6._m0 = select(uint4(0u), uint4(1u), _5._m1 >= uint4(_5._m0)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/bitcast_sar.asm.comp000066400000000000000000000010661400026215700270320ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& _5 [[buffer(0)]], device _4& _6 [[buffer(1)]]) { int4 _22 = _5._m0; uint4 _23 = _5._m1; _6._m0 = uint4(int4(_23) >> _22); _6._m0 = uint4(_22 >> int4(_23)); _6._m0 = uint4(int4(_23) >> int4(_23)); _6._m0 = uint4(_22 >> _22); _6._m1 = int4(_23) >> int4(_23); _6._m1 = _22 >> _22; _6._m1 = int4(_23) >> _22; _6._m1 = _22 >> int4(_23); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/bitcast_sdiv.asm.comp000066400000000000000000000010561400026215700272110ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& _5 [[buffer(0)]], device _4& _6 [[buffer(1)]]) { int4 _22 = _5._m0; uint4 _23 = _5._m1; _6._m0 = uint4(int4(_23) / _22); _6._m0 = uint4(_22 / int4(_23)); _6._m0 = uint4(int4(_23) / int4(_23)); _6._m0 = uint4(_22 / _22); _6._m1 = int4(_23) / int4(_23); _6._m1 = _22 / _22; _6._m1 = int4(_23) / _22; _6._m1 = _22 / int4(_23); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/bitcast_slr.asm.comp000066400000000000000000000010721400026215700270420ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& _5 [[buffer(0)]], device _4& _6 [[buffer(1)]]) { int4 _22 = _5._m0; uint4 _23 = _5._m1; _6._m0 = _23 >> uint4(_22); _6._m0 = uint4(_22) >> _23; _6._m0 = _23 >> _23; _6._m0 = uint4(_22) >> uint4(_22); _6._m1 = int4(_23 >> _23); _6._m1 = int4(uint4(_22) >> uint4(_22)); _6._m1 = int4(_23 >> uint4(_22)); _6._m1 = int4(uint4(_22) >> _23); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/block-name-alias-global.asm.comp000066400000000000000000000014711400026215700310710ustar00rootroot00000000000000#include #include using namespace metal; struct A { int a; int b; }; struct A_1 { A Data[1]; }; struct A_2 { int a; int b; char _m0_final_padding[8]; }; struct A_3 { A_2 Data[1024]; }; struct B { A Data[1]; }; struct B_1 { A_2 Data[1024]; }; kernel void main0(device A_1& C1 [[buffer(0)]], constant A_3& C2 [[buffer(1)]], device B& C3 [[buffer(2)]], constant B_1& C4 [[buffer(3)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { C1.Data[gl_GlobalInvocationID.x].a = C2.Data[gl_GlobalInvocationID.x].a; C1.Data[gl_GlobalInvocationID.x].b = C2.Data[gl_GlobalInvocationID.x].b; C3.Data[gl_GlobalInvocationID.x].a = C4.Data[gl_GlobalInvocationID.x].a; C3.Data[gl_GlobalInvocationID.x].b = C4.Data[gl_GlobalInvocationID.x].b; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/buffer-write-relative-addr.asm.comp000066400000000000000000000017041400026215700316550ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct cb5_struct { float4 _m0[5]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } kernel void main0(constant cb5_struct& cb0_5 [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { uint _44 = as_type(as_type(int(gl_LocalInvocationID.x) << 4)) >> 2u; uint4 _51 = as_type(cb0_5._m0[uint(as_type(as_type(int(gl_LocalInvocationID.x)))) + 1u]); u0.write(_51.xxxx, spvTexelBufferCoord(_44)); u0.write(_51.yyyy, spvTexelBufferCoord((_44 + 1u))); u0.write(_51.zzzz, spvTexelBufferCoord((_44 + 2u))); u0.write(_51.wwww, spvTexelBufferCoord((_44 + 3u))); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/buffer-write.asm.comp000066400000000000000000000012671400026215700271400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct cb { float value; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } kernel void main0(constant cb& _6 [[buffer(0)]], texture2d _buffer [[texture(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { _buffer.write(float4(_6.value), spvTexelBufferCoord(((32u * gl_WorkGroupID.x) + gl_LocalInvocationIndex))); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/global-parameter-name-alias.asm.comp000066400000000000000000000001411400026215700317500ustar00rootroot00000000000000#include #include using namespace metal; kernel void main0() { } image-load-store-short-vector.invalid.asm.comp000066400000000000000000000012431400026215700336650ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; static inline __attribute__((always_inline)) void _main(thread const uint3& id, thread texture2d TargetTexture) { float2 loaded = TargetTexture.read(uint2(id.xy)).xy; float2 storeTemp = loaded + float2(1.0); TargetTexture.write(storeTemp.xyyy, uint2((id.xy + uint2(1u)))); } kernel void main0(texture2d TargetTexture [[texture(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]]) { uint3 id = gl_WorkGroupID; uint3 param = id; _main(param, TargetTexture); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/multiple-entry.asm.comp000066400000000000000000000010341400026215700275210ustar00rootroot00000000000000#include #include using namespace metal; struct _6 { int4 _m0; uint4 _m1; }; struct _7 { uint4 _m0; int4 _m1; }; kernel void main0(device _6& restrict _8 [[buffer(0)]], device _7& restrict _9 [[buffer(1)]]) { _9._m0 = _8._m1 + uint4(_8._m0); _9._m0 = uint4(_8._m0) + _8._m1; _9._m0 = _8._m1 + _8._m1; _9._m0 = uint4(_8._m0 + _8._m0); _9._m1 = int4(_8._m1 + _8._m1); _9._m1 = _8._m0 + _8._m0; _9._m1 = int4(_8._m1) + _8._m0; _9._m1 = _8._m0 + int4(_8._m1); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/quantize.asm.comp000066400000000000000000000006251400026215700263740ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO0 { float scalar; float2 vec2_val; float3 vec3_val; float4 vec4_val; }; kernel void main0(device SSBO0& _4 [[buffer(0)]]) { _4.scalar = float(half(_4.scalar)); _4.vec2_val = float2(half2(_4.vec2_val)); _4.vec3_val = float3(half3(_4.vec3_val)); _4.vec4_val = float4(half4(_4.vec4_val)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/relaxed-block-layout.asm.comp000066400000000000000000000013031400026215700305550ustar00rootroot00000000000000#include #include using namespace metal; struct foo { uint bar; packed_float3 baz; uchar quux; packed_uchar4 blah; packed_half2 wibble; }; kernel void main0(device foo& _8 [[buffer(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_NumWorkGroups [[threadgroups_per_grid]]) { _8.bar = gl_LocalInvocationID.x; _8.baz = float3(gl_GlobalInvocationID); _8.blah = uchar4(uint4(uint4(uchar4(_8.blah)).xyz + gl_WorkGroupID, 0u)); _8.wibble = half2(float2(half2(_8.wibble)) * float2(gl_NumWorkGroups.xy)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/specialization-constant-workgroup.asm.comp000066400000000000000000000007441400026215700334400ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float a; }; constant uint _5_tmp [[function_constant(10)]]; constant uint _5 = is_function_constant_defined(_5_tmp) ? _5_tmp : 9u; constant uint _6_tmp [[function_constant(12)]]; constant uint _6 = is_function_constant_defined(_6_tmp) ? _6_tmp : 4u; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(_5, 20u, _6); kernel void main0(device SSBO& _4 [[buffer(0)]]) { _4.a += 1.0; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/struct-resource-name-aliasing.asm.comp000066400000000000000000000003721400026215700324070ustar00rootroot00000000000000#include #include using namespace metal; struct bufA { uint _data[1]; }; kernel void main0(device bufA& bufA_1 [[buffer(0)]], device bufA& bufB [[buffer(1)]]) { bufA_1._data[0] = 0u; bufB._data[0] = 0u; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/variable-pointers-2.asm.comp000066400000000000000000000020271400026215700303170ustar00rootroot00000000000000#include #include using namespace metal; struct foo { int a[128]; uint b; float2 c; }; struct bar { int d; }; kernel void main0(device foo& buf [[buffer(0)]], constant bar& cb [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { bool _71 = cb.d != 0; device foo* _72 = _71 ? &buf : nullptr; device foo* _67 = _72; device foo* _45 = _72; thread uint3* _79 = _71 ? &gl_GlobalInvocationID : &gl_LocalInvocationID; thread uint3* _74 = _79; device int* _52; device int* _55; _52 = &_72->a[0u]; _55 = &buf.a[0u]; int _57; int _58; for (;;) { _57 = *_52; _58 = *_55; if (_57 != _58) { int _66 = (_57 + _58) + int((*_79).x); *_52 = _66; *_55 = _66; _52 = &_52[1u]; _55 = &_55[1u]; continue; } else { break; } } } variable-pointers-store-forwarding.asm.comp000066400000000000000000000006731400026215700334000ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp#include #include using namespace metal; struct foo { int a; }; struct bar { int b; }; kernel void main0(device foo& x [[buffer(0)]], device bar& y [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { device int* _47 = (gl_GlobalInvocationID.x != 0u) ? &x.a : &y.b; device int* _40 = _47; device int* _33 = _47; int _37 = x.a; *_47 = 0; y.b = _37 + _37; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/vector-builtin-type-cast-func.asm.comp000066400000000000000000000014011400026215700323330ustar00rootroot00000000000000#include #include using namespace metal; struct cb1_struct { float4 _RESERVED_IDENTIFIER_FIXUP_m0[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(16u, 16u, 1u); kernel void main0(constant cb1_struct& cb0_1 [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { int2 _46 = int2(u0.get_width(), u0.get_height()) >> int2(uint2(4u)); int _98; _98 = 0; for (; _98 < _46.y; _98++) { for (int _99 = 0; _99 < _46.x; ) { u0.write(cb0_1._RESERVED_IDENTIFIER_FIXUP_m0[0].xxxx, uint2(((_46 * int3(gl_LocalInvocationID).xy) + int2(_98, _99)))); _99++; continue; } } } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/comp/vector-builtin-type-cast.asm.comp000066400000000000000000000014011400026215700314020ustar00rootroot00000000000000#include #include using namespace metal; struct cb1_struct { float4 _RESERVED_IDENTIFIER_FIXUP_m0[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(16u, 16u, 1u); kernel void main0(constant cb1_struct& cb0_1 [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { int2 _40 = int2(u0.get_width(), u0.get_height()) >> int2(uint2(4u)); int _80; _80 = 0; for (; _80 < _40.y; _80++) { for (int _81 = 0; _81 < _40.x; ) { u0.write(cb0_1._RESERVED_IDENTIFIER_FIXUP_m0[0].xxxx, uint2(((_40 * int3(gl_LocalInvocationID).xy) + int2(_80, _81)))); _81++; continue; } } } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/000077500000000000000000000000001400026215700230535ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/combined-sampler-reuse.asm.frag000066400000000000000000000007171400026215700310420ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uTex [[texture(0)]], sampler uSampler [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample(uSampler, in.vUV); out.FragColor += uTex.sample(uSampler, in.vUV, int2(1)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/default-member-names.asm.frag000066400000000000000000000003711400026215700304660ustar00rootroot00000000000000#include #include using namespace metal; constant float _49 = {}; struct main0_out { float4 m_3 [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.m_3 = float4(_49); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/descriptor-array-unnamed.asm.frag000066400000000000000000000015631400026215700314170ustar00rootroot00000000000000#include #include using namespace metal; struct _4 { float4 _m0; }; struct _6 { int _m0; }; struct _7 { float4 _m0; }; struct main0_out { float4 m_3 [[color(0)]]; }; fragment main0_out main0(const device _4* _5_0 [[buffer(0)]], const device _4* _5_1 [[buffer(1)]], const device _4* _5_2 [[buffer(2)]], const device _4* _5_3 [[buffer(3)]], constant _6& _20 [[buffer(4)]], constant _7* _8_0 [[buffer(5)]], constant _7* _8_1 [[buffer(6)]], constant _7* _8_2 [[buffer(7)]], constant _7* _8_3 [[buffer(8)]]) { const device _4* _5[] = { _5_0, _5_1, _5_2, _5_3, }; constant _7* _8[] = { _8_0, _8_1, _8_2, _8_3, }; main0_out out = {}; out.m_3 = _5[_20._m0]->_m0 + (_8[_20._m0]->_m0 * float4(0.20000000298023223876953125)); return out; } disable-renamed-output.frag-output.asm.frag000066400000000000000000000013521400026215700332430ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag#include #include using namespace metal; struct main0_out { float4 o1 [[color(1)]]; float4 o3 [[color(3)]]; float4 o6 [[color(6)]]; float4 o7 [[color(7)]]; }; fragment main0_out main0() { float4 o0; float4 o2; float4 o4; float4 o5; float gl_FragDepth; int gl_FragStencilRefARB; main0_out out = {}; o0 = float4(0.0, 0.0, 0.0, 1.0); out.o1 = float4(1.0, 0.0, 0.0, 1.0); o2 = float4(0.0, 1.0, 0.0, 1.0); out.o3 = float4(0.0, 0.0, 1.0, 1.0); o4 = float4(1.0, 0.0, 1.0, 0.5); o5 = float4(0.25); out.o6 = float4(0.75); out.o7 = float4(1.0); gl_FragDepth = 0.89999997615814208984375; gl_FragStencilRefARB = uint(127); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/empty-struct.asm.frag000066400000000000000000000001431400026215700271510ustar00rootroot00000000000000#include #include using namespace metal; fragment void main0() { } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/extract-packed-from-composite.asm.frag000066400000000000000000000010241400026215700323300ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { packed_float3 a; float b; }; struct buf { Foo results[16]; float4 bar; }; struct main0_out { float4 _entryPointOutput [[color(0)]]; }; fragment main0_out main0(constant buf& _11 [[buffer(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; int _68 = int(gl_FragCoord.x) % 16; out._entryPointOutput = float4(dot(float3(_11.results[_68].a), _11.bar.xyz), _11.results[_68].b, 0.0, 0.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/frem.asm.frag000066400000000000000000000005361400026215700254300ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vA [[user(locn0)]]; float4 vB [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = fmod(in.vA, in.vB); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/function-overload-alias.asm.frag000066400000000000000000000003541400026215700312220ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(10.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/image-extract-reuse.asm.frag000066400000000000000000000006111400026215700303440ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { int2 Size [[color(0)]]; }; fragment main0_out main0(texture2d uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]]) { main0_out out = {}; out.Size = int2(uTexture.get_width(), uTexture.get_height()) + int2(uTexture.get_width(1), uTexture.get_height(1)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/implicit-read-dep-phi.asm.frag000066400000000000000000000016401400026215700305430ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 v0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uImage [[texture(0)]], sampler uImageSmplr [[sampler(0)]]) { main0_out out = {}; float phi; float4 _36; int _51; _51 = 0; phi = 1.0; _36 = float4(1.0, 2.0, 1.0, 2.0); for (;;) { out.FragColor = _36; if (_51 < 4) { if (in.v0[_51] > 0.0) { float2 _48 = float2(phi); _51++; phi += 2.0; _36 = uImage.sample(uImageSmplr, _48, level(0.0)); continue; } else { break; } } else { break; } } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/inf-nan-constant.asm.frag000066400000000000000000000004751400026215700276560ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float3 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float3(as_type(0x7f800000u), as_type(0xff800000u), as_type(0x7fc00000u)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/interpolation-qualifiers-struct.asm.frag000066400000000000000000000020271400026215700330470ustar00rootroot00000000000000#include #include using namespace metal; struct Input { float2 v0; float2 v1; float3 v2; float4 v3; float v4; float v5; float v6; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 Input_v0 [[user(locn0)]]; float2 Input_v1 [[user(locn1), center_no_perspective]]; float3 Input_v2 [[user(locn2), centroid_perspective]]; float4 Input_v3 [[user(locn3), centroid_no_perspective]]; float Input_v4 [[user(locn4), sample_perspective]]; float Input_v5 [[user(locn5), sample_no_perspective]]; float Input_v6 [[user(locn6), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; Input inp = {}; inp.v0 = in.Input_v0; inp.v1 = in.Input_v1; inp.v2 = in.Input_v2; inp.v3 = in.Input_v3; inp.v4 = in.Input_v4; inp.v5 = in.Input_v5; inp.v6 = in.Input_v6; out.FragColor = float4(inp.v0.x + inp.v1.y, inp.v2.xy, ((inp.v3.w * inp.v4) + inp.v5) - inp.v6); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/line-directive.line.asm.frag000066400000000000000000000032421400026215700303250ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float vColor [[user(locn0)]]; }; #line 8 "test.frag" fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; #line 8 "test.frag" out.FragColor = 1.0; #line 9 "test.frag" out.FragColor = 2.0; #line 10 "test.frag" if (in.vColor < 0.0) { #line 12 "test.frag" out.FragColor = 3.0; } else { #line 16 "test.frag" out.FragColor = 4.0; } #line 19 "test.frag" for (int _127 = 0; float(_127) < (40.0 + in.vColor); ) { #line 21 "test.frag" out.FragColor += 0.20000000298023223876953125; #line 22 "test.frag" out.FragColor += 0.300000011920928955078125; #line 19 "test.frag" _127 += (int(in.vColor) + 5); continue; } #line 25 "test.frag" switch (int(in.vColor)) { case 0: { #line 28 "test.frag" out.FragColor += 0.20000000298023223876953125; #line 29 "test.frag" break; } case 1: { #line 32 "test.frag" out.FragColor += 0.4000000059604644775390625; #line 33 "test.frag" break; } default: { #line 36 "test.frag" out.FragColor += 0.800000011920928955078125; #line 37 "test.frag" break; } } for (;;) { #line 42 "test.frag" out.FragColor += (10.0 + in.vColor); #line 43 "test.frag" #line 42 "test.frag" #line 43 "test.frag" if (out.FragColor < 100.0) { } else { break; } } #line 48 "test.frag" return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/locations-components.asm.frag000066400000000000000000000014011400026215700306450ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 o0 [[color(0)]]; }; struct main0_in { float2 m_2 [[user(locn1)]]; float m_3 [[user(locn1_2)]]; float m_4 [[user(locn2), flat]]; uint m_5 [[user(locn2_1)]]; uint m_6 [[user(locn2_2)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float4 v1; v1 = float4(in.m_2.x, in.m_2.y, v1.z, v1.w); v1.z = in.m_3; float4 v2; v2.x = in.m_4; v2.y = as_type(in.m_5); v2.z = as_type(in.m_6); out.o0.y = float(as_type(as_type(as_type(v2.y) + as_type(v2.z)))); out.o0.x = v1.y + v2.x; out.o0 = float4(out.o0.x, out.o0.y, v1.z, v1.x); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/lut-promotion-initializer.asm.frag000066400000000000000000000045211400026215700316460ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _46 = spvUnsafeArray({ 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0 }); constant spvUnsafeArray _76 = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); constant spvUnsafeArray _90 = spvUnsafeArray({ float4(20.0), float4(30.0), float4(50.0), float4(60.0) }); struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { int index [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { spvUnsafeArray foobar = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); spvUnsafeArray baz = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); main0_out out = {}; out.FragColor = _46[in.index]; if (in.index < 10) { out.FragColor += _46[in.index ^ 1]; } else { out.FragColor += _46[in.index & 1]; } bool _99 = in.index > 30; if (_99) { out.FragColor += _76[in.index & 3].y; } else { out.FragColor += _76[in.index & 1].x; } if (_99) { foobar[1].z = 20.0; } int _37 = in.index & 3; out.FragColor += foobar[_37].z; baz = _90; out.FragColor += baz[_37].z; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/min-lod.msl22.asm.frag000066400000000000000000000006701400026215700267730ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = uSampler.sample(uSamplerSmplr, in.vUV, min_lod_clamp(4.0)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/op-constant-null.asm.frag000066400000000000000000000003421400026215700277070ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = 0.0; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/op-image-sampled-image.asm.frag000066400000000000000000000006751400026215700307040ustar00rootroot00000000000000#include #include using namespace metal; struct push_cb { float4 cb0[1]; }; struct main0_out { float4 o0 [[color(0)]]; }; fragment main0_out main0(constant push_cb& _19 [[buffer(0)]], texture2d t0 [[texture(0)]], sampler dummy_sampler [[sampler(0)]]) { main0_out out = {}; out.o0 = t0.read(uint2(as_type(_19.cb0[0u].zw)) + uint2(int2(-1, -2)), as_type(0.0)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/pass-by-value.asm.frag000066400000000000000000000005041400026215700271620ustar00rootroot00000000000000#include #include using namespace metal; struct Registers { float foo; }; struct main0_out { float FragColor [[color(0)]]; }; fragment main0_out main0(constant Registers& registers [[buffer(0)]]) { main0_out out = {}; out.FragColor = 10.0 + registers.foo; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/phi-loop-variable.asm.frag000066400000000000000000000001431400026215700300030ustar00rootroot00000000000000#include #include using namespace metal; fragment void main0() { } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/pull-model-interpolation.asm.msl23.frag000066400000000000000000000217411400026215700323760ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct _13 { float4 x; float4 y; float4 z; spvUnsafeArray u; spvUnsafeArray v; spvUnsafeArray w; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { interpolant foo [[user(locn0)]]; interpolant bar [[user(locn1)]]; interpolant baz [[user(locn2)]]; int sid [[user(locn3)]]; interpolant a_0 [[user(locn4)]]; interpolant a_1 [[user(locn5)]]; interpolant b_0 [[user(locn6)]]; interpolant b_1 [[user(locn7)]]; interpolant c_0 [[user(locn8)]]; interpolant c_1 [[user(locn9)]]; interpolant m_13_x [[user(locn10)]]; interpolant m_13_y [[user(locn11)]]; interpolant m_13_z [[user(locn12)]]; interpolant m_13_u_0 [[user(locn13)]]; interpolant m_13_u_1 [[user(locn14)]]; interpolant m_13_v_0 [[user(locn15)]]; interpolant m_13_v_1 [[user(locn16)]]; interpolant m_13_w_0 [[user(locn17)]]; interpolant m_13_w_1 [[user(locn18)]]; interpolant m_13_w_2 [[user(locn19)]]; }; fragment main0_out main0(main0_in in [[stage_in]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; spvUnsafeArray a = {}; _13 s = {}; spvUnsafeArray b = {}; spvUnsafeArray c = {}; a[0] = in.a_0.interpolate_at_center(); a[1] = in.a_1.interpolate_at_center(); s.x = in.m_13_x.interpolate_at_center(); s.y = in.m_13_y.interpolate_at_centroid(); s.z = in.m_13_z.interpolate_at_sample(gl_SampleID); s.u[0] = in.m_13_u_0.interpolate_at_centroid(); s.u[1] = in.m_13_u_1.interpolate_at_centroid(); s.v[0] = in.m_13_v_0.interpolate_at_sample(gl_SampleID); s.v[1] = in.m_13_v_1.interpolate_at_sample(gl_SampleID); s.w[0] = in.m_13_w_0.interpolate_at_center(); s.w[1] = in.m_13_w_1.interpolate_at_center(); s.w[2] = in.m_13_w_2.interpolate_at_center(); b[0] = in.b_0.interpolate_at_centroid(); b[1] = in.b_1.interpolate_at_centroid(); c[0] = in.c_0.interpolate_at_sample(gl_SampleID); c[1] = in.c_1.interpolate_at_sample(gl_SampleID); out.FragColor = in.foo.interpolate_at_center(); out.FragColor += in.foo.interpolate_at_centroid(); out.FragColor += in.foo.interpolate_at_sample(in.sid); out.FragColor += in.foo.interpolate_at_offset(float2(0.100000001490116119384765625) + 0.4375); float3 _65 = out.FragColor.xyz + in.bar.interpolate_at_centroid(); out.FragColor = float4(_65.x, _65.y, _65.z, out.FragColor.w); float3 _71 = out.FragColor.xyz + in.bar.interpolate_at_centroid(); out.FragColor = float4(_71.x, _71.y, _71.z, out.FragColor.w); float3 _78 = out.FragColor.xyz + in.bar.interpolate_at_sample(in.sid); out.FragColor = float4(_78.x, _78.y, _78.z, out.FragColor.w); float3 _84 = out.FragColor.xyz + in.bar.interpolate_at_offset(float2(-0.100000001490116119384765625) + 0.4375); out.FragColor = float4(_84.x, _84.y, _84.z, out.FragColor.w); float2 _91 = out.FragColor.xy + b[0]; out.FragColor = float4(_91.x, _91.y, out.FragColor.z, out.FragColor.w); float2 _98 = out.FragColor.xy + in.b_1.interpolate_at_centroid(); out.FragColor = float4(_98.x, _98.y, out.FragColor.z, out.FragColor.w); float2 _105 = out.FragColor.xy + in.b_0.interpolate_at_sample(2); out.FragColor = float4(_105.x, _105.y, out.FragColor.z, out.FragColor.w); float2 _112 = out.FragColor.xy + in.b_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); out.FragColor = float4(_112.x, _112.y, out.FragColor.z, out.FragColor.w); float2 _119 = out.FragColor.xy + c[0]; out.FragColor = float4(_119.x, _119.y, out.FragColor.z, out.FragColor.w); float2 _127 = out.FragColor.xy + in.c_1.interpolate_at_centroid().xy; out.FragColor = float4(_127.x, _127.y, out.FragColor.z, out.FragColor.w); float2 _135 = out.FragColor.xy + in.c_0.interpolate_at_sample(2).yx; out.FragColor = float4(_135.x, _135.y, out.FragColor.z, out.FragColor.w); float2 _143 = out.FragColor.xy + in.c_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375).xx; out.FragColor = float4(_143.x, _143.y, out.FragColor.z, out.FragColor.w); out.FragColor += s.x; out.FragColor += in.m_13_x.interpolate_at_centroid(); out.FragColor += in.m_13_x.interpolate_at_sample(in.sid); out.FragColor += in.m_13_x.interpolate_at_offset(float2(0.100000001490116119384765625) + 0.4375); out.FragColor += s.y; out.FragColor += in.m_13_y.interpolate_at_centroid(); out.FragColor += in.m_13_y.interpolate_at_sample(in.sid); out.FragColor += in.m_13_y.interpolate_at_offset(float2(-0.100000001490116119384765625) + 0.4375); float2 _184 = out.FragColor.xy + s.v[0]; out.FragColor = float4(_184.x, _184.y, out.FragColor.z, out.FragColor.w); float2 _191 = out.FragColor.xy + in.m_13_v_1.interpolate_at_centroid(); out.FragColor = float4(_191.x, _191.y, out.FragColor.z, out.FragColor.w); float2 _198 = out.FragColor.xy + in.m_13_v_0.interpolate_at_sample(2); out.FragColor = float4(_198.x, _198.y, out.FragColor.z, out.FragColor.w); float2 _205 = out.FragColor.xy + in.m_13_v_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); out.FragColor = float4(_205.x, _205.y, out.FragColor.z, out.FragColor.w); out.FragColor.x += s.w[0]; out.FragColor.x += in.m_13_w_1.interpolate_at_centroid(); out.FragColor.x += in.m_13_w_0.interpolate_at_sample(2); out.FragColor.x += in.m_13_w_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); float2 _328 = out.FragColor.xy + in.baz.interpolate_at_sample(gl_SampleID); out.FragColor = float4(_328.x, _328.y, out.FragColor.z, out.FragColor.w); out.FragColor.x += in.baz.interpolate_at_centroid().x; out.FragColor.y += in.baz.interpolate_at_sample(3).y; out.FragColor.z += in.baz.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375).y; float2 _353 = out.FragColor.xy + in.a_1.interpolate_at_centroid(); out.FragColor = float4(_353.x, _353.y, out.FragColor.z, out.FragColor.w); float2 _360 = out.FragColor.xy + in.a_0.interpolate_at_sample(2); out.FragColor = float4(_360.x, _360.y, out.FragColor.z, out.FragColor.w); float2 _367 = out.FragColor.xy + in.a_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); out.FragColor = float4(_367.x, _367.y, out.FragColor.z, out.FragColor.w); out.FragColor += s.z; float2 _379 = out.FragColor.xy + in.m_13_z.interpolate_at_centroid().yy; out.FragColor = float4(_379.x, _379.y, out.FragColor.z, out.FragColor.w); float2 _387 = out.FragColor.yz + in.m_13_z.interpolate_at_sample(3).xy; out.FragColor = float4(out.FragColor.x, _387.x, _387.y, out.FragColor.w); float2 _395 = out.FragColor.zw + in.m_13_z.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375).wx; out.FragColor = float4(out.FragColor.x, out.FragColor.y, _395.x, _395.y); out.FragColor += s.u[0]; out.FragColor += in.m_13_u_1.interpolate_at_centroid(); out.FragColor += in.m_13_u_0.interpolate_at_sample(2); out.FragColor += in.m_13_u_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/sample-and-compare.asm.frag000066400000000000000000000011131400026215700301340ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float out_var_SV_Target [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d g_Texture [[texture(0)]], sampler g_Sampler [[sampler(0)]], sampler g_CompareSampler [[sampler(1)]]) { main0_out out = {}; out.out_var_SV_Target = float4(g_Texture.sample(g_Sampler, in.in_var_TEXCOORD0)).x + g_Texture.sample_compare(g_CompareSampler, in.in_var_TEXCOORD0, 0.5, level(0.0)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/single-function-private-lut.asm.frag000066400000000000000000000033171400026215700320550ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct myType { float data; }; struct main0_out { float4 o_color [[color(0)]]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } fragment main0_out main0(float4 gl_FragCoord [[position]]) { spvUnsafeArray _21 = spvUnsafeArray({ myType{ 0.0 }, myType{ 1.0 }, myType{ 0.0 }, myType{ 1.0 }, myType{ 0.0 } }); main0_out out = {}; if (_21[int(mod(gl_FragCoord.x, 4.0))].data > 0.0) { out.o_color = float4(0.0, 1.0, 0.0, 1.0); } else { out.o_color = float4(1.0, 0.0, 0.0, 1.0); } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/srem.asm.frag000066400000000000000000000005571400026215700254500ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int4 vA [[user(locn0)]]; int4 vB [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = float4(in.vA - in.vB * (in.vA / in.vB)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/storage-class-output-initializer.asm.frag000066400000000000000000000030371400026215700331240ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _20 = spvUnsafeArray({ float4(1.0, 2.0, 3.0, 4.0), float4(10.0) }); struct main0_out { float4 FragColors_0 [[color(0)]]; float4 FragColors_1 [[color(1)]]; float4 FragColor [[color(2)]]; }; fragment main0_out main0() { main0_out out = {}; spvUnsafeArray FragColors = spvUnsafeArray({ float4(1.0, 2.0, 3.0, 4.0), float4(10.0) }); out.FragColor = float4(5.0); out.FragColors_0 = FragColors[0]; out.FragColors_1 = FragColors[1]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/texel-fetch-no-lod.asm.frag000066400000000000000000000005761400026215700301010ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = uTexture.read(uint2(int2(gl_FragCoord.xy)), 0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/texture-atomics.asm.frag000066400000000000000000000074141400026215700276360ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_StructuredBuffer_v4float { spvUnsafeArray _m0; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device type_StructuredBuffer_v4float& CulledObjectBoxBounds [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d RWShadowTileNumCulledObjects [[texture(2)]], device atomic_uint* RWShadowTileNumCulledObjects_atomic [[buffer(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float((_Globals.ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2(_Globals.ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _107 = _103 + 1u; if (all(CulledObjectBoxBounds._m0[_107].xy > _96.xy) && all(CulledObjectBoxBounds._m0[_103].xyz < _102)) { float _122 = _96.x; float _123 = _96.y; spvUnsafeArray _73; _73[0] = float3(_122, _123, -1000.0); float _126 = _100.x; _73[1] = float3(_126, _123, -1000.0); float _129 = _100.y; _73[2] = float3(_122, _129, -1000.0); _73[3] = float3(_126, _129, -1000.0); _73[4] = float3(_122, _123, 1.0); _73[5] = float3(_126, _123, 1.0); _73[6] = float3(_122, _129, 1.0); _73[7] = float3(_126, _129, 1.0); float3 _155; float3 _158; _155 = float3(-500000.0); _158 = float3(500000.0); for (int _160 = 0; _160 < 8; ) { float3 _166 = _73[_160] - (float3(0.5) * (CulledObjectBoxBounds._m0[_103].xyz + CulledObjectBoxBounds._m0[_107].xyz)); float3 _170 = float3(dot(_166, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); _155 = fast::max(_155, _170); _158 = fast::min(_158, _170); _160++; continue; } if (all(_158 < float3(1.0)) && all(_155 > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&RWShadowTileNumCulledObjects_atomic[(_78 * _Globals.ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } texture-atomics.asm.graphics-robust-access.frag000066400000000000000000000104521400026215700341250ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_StructuredBuffer_v4float { spvUnsafeArray _m0; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvBufferSizeConstants [[buffer(25)]], const device type_StructuredBuffer_v4float& CulledObjectBoxBounds [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d RWShadowTileNumCulledObjects [[texture(2)]], device atomic_uint* RWShadowTileNumCulledObjects_atomic [[buffer(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; constant uint& CulledObjectBoxBoundsBufferSize = spvBufferSizeConstants[0]; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float((_Globals.ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2(_Globals.ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _186 = clamp(_103 + 1u, 0u, ((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u); if (all(CulledObjectBoxBounds._m0[_186].xy > _96.xy) && all(CulledObjectBoxBounds._m0[clamp(_103, 0u, ((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u)].xyz < _102)) { float _122 = _96.x; float _123 = _96.y; spvUnsafeArray _73; _73[0] = float3(_122, _123, -1000.0); float _126 = _100.x; _73[1] = float3(_126, _123, -1000.0); float _129 = _100.y; _73[2] = float3(_122, _129, -1000.0); _73[3] = float3(_126, _129, -1000.0); _73[4] = float3(_122, _123, 1.0); _73[5] = float3(_126, _123, 1.0); _73[6] = float3(_122, _129, 1.0); _73[7] = float3(_126, _129, 1.0); float3 _155; float3 _158; _155 = float3(-500000.0); _158 = float3(500000.0); for (int _160 = 0; _160 < 8; ) { float3 _166 = _73[int(clamp(uint(_160), uint(0), uint(7)))] - (float3(0.5) * (CulledObjectBoxBounds._m0[clamp(_103, 0u, ((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u)].xyz + CulledObjectBoxBounds._m0[_186].xyz)); float3 _170 = float3(dot(_166, CulledObjectBoxBounds._m0[clamp(_103 + 2u, 0u, ((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u)].xyz), dot(_166, CulledObjectBoxBounds._m0[clamp(_103 + 3u, 0u, ((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u)].xyz), dot(_166, CulledObjectBoxBounds._m0[clamp(_103 + 4u, 0u, ((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u)].xyz)); _155 = fast::max(_155, _170); _158 = fast::min(_158, _170); _160++; continue; } if (all(_158 < float3(1.0)) && all(_155 > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&RWShadowTileNumCulledObjects_atomic[(_78 * _Globals.ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/texture-sampling-fp16.asm.frag000066400000000000000000000006571400026215700305650ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { half4 FragColor [[color(0)]]; }; struct main0_in { half2 UV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = half4(uTexture.sample(uTextureSmplr, float2(in.UV))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/undef-variable-store.asm.frag000066400000000000000000000004121400026215700305060ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 _entryPointOutput [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out._entryPointOutput = float4(1.0, 1.0, 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/unknown-depth-state.asm.frag000066400000000000000000000010641400026215700304130ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d uShadow [[texture(0)]], depth2d uTexture [[texture(1)]], sampler uShadowSmplr [[sampler(0)]], sampler uSampler [[sampler(1)]]) { main0_out out = {}; out.FragColor = uShadow.sample_compare(uShadowSmplr, in.vUV.xy, in.vUV.z) + uTexture.sample_compare(uSampler, in.vUV.xy, in.vUV.z); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/unord-relational-op.asm.frag000066400000000000000000000007301400026215700303660ustar00rootroot00000000000000#include #include using namespace metal; constant float a_tmp [[function_constant(1)]]; constant float a = is_function_constant_defined(a_tmp) ? a_tmp : 1.0; constant float b_tmp [[function_constant(2)]]; constant float b = is_function_constant_defined(b_tmp) ? b_tmp : 2.0; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(a + b); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/unreachable.asm.frag000066400000000000000000000010241400026215700267410ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int counter [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float4 _33; for (;;) { if (in.counter == 10) { _33 = float4(10.0); break; } else { _33 = float4(30.0); break; } } out.FragColor = _33; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/frag/vector-shuffle-oom.asm.frag000066400000000000000000000201071400026215700302170ustar00rootroot00000000000000#include #include using namespace metal; struct _28 { float4 _m0; }; struct _6 { float4 _m0; float _m1; float4 _m2; }; struct _10 { float3 _m0; packed_float3 _m1; float _m2; packed_float3 _m3; float _m4; packed_float3 _m5; float _m6; packed_float3 _m7; float _m8; packed_float3 _m9; float _m10; packed_float3 _m11; float _m12; float2 _m13; float2 _m14; packed_float3 _m15; float _m16; float _m17; float _m18; float _m19; float _m20; float4 _m21; float4 _m22; float4x4 _m23; float4 _m24; }; struct _18 { float4x4 _m0; float4x4 _m1; float4x4 _m2; float4x4 _m3; float4 _m4; float4 _m5; float _m6; float _m7; float _m8; float _m9; packed_float3 _m10; float _m11; packed_float3 _m12; float _m13; packed_float3 _m14; float _m15; packed_float3 _m16; float _m17; float _m18; float _m19; float2 _m20; float2 _m21; float2 _m22; float4 _m23; float2 _m24; float2 _m25; float2 _m26; char _m27_pad[8]; packed_float3 _m27; float _m28; float _m29; float _m30; float _m31; float _m32; float2 _m33; float _m34; float _m35; float3 _m36; float4x4 _m37[2]; float4 _m38[2]; }; constant _28 _74 = {}; struct main0_out { float4 m_5 [[color(0)]]; }; fragment main0_out main0(constant _6& _7 [[buffer(0)]], constant _10& _11 [[buffer(1)]], constant _18& _19 [[buffer(2)]], texture2d _8 [[texture(0)]], texture2d _12 [[texture(1)]], texture2d _14 [[texture(2)]], sampler _9 [[sampler(0)]], sampler _13 [[sampler(1)]], sampler _15 [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; float2 _82 = gl_FragCoord.xy * _19._m23.xy; float4 _88 = _7._m2 * _7._m0.xyxy; float2 _95 = _88.xy; float2 _96 = _88.zw; float2 _97 = fast::clamp(_82 + (float2(0.0, -2.0) * _7._m0.xy), _95, _96); float3 _109 = float3(_11._m5) * fast::clamp(_8.sample(_9, _97, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _113 = _12.sample(_13, _97, level(0.0)); float _114 = _113.y; float3 _129; if (_114 > 0.0) { _129 = _109 + (_14.sample(_15, _97, level(0.0)).xyz * fast::clamp(_114 * _113.z, 0.0, 1.0)); } else { _129 = _109; } float2 _144 = fast::clamp(_82 + (float2(-1.0) * _7._m0.xy), _95, _96); float3 _156 = float3(_11._m5) * fast::clamp(_8.sample(_9, _144, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _160 = _12.sample(_13, _144, level(0.0)); float _161 = _160.y; float3 _176; if (_161 > 0.0) { _176 = _156 + (_14.sample(_15, _144, level(0.0)).xyz * fast::clamp(_161 * _160.z, 0.0, 1.0)); } else { _176 = _156; } float2 _191 = fast::clamp(_82 + (float2(0.0, -1.0) * _7._m0.xy), _95, _96); float3 _203 = float3(_11._m5) * fast::clamp(_8.sample(_9, _191, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _207 = _12.sample(_13, _191, level(0.0)); float _208 = _207.y; float3 _223; if (_208 > 0.0) { _223 = _203 + (_14.sample(_15, _191, level(0.0)).xyz * fast::clamp(_208 * _207.z, 0.0, 1.0)); } else { _223 = _203; } float2 _238 = fast::clamp(_82 + (float2(1.0, -1.0) * _7._m0.xy), _95, _96); float3 _250 = float3(_11._m5) * fast::clamp(_8.sample(_9, _238, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _254 = _12.sample(_13, _238, level(0.0)); float _255 = _254.y; float3 _270; if (_255 > 0.0) { _270 = _250 + (_14.sample(_15, _238, level(0.0)).xyz * fast::clamp(_255 * _254.z, 0.0, 1.0)); } else { _270 = _250; } float2 _285 = fast::clamp(_82 + (float2(-2.0, 0.0) * _7._m0.xy), _95, _96); float3 _297 = float3(_11._m5) * fast::clamp(_8.sample(_9, _285, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _301 = _12.sample(_13, _285, level(0.0)); float _302 = _301.y; float3 _317; if (_302 > 0.0) { _317 = _297 + (_14.sample(_15, _285, level(0.0)).xyz * fast::clamp(_302 * _301.z, 0.0, 1.0)); } else { _317 = _297; } float2 _332 = fast::clamp(_82 + (float2(-1.0, 0.0) * _7._m0.xy), _95, _96); float3 _344 = float3(_11._m5) * fast::clamp(_8.sample(_9, _332, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _348 = _12.sample(_13, _332, level(0.0)); float _349 = _348.y; float3 _364; if (_349 > 0.0) { _364 = _344 + (_14.sample(_15, _332, level(0.0)).xyz * fast::clamp(_349 * _348.z, 0.0, 1.0)); } else { _364 = _344; } float2 _379 = fast::clamp(_82, _95, _96); float3 _391 = float3(_11._m5) * fast::clamp(_8.sample(_9, _379, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _395 = _12.sample(_13, _379, level(0.0)); float _396 = _395.y; float3 _411; if (_396 > 0.0) { _411 = _391 + (_14.sample(_15, _379, level(0.0)).xyz * fast::clamp(_396 * _395.z, 0.0, 1.0)); } else { _411 = _391; } float2 _426 = fast::clamp(_82 + (float2(1.0, 0.0) * _7._m0.xy), _95, _96); float3 _438 = float3(_11._m5) * fast::clamp(_8.sample(_9, _426, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _442 = _12.sample(_13, _426, level(0.0)); float _443 = _442.y; float3 _458; if (_443 > 0.0) { _458 = _438 + (_14.sample(_15, _426, level(0.0)).xyz * fast::clamp(_443 * _442.z, 0.0, 1.0)); } else { _458 = _438; } float2 _473 = fast::clamp(_82 + (float2(2.0, 0.0) * _7._m0.xy), _95, _96); float3 _485 = float3(_11._m5) * fast::clamp(_8.sample(_9, _473, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _489 = _12.sample(_13, _473, level(0.0)); float _490 = _489.y; float3 _505; if (_490 > 0.0) { _505 = _485 + (_14.sample(_15, _473, level(0.0)).xyz * fast::clamp(_490 * _489.z, 0.0, 1.0)); } else { _505 = _485; } float2 _520 = fast::clamp(_82 + (float2(-1.0, 1.0) * _7._m0.xy), _95, _96); float3 _532 = float3(_11._m5) * fast::clamp(_8.sample(_9, _520, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _536 = _12.sample(_13, _520, level(0.0)); float _537 = _536.y; float3 _552; if (_537 > 0.0) { _552 = _532 + (_14.sample(_15, _520, level(0.0)).xyz * fast::clamp(_537 * _536.z, 0.0, 1.0)); } else { _552 = _532; } float2 _567 = fast::clamp(_82 + (float2(0.0, 1.0) * _7._m0.xy), _95, _96); float3 _579 = float3(_11._m5) * fast::clamp(_8.sample(_9, _567, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _583 = _12.sample(_13, _567, level(0.0)); float _584 = _583.y; float3 _599; if (_584 > 0.0) { _599 = _579 + (_14.sample(_15, _567, level(0.0)).xyz * fast::clamp(_584 * _583.z, 0.0, 1.0)); } else { _599 = _579; } float2 _614 = fast::clamp(_82 + _7._m0.xy, _95, _96); float3 _626 = float3(_11._m5) * fast::clamp(_8.sample(_9, _614, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _630 = _12.sample(_13, _614, level(0.0)); float _631 = _630.y; float3 _646; if (_631 > 0.0) { _646 = _626 + (_14.sample(_15, _614, level(0.0)).xyz * fast::clamp(_631 * _630.z, 0.0, 1.0)); } else { _646 = _626; } float2 _661 = fast::clamp(_82 + (float2(0.0, 2.0) * _7._m0.xy), _95, _96); float3 _673 = float3(_11._m5) * fast::clamp(_8.sample(_9, _661, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _677 = _12.sample(_13, _661, level(0.0)); float _678 = _677.y; float3 _693; if (_678 > 0.0) { _693 = _673 + (_14.sample(_15, _661, level(0.0)).xyz * fast::clamp(_678 * _677.z, 0.0, 1.0)); } else { _693 = _673; } float3 _702 = (((((((((((((_129 * 0.5).xyz + (_176 * 0.5)).xyz + (_223 * 0.75)).xyz + (_270 * 0.5)).xyz + (_317 * 0.5)).xyz + (_364 * 0.75)).xyz + (_411 * 1.0)).xyz + (_458 * 0.75)).xyz + (_505 * 0.5)).xyz + (_552 * 0.5)).xyz + (_599 * 0.75)).xyz + (_646 * 0.5)).xyz + (_693 * 0.5)).xyz * float3(0.125); _28 _704 = _74; _704._m0 = float4(_702.x, _702.y, _702.z, float4(0.0).w); _28 _705 = _704; _705._m0.w = 1.0; out.m_5 = _705._m0; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/tesc/000077500000000000000000000000001400026215700230725ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/tesc/tess-level-overrun.asm.tesc000066400000000000000000000015151400026215700303140ustar00rootroot00000000000000#include #include using namespace metal; struct TessLevels { float inner0; float inner1; float outer0; float outer1; float outer2; float outer3; }; kernel void main0(const device TessLevels& sb_levels [[buffer(0)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(sb_levels.inner0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(sb_levels.outer0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(sb_levels.outer1); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(sb_levels.outer2); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/tesc/tess-level-overrun.multi-patch.asm.tesc000066400000000000000000000015541400026215700325450ustar00rootroot00000000000000#include #include using namespace metal; struct TessLevels { float inner0; float inner1; float outer0; float outer1; float outer2; float outer3; }; kernel void main0(const device TessLevels& sb_levels [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1]); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(sb_levels.inner0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(sb_levels.outer0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(sb_levels.outer1); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(sb_levels.outer2); } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/tese/000077500000000000000000000000001400026215700230745ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/tese/unnamed-builtin-array.asm.tese000066400000000000000000000014371400026215700307510ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_patchIn { float2 gl_TessLevelInner [[attribute(0)]]; float4 gl_TessLevelOuter [[attribute(1)]]; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; out.gl_Position = float4(((gl_TessCoord.x * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.x) + (((1.0 - gl_TessCoord.x) * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.z), ((gl_TessCoord.y * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.y) + (((1.0 - gl_TessCoord.y) * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.w), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/000077500000000000000000000000001400026215700231145ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/clip-distance-plain-variable.asm.vert000066400000000000000000000011701400026215700321770ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; float gl_ClipDistance_0 [[user(clip0)]]; float gl_ClipDistance_1 [[user(clip1)]]; }; struct main0_in { float4 pos [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.pos; out.gl_ClipDistance[0] = in.pos.x; out.gl_ClipDistance[1] = in.pos.y; out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; out.gl_ClipDistance_1 = out.gl_ClipDistance[1]; return out; } clip-distance-plain-variable.no-user-varying.asm.vert000066400000000000000000000006661400026215700351750ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; }; struct main0_in { float4 pos [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.pos; out.gl_ClipDistance[0] = in.pos.x; out.gl_ClipDistance[1] = in.pos.y; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/copy-memory-interface.asm.vert000066400000000000000000000006101400026215700310100ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 o1 [[user(locn1)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 v0 [[attribute(0)]]; float4 v1 [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.v0; out.o1 = in.v1; return out; } extract-transposed-matrix-from-struct.asm.vert000066400000000000000000000013351400026215700341370ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert#include #include using namespace metal; struct InstanceData { float4x4 MATRIX_MVP; float4 Color; }; struct gInstanceData { InstanceData _data[1]; }; struct main0_out { float4 _entryPointOutput_Color [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 PosL [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], const device gInstanceData& gInstanceData_1 [[buffer(0)]], uint gl_InstanceIndex [[instance_id]]) { main0_out out = {}; out.gl_Position = float4(in.PosL, 1.0) * gInstanceData_1._data[gl_InstanceIndex].MATRIX_MVP; out._entryPointOutput_Color = gInstanceData_1._data[gl_InstanceIndex].Color; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/fake-builtin-input.asm.vert000066400000000000000000000006161400026215700303070ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { half4 out_var_SV_Target [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float2 in_var_POSITION [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = float4(in.in_var_POSITION, 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/invariant.msl21.asm.vert000066400000000000000000000003701400026215700275250ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position, invariant]]; }; vertex main0_out main0() { main0_out out = {}; out.gl_Position = float4(1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/packed-bool-to-uint.asm.vert000066400000000000000000000013211400026215700303470ustar00rootroot00000000000000#include #include using namespace metal; struct Struct { uint flags[1]; }; struct defaultUniformsVS { Struct flags; float4 uquad[4]; float4x4 umatrix; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant defaultUniformsVS& _9 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.gl_Position = _9.umatrix * float4(_9.uquad[int(gl_VertexIndex)].x, _9.uquad[int(gl_VertexIndex)].y, in.a_position.z, in.a_position.w); if (_9.flags.flags[0] != 0u) { out.gl_Position.z = 0.0; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/packed-bool2-to-packed_uint2.asm.vert000066400000000000000000000013241400026215700320250ustar00rootroot00000000000000#include #include using namespace metal; struct Struct { uint2 flags[1]; }; struct defaultUniformsVS { Struct flags; float4 uquad[4]; float4x4 umatrix; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant defaultUniformsVS& _9 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.gl_Position = _9.umatrix * float4(_9.uquad[int(gl_VertexIndex)].x, _9.uquad[int(gl_VertexIndex)].y, in.a_position.z, in.a_position.w); if (_9.flags.flags[0].x != 0u) { out.gl_Position.z = 0.0; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/packing-test.asm.vert000066400000000000000000000001411400026215700271620ustar00rootroot00000000000000#include #include using namespace metal; vertex void main0() { } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/spec-constant-op-composite.asm.vert000066400000000000000000000015771400026215700320040ustar00rootroot00000000000000#include #include using namespace metal; constant int _7_tmp [[function_constant(201)]]; constant int _7 = is_function_constant_defined(_7_tmp) ? _7_tmp : -10; constant int _20 = (_7 + 2); constant uint _8_tmp [[function_constant(202)]]; constant uint _8 = is_function_constant_defined(_8_tmp) ? _8_tmp : 100u; constant uint _25 = (_8 % 5u); constant int4 _30 = int4(20, 30, _20, _20); constant int2 _32 = int2(_30.y, _30.x); constant int _33 = _30.y; struct main0_out { int m_4 [[user(locn0)]]; float4 gl_Position [[position]]; }; vertex main0_out main0() { main0_out out = {}; float4 _63 = float4(0.0); _63.y = float(_20); float4 _66 = _63; _66.z = float(_25); float4 _52 = _66 + float4(_30); float2 _56 = _52.xy + float2(_32); out.gl_Position = float4(_56.x, _56.y, _52.z, _52.w); out.m_4 = _33; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/asm/vert/uint-vertex-id-instance-id.asm.vert000066400000000000000000000005321400026215700316550ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0(uint gl_VertexIndex [[vertex_id]], uint gl_InstanceIndex [[instance_id]]) { main0_out out = {}; out.gl_Position = float4(float(gl_VertexIndex + gl_InstanceIndex)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/000077500000000000000000000000001400026215700223125ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/access-private-workgroup-in-function.comp000066400000000000000000000002401400026215700323630ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0() { } argument-buffers-discrete.msl2.argument.discrete.comp000066400000000000000000000013471400026215700344720ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/comp#include #include using namespace metal; struct SSBO3 { float4 v; }; struct SSBO0 { float4 v; }; struct SSBO1 { float4 v; }; struct SSBO2 { float4 v; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); struct spvDescriptorSetBuffer0 { const device SSBO0* ssbo0 [[id(0)]]; }; struct spvDescriptorSetBuffer1 { const device SSBO1* ssbo1 [[id(0)]]; }; kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], device SSBO3& ssbo3 [[buffer(2)]], const device SSBO2& ssbo2 [[buffer(3)]]) { ssbo3.v = ((*spvDescriptorSet0.ssbo0).v + (*spvDescriptorSet1.ssbo1).v) + ssbo2.v; } argument-buffers-image-load-store.ios.msl2.argument.comp000066400000000000000000000005451400026215700350100ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/comp#include #include using namespace metal; kernel void main0(texture2d uImage [[texture(0)]], texture2d uImageRead [[texture(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { int2 _17 = int2(gl_GlobalInvocationID.xy); uImage.write(uImageRead.read(uint2(_17)), uint2(_17)); } argument-buffers-image-load-store.msl2.argument.comp000066400000000000000000000007571400026215700342240ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/comp#include #include using namespace metal; struct spvDescriptorSetBuffer0 { texture2d uImage [[id(0)]]; texture2d uImageRead [[id(1)]]; }; kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { int2 _17 = int2(gl_GlobalInvocationID.xy); spvDescriptorSet0.uImage.write(spvDescriptorSet0.uImageRead.read(uint2(_17)), uint2(_17)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/array-length.comp000066400000000000000000000012701400026215700255670ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { uint size; float4 v[1]; }; struct SSBO1 { float bz[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(constant uint* spvBufferSizeConstants [[buffer(25)]], device SSBO& _14 [[buffer(0)]], device SSBO1* ssbos_0 [[buffer(1)]], device SSBO1* ssbos_1 [[buffer(2)]]) { device SSBO1* ssbos[] = { ssbos_0, ssbos_1, }; constant uint& _14BufferSize = spvBufferSizeConstants[0]; constant uint* ssbosBufferSize = &spvBufferSizeConstants[1]; _14.size = uint(int((_14BufferSize - 16) / 16) + int((ssbosBufferSize[1] - 0) / 4)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/array-length.msl2.argument.discrete.comp000066400000000000000000000027671400026215700321010ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { uint size; float4 v[1]; }; struct SSBO1 { float bz[1]; }; struct SSBO2 { uint size2; float4 w[1]; }; struct SSBO3 { float bz[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); struct spvDescriptorSetBuffer0 { device SSBO* m_16 [[id(0)]]; constant uint* spvBufferSizeConstants [[id(1)]]; }; struct spvDescriptorSetBuffer1 { device SSBO1* ssbos [[id(0)]][2]; constant uint* spvBufferSizeConstants [[id(2)]]; }; kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], constant uint* spvBufferSizeConstants [[buffer(25)]], device SSBO2& _38 [[buffer(2)]], device SSBO3* ssbos2_0 [[buffer(3)]], device SSBO3* ssbos2_1 [[buffer(4)]]) { device SSBO3* ssbos2[] = { ssbos2_0, ssbos2_1, }; constant uint& spvDescriptorSet0_m_16BufferSize = spvDescriptorSet0.spvBufferSizeConstants[0]; constant uint* spvDescriptorSet1_ssbosBufferSize = &spvDescriptorSet1.spvBufferSizeConstants[0]; constant uint& _38BufferSize = spvBufferSizeConstants[2]; constant uint* ssbos2BufferSize = &spvBufferSizeConstants[3]; (*spvDescriptorSet0.m_16).size = ((uint(int((spvDescriptorSet0_m_16BufferSize - 16) / 16)) + uint(int((spvDescriptorSet1_ssbosBufferSize[1] - 0) / 4))) + uint(int((_38BufferSize - 16) / 16))) + uint(int((ssbos2BufferSize[0] - 0) / 4)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/atomic.comp000066400000000000000000000077521400026215700244610ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { uint u32; int i32; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& ssbo [[buffer(0)]]) { threadgroup uint shared_u32; threadgroup int shared_i32; uint _16 = atomic_fetch_add_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _18 = atomic_fetch_or_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _20 = atomic_fetch_xor_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _22 = atomic_fetch_and_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _24 = atomic_fetch_min_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _26 = atomic_fetch_max_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _28 = atomic_exchange_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _32; do { _32 = 10u; } while (!atomic_compare_exchange_weak_explicit((device atomic_uint*)&ssbo.u32, &_32, 2u, memory_order_relaxed, memory_order_relaxed) && _32 == 10u); int _36 = atomic_fetch_add_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _38 = atomic_fetch_or_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _40 = atomic_fetch_xor_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _42 = atomic_fetch_and_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _44 = atomic_fetch_min_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _46 = atomic_fetch_max_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _48 = atomic_exchange_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _52; do { _52 = 10; } while (!atomic_compare_exchange_weak_explicit((device atomic_int*)&ssbo.i32, &_52, 2, memory_order_relaxed, memory_order_relaxed) && _52 == 10); shared_u32 = 10u; shared_i32 = 10; uint _57 = atomic_fetch_add_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _58 = atomic_fetch_or_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _59 = atomic_fetch_xor_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _60 = atomic_fetch_and_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _61 = atomic_fetch_min_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _62 = atomic_fetch_max_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _63 = atomic_exchange_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _64; do { _64 = 10u; } while (!atomic_compare_exchange_weak_explicit((threadgroup atomic_uint*)&shared_u32, &_64, 2u, memory_order_relaxed, memory_order_relaxed) && _64 == 10u); int _65 = atomic_fetch_add_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _66 = atomic_fetch_or_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _67 = atomic_fetch_xor_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _68 = atomic_fetch_and_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _69 = atomic_fetch_min_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _70 = atomic_fetch_max_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _71 = atomic_exchange_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _72; do { _72 = 10; } while (!atomic_compare_exchange_weak_explicit((threadgroup atomic_int*)&shared_i32, &_72, 2, memory_order_relaxed, memory_order_relaxed) && _72 == 10); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/barriers.comp000066400000000000000000000016411400026215700250050ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(4u, 1u, 1u); kernel void main0() { threadgroup_barrier(mem_flags::mem_threadgroup); threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); threadgroup_barrier(mem_flags::mem_texture); threadgroup_barrier(mem_flags::mem_device); threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); threadgroup_barrier(mem_flags::mem_threadgroup); threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); threadgroup_barrier(mem_flags::mem_texture); threadgroup_barrier(mem_flags::mem_device); threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); threadgroup_barrier(mem_flags::mem_threadgroup); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/basic.comp000066400000000000000000000014341400026215700242550ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; struct SSBO3 { uint counter; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(const device SSBO& _23 [[buffer(0)]], device SSBO2& _45 [[buffer(1)]], device SSBO3& _48 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { float4 _29 = _23.in_data[gl_GlobalInvocationID.x]; if (dot(_29, float4(1.0, 5.0, 6.0, 2.0)) > 8.19999980926513671875) { uint _52 = atomic_fetch_add_explicit((device atomic_uint*)&_48.counter, 1u, memory_order_relaxed); _45.out_data[_52] = _29; } } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/basic.dispatchbase.comp000066400000000000000000000020101400026215700266750ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; struct SSBO3 { uint counter; }; constant uint _59_tmp [[function_constant(10)]]; constant uint _59 = is_function_constant_defined(_59_tmp) ? _59_tmp : 1u; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(_59, 1u, 1u); kernel void main0(const device SSBO& _27 [[buffer(0)]], device SSBO2& _49 [[buffer(1)]], device SSBO3& _52 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 spvDispatchBase [[grid_origin]]) { gl_GlobalInvocationID += spvDispatchBase * gl_WorkGroupSize; float4 _33 = _27.in_data[gl_GlobalInvocationID.x]; if (dot(_33, float4(1.0, 5.0, 6.0, 2.0)) > 8.19999980926513671875) { uint _56 = atomic_fetch_add_explicit((device atomic_uint*)&_52.counter, 1u, memory_order_relaxed); _49.out_data[_56] = _33; } } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/basic.dispatchbase.msl11.comp000066400000000000000000000016151400026215700276430ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; struct SSBO3 { uint counter; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(constant uint3& spvDispatchBase [[buffer(29)]], const device SSBO& _27 [[buffer(0)]], device SSBO2& _49 [[buffer(1)]], device SSBO3& _52 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { gl_GlobalInvocationID += spvDispatchBase * gl_WorkGroupSize; float4 _33 = _27.in_data[gl_GlobalInvocationID.x]; if (dot(_33, float4(1.0, 5.0, 6.0, 2.0)) > 8.19999980926513671875) { uint _56 = atomic_fetch_add_explicit((device atomic_uint*)&_52.counter, 1u, memory_order_relaxed); _49.out_data[_56] = _33; } } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/basic.inline-block.msl2.comp000066400000000000000000000017401400026215700274760ustar00rootroot00000000000000#include #include using namespace metal; typedef packed_float4 packed_float4x4[4]; struct Baz { int f; int g; }; struct X { int x; int y; float z; }; struct Foo { int a; int b; packed_float4x4 c; X x[2]; }; struct Bar { int d; int e; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(3u, 3u, 2u); struct spvDescriptorSetBuffer0 { constant Bar* m_38 [[id(0)]]; Foo m_32 [[id(1)]]; }; struct spvDescriptorSetBuffer1 { device Baz* baz [[id(0)]][3]; }; kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { spvDescriptorSet1.baz[gl_GlobalInvocationID.x]->f = spvDescriptorSet0.m_32.a + (*spvDescriptorSet0.m_38).d; spvDescriptorSet1.baz[gl_GlobalInvocationID.x]->g = spvDescriptorSet0.m_32.b * (*spvDescriptorSet0.m_38).e; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/builtins.comp000066400000000000000000000002501400026215700250200ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(8u, 4u, 2u); kernel void main0() { } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/cfg-preserve-parameter.comp000066400000000000000000000001411400026215700275340ustar00rootroot00000000000000#include #include using namespace metal; kernel void main0() { } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/coherent-block.comp000066400000000000000000000004111400026215700260650ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 value; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(volatile device SSBO& _10 [[buffer(0)]]) { _10.value = float4(20.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/coherent-image.comp000066400000000000000000000004751400026215700260670ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { int4 value; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(volatile device SSBO& _10 [[buffer(0)]], texture2d uImage [[texture(0)]]) { _10.value = uImage.read(uint2(int2(10))); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/complex-composite-constant-array.comp000066400000000000000000000027021400026215700316050ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct SSBO { float4x4 a; uint index; }; kernel void main0(device SSBO& _14 [[buffer(0)]]) { spvUnsafeArray _32 = spvUnsafeArray({ float4x4(float4(1.0, 0.0, 0.0, 0.0), float4(0.0, 1.0, 0.0, 0.0), float4(0.0, 0.0, 1.0, 0.0), float4(0.0, 0.0, 0.0, 1.0)), float4x4(float4(2.0, 0.0, 0.0, 0.0), float4(0.0, 2.0, 0.0, 0.0), float4(0.0, 0.0, 2.0, 0.0), float4(0.0, 0.0, 0.0, 2.0)) }); _14.a = _32[_14.index]; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/complex-type-alias.comp000066400000000000000000000016311400026215700267100ustar00rootroot00000000000000#include #include using namespace metal; struct Foo0 { float a; }; struct Foo1 { Foo0 a; }; struct Foo2 { Foo1 a; float weight; }; struct Foo0_1 { float a; }; struct Foo1_1 { Foo0_1 a; }; struct Foo2_1 { Foo1_1 a; float weight; }; struct SSBO { Foo2_1 outputs[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(8u, 8u, 1u); kernel void main0(device SSBO& _53 [[buffer(0)]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]]) { threadgroup Foo2 coeffs[64]; coeffs[gl_LocalInvocationIndex] = Foo2{ Foo1{ Foo0{ 0.0 } }, 0.0 }; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_LocalInvocationIndex == 0u) { _53.outputs[gl_WorkGroupID.x].a.a.a = coeffs[0].a.a.a; _53.outputs[gl_WorkGroupID.x].weight = coeffs[0].weight; } } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/composite-array-initialization.comp000066400000000000000000000036651400026215700313470ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Data { float a; float b; }; constant float X_tmp [[function_constant(0)]]; constant float X = is_function_constant_defined(X_tmp) ? X_tmp : 4.0; struct Data_1 { float a; float b; }; struct SSBO { Data_1 outdata[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(2u, 1u, 1u); kernel void main0(device SSBO& _53 [[buffer(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { spvUnsafeArray _25 = spvUnsafeArray({ Data{ 1.0, 2.0 }, Data{ 3.0, 4.0 } }); spvUnsafeArray _31 = spvUnsafeArray({ Data{ X, 2.0 }, Data{ 3.0, 5.0 } }); spvUnsafeArray data2; data2 = _31; _53.outdata[gl_WorkGroupID.x].a = _25[gl_LocalInvocationID.x].a + data2[gl_LocalInvocationID.x].a; _53.outdata[gl_WorkGroupID.x].b = _25[gl_LocalInvocationID.x].b + data2[gl_LocalInvocationID.x].b; } composite-array-initialization.force-native-array.comp000066400000000000000000000065061400026215700347620ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Data { float a; float b; }; constant float X_tmp [[function_constant(0)]]; constant float X = is_function_constant_defined(X_tmp) ? X_tmp : 4.0; struct Data_1 { float a; float b; }; struct SSBO { Data_1 outdata[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(2u, 1u, 1u); template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } kernel void main0(device SSBO& _53 [[buffer(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { Data _25[2] = { Data{ 1.0, 2.0 }, Data{ 3.0, 4.0 } }; Data _31[2] = { Data{ X, 2.0 }, Data{ 3.0, 5.0 } }; Data data2[2]; spvArrayCopyFromStackToStack1(data2, _31); _53.outdata[gl_WorkGroupID.x].a = _25[gl_LocalInvocationID.x].a + data2[gl_LocalInvocationID.x].a; _53.outdata[gl_WorkGroupID.x].b = _25[gl_LocalInvocationID.x].b + data2[gl_LocalInvocationID.x].b; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/composite-construct.comp000066400000000000000000000031421400026215700272160ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct SSBO0 { float4 as[1]; }; struct SSBO1 { float4 bs[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO0& _16 [[buffer(0)]], device SSBO1& _32 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { spvUnsafeArray _37 = spvUnsafeArray({ _16.as[gl_GlobalInvocationID.x], _32.bs[gl_GlobalInvocationID.x] }); spvUnsafeArray values; values = _37; _16.as[0] = values[gl_LocalInvocationIndex]; _32.bs[1] = float4(40.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/copy-array-of-arrays.comp000066400000000000000000000004151400026215700271610ustar00rootroot00000000000000#include #include using namespace metal; struct BUF { int a; float b; float c; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device BUF& o [[buffer(0)]]) { o.a = 4; o.b = o.c; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/copy-array-of-arrays.force-native-array.comp000066400000000000000000000004151400026215700326560ustar00rootroot00000000000000#include #include using namespace metal; struct BUF { int a; float b; float c; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device BUF& o [[buffer(0)]]) { o.a = 4; o.b = o.c; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/culling.comp000066400000000000000000000013521400026215700246300ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float in_data[1]; }; struct SSBO2 { float out_data[1]; }; struct SSBO3 { uint count; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(4u, 1u, 1u); kernel void main0(const device SSBO& _22 [[buffer(0)]], device SSBO2& _38 [[buffer(1)]], device SSBO3& _41 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { float _28 = _22.in_data[gl_GlobalInvocationID.x]; if (_28 > 12.0) { uint _45 = atomic_fetch_add_explicit((device atomic_uint*)&_41.count, 1u, memory_order_relaxed); _38.out_data[_45] = _28; } } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/defer-parens.comp000066400000000000000000000007611400026215700255510ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 data; int index; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _13 [[buffer(0)]]) { float4 _17 = _13.data; float2 _28 = _17.yz + float2(10.0); _13.data = float4(_17.x, _28, _17.w); _13.data = (_17 + _17) + _17; _13.data = _28.xxyy; _13.data = float4(_28.y); _13.data = float4((_17.zw + float2(10.0))[_13.index]); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/dowhile.comp000066400000000000000000000013741400026215700246320ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4x4 mvp; float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(const device SSBO& _28 [[buffer(0)]], device SSBO2& _52 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { float4 _59; int _60; _60 = 0; _59 = _28.in_data[gl_GlobalInvocationID.x]; float4 _42; for (;;) { _42 = _28.mvp * _59; int _44 = _60 + 1; if (_44 < 16) { _60 = _44; _59 = _42; } else { break; } } _52.out_data[gl_GlobalInvocationID.x] = _42; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/force-recompile-hooks.swizzle.comp000066400000000000000000000041351400026215700310770ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } kernel void main0(constant uint* spvSwizzleConstants [[buffer(30)]], texture2d foo [[texture(0)]], texture2d bar [[texture(1)]], sampler fooSmplr [[sampler(0)]]) { constant uint& fooSwzl = spvSwizzleConstants[0]; bar.write(spvTextureSwizzle(foo.sample(fooSmplr, float2(1.0), level(0.0)), fooSwzl), uint2(int2(0))); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/functions.comp000066400000000000000000000001411400026215700251760ustar00rootroot00000000000000#include #include using namespace metal; kernel void main0() { } global-invocation-id-writable-ssbo-in-function.comp000066400000000000000000000012201400026215700341110ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b[1]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(device myBlock& myStorage [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_GlobalInvocationID.x] = mod(myStorage.b[gl_GlobalInvocationID.x] + 0.0199999995529651641845703125, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/global-invocation-id.comp000066400000000000000000000012201400026215700271660ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b[1]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(device myBlock& myStorage [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_GlobalInvocationID.x] = mod(myStorage.b[gl_GlobalInvocationID.x] + 0.0199999995529651641845703125, 1.0); } image-atomic-automatic-bindings.argument.msl2.comp000066400000000000000000000031151400026215700337230ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 outdata; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); struct spvDescriptorSetBuffer0 { texture2d uImage [[id(0)]]; device atomic_uint* uImage_atomic [[id(1)]]; device SSBO* m_31 [[id(2)]]; texture2d uTexture [[id(3)]]; sampler uTextureSmplr [[id(4)]]; }; // The required alignment of a linear texture of R32Uint format. constant uint spvLinearTextureAlignmentOverride [[function_constant(65535)]]; constant uint spvLinearTextureAlignment = is_function_constant_defined(spvLinearTextureAlignmentOverride) ? spvLinearTextureAlignmentOverride : 4; // Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics #define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + spvLinearTextureAlignment / 4 - 1) & ~( spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x) kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint _26 = atomic_fetch_add_explicit((device atomic_uint*)&spvDescriptorSet0.uImage_atomic[spvImage2DAtomicCoord(int2(gl_GlobalInvocationID.xy), spvDescriptorSet0.uImage)], 10u, memory_order_relaxed); (*spvDescriptorSet0.m_31).outdata = spvDescriptorSet0.uTexture.sample(spvDescriptorSet0.uTextureSmplr, float2(gl_GlobalInvocationID.xy), level(0.0)) + float4(float(_26)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/image-atomic-automatic-bindings.comp000066400000000000000000000026111400026215700313050ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 outdata; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); // The required alignment of a linear texture of R32Uint format. constant uint spvLinearTextureAlignmentOverride [[function_constant(65535)]]; constant uint spvLinearTextureAlignment = is_function_constant_defined(spvLinearTextureAlignmentOverride) ? spvLinearTextureAlignmentOverride : 4; // Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics #define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + spvLinearTextureAlignment / 4 - 1) & ~( spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x) kernel void main0(device SSBO& _31 [[buffer(1)]], texture2d uImage [[texture(0)]], device atomic_uint* uImage_atomic [[buffer(0)]], texture2d uTexture [[texture(1)]], sampler uTextureSmplr [[sampler(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint _26 = atomic_fetch_add_explicit((device atomic_uint*)&uImage_atomic[spvImage2DAtomicCoord(int2(gl_GlobalInvocationID.xy), uImage)], 10u, memory_order_relaxed); _31.outdata = uTexture.sample(uTextureSmplr, float2(gl_GlobalInvocationID.xy), level(0.0)) + float4(float(_26)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/image-cube-array-load-store.comp000066400000000000000000000007361400026215700303610ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(texturecube_array uImageIn [[texture(0)]], texturecube_array uImageOut [[texture(1)]]) { uImageOut.write(uImageIn.read(uint2(int3(9, 7, 11).xy), uint(int3(9, 7, 11).z) % 6u, uint(int3(9, 7, 11).z) / 6u), uint2(int3(9, 7, 11).xy), uint(int3(9, 7, 11).z) % 6u, uint(int3(9, 7, 11).z) / 6u); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/image.comp000066400000000000000000000007341400026215700242600ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(texture2d uImageIn [[texture(0)]], texture2d uImageOut [[texture(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { int2 _23 = int2(gl_GlobalInvocationID.xy); uImageOut.write(uImageIn.read(uint2((_23 + int2(uImageIn.get_width(), uImageIn.get_height())))), uint2(_23)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/insert.comp000066400000000000000000000011251400026215700244750ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); constant float4 _53 = {}; kernel void main0(device SSBO& _27 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { float4 _46 = _53; _46.x = 10.0; float4 _48 = _46; _48.y = 30.0; float4 _50 = _48; _50.z = 70.0; float4 _52 = _50; _52.w = 90.0; _27.out_data[gl_GlobalInvocationID.x] = _52; ((device float*)&_27.out_data[gl_GlobalInvocationID.x])[1u] = 20.0; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/inverse.comp000066400000000000000000000133701400026215700246510ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct MatrixOut { float2x2 m2out; float3x3 m3out; float4x4 m4out; }; struct MatrixIn { float2x2 m2in; float3x3 m3in; float4x4 m4in; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); // Returns the determinant of a 2x2 matrix. static inline __attribute__((always_inline)) float spvDet2x2(float a1, float a2, float b1, float b2) { return a1 * b2 - b1 * a2; } // Returns the determinant of a 3x3 matrix. static inline __attribute__((always_inline)) float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) { return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3); } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float4x4 spvInverse4x4(float4x4 m) { float4x4 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]); adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]); adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]); adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]); adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]); adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]); adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]); adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] * m[3][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float3x3 spvInverse3x3(float3x3 m) { float3x3 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]); adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]); adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]); adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]); adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]); adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]); adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]); adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]); adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float2x2 spvInverse2x2(float2x2 m) { float2x2 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = m[1][1]; adj[0][1] = -m[0][1]; adj[1][0] = -m[1][0]; adj[1][1] = m[0][0]; // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } kernel void main0(device MatrixOut& _15 [[buffer(0)]], const device MatrixIn& _20 [[buffer(1)]]) { _15.m2out = spvInverse2x2(_20.m2in); _15.m3out = spvInverse3x3(_20.m3in); _15.m4out = spvInverse4x4(_20.m4in); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/local-invocation-id.comp000066400000000000000000000012241400026215700270240ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b[1]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(device myBlock& myStorage [[buffer(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_LocalInvocationID.x] = mod(myStorage.b[gl_LocalInvocationID.x] + 0.0199999995529651641845703125, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/local-invocation-index.comp000066400000000000000000000012251400026215700275400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b[1]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(device myBlock& myStorage [[buffer(0)]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_LocalInvocationIndex] = mod(myStorage.b[gl_LocalInvocationIndex] + 0.0199999995529651641845703125, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/mat3.comp000066400000000000000000000006051400026215700240370ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO2 { float3x3 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO2& _22 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _22.out_data[gl_GlobalInvocationID.x] = float3x3(float3(10.0), float3(20.0), float3(40.0)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/mod.comp000066400000000000000000000020741400026215700237540ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(const device SSBO& _23 [[buffer(0)]], device SSBO2& _33 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _33.out_data[gl_GlobalInvocationID.x] = mod(_23.in_data[gl_GlobalInvocationID.x], _33.out_data[gl_GlobalInvocationID.x]); _33.out_data[gl_GlobalInvocationID.x] = as_type(as_type(_23.in_data[gl_GlobalInvocationID.x]) % as_type(_33.out_data[gl_GlobalInvocationID.x])); _33.out_data[gl_GlobalInvocationID.x] = as_type(as_type(_23.in_data[gl_GlobalInvocationID.x]) % as_type(_33.out_data[gl_GlobalInvocationID.x])); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/modf.comp000066400000000000000000000007611400026215700241230ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(const device SSBO& _23 [[buffer(0)]], device SSBO2& _35 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { float4 i; float4 _31 = modf(_23.in_data[gl_GlobalInvocationID.x], i); _35.out_data[gl_GlobalInvocationID.x] = _31; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/outer-product.comp000066400000000000000000000022701400026215700260070ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float2x2 m22; float2x3 m23; float2x4 m24; float3x2 m32; float3x3 m33; float3x4 m34; float4x2 m42; float4x3 m43; float4x4 m44; }; struct ReadSSBO { float2 v2; float3 v3; float4 v4; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _21 [[buffer(0)]], const device ReadSSBO& _26 [[buffer(1)]]) { _21.m22 = float2x2(_26.v2 * _26.v2.x, _26.v2 * _26.v2.y); _21.m23 = float2x3(_26.v3 * _26.v2.x, _26.v3 * _26.v2.y); _21.m24 = float2x4(_26.v4 * _26.v2.x, _26.v4 * _26.v2.y); _21.m32 = float3x2(_26.v2 * _26.v3.x, _26.v2 * _26.v3.y, _26.v2 * _26.v3.z); _21.m33 = float3x3(_26.v3 * _26.v3.x, _26.v3 * _26.v3.y, _26.v3 * _26.v3.z); _21.m34 = float3x4(_26.v4 * _26.v3.x, _26.v4 * _26.v3.y, _26.v4 * _26.v3.z); _21.m42 = float4x2(_26.v2 * _26.v4.x, _26.v2 * _26.v4.y, _26.v2 * _26.v4.z, _26.v2 * _26.v4.w); _21.m43 = float4x3(_26.v3 * _26.v4.x, _26.v3 * _26.v4.y, _26.v3 * _26.v4.z, _26.v3 * _26.v4.w); _21.m44 = float4x4(_26.v4 * _26.v4.x, _26.v4 * _26.v4.y, _26.v4 * _26.v4.z, _26.v4 * _26.v4.w); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/packing-test-1.comp000066400000000000000000000007341400026215700257250ustar00rootroot00000000000000#include #include using namespace metal; struct T1 { packed_float3 a; float b; }; struct Buffer0 { T1 buf0[1]; }; struct Buffer1 { float buf1[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(32u, 1u, 1u); kernel void main0(device Buffer0& _15 [[buffer(0)]], device Buffer1& _34 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _34.buf1[gl_GlobalInvocationID.x] = _15.buf0[0].b; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/packing-test-2.comp000066400000000000000000000007341400026215700257260ustar00rootroot00000000000000#include #include using namespace metal; struct T1 { packed_float3 a; float b; }; struct Buffer0 { T1 buf0[1]; }; struct Buffer1 { float buf1[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(32u, 1u, 1u); kernel void main0(device Buffer0& _14 [[buffer(0)]], device Buffer1& _24 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _24.buf1[gl_GlobalInvocationID.x] = _14.buf0[0].b; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/read-write-only.comp000066400000000000000000000007721400026215700262220ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO2 { float4 data4; float4 data5; }; struct SSBO0 { float4 data0; float4 data1; }; struct SSBO1 { float4 data2; float4 data3; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO2& _10 [[buffer(0)]], const device SSBO0& _15 [[buffer(1)]], device SSBO1& _21 [[buffer(2)]]) { _10.data4 = _15.data0 + _21.data2; _10.data5 = _15.data1 + _21.data3; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/rmw-matrix.comp000066400000000000000000000005571400026215700253100ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float a; float4 b; float4x4 c; float a1; float4 b1; float4x4 c1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _11 [[buffer(0)]]) { _11.a *= _11.a1; _11.b *= _11.b1; _11.c = _11.c * _11.c1; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/rmw-opt.comp000066400000000000000000000006231400026215700246000ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { int a; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _9 [[buffer(0)]]) { _9.a += 10; _9.a -= 10; _9.a *= 10; _9.a /= 10; _9.a = _9.a << 2; _9.a = _9.a >> 3; _9.a &= 40; _9.a ^= 10; _9.a %= 40; _9.a |= 1; _9.a = 0; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/scalar-std450-distance-length-normalize.comp000066400000000000000000000006241400026215700325270ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float a; float b; float c; float d; float e; float f; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _9 [[buffer(0)]]) { _9.c = abs(_9.a - _9.b); _9.d = abs(_9.a); _9.e = sign(_9.a); _9.f = abs((_9.a - 1.0) - (_9.b - 2.0)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/shared-array-of-arrays.comp000066400000000000000000000014101400026215700274510ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(4u, 4u, 1u); kernel void main0(device SSBO& _67 [[buffer(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { threadgroup float foo[4][4]; foo[gl_LocalInvocationID.x][gl_LocalInvocationID.y] = float(gl_LocalInvocationIndex); threadgroup_barrier(mem_flags::mem_threadgroup); _67.out_data[gl_GlobalInvocationID.x] = ((foo[gl_LocalInvocationID.x][0] + foo[gl_LocalInvocationID.x][1]) + foo[gl_LocalInvocationID.x][2]) + foo[gl_LocalInvocationID.x][3]; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/shared.comp000066400000000000000000000012551400026215700244430ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float in_data[1]; }; struct SSBO2 { float out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(4u, 1u, 1u); kernel void main0(const device SSBO& _22 [[buffer(0)]], device SSBO2& _44 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { threadgroup float sShared[4]; sShared[gl_LocalInvocationIndex] = _22.in_data[gl_GlobalInvocationID.x]; threadgroup_barrier(mem_flags::mem_threadgroup); _44.out_data[gl_GlobalInvocationID.x] = sShared[3u - gl_LocalInvocationIndex]; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/spec-constant-op-member-array.comp000066400000000000000000000017761400026215700307630ustar00rootroot00000000000000#include #include using namespace metal; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 100 #endif constant int a = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 200 #endif constant int b = SPIRV_CROSS_CONSTANT_ID_1; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 300 #endif constant int c = SPIRV_CROSS_CONSTANT_ID_2; constant int d = (c + 50); struct SSBO { A member_a; B member_b; int v[a]; int w[d]; }; constant int e_tmp [[function_constant(3)]]; constant int e = is_function_constant_defined(e_tmp) ? e_tmp : 400; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _22 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _22.w[gl_GlobalInvocationID.x] += (_22.v[gl_GlobalInvocationID.x] + e); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/spec-constant-work-group-size.comp000066400000000000000000000035301400026215700310360ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 2 #endif constant int b = SPIRV_CROSS_CONSTANT_ID_1; constant int a_tmp [[function_constant(0)]]; constant int a = is_function_constant_defined(a_tmp) ? a_tmp : 1; struct SSBO { int v[1]; }; constant uint _21 = (uint(a) + 0u); constant uint _22_tmp [[function_constant(10)]]; constant uint _22 = is_function_constant_defined(_22_tmp) ? _22_tmp : 1u; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(_22, 20u, 1u); constant uint _27 = gl_WorkGroupSize.x; constant uint _28 = (_21 + _27); constant uint _29 = gl_WorkGroupSize.y; constant uint _30 = (_28 + _29); constant int _32 = (1 - a); kernel void main0(device SSBO& _17 [[buffer(0)]]) { spvUnsafeArray spec_const_array_size; spec_const_array_size[a] = a; _17.v[_30] = b + spec_const_array_size[_32]; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/storage-buffer-std140-vector-array.comp000066400000000000000000000051501400026215700315370ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Sub { float4 f[2]; float4 f2[2]; float3 f3[2]; float4 f4[2]; }; struct SSBO { Sub sub[2]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _27 [[buffer(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { spvUnsafeArray _155; _155[0] = _27.sub[gl_WorkGroupID.x].f[0].x; _155[1] = _27.sub[gl_WorkGroupID.x].f[1].x; spvUnsafeArray _156; _156[0] = _27.sub[gl_WorkGroupID.x].f2[0].xy; _156[1] = _27.sub[gl_WorkGroupID.x].f2[1].xy; spvUnsafeArray _157; _157[0] = _27.sub[gl_WorkGroupID.x].f3[0]; _157[1] = _27.sub[gl_WorkGroupID.x].f3[1]; spvUnsafeArray _158; _158[0] = _27.sub[gl_WorkGroupID.x].f4[0]; _158[1] = _27.sub[gl_WorkGroupID.x].f4[1]; _155[gl_GlobalInvocationID.x] += 1.0; _156[gl_GlobalInvocationID.x] += float2(2.0); _157[gl_GlobalInvocationID.x] += float3(3.0); _158[gl_GlobalInvocationID.x] += float4(4.0); (device float&)_27.sub[gl_WorkGroupID.x].f[0] = _155[0]; (device float&)_27.sub[gl_WorkGroupID.x].f[1] = _155[1]; (device float2&)_27.sub[gl_WorkGroupID.x].f2[0] = _156[0]; (device float2&)_27.sub[gl_WorkGroupID.x].f2[1] = _156[1]; _27.sub[gl_WorkGroupID.x].f3[0] = _157[0]; _27.sub[gl_WorkGroupID.x].f3[1] = _157[1]; _27.sub[gl_WorkGroupID.x].f4[0] = _158[0]; _27.sub[gl_WorkGroupID.x].f4[1] = _158[1]; (device float&)_27.sub[0].f[0] = _27.sub[0].f[0].x + 5.0; (device float2&)_27.sub[0].f2[1] = _27.sub[0].f2[1].xy + float2(5.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/struct-layout.comp000066400000000000000000000010141400026215700260250ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { float4x4 m; }; struct SSBO2 { Foo out_data[1]; }; struct SSBO { Foo in_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO2& _23 [[buffer(0)]], const device SSBO& _30 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _23.out_data[gl_GlobalInvocationID.x].m = _30.in_data[gl_GlobalInvocationID.x].m * _30.in_data[gl_GlobalInvocationID.x].m; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/struct-nested.comp000066400000000000000000000004701400026215700257770ustar00rootroot00000000000000#include #include using namespace metal; struct s1 { int a; }; struct s2 { s1 b; }; struct dstbuffer { s2 test[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device dstbuffer& _19 [[buffer(0)]]) { _19.test[0].b.a = 0; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/struct-packing.comp000066400000000000000000000052151400026215700261330ustar00rootroot00000000000000#include #include using namespace metal; struct S0 { float2 a[1]; float b; char _m0_final_padding[4]; }; struct S1 { packed_float3 a; float b; }; struct S2 { float3 a[1]; float b; char _m0_final_padding[12]; }; struct S3 { float2 a; float b; }; struct S4 { float2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; S4 m3s[8]; char _m0_final_padding[8]; }; struct SSBO1 { Content content; Content content1[2]; Content content2; float2x2 m0; float2x2 m1; float2x3 m2[4]; float3x2 m3; float2x2 m4; float2x2 m5[9]; float3x2 m6[4][2]; float2x3 m7; float array[1]; }; struct S0_1 { float2 a[1]; char _m1_pad[8]; float b; char _m0_final_padding[12]; }; struct S1_1 { packed_float3 a; float b; }; struct S2_1 { float3 a[1]; float b; char _m0_final_padding[12]; }; struct S3_1 { float2 a; float b; }; struct S4_1 { float2 c; char _m0_final_padding[8]; }; struct Content_1 { S0_1 m0s[1]; S1_1 m1s[1]; S2_1 m2s[1]; S0_1 m0; S1_1 m1; S2_1 m2; S3_1 m3; float m4; char _m8_pad[8]; S4_1 m3s[8]; }; struct SSBO0 { Content_1 content; Content_1 content1[2]; Content_1 content2; float4 array[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO1& ssbo_430 [[buffer(0)]], device SSBO0& ssbo_140 [[buffer(1)]]) { Content_1 _60 = ssbo_140.content; ssbo_430.content.m0s[0].a[0] = _60.m0s[0].a[0]; ssbo_430.content.m0s[0].b = _60.m0s[0].b; ssbo_430.content.m1s[0].a = float3(_60.m1s[0].a); ssbo_430.content.m1s[0].b = _60.m1s[0].b; ssbo_430.content.m2s[0].a[0] = _60.m2s[0].a[0]; ssbo_430.content.m2s[0].b = _60.m2s[0].b; ssbo_430.content.m0.a[0] = _60.m0.a[0]; ssbo_430.content.m0.b = _60.m0.b; ssbo_430.content.m1.a = float3(_60.m1.a); ssbo_430.content.m1.b = _60.m1.b; ssbo_430.content.m2.a[0] = _60.m2.a[0]; ssbo_430.content.m2.b = _60.m2.b; ssbo_430.content.m3.a = _60.m3.a; ssbo_430.content.m3.b = _60.m3.b; ssbo_430.content.m4 = _60.m4; ssbo_430.content.m3s[0].c = _60.m3s[0].c; ssbo_430.content.m3s[1].c = _60.m3s[1].c; ssbo_430.content.m3s[2].c = _60.m3s[2].c; ssbo_430.content.m3s[3].c = _60.m3s[3].c; ssbo_430.content.m3s[4].c = _60.m3s[4].c; ssbo_430.content.m3s[5].c = _60.m3s[5].c; ssbo_430.content.m3s[6].c = _60.m3s[6].c; ssbo_430.content.m3s[7].c = _60.m3s[7].c; ssbo_430.content.m1.a = ssbo_430.content.m3.a * ssbo_430.m6[1][1]; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/torture-loop.comp000066400000000000000000000015741400026215700256540ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4x4 mvp; float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(const device SSBO& _24 [[buffer(0)]], device SSBO2& _89 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { float4 _101; _101 = _24.in_data[gl_GlobalInvocationID.x]; for (int _95 = 0; (_95 + 1) < 10; ) { _101 *= 2.0; _95 += 2; continue; } float4 _100; _100 = _101; float4 _105; for (uint _96 = 0u; _96 < 16u; _100 = _105, _96++) { _105 = _100; for (uint _102 = 0u; _102 < 30u; ) { _105 = _24.mvp * _105; _102++; continue; } } _89.out_data[gl_GlobalInvocationID.x] = _100; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/type-alias.comp000066400000000000000000000011301400026215700252350ustar00rootroot00000000000000#include #include using namespace metal; struct S0 { float4 a; }; struct SSBO0 { S0 s0s[1]; }; struct S1 { float4 a; }; struct SSBO1 { S1 s1s[1]; }; struct SSBO2 { float4 outputs[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO0& _36 [[buffer(0)]], device SSBO1& _55 [[buffer(1)]], device SSBO2& _66 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _66.outputs[gl_GlobalInvocationID.x] = _36.s0s[gl_GlobalInvocationID.x].a + _55.s1s[gl_GlobalInvocationID.x].a; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/udiv.comp000066400000000000000000000006741400026215700241500ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO2 { uint outputs[1]; }; struct SSBO { uint inputs[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO2& _10 [[buffer(0)]], device SSBO& _23 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _10.outputs[gl_GlobalInvocationID.x] = _23.inputs[gl_GlobalInvocationID.x] / 29u; } spirv-cross-2021.01.15/reference/opt/shaders-msl/comp/writable-ssbo.comp000066400000000000000000000010421400026215700257440ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(device myBlock& myStorage [[buffer(0)]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b = mod(myStorage.b + 0.0199999995529651641845703125, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/000077500000000000000000000000001400026215700240045ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/comp/000077500000000000000000000000001400026215700247425ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/comp/extended-arithmetic.desktop.comp000066400000000000000000000062611400026215700332260ustar00rootroot00000000000000#include #include using namespace metal; struct SSBOUint { uint a; uint b; uint c; uint d; uint2 a2; uint2 b2; uint2 c2; uint2 d2; uint3 a3; uint3 b3; uint3 c3; uint3 d3; uint4 a4; uint4 b4; uint4 c4; uint4 d4; }; struct ResType { uint _m0; uint _m1; }; struct ResType_1 { uint2 _m0; uint2 _m1; }; struct ResType_2 { uint3 _m0; uint3 _m1; }; struct ResType_3 { uint4 _m0; uint4 _m1; }; struct SSBOInt { int a; int b; int c; int d; int2 a2; int2 b2; int2 c2; int2 d2; int3 a3; int3 b3; int3 c3; int3 d3; int4 a4; int4 b4; int4 c4; int4 d4; }; struct ResType_4 { int _m0; int _m1; }; struct ResType_5 { int2 _m0; int2 _m1; }; struct ResType_6 { int3 _m0; int3 _m1; }; struct ResType_7 { int4 _m0; int4 _m1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBOUint& u [[buffer(0)]], device SSBOInt& i [[buffer(1)]]) { ResType _25; _25._m0 = u.a + u.b; _25._m1 = select(uint(1), uint(0), _25._m0 >= max(u.a, u.b)); u.d = _25._m1; u.c = _25._m0; ResType_1 _40; _40._m0 = u.a2 + u.b2; _40._m1 = select(uint2(1), uint2(0), _40._m0 >= max(u.a2, u.b2)); u.d2 = _40._m1; u.c2 = _40._m0; ResType_2 _55; _55._m0 = u.a3 + u.b3; _55._m1 = select(uint3(1), uint3(0), _55._m0 >= max(u.a3, u.b3)); u.d3 = _55._m1; u.c3 = _55._m0; ResType_3 _70; _70._m0 = u.a4 + u.b4; _70._m1 = select(uint4(1), uint4(0), _70._m0 >= max(u.a4, u.b4)); u.d4 = _70._m1; u.c4 = _70._m0; ResType _79; _79._m0 = u.a - u.b; _79._m1 = select(uint(1), uint(0), u.a >= u.b); u.d = _79._m1; u.c = _79._m0; ResType_1 _88; _88._m0 = u.a2 - u.b2; _88._m1 = select(uint2(1), uint2(0), u.a2 >= u.b2); u.d2 = _88._m1; u.c2 = _88._m0; ResType_2 _97; _97._m0 = u.a3 - u.b3; _97._m1 = select(uint3(1), uint3(0), u.a3 >= u.b3); u.d3 = _97._m1; u.c3 = _97._m0; ResType_3 _106; _106._m0 = u.a4 - u.b4; _106._m1 = select(uint4(1), uint4(0), u.a4 >= u.b4); u.d4 = _106._m1; u.c4 = _106._m0; ResType _116; _116._m0 = u.a * u.b; _116._m1 = mulhi(u.a, u.b); u.d = _116._m0; u.c = _116._m1; ResType_1 _125; _125._m0 = u.a2 * u.b2; _125._m1 = mulhi(u.a2, u.b2); u.d2 = _125._m0; u.c2 = _125._m1; ResType_2 _134; _134._m0 = u.a3 * u.b3; _134._m1 = mulhi(u.a3, u.b3); u.d3 = _134._m0; u.c3 = _134._m1; ResType_3 _143; _143._m0 = u.a4 * u.b4; _143._m1 = mulhi(u.a4, u.b4); u.d4 = _143._m0; u.c4 = _143._m1; ResType_4 _160; _160._m0 = i.a * i.b; _160._m1 = mulhi(i.a, i.b); i.d = _160._m0; i.c = _160._m1; ResType_5 _171; _171._m0 = i.a2 * i.b2; _171._m1 = mulhi(i.a2, i.b2); i.d2 = _171._m0; i.c2 = _171._m1; ResType_6 _182; _182._m0 = i.a3 * i.b3; _182._m1 = mulhi(i.a3, i.b3); i.d3 = _182._m0; i.c3 = _182._m1; ResType_7 _193; _193._m0 = i.a4 * i.b4; _193._m1 = mulhi(i.a4, i.b4); i.d4 = _193._m0; i.c4 = _193._m1; } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/frag/000077500000000000000000000000001400026215700247235ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/frag/image-ms.desktop.frag000066400000000000000000000007371400026215700307420ustar00rootroot00000000000000#include #include using namespace metal; fragment void main0(texture2d_ms uImageMS [[texture(0)]], texture2d_array uImageArray [[texture(1)]], texture2d uImage [[texture(2)]]) { uImage.write(uImageMS.read(uint2(int2(1, 2)), 2), uint2(int2(2, 3))); uImageArray.write(uImageArray.read(uint2(int3(1, 2, 4).xy), uint(int3(1, 2, 4).z)), uint2(int3(2, 3, 7).xy), uint(int3(2, 3, 7).z)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/frag/query-levels.desktop.frag000066400000000000000000000005371400026215700316760ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = float4(float(int(uSampler.get_num_mip_levels()))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/frag/sampler-ms-query.desktop.frag000066400000000000000000000006521400026215700324620ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d_ms uSampler [[texture(0)]], texture2d_ms uImage [[texture(1)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = float4(float(int(uSampler.get_num_samples()) + int(uImage.get_num_samples()))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/tesc/000077500000000000000000000000001400026215700247425ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/tesc/arrayed-output.desktop.sso.tesc000066400000000000000000000051731400026215700330700ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float3 vVertex; }; struct main0_patchOut { spvUnsafeArray vPatch; }; struct main0_in { float3 vInput [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; gl_out[gl_InvocationID].vVertex = gl_in[gl_InvocationID].vInput + gl_in[gl_InvocationID ^ 1].vInput; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0) { patchOut.vPatch[0] = float3(10.0); patchOut.vPatch[1] = float3(20.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0); } } basic.desktop.sso.multi-patch.tesc000066400000000000000000000032151400026215700333260ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/tesc#include #include using namespace metal; struct main0_out { float4 gl_Position; }; struct main0_patchOut { float3 vFoo; }; struct main0_in { uint3 m_86; ushort2 m_90; float4 gl_Position; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 1]; device main0_patchOut& patchOut = spvPatchOut[gl_GlobalInvocationID.x / 1]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 1; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1]); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625); patchOut.vFoo = float3(1.0); gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position; } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/tesc/basic.desktop.sso.tesc000066400000000000000000000031301400026215700311530ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position; }; struct main0_patchOut { float3 vFoo; }; struct main0_in { float4 gl_Position [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 1]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 1) return; spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625); patchOut.vFoo = float3(1.0); gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position; } struct-copy.desktop.sso.multi-patch.tesc000066400000000000000000000025731400026215700345470ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/tesc#include #include using namespace metal; struct Boo { float3 a; uint3 b; }; struct main0_out { Boo vVertex; }; struct main0_in { float3 Boo_a; uint3 Boo_b; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); Boo _26 = Boo{ gl_in[gl_InvocationID].Boo_a, gl_in[gl_InvocationID].Boo_b }; gl_out[gl_InvocationID].vVertex = _26; spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/tesc/struct-copy.desktop.sso.tesc000066400000000000000000000026101400026215700323700ustar00rootroot00000000000000#include #include using namespace metal; struct Boo { float3 a; float3 b; }; struct main0_out { Boo vVertex; }; struct main0_in { float3 Boo_a [[attribute(0)]]; float3 Boo_b [[attribute(1)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; Boo _25 = Boo{ gl_in[gl_InvocationID].Boo_a, gl_in[gl_InvocationID].Boo_b }; gl_out[gl_InvocationID].vVertex = _25; spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/tese/000077500000000000000000000000001400026215700247445ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/tese/triangle.desktop.sso.tese000066400000000000000000000011401400026215700317020ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 gl_Position [[attribute(0)]]; }; struct main0_patchIn { patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; out.gl_Position = ((patchIn.gl_in[0].gl_Position * gl_TessCoord.x) + (patchIn.gl_in[1].gl_Position * gl_TessCoord.y)) + (patchIn.gl_in[2].gl_Position * gl_TessCoord.z); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/vert/000077500000000000000000000000001400026215700247645ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/vert/basic.desktop.sso.vert000066400000000000000000000007661400026215700312330ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; return out; } clip-cull-distance..no-user-varying.desktop.vert000066400000000000000000000005431400026215700360570ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/vert#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; }; vertex main0_out main0() { main0_out out = {}; out.gl_Position = float4(10.0); out.gl_ClipDistance[0] = 1.0; out.gl_ClipDistance[1] = 4.0; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/vert/clip-cull-distance.desktop.vert000066400000000000000000000010451400026215700330120ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; float gl_ClipDistance_0 [[user(clip0)]]; float gl_ClipDistance_1 [[user(clip1)]]; }; vertex main0_out main0() { main0_out out = {}; out.gl_Position = float4(10.0); out.gl_ClipDistance[0] = 1.0; out.gl_ClipDistance[1] = 4.0; out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; out.gl_ClipDistance_1 = out.gl_ClipDistance[1]; return out; } shader-draw-parameters.desktop.for-tess.vert000066400000000000000000000012561400026215700353660ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/vert#include #include using namespace metal; struct main0_out { float4 gl_Position; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 spvStageInputSize [[grid_size]], uint3 spvDispatchBase [[grid_origin]], device main0_out* spvOut [[buffer(28)]]) { device main0_out& out = spvOut[gl_GlobalInvocationID.y * spvStageInputSize.x + gl_GlobalInvocationID.x]; if (any(gl_GlobalInvocationID >= spvStageInputSize)) return; uint gl_BaseVertex = spvDispatchBase.x; uint gl_BaseInstance = spvDispatchBase.y; out.gl_Position = float4(float(int(gl_BaseVertex)), float(int(gl_BaseInstance)), 0.0, 1.0); } shader-draw-parameters.desktop.vert000066400000000000000000000005641400026215700336260ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/desktop-only/vert#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0(uint gl_BaseVertex [[base_vertex]], uint gl_BaseInstance [[base_instance]]) { main0_out out = {}; out.gl_Position = float4(float(int(gl_BaseVertex)), float(int(gl_BaseInstance)), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/flatten/000077500000000000000000000000001400026215700230115ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/flatten/basic.flatten.vert000066400000000000000000000007661400026215700264410ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/flatten/multiindex.flatten.vert000066400000000000000000000006351400026215700275350ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 Data[3][5]; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { int2 aIndex [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _20 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _20.Data[in.aIndex.x][in.aIndex.y]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/flatten/push-constant.flatten.vert000066400000000000000000000011011400026215700301460ustar00rootroot00000000000000#include #include using namespace metal; struct PushMe { float4x4 MVP; float2x2 Rot; float Arr[4]; }; struct main0_out { float2 vRot [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float2 Rot [[attribute(0)]]; float4 Pos [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant PushMe& registers [[buffer(0)]]) { main0_out out = {}; out.gl_Position = registers.MVP * in.Pos; out.vRot = (registers.Rot * in.Rot) + float2(registers.Arr[2]); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/flatten/rowmajor.flatten.vert000066400000000000000000000007251400026215700272130ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVPR; float4x4 uMVPC; float4x4 uMVP; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = (_18.uMVPR * in.aVertex) + (in.aVertex * _18.uMVPC); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/flatten/struct.flatten.vert000066400000000000000000000014401400026215700266720ustar00rootroot00000000000000#include #include using namespace metal; struct Light { packed_float3 Position; float Radius; float4 Color; }; struct UBO { float4x4 uMVP; Light light; }; struct main0_out { float4 vColor [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _18.uMVP * in.aVertex; out.vColor = float4(0.0); float3 _39 = in.aVertex.xyz - float3(_18.light.Position); out.vColor += ((_18.light.Color * fast::clamp(1.0 - (length(_39) / _18.light.Radius), 0.0, 1.0)) * dot(in.aNormal, normalize(_39))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/flatten/swizzle.flatten.vert000066400000000000000000000017761400026215700270710ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 A; float2 B0; float2 B1; float C0; float3 C1; packed_float3 D0; float D1; float E0; float E1; float E2; float E3; float F0; float2 F1; float F2; }; struct main0_out { float4 oA [[user(locn0)]]; float4 oB [[user(locn1)]]; float4 oC [[user(locn2)]]; float4 oD [[user(locn3)]]; float4 oE [[user(locn4)]]; float4 oF [[user(locn5)]]; float4 gl_Position [[position]]; }; vertex main0_out main0(constant UBO& _22 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = float4(0.0); out.oA = _22.A; out.oB = float4(_22.B0, _22.B1); out.oC = float4(_22.C0, _22.C1) + float4(_22.C1.xy, _22.C1.z, _22.C0); out.oD = float4(_22.D0[0], _22.D0[1], _22.D0[2], _22.D1) + float4(_22.D0[0], _22.D0[1], _22.D0[2u], _22.D1); out.oE = float4(_22.E0, _22.E1, _22.E2, _22.E3); out.oF = float4(_22.F0, _22.F1, _22.F2); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/flatten/types.flatten.frag000066400000000000000000000010351400026215700264510ustar00rootroot00000000000000#include #include using namespace metal; struct UBO1 { int4 c; int4 d; }; struct UBO2 { uint4 e; uint4 f; }; struct UBO0 { float4 a; float4 b; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant UBO1& _14 [[buffer(0)]], constant UBO2& _29 [[buffer(1)]], constant UBO0& _41 [[buffer(2)]]) { main0_out out = {}; out.FragColor = ((((float4(_14.c) + float4(_14.d)) + float4(_29.e)) + float4(_29.f)) + _41.a) + _41.b; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/000077500000000000000000000000001400026215700222735ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/argument-buffers.msl2.argument.frag000066400000000000000000000034631400026215700311130ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 ssbo; }; struct SSBOs { float4 ssbo; }; struct Push { float4 push; }; struct UBO { float4 ubo; }; struct UBOs { float4 ubo; }; struct spvDescriptorSetBuffer0 { texture2d uTexture [[id(0)]]; sampler uTextureSmplr [[id(1)]]; array, 2> uTextures [[id(2)]]; array uTexturesSmplr [[id(4)]]; constant UBO* m_90 [[id(6)]]; }; struct spvDescriptorSetBuffer1 { array, 4> uTexture2 [[id(0)]]; array uSampler [[id(4)]]; device SSBO* m_60 [[id(6)]]; const device SSBOs* ssbos [[id(7)]][2]; }; struct spvDescriptorSetBuffer2 { constant UBOs* ubos [[id(0)]][4]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], constant spvDescriptorSetBuffer2& spvDescriptorSet2 [[buffer(2)]], constant Push& registers [[buffer(3)]]) { main0_out out = {}; out.FragColor = ((((((spvDescriptorSet0.uTexture.sample(spvDescriptorSet0.uTextureSmplr, in.vUV) + spvDescriptorSet1.uTexture2[2].sample(spvDescriptorSet1.uSampler[1], in.vUV)) + spvDescriptorSet0.uTextures[1].sample(spvDescriptorSet0.uTexturesSmplr[1], in.vUV)) + (*spvDescriptorSet1.m_60).ssbo) + spvDescriptorSet1.ssbos[0]->ssbo) + registers.push) + (*spvDescriptorSet0.m_90).ubo) + spvDescriptorSet2.ubos[0]->ubo; out.FragColor += (*spvDescriptorSet0.m_90).ubo; out.FragColor += (*spvDescriptorSet1.m_60).ssbo; out.FragColor += spvDescriptorSet2.ubos[1]->ubo; out.FragColor += registers.push; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/array-lut-no-loop-variable.frag000066400000000000000000000025671400026215700302320ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _17 = spvUnsafeArray({ 1.0, 2.0, 3.0, 4.0, 5.0 }); struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; for (int _46 = 0; _46 < 4; ) { int _33 = _46 + 1; out.FragColor += float4(_17[_33]); _46 = _33; continue; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/array-of-array-lut.frag000066400000000000000000000032141400026215700265720ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _17 = spvUnsafeArray({ 1.0, 2.0, 3.0 }); constant spvUnsafeArray _21 = spvUnsafeArray({ 4.0, 5.0, 6.0 }); constant spvUnsafeArray, 2> _22 = spvUnsafeArray, 2>({ spvUnsafeArray({ 1.0, 2.0, 3.0 }), spvUnsafeArray({ 4.0, 5.0, 6.0 }) }); struct main0_out { float vOutput [[color(0)]]; }; struct main0_in { int vIndex1 [[user(locn0)]]; int vIndex2 [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.vOutput = _22[in.vIndex1][in.vIndex2]; return out; } array-of-texture-swizzle-nonconstant-uniform.msl2.argument.discrete.swizzle.frag000066400000000000000000000057221400026215700420310ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { uint index; }; struct UBO2 { uint index2; }; struct spvDescriptorSetBuffer0 { array, 4> uSampler [[id(0)]]; array uSamplerSmplr [[id(4)]]; constant UBO* uUBO [[id(8)]]; constant UBO2* m_50 [[id(9)]]; constant uint* spvSwizzleConstants [[id(10)]]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant uint* spvSwizzleConstants [[buffer(30)]]) { main0_out out = {}; constant uint* spvDescriptorSet0_uSamplerSwzl = &spvDescriptorSet0.spvSwizzleConstants[0]; out.FragColor = spvTextureSwizzle(spvDescriptorSet0.uSampler[(*spvDescriptorSet0.uUBO).index].sample(spvDescriptorSet0.uSamplerSmplr[(*spvDescriptorSet0.uUBO).index], in.vUV), spvDescriptorSet0_uSamplerSwzl[(*spvDescriptorSet0.uUBO).index]); out.FragColor += spvTextureSwizzle(spvDescriptorSet0.uSampler[(*spvDescriptorSet0.m_50).index2].sample(spvDescriptorSet0.uSamplerSmplr[(*spvDescriptorSet0.m_50).index2], in.vUV), spvDescriptorSet0_uSamplerSwzl[(*spvDescriptorSet0.m_50).index2]); return out; } array-of-texture-swizzle-nonconstant-uniform.msl2.swizzle.frag000066400000000000000000000050471400026215700364070ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { uint index; }; struct UBO2 { uint index2; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvSwizzleConstants [[buffer(30)]], constant UBO& uUBO [[buffer(0)]], constant UBO2& _50 [[buffer(1)]], array, 4> uSampler [[texture(0)]], array uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; constant uint* uSamplerSwzl = &spvSwizzleConstants[0]; out.FragColor = spvTextureSwizzle(uSampler[uUBO.index].sample(uSamplerSmplr[uUBO.index], in.vUV), uSamplerSwzl[uUBO.index]); out.FragColor += spvTextureSwizzle(uSampler[_50.index2].sample(uSamplerSmplr[_50.index2], in.vUV), uSamplerSwzl[_50.index2]); return out; } array-of-texture-swizzle.msl2.argument.discrete.swizzle.frag000066400000000000000000000056701400026215700360140ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct spvDescriptorSetBuffer0 { array, 4> uSampler0 [[id(0)]]; array uSampler0Smplr [[id(4)]]; constant uint* spvSwizzleConstants [[id(8)]]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant uint* spvSwizzleConstants [[buffer(30)]], texture2d uSampler1 [[texture(0)]], sampler uSampler1Smplr [[sampler(0)]]) { main0_out out = {}; constant uint* spvDescriptorSet0_uSampler0Swzl = &spvDescriptorSet0.spvSwizzleConstants[0]; constant uint& uSampler1Swzl = spvSwizzleConstants[0]; out.FragColor = spvTextureSwizzle(spvDescriptorSet0.uSampler0[2].sample(spvDescriptorSet0.uSampler0Smplr[2], in.vUV), spvDescriptorSet0_uSampler0Swzl[2]); float4 _73 = spvTextureSwizzle(uSampler1.sample(uSampler1Smplr, in.vUV), uSampler1Swzl); out.FragColor += _73; out.FragColor += spvTextureSwizzle(spvDescriptorSet0.uSampler0[1].sample(spvDescriptorSet0.uSampler0Smplr[1], in.vUV), spvDescriptorSet0_uSampler0Swzl[1]); out.FragColor += _73; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/array-of-texture-swizzle.msl2.swizzle.frag000066400000000000000000000045511400026215700324460ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvSwizzleConstants [[buffer(30)]], array, 4> uSampler [[texture(0)]], array uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; constant uint* uSamplerSwzl = &spvSwizzleConstants[0]; out.FragColor = spvTextureSwizzle(uSampler[2].sample(uSamplerSmplr[2], in.vUV), uSamplerSwzl[2]); out.FragColor += spvTextureSwizzle(uSampler[1].sample(uSamplerSmplr[1], in.vUV), uSamplerSwzl[1]); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/barycentric-nv-nopersp.msl22.frag000066400000000000000000000012061400026215700305030ustar00rootroot00000000000000#include #include using namespace metal; struct Vertices { float2 uvs[1]; }; struct main0_out { float2 value [[color(0)]]; }; struct main0_in { float3 gl_BaryCoordNoPerspNV [[barycentric_coord, center_no_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device Vertices& _19 [[buffer(0)]], uint gl_PrimitiveID [[primitive_id]]) { main0_out out = {}; int _23 = 3 * int(gl_PrimitiveID); out.value = ((_19.uvs[_23] * in.gl_BaryCoordNoPerspNV.x) + (_19.uvs[_23 + 1] * in.gl_BaryCoordNoPerspNV.y)) + (_19.uvs[_23 + 2] * in.gl_BaryCoordNoPerspNV.z); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/barycentric-nv.msl22.frag000066400000000000000000000011471400026215700270230ustar00rootroot00000000000000#include #include using namespace metal; struct Vertices { float2 uvs[1]; }; struct main0_out { float2 value [[color(0)]]; }; struct main0_in { float3 gl_BaryCoordNV [[barycentric_coord, center_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device Vertices& _19 [[buffer(0)]], uint gl_PrimitiveID [[primitive_id]]) { main0_out out = {}; int _23 = 3 * int(gl_PrimitiveID); out.value = ((_19.uvs[_23] * in.gl_BaryCoordNV.x) + (_19.uvs[_23 + 1] * in.gl_BaryCoordNV.y)) + (_19.uvs[_23 + 2] * in.gl_BaryCoordNV.z); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/basic.force-sample.frag000066400000000000000000000007451400026215700265770ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; out.FragColor = in.vColor * uTex.sample(uTexSmplr, in.vTex); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/basic.frag000066400000000000000000000007051400026215700242170ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = in.vColor * uTex.sample(uTexSmplr, in.vTex); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/binary-func-unpack-pack-arguments.frag000066400000000000000000000006431400026215700315520ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { packed_float3 color; float v; }; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vIn [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant UBO& _15 [[buffer(0)]]) { main0_out out = {}; out.FragColor = dot(in.vIn, float3(_15.color)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/binary-unpack-pack-arguments.frag000066400000000000000000000006571400026215700306260ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { packed_float3 color; float v; }; struct main0_out { float3 FragColor [[color(0)]]; }; struct main0_in { float3 vIn [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant UBO& _15 [[buffer(0)]]) { main0_out out = {}; out.FragColor = cross(in.vIn, float3(_15.color) - in.vIn); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/bitcasting.1d-as-2d.frag000066400000000000000000000015521400026215700264750ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor0 [[color(0)]]; float4 FragColor1 [[color(1)]]; }; struct main0_in { float4 VertGeom [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d TextureBase [[texture(0)]], texture2d TextureDetail [[texture(1)]], sampler TextureBaseSmplr [[sampler(0)]], sampler TextureDetailSmplr [[sampler(1)]]) { main0_out out = {}; float4 _22 = TextureBase.sample(TextureBaseSmplr, float2(in.VertGeom.x, 0.5)); float4 _30 = TextureDetail.sample(TextureDetailSmplr, float2(in.VertGeom.x, 0.5), int2(3, 0)); out.FragColor0 = as_type(as_type(_22)) * as_type(as_type(_30)); out.FragColor1 = as_type(as_type(_22)) * as_type(as_type(_30)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/bitcasting.frag000066400000000000000000000015221400026215700252630ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor0 [[color(0)]]; float4 FragColor1 [[color(1)]]; }; struct main0_in { float4 VertGeom [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d TextureBase [[texture(0)]], texture2d TextureDetail [[texture(1)]], sampler TextureBaseSmplr [[sampler(0)]], sampler TextureDetailSmplr [[sampler(1)]]) { main0_out out = {}; float4 _20 = TextureBase.sample(TextureBaseSmplr, in.VertGeom.xy); float4 _31 = TextureDetail.sample(TextureDetailSmplr, in.VertGeom.xy, int2(3, 2)); out.FragColor0 = as_type(as_type(_20)) * as_type(as_type(_31)); out.FragColor1 = as_type(as_type(_20)) * as_type(as_type(_31)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/buffer-read-write.frag000066400000000000000000000013021400026215700264420ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } fragment main0_out main0(texture2d buf [[texture(0)]], texture2d bufOut [[texture(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = buf.read(spvTexelBufferCoord(0)); bufOut.write(out.FragColor, spvTexelBufferCoord(int(gl_FragCoord.x))); return out; } buffer-read-write.texture-buffer-native.msl21.frag000066400000000000000000000006631400026215700335630ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/frag#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture_buffer buf [[texture(0)]], texture_buffer bufOut [[texture(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = buf.read(uint(0)); bufOut.write(out.FragColor, uint(int(gl_FragCoord.x))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/builtins.frag000066400000000000000000000006561400026215700247740ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; float gl_FragDepth [[depth(any)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = gl_FragCoord + in.vColor; out.gl_FragDepth = 0.5; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/clip-distance-varying.frag000066400000000000000000000027451400026215700273400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float gl_ClipDistance_0 [[user(clip0)]]; float gl_ClipDistance_1 [[user(clip1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray gl_ClipDistance = {}; gl_ClipDistance[0] = in.gl_ClipDistance_0; gl_ClipDistance[1] = in.gl_ClipDistance_1; out.FragColor = float4((1.0 - gl_ClipDistance[0]) - gl_ClipDistance[1]); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/complex-expression-in-access-chain.frag000066400000000000000000000012251400026215700317230ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 results[1024]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int vIn [[user(locn0)]]; int vIn2 [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], device UBO& _34 [[buffer(0)]], texture2d Buf [[texture(0)]], sampler BufSmplr [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; int _40 = Buf.read(uint2(int2(gl_FragCoord.xy)), 0).x % 16; out.FragColor = (_34.results[_40] + _34.results[_40]) + _34.results[(in.vIn * in.vIn) + (in.vIn2 * in.vIn2)]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/composite-extract-forced-temporary.frag000066400000000000000000000007471400026215700320760ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vTexCoord [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d Texture [[texture(0)]], sampler TextureSmplr [[sampler(0)]]) { main0_out out = {}; float4 _19 = Texture.sample(TextureSmplr, in.vTexCoord); float _22 = _19.x; out.FragColor = float4(_22 * _22); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/constant-array.frag000066400000000000000000000040041400026215700260770ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Foobar { float a; float b; }; constant spvUnsafeArray _37 = spvUnsafeArray({ float4(1.0), float4(2.0), float4(3.0) }); constant spvUnsafeArray _49 = spvUnsafeArray({ float4(1.0), float4(2.0) }); constant spvUnsafeArray _54 = spvUnsafeArray({ float4(8.0), float4(10.0) }); constant spvUnsafeArray, 2> _55 = spvUnsafeArray, 2>({ spvUnsafeArray({ float4(1.0), float4(2.0) }), spvUnsafeArray({ float4(8.0), float4(10.0) }) }); struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int index [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { spvUnsafeArray _75 = spvUnsafeArray({ Foobar{ 10.0, 40.0 }, Foobar{ 90.0, 70.0 } }); main0_out out = {}; out.FragColor = ((_37[in.index] + _55[in.index][in.index + 1]) + float4(30.0)) + float4(_75[in.index].a + _75[in.index].b); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/constant-composites.frag000066400000000000000000000030451400026215700271520ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Foo { float a; float b; }; constant spvUnsafeArray _16 = spvUnsafeArray({ 1.0, 4.0, 3.0, 2.0 }); struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int line [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { spvUnsafeArray _28 = spvUnsafeArray({ Foo{ 10.0, 20.0 }, Foo{ 30.0, 40.0 } }); main0_out out = {}; out.FragColor = float4(_16[in.line]); out.FragColor += float4(_28[in.line].a * _28[1 - in.line].a); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/control-dependent-in-branch.desktop.frag000066400000000000000000000021251400026215700320670ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vInput [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = in.vInput; float4 _23 = uSampler.sample(uSamplerSmplr, in.vInput.xy); float4 _26 = dfdx(in.vInput); float4 _29 = dfdy(in.vInput); float4 _32 = fwidth(in.vInput); float4 _35 = dfdx(in.vInput); float4 _38 = dfdy(in.vInput); float4 _41 = fwidth(in.vInput); float4 _44 = dfdx(in.vInput); float4 _47 = dfdy(in.vInput); float4 _50 = fwidth(in.vInput); if (in.vInput.y > 10.0) { out.FragColor += _23; out.FragColor += _26; out.FragColor += _29; out.FragColor += _32; out.FragColor += _35; out.FragColor += _38; out.FragColor += _41; out.FragColor += _44; out.FragColor += _47; out.FragColor += _50; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/depth-greater-than.frag000066400000000000000000000003561400026215700266230ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float gl_FragDepth [[depth(greater)]]; }; fragment main0_out main0() { main0_out out = {}; out.gl_FragDepth = 0.5; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/depth-less-than.frag000066400000000000000000000003531400026215700261350ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float gl_FragDepth [[depth(less)]]; }; fragment main0_out main0() { main0_out out = {}; out.gl_FragDepth = 0.5; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/disable-frag-output.frag-output.frag000066400000000000000000000014121400026215700312640ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 buf1 [[color(1)]]; float4 buf3 [[color(3)]]; float4 buf6 [[color(6)]]; float4 buf7 [[color(7)]]; }; fragment main0_out main0() { float4 buf0; float4 buf2; float4 buf4; float4 buf5; float gl_FragDepth; int gl_FragStencilRefARB; main0_out out = {}; buf0 = float4(0.0, 0.0, 0.0, 1.0); out.buf1 = float4(1.0, 0.0, 0.0, 1.0); buf2 = float4(0.0, 1.0, 0.0, 1.0); out.buf3 = float4(0.0, 0.0, 1.0, 1.0); buf4 = float4(1.0, 0.0, 1.0, 0.5); buf5 = float4(0.25); out.buf6 = float4(0.75); out.buf7 = float4(1.0); gl_FragDepth = 0.89999997615814208984375; gl_FragStencilRefARB = uint(127); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/dual-source-blending.frag000066400000000000000000000005071400026215700271410ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor0 [[color(0), index(0)]]; float4 FragColor1 [[color(0), index(1)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor0 = float4(1.0); out.FragColor1 = float4(2.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/early-fragment-tests.frag000066400000000000000000000004061400026215700272110ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; [[ early_fragment_tests ]] fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/false-loop-init.frag000066400000000000000000000007111400026215700261350ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 result [[color(0)]]; }; struct main0_in { float4 accum [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.result = float4(0.0); for (int _48 = 0; _48 < 4; ) { out.result += in.accum; _48 += int((in.accum.y > 10.0) ? 40u : 30u); continue; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/flush_params.frag000066400000000000000000000003541400026215700256220ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(10.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/for-loop-continue-control-flow.frag000066400000000000000000000005431400026215700311400ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(0.0); for (int _43 = 0; _43 < 3; ) { out.FragColor[_43] += float(_43); _43++; continue; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/for-loop-init.frag000066400000000000000000000026161400026215700256370ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { int FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; do { out.FragColor = 16; for (int _143 = 0; _143 < 25; ) { out.FragColor += 10; _143++; continue; } for (int _144 = 1; _144 < 30; ) { out.FragColor += 11; _144++; continue; } int _145; _145 = 0; for (; _145 < 20; ) { out.FragColor += 12; _145++; continue; } int _62 = _145 + 3; out.FragColor += _62; if (_62 == 40) { for (int _149 = 0; _149 < 40; ) { out.FragColor += 13; _149++; continue; } break; } out.FragColor += _62; int2 _146; _146 = int2(0); for (; _146.x < 10; ) { out.FragColor += _146.y; int2 _142 = _146; _142.x = _146.x + 4; _146 = _142; continue; } for (int _148 = _62; _148 < 40; ) { out.FragColor += _148; _148++; continue; } out.FragColor += _62; break; } while(false); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/fp16-packing.frag000066400000000000000000000006771400026215700253340ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float2 FP32Out [[color(0)]]; uint FP16Out [[color(1)]]; }; struct main0_in { uint FP16 [[user(locn0)]]; float2 FP32 [[user(locn1), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FP32Out = float2(as_type(in.FP16)); out.FP16Out = as_type(half2(in.FP32)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/fragment-component-padding.pad-fragment.frag000066400000000000000000000033151400026215700327110ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColors_0 [[color(0)]]; float4 FragColors_1 [[color(1)]]; float4 FragColor2 [[color(2)]]; float4 FragColor3 [[color(3)]]; }; struct main0_in { float3 vColor [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray FragColors = {}; float2 FragColor2 = {}; float3 FragColor3 = {}; FragColors[0] = in.vColor.x; FragColors[1] = in.vColor.y; FragColor2 = in.vColor.xz; FragColor3 = in.vColor.zzz; out.FragColors_0 = float4(FragColors[0]); out.FragColors_1 = float4(FragColors[1]); out.FragColor2.xy = FragColor2; out.FragColor3.xyz = FragColor3; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/front-facing.frag000066400000000000000000000007231400026215700255130ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vA [[user(locn0)]]; float4 vB [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], bool gl_FrontFacing [[front_facing]]) { main0_out out = {}; if (gl_FrontFacing) { out.FragColor = in.vA; } else { out.FragColor = in.vB; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/gather-dref.frag000066400000000000000000000006371400026215700253320ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d uT [[texture(0)]], sampler uTSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = uT.gather_compare(uTSmplr, in.vUV.xy, in.vUV.z); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/gather-offset.frag000066400000000000000000000005301400026215700256700ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uT [[texture(0)]], sampler uTSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = uT.gather(uTSmplr, float2(0.5), int2(0), component::w); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/helper-invocation.msl21.frag000066400000000000000000000011451400026215700275200ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; bool gl_HelperInvocation = simd_is_helper_thread(); float4 _52; if (!gl_HelperInvocation) { _52 = uSampler.sample(uSamplerSmplr, in.vUV, level(0.0)); } else { _52 = float4(1.0); } out.FragColor = _52; return out; } huge-argument-buffer.device-argument-buffer.argument.msl2.frag000066400000000000000000000020711400026215700361160ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/frag#include #include using namespace metal; struct UBO { float4 v; }; struct spvDescriptorSetBuffer0 { array, 10000> uSamplers [[id(0)]]; array uSamplersSmplr [[id(10000)]]; }; struct spvDescriptorSetBuffer1 { constant UBO* vs [[id(0)]][10000]; }; struct spvDescriptorSetBuffer2 { texture2d uSampler [[id(0)]]; sampler uSamplerSmplr [[id(1)]]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], const device spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], constant spvDescriptorSetBuffer2& spvDescriptorSet2 [[buffer(2)]]) { main0_out out = {}; out.FragColor = (spvDescriptorSet0.uSamplers[9999].sample(spvDescriptorSet0.uSamplersSmplr[9999], in.vUV) + spvDescriptorSet1.vs[5000]->v) + spvDescriptorSet2.uSampler.sample(spvDescriptorSet2.uSamplerSmplr, in.vUV); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/illegal-name-test-0.frag000066400000000000000000000003541400026215700265770ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(40.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/image-query-lod.msl22.frag000066400000000000000000000056301400026215700270770ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float2 FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler2D [[texture(0)]], texture3d uSampler3D [[texture(1)]], texturecube uSamplerCube [[texture(2)]], texture2d uTexture2D [[texture(3)]], texture3d uTexture3D [[texture(4)]], texturecube uTextureCube [[texture(5)]], sampler uSampler2DSmplr [[sampler(0)]], sampler uSampler3DSmplr [[sampler(1)]], sampler uSamplerCubeSmplr [[sampler(2)]], sampler uSampler [[sampler(3)]]) { main0_out out = {}; out.FragColor = float2(0.0); float2 _79; _79.x = uSampler2D.calculate_clamped_lod(uSampler2DSmplr, in.vUV.xy); _79.y = uSampler2D.calculate_unclamped_lod(uSampler2DSmplr, in.vUV.xy); out.FragColor += _79; float2 _84; _84.x = uSampler3D.calculate_clamped_lod(uSampler3DSmplr, in.vUV); _84.y = uSampler3D.calculate_unclamped_lod(uSampler3DSmplr, in.vUV); out.FragColor += _84; float2 _89; _89.x = uSamplerCube.calculate_clamped_lod(uSamplerCubeSmplr, in.vUV); _89.y = uSamplerCube.calculate_unclamped_lod(uSamplerCubeSmplr, in.vUV); out.FragColor += _89; float2 _97; _97.x = uTexture2D.calculate_clamped_lod(uSampler, in.vUV.xy); _97.y = uTexture2D.calculate_unclamped_lod(uSampler, in.vUV.xy); out.FragColor += _97; float2 _104; _104.x = uTexture3D.calculate_clamped_lod(uSampler, in.vUV); _104.y = uTexture3D.calculate_unclamped_lod(uSampler, in.vUV); out.FragColor += _104; float2 _111; _111.x = uTextureCube.calculate_clamped_lod(uSampler, in.vUV); _111.y = uTextureCube.calculate_unclamped_lod(uSampler, in.vUV); out.FragColor += _111; float2 _119; _119.x = uSampler2D.calculate_clamped_lod(uSampler2DSmplr, in.vUV.xy); _119.y = uSampler2D.calculate_unclamped_lod(uSampler2DSmplr, in.vUV.xy); out.FragColor += _119; float2 _124; _124.x = uSampler3D.calculate_clamped_lod(uSampler3DSmplr, in.vUV); _124.y = uSampler3D.calculate_unclamped_lod(uSampler3DSmplr, in.vUV); out.FragColor += _124; float2 _129; _129.x = uSamplerCube.calculate_clamped_lod(uSamplerCubeSmplr, in.vUV); _129.y = uSamplerCube.calculate_unclamped_lod(uSamplerCubeSmplr, in.vUV); out.FragColor += _129; float2 _137; _137.x = uTexture2D.calculate_clamped_lod(uSampler, in.vUV.xy); _137.y = uTexture2D.calculate_unclamped_lod(uSampler, in.vUV.xy); out.FragColor += _137; float2 _144; _144.x = uTexture3D.calculate_clamped_lod(uSampler, in.vUV); _144.y = uTexture3D.calculate_unclamped_lod(uSampler, in.vUV); out.FragColor += _144; float2 _151; _151.x = uTextureCube.calculate_clamped_lod(uSampler, in.vUV); _151.y = uTextureCube.calculate_unclamped_lod(uSampler, in.vUV); out.FragColor += _151; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/in_block.frag000066400000000000000000000010521400026215700247120ustar00rootroot00000000000000#include #include using namespace metal; struct VertexOut { float4 color; float4 color2; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 VertexOut_color [[user(locn2)]]; float4 VertexOut_color2 [[user(locn3)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; VertexOut inputs = {}; inputs.color = in.VertexOut_color; inputs.color2 = in.VertexOut_color2; out.FragColor = inputs.color + inputs.color2; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/in_mat.frag000066400000000000000000000021371400026215700244060ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 outFragColor [[color(0)]]; }; struct main0_in { float3 inPos [[user(locn0)]]; float3 inNormal [[user(locn1)]]; float4 inInvModelView_0 [[user(locn2)]]; float4 inInvModelView_1 [[user(locn3)]]; float4 inInvModelView_2 [[user(locn4)]]; float4 inInvModelView_3 [[user(locn5)]]; float inLodBias [[user(locn6)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texturecube samplerColor [[texture(0)]], sampler samplerColorSmplr [[sampler(0)]]) { main0_out out = {}; float4x4 inInvModelView = {}; inInvModelView[0] = in.inInvModelView_0; inInvModelView[1] = in.inInvModelView_1; inInvModelView[2] = in.inInvModelView_2; inInvModelView[3] = in.inInvModelView_3; float4 _31 = inInvModelView * float4(reflect(normalize(in.inPos), normalize(in.inNormal)), 0.0); float _33 = _31.x; float3 _59 = float3(_33, _31.yz); _59.x = _33 * (-1.0); out.outFragColor = samplerColor.sample(samplerColorSmplr, _59, bias(in.inLodBias)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/input-attachment-ms.arrayed-subpass.msl21.frag000066400000000000000000000012371400026215700331020ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d_ms_array uSubpass0 [[texture(0)]], texture2d_ms_array uSubpass1 [[texture(1)]], uint gl_SampleID [[sample_id]], float4 gl_FragCoord [[position]], uint gl_Layer [[render_target_array_index]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; out.FragColor = (uSubpass0.read(uint2(gl_FragCoord.xy), gl_Layer, 1) + uSubpass1.read(uint2(gl_FragCoord.xy), gl_Layer, 2)) + uSubpass0.read(uint2(gl_FragCoord.xy), gl_Layer, gl_SampleID); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/input-attachment-ms.frag000066400000000000000000000011101400026215700270270ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d_ms uSubpass0 [[texture(0)]], texture2d_ms uSubpass1 [[texture(1)]], uint gl_SampleID [[sample_id]], float4 gl_FragCoord [[position]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; out.FragColor = (uSubpass0.read(uint2(gl_FragCoord.xy), 1) + uSubpass1.read(uint2(gl_FragCoord.xy), 2)) + uSubpass0.read(uint2(gl_FragCoord.xy), gl_SampleID); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/input-attachment-ms.multiview.msl21.frag000066400000000000000000000013761400026215700320260ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant uint* spvViewMask [[buffer(24)]], texture2d_ms_array uSubpass0 [[texture(0)]], texture2d_ms_array uSubpass1 [[texture(1)]], uint gl_SampleID [[sample_id]], float4 gl_FragCoord [[position]], uint gl_ViewIndex [[render_target_array_index]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; gl_ViewIndex += spvViewMask[0]; out.FragColor = (uSubpass0.read(uint2(gl_FragCoord.xy), gl_ViewIndex, 1) + uSubpass1.read(uint2(gl_FragCoord.xy), gl_ViewIndex, 2)) + uSubpass0.read(uint2(gl_FragCoord.xy), gl_ViewIndex, gl_SampleID); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/input-attachment.arrayed-subpass.frag000066400000000000000000000007621400026215700315320ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d_array uSubpass0 [[texture(0)]], texture2d_array uSubpass1 [[texture(1)]], float4 gl_FragCoord [[position]], uint gl_Layer [[render_target_array_index]]) { main0_out out = {}; out.FragColor = uSubpass0.read(uint2(gl_FragCoord.xy), gl_Layer) + uSubpass1.read(uint2(gl_FragCoord.xy), gl_Layer); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/input-attachment.frag000066400000000000000000000006451400026215700264260ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uSubpass0 [[texture(0)]], texture2d uSubpass1 [[texture(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = uSubpass0.read(uint2(gl_FragCoord.xy)) + uSubpass1.read(uint2(gl_FragCoord.xy)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/input-attachment.multiview.frag000066400000000000000000000011151400026215700304430ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant uint* spvViewMask [[buffer(24)]], texture2d_array uSubpass0 [[texture(0)]], texture2d_array uSubpass1 [[texture(1)]], float4 gl_FragCoord [[position]], uint gl_ViewIndex [[render_target_array_index]]) { main0_out out = {}; gl_ViewIndex += spvViewMask[0]; out.FragColor = uSubpass0.read(uint2(gl_FragCoord.xy), gl_ViewIndex) + uSubpass1.read(uint2(gl_FragCoord.xy), gl_ViewIndex); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/interpolation-qualifiers-block.frag000066400000000000000000000021171400026215700312560ustar00rootroot00000000000000#include #include using namespace metal; struct Input { float2 v0; float2 v1; float3 v2; float4 v3; float v4; float v5; float v6; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 Input_v0 [[user(locn0), centroid_no_perspective]]; float2 Input_v1 [[user(locn1), centroid_no_perspective]]; float3 Input_v2 [[user(locn2), centroid_no_perspective]]; float4 Input_v3 [[user(locn3), centroid_no_perspective]]; float Input_v4 [[user(locn4), centroid_no_perspective]]; float Input_v5 [[user(locn5), centroid_no_perspective]]; float Input_v6 [[user(locn6), centroid_no_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; Input inp = {}; inp.v0 = in.Input_v0; inp.v1 = in.Input_v1; inp.v2 = in.Input_v2; inp.v3 = in.Input_v3; inp.v4 = in.Input_v4; inp.v5 = in.Input_v5; inp.v6 = in.Input_v6; out.FragColor = float4(inp.v0.x + inp.v1.y, inp.v2.xy, ((inp.v3.w * inp.v4) + inp.v5) - inp.v6); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/interpolation-qualifiers.frag000066400000000000000000000012431400026215700301650ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 v0 [[user(locn0)]]; float2 v1 [[user(locn1), center_no_perspective]]; float3 v2 [[user(locn2), centroid_perspective]]; float4 v3 [[user(locn3), centroid_no_perspective]]; float v4 [[user(locn4), sample_perspective]]; float v5 [[user(locn5), sample_no_perspective]]; float v6 [[user(locn6), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = float4(in.v0.x + in.v1.y, in.v2.xy, ((in.v3.w * in.v4) + in.v5) - in.v6); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/lut-promotion.frag000066400000000000000000000043151400026215700257670ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _16 = spvUnsafeArray({ 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0 }); constant spvUnsafeArray _60 = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); constant spvUnsafeArray _104 = spvUnsafeArray({ float4(20.0), float4(30.0), float4(50.0), float4(60.0) }); struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { int index [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = _16[in.index]; if (in.index < 10) { out.FragColor += _16[in.index ^ 1]; } else { out.FragColor += _16[in.index & 1]; } bool _63 = in.index > 30; if (_63) { out.FragColor += _60[in.index & 3].y; } else { out.FragColor += _60[in.index & 1].x; } spvUnsafeArray foobar = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); if (_63) { foobar[1].z = 20.0; } int _91 = in.index & 3; out.FragColor += foobar[_91].z; out.FragColor += _104[_91].z; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/mix.frag000066400000000000000000000010561400026215700237330ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vIn0 [[user(locn0)]]; float4 vIn1 [[user(locn1)]]; float vIn2 [[user(locn2)]]; float vIn3 [[user(locn3)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = float4(in.vIn0.x, in.vIn1.y, in.vIn0.z, in.vIn0.w); out.FragColor = float4(in.vIn3); out.FragColor = in.vIn0.xyzw; out.FragColor = float4(in.vIn2); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/mrt-array.frag000066400000000000000000000035451400026215700250610ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor_0 [[color(0)]]; float4 FragColor_1 [[color(1)]]; float4 FragColor_2 [[color(2)]]; float4 FragColor_3 [[color(3)]]; }; struct main0_in { float4 vA [[user(locn0)]]; float4 vB [[user(locn1)]]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray FragColor = {}; FragColor[0] = mod(in.vA, in.vB); FragColor[1] = in.vA + in.vB; FragColor[2] = in.vA - in.vB; FragColor[3] = in.vA * in.vB; out.FragColor_0 = FragColor[0]; out.FragColor_1 = FragColor[1]; out.FragColor_2 = FragColor[2]; out.FragColor_3 = FragColor[3]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/nonuniform-qualifier.msl2.frag000066400000000000000000000024131400026215700301610ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 v[64]; }; struct SSBO { float4 v[1]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int vIndex [[user(locn0)]]; float2 vUV [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant UBO* ubos_0 [[buffer(0)]], constant UBO* ubos_1 [[buffer(1)]], const device SSBO* ssbos_0 [[buffer(2)]], const device SSBO* ssbos_1 [[buffer(3)]], array, 8> uSamplers [[texture(0)]], array, 8> uCombinedSamplers [[texture(8)]], array uSamps [[sampler(0)]], array uCombinedSamplersSmplr [[sampler(7)]]) { constant UBO* ubos[] = { ubos_0, ubos_1, }; const device SSBO* ssbos[] = { ssbos_0, ssbos_1, }; main0_out out = {}; int _25 = in.vIndex + 10; int _37 = in.vIndex + 40; out.FragColor = uSamplers[_25].sample(uSamps[_37], in.vUV); out.FragColor = uCombinedSamplers[_25].sample(uCombinedSamplersSmplr[_25], in.vUV); int _69 = in.vIndex + 20; out.FragColor += ubos[(_69)]->v[_37]; int _87 = in.vIndex + 50; int _91 = in.vIndex + 60; out.FragColor += ssbos[(_87)]->v[_91]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/packed-expression-vector-shuffle.frag000066400000000000000000000005651400026215700315200ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { packed_float3 color; float v; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant UBO& _15 [[buffer(0)]]) { main0_out out = {}; out.FragColor = float4(_15.color[0], _15.color[1], _15.color[2], float4(1.0).w); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/packing-test-3.frag000066400000000000000000000011411400026215700256620ustar00rootroot00000000000000#include #include using namespace metal; struct TestStruct { packed_float3 position; float radius; }; struct CB0 { TestStruct CB0[16]; }; struct main0_out { float4 _entryPointOutput [[color(0)]]; }; fragment main0_out main0(constant CB0& _RESERVED_IDENTIFIER_FIXUP_24 [[buffer(0)]]) { main0_out out = {}; out._entryPointOutput = float4(_RESERVED_IDENTIFIER_FIXUP_24.CB0[1].position[0], _RESERVED_IDENTIFIER_FIXUP_24.CB0[1].position[1], _RESERVED_IDENTIFIER_FIXUP_24.CB0[1].position[2], _RESERVED_IDENTIFIER_FIXUP_24.CB0[1].radius); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/pixel-interlock-ordered.msl2.argument.frag000066400000000000000000000040121400026215700323610ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct Buffer3 { int baz; }; struct Buffer { int foo; uint bar; }; struct Buffer2 { uint quux; }; struct spvDescriptorSetBuffer0 { device Buffer3* m_9 [[id(0)]]; texture2d img4 [[id(1)]]; texture2d img [[id(2), raster_order_group(0)]]; texture2d img3 [[id(3), raster_order_group(0)]]; texture2d img2 [[id(4), raster_order_group(0)]]; device atomic_uint* img2_atomic [[id(5), raster_order_group(0)]]; volatile device Buffer* m_42 [[id(6), raster_order_group(0)]]; device Buffer2* m_52 [[id(7), raster_order_group(0)]]; }; // The required alignment of a linear texture of R32Uint format. constant uint spvLinearTextureAlignmentOverride [[function_constant(65535)]]; constant uint spvLinearTextureAlignment = is_function_constant_defined(spvLinearTextureAlignmentOverride) ? spvLinearTextureAlignmentOverride : 4; // Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics #define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + spvLinearTextureAlignment / 4 - 1) & ~( spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x) fragment void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]]) { (*spvDescriptorSet0.m_9).baz = 0; spvDescriptorSet0.img4.write(float4(1.0, 0.0, 0.0, 1.0), uint2(int2(1))); spvDescriptorSet0.img.write(spvDescriptorSet0.img3.read(uint2(int2(0))), uint2(int2(0))); uint _39 = atomic_fetch_add_explicit((device atomic_uint*)&spvDescriptorSet0.img2_atomic[spvImage2DAtomicCoord(int2(0), spvDescriptorSet0.img2)], 1u, memory_order_relaxed); (*spvDescriptorSet0.m_42).foo += 42; uint _55 = atomic_fetch_and_explicit((volatile device atomic_uint*)&(*spvDescriptorSet0.m_42).bar, (*spvDescriptorSet0.m_52).quux, memory_order_relaxed); } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/pixel-interlock-ordered.msl2.frag000066400000000000000000000033611400026215700305460ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct Buffer3 { int baz; }; struct Buffer { int foo; uint bar; }; struct Buffer2 { uint quux; }; // The required alignment of a linear texture of R32Uint format. constant uint spvLinearTextureAlignmentOverride [[function_constant(65535)]]; constant uint spvLinearTextureAlignment = is_function_constant_defined(spvLinearTextureAlignmentOverride) ? spvLinearTextureAlignmentOverride : 4; // Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics #define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + spvLinearTextureAlignment / 4 - 1) & ~( spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x) fragment void main0(device Buffer3& _9 [[buffer(0)]], volatile device Buffer& _42 [[buffer(2), raster_order_group(0)]], device Buffer2& _52 [[buffer(3), raster_order_group(0)]], texture2d img4 [[texture(0)]], texture2d img [[texture(1), raster_order_group(0)]], texture2d img3 [[texture(2), raster_order_group(0)]], texture2d img2 [[texture(3), raster_order_group(0)]], device atomic_uint* img2_atomic [[buffer(1), raster_order_group(0)]]) { _9.baz = 0; img4.write(float4(1.0, 0.0, 0.0, 1.0), uint2(int2(1))); img.write(img3.read(uint2(int2(0))), uint2(int2(0))); uint _39 = atomic_fetch_add_explicit((device atomic_uint*)&img2_atomic[spvImage2DAtomicCoord(int2(0), img2)], 1u, memory_order_relaxed); _42.foo += 42; uint _55 = atomic_fetch_and_explicit((volatile device atomic_uint*)&_42.bar, _52.quux, memory_order_relaxed); } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/pls.frag000066400000000000000000000011611400026215700237310ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 PLSOut0 [[color(0)]]; float4 PLSOut1 [[color(1)]]; float4 PLSOut2 [[color(2)]]; float4 PLSOut3 [[color(3)]]; }; struct main0_in { float4 PLSIn0 [[user(locn0)]]; float4 PLSIn1 [[user(locn1)]]; float4 PLSIn2 [[user(locn2)]]; float4 PLSIn3 [[user(locn3)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.PLSOut0 = in.PLSIn0 * 2.0; out.PLSOut1 = in.PLSIn1 * 6.0; out.PLSOut2 = in.PLSIn2 * 7.0; out.PLSOut3 = in.PLSIn3 * 4.0; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/post-depth-coverage.ios.msl2.frag000066400000000000000000000005221400026215700304600ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; [[ early_fragment_tests ]] fragment main0_out main0(uint gl_SampleMaskIn [[sample_mask, post_depth_coverage]]) { main0_out out = {}; out.FragColor = float4(float(gl_SampleMaskIn)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/post-depth-coverage.msl23.frag000066400000000000000000000005221400026215700277520ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; [[ early_fragment_tests ]] fragment main0_out main0(uint gl_SampleMaskIn [[sample_mask, post_depth_coverage]]) { main0_out out = {}; out.FragColor = float4(float(gl_SampleMaskIn)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/private-variable-prototype-declaration.frag000066400000000000000000000003531400026215700327200ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float3 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float3(1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/readonly-ssbo.frag000066400000000000000000000004611400026215700257160ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 v; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(const device SSBO& _13 [[buffer(0)]]) { main0_out out = {}; out.FragColor = _13.v + _13.v; return out; } sample-depth-propagate-state-from-resource.frag000066400000000000000000000010361400026215700333240ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/frag#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d uTexture [[texture(0)]], sampler uSampler [[sampler(0)]], sampler uSamplerShadow [[sampler(1)]]) { main0_out out = {}; out.FragColor = float4(uTexture.sample(uSampler, in.vUV.xy)).x; out.FragColor += uTexture.sample_compare(uSamplerShadow, in.vUV.xy, in.vUV.z); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-depth-separate-image-sampler.frag000066400000000000000000000007261400026215700320470ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; fragment main0_out main0(depth2d uDepth [[texture(0)]], texture2d uColor [[texture(1)]], sampler uSamplerShadow [[sampler(0)]], sampler uSampler [[sampler(1)]]) { main0_out out = {}; out.FragColor = uDepth.sample_compare(uSamplerShadow, float3(0.5).xy, 0.5) + uColor.sample(uSampler, float2(0.5)).x; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-mask-in-and-out.fixed-sample-mask.frag000066400000000000000000000005751400026215700326340ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; fragment main0_out main0(uint gl_SampleMaskIn [[sample_mask]]) { main0_out out = {}; out.FragColor = float4(1.0); out.gl_SampleMask = gl_SampleMaskIn; out.gl_SampleMask &= 34; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-mask-not-used.fixed-sample-mask.frag000066400000000000000000000004571400026215700324160ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(1.0); out.gl_SampleMask = 34; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-mask.fixed-sample-mask.frag000066400000000000000000000005131400026215700306530ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(1.0); out.gl_SampleMask = 0; out.gl_SampleMask &= 34; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-mask.frag000066400000000000000000000004561400026215700253530ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(1.0); out.gl_SampleMask = 0; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-position-func.frag000066400000000000000000000006751400026215700272200ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int index [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; float2 gl_SamplePosition = get_sample_position(gl_SampleID); out.FragColor = float4(gl_SamplePosition, float(in.index), 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-position.frag000066400000000000000000000005611400026215700262610ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(uint gl_SampleID [[sample_id]]) { main0_out out = {}; float2 gl_SamplePosition = get_sample_position(gl_SampleID); out.FragColor = float4(gl_SamplePosition, float(gl_SampleID), 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-rate-frag-coord-sample-id.frag000066400000000000000000000010311400026215700312330ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d_array tex [[texture(0)]], sampler texSmplr [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float3 _28 = float3(gl_FragCoord.xy, float(gl_SampleID)); out.FragColor = tex.sample(texSmplr, _28.xy, uint(round(_28.z))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-rate-frag-coord-sample-input.frag000066400000000000000000000011601400026215700320010ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float foo [[user(locn0), sample_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d_array tex [[texture(0)]], sampler texSmplr [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float3 _26 = float3(gl_FragCoord.xy, in.foo); out.FragColor = tex.sample(texSmplr, _26.xy, uint(round(_26.z))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-rate-frag-coord-sample-pos.frag000066400000000000000000000010411400026215700314410ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d tex [[texture(0)]], sampler texSmplr [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float2 gl_SamplePosition = get_sample_position(gl_SampleID); out.FragColor = tex.sample(texSmplr, (gl_FragCoord.xy - gl_SamplePosition)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sample-rate-frag-coord.force-sample.frag000066400000000000000000000007121400026215700317430ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d tex [[texture(0)]], sampler texSmplr [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; out.FragColor = tex.sample(texSmplr, gl_FragCoord.xy); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sampler-1d-lod.1d-as-2d.frag000066400000000000000000000011301400026215700270570ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float vTex [[user(locn0), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor += ((uSampler.sample(uSamplerSmplr, float2(in.vTex, 0.5), bias(2.0)) + uSampler.sample(uSamplerSmplr, float2(in.vTex, 0.5), level(3.0))) + uSampler.sample(uSamplerSmplr, float2(in.vTex, 0.5), gradient2d(5.0, 8.0))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sampler-1d-lod.frag000066400000000000000000000010041400026215700256500ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float vTex [[user(locn0), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture1d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor += ((uSampler.sample(uSamplerSmplr, in.vTex) + uSampler.sample(uSamplerSmplr, in.vTex)) + uSampler.sample(uSamplerSmplr, in.vTex)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sampler-compare-bias.msl23.1d-as-2d.frag000066400000000000000000000007261400026215700313120ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d_array uTex [[texture(0)]], sampler uShadow [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample_compare(uShadow, float2(in.vUV.x, 0.5), uint(round(in.vUV.y)), in.vUV.z, bias(1.0)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sampler-compare-cascade-gradient.frag000066400000000000000000000007111400026215700313760ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d_array uTex [[texture(0)]], sampler uShadow [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample_compare(uShadow, in.vUV.xy, uint(round(in.vUV.z)), in.vUV.w, level(0)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sampler-compare-cascade-gradient.ios.frag000066400000000000000000000007451400026215700321760ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d_array uTex [[texture(0)]], sampler uShadow [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample_compare(uShadow, in.vUV.xy, uint(round(in.vUV.z)), in.vUV.w, gradient2d(float2(0.0), float2(0.0))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sampler-compare-cascade-gradient.msl23.frag000066400000000000000000000010721400026215700323360ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d_array uTex [[texture(0)]], sampler uShadow [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample_compare(uShadow, in.vUV.xy, uint(round(in.vUV.z)), in.vUV.w, level(0)) + uTex.sample_compare(uShadow, in.vUV.xy, uint(round(in.vUV.z)), in.vUV.w, gradient2d(float2(1.0), float2(1.0))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sampler-image-arrays.msl2.frag000066400000000000000000000020401400026215700300260ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vTex [[user(locn0), flat]]; int vIndex [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], array, 4> uSampler [[texture(0)]], array, 4> uTextures [[texture(4)]], array uSamplerSmplr [[sampler(0)]], array uSamplers [[sampler(4)]]) { main0_out out = {}; out.FragColor = float4(0.0); out.FragColor += uTextures[2].sample(uSamplers[1], in.vTex); out.FragColor += uSampler[in.vIndex].sample(uSamplerSmplr[in.vIndex], in.vTex); out.FragColor += uSampler[in.vIndex].sample(uSamplerSmplr[in.vIndex], (in.vTex + float2(0.100000001490116119384765625))); out.FragColor += uSampler[in.vIndex].sample(uSamplerSmplr[in.vIndex], (in.vTex + float2(0.20000000298023223876953125))); out.FragColor += uSampler[3].sample(uSamplerSmplr[3], (in.vTex + float2(0.300000011920928955078125))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sampler-ms.frag000066400000000000000000000007661400026215700252250ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d_ms uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; int2 _17 = int2(gl_FragCoord.xy); out.FragColor = ((uSampler.read(uint2(_17), 0) + uSampler.read(uint2(_17), 1)) + uSampler.read(uint2(_17), 2)) + uSampler.read(uint2(_17), 3); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/sampler.frag000066400000000000000000000007051400026215700246010ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = in.vColor * uTex.sample(uTexSmplr, in.vTex); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/scalar-refract-reflect.frag000066400000000000000000000017331400026215700274530ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vRefract [[user(locn0)]]; }; template inline T spvReflect(T i, T n) { return i - T(2) * i * n * n; } template inline T spvRefract(T i, T n, T eta) { T NoI = n * i; T NoI2 = NoI * NoI; T k = T(1) - eta * eta * (T(1) - NoI2); if (k < T(0)) { return T(0); } else { return eta * i - (eta * NoI + sqrt(k)) * n; } } fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = spvRefract(in.vRefract.x, in.vRefract.y, in.vRefract.z); out.FragColor += spvReflect(in.vRefract.x, in.vRefract.y); out.FragColor += refract(in.vRefract.xy, in.vRefract.yz, in.vRefract.z).y; out.FragColor += reflect(in.vRefract.xy, in.vRefract.zy).y; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/separate-image-sampler-argument.frag000066400000000000000000000005131400026215700313000ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uDepth [[texture(0)]], sampler uSampler [[sampler(0)]]) { main0_out out = {}; out.FragColor = uDepth.sample(uSampler, float2(0.5)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/shader-arithmetic-8bit.frag000066400000000000000000000023461400026215700274020ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { char i8[16]; uchar u8[16]; }; struct Push { char i8; uchar u8; }; struct UBO { char i8; uchar u8; }; struct main0_out { int4 FragColorInt [[color(0)]]; uint4 FragColorUint [[color(1)]]; }; struct main0_in { int4 vColor [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], device SSBO& ssbo [[buffer(0)]], constant Push& registers [[buffer(1)]], constant UBO& ubo [[buffer(2)]]) { main0_out out = {}; char4 _199 = as_type(20); ssbo.i8[0] = _199.x; ssbo.i8[1] = _199.y; ssbo.i8[2] = _199.z; ssbo.i8[3] = _199.w; uchar4 _224 = as_type(20u); ssbo.u8[0] = _224.x; ssbo.u8[1] = _224.y; ssbo.u8[2] = _224.z; ssbo.u8[3] = _224.w; char4 _249 = char4(in.vColor); out.FragColorInt = int4((((((_249 + char4(registers.i8)) + char4(-40)) + char4(-50)) + char4(char(10), char(20), char(30), char(40))) + char4(ssbo.i8[4])) + char4(ubo.i8)); out.FragColorUint = uint4((((((uchar4(_249) + uchar4(registers.u8)) + uchar4(216)) + uchar4(206)) + uchar4(uchar(10), uchar(20), uchar(30), uchar(40))) + uchar4(ssbo.u8[4])) + uchar4(ubo.u8)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/spec-constant-block-size.frag000066400000000000000000000010461400026215700277560ustar00rootroot00000000000000#include #include using namespace metal; #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 2 #endif constant int Value = SPIRV_CROSS_CONSTANT_ID_10; struct SpecConstArray { float4 samples[Value]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int Index [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant SpecConstArray& _15 [[buffer(0)]]) { main0_out out = {}; out.FragColor = _15.samples[in.Index]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/spec-constant-ternary.frag000066400000000000000000000006351400026215700274030ustar00rootroot00000000000000#include #include using namespace metal; constant uint s_tmp [[function_constant(0)]]; constant uint s = is_function_constant_defined(s_tmp) ? s_tmp : 10u; constant bool _13 = (s > 20u); constant uint f = _13 ? 30u : 50u; struct main0_out { float FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float(f); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/stencil-export.msl21.frag000066400000000000000000000007101400026215700270470ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 MRT0 [[color(0)]]; float4 MRT1 [[color(1)]]; uint gl_FragStencilRefARB [[stencil]]; }; fragment main0_out main0() { main0_out out = {}; out.MRT0 = float4(1.0); out.MRT1 = float4(1.0, 0.0, 1.0, 1.0); out.gl_FragStencilRefARB = uint(100); out.gl_FragStencilRefARB = uint(int(out.gl_FragStencilRefARB) + 10); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/subgroup-builtins.msl22.frag000066400000000000000000000006111400026215700275650ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { uint2 FragColor [[color(0)]]; }; fragment main0_out main0(uint gl_SubgroupSize [[threads_per_simdgroup]], uint gl_SubgroupInvocationID [[thread_index_in_simdgroup]]) { main0_out out = {}; out.FragColor.x = gl_SubgroupSize; out.FragColor.y = gl_SubgroupInvocationID; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/subgroup-globals-extract.msl22.frag000066400000000000000000000052561400026215700310410ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { uint2 FragColor [[color(0)]]; }; inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0); } inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - (clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), ballot.z == 0), ballot.w == 0); } inline uint spvPopCount4(uint4 ballot) { return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w); } inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } fragment main0_out main0(uint gl_SubgroupInvocationID [[thread_index_in_simdgroup]], uint gl_SubgroupSize [[threads_per_simdgroup]]) { main0_out out = {}; out.FragColor.x = (((spvSubgroupBallotFindLSB(uint4(1u, 2u, 3u, 4u), gl_SubgroupSize) + spvSubgroupBallotFindMSB(uint4(1u, 2u, 3u, 4u), gl_SubgroupSize)) + spvSubgroupBallotBitCount(uint4(1u, 2u, 3u, 4u), gl_SubgroupSize)) + spvSubgroupBallotInclusiveBitCount(uint4(1u, 2u, 3u, 4u), gl_SubgroupInvocationID)) + spvSubgroupBallotExclusiveBitCount(uint4(1u, 2u, 3u, 4u), gl_SubgroupInvocationID); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/switch-unsigned-case.frag000066400000000000000000000011211400026215700271530ustar00rootroot00000000000000#include #include using namespace metal; struct Buff { uint TestVal; }; struct main0_out { float4 fsout_Color [[color(0)]]; }; fragment main0_out main0(constant Buff& _15 [[buffer(0)]]) { main0_out out = {}; out.fsout_Color = float4(1.0); switch (_15.TestVal) { case 0u: { out.fsout_Color = float4(0.100000001490116119384765625); break; } case 1u: { out.fsout_Color = float4(0.20000000298023223876953125); break; } } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/swizzle.frag000066400000000000000000000015531400026215700246470ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float3 vNormal [[user(locn1)]]; float2 vUV [[user(locn2)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d samp [[texture(0)]], sampler sampSmplr [[sampler(0)]]) { main0_out out = {}; float4 _19 = samp.sample(sampSmplr, in.vUV); float _23 = _19.x; out.FragColor = float4(_23, _19.yz, 1.0); out.FragColor = float4(_23, _19.z, 1.0, 4.0); out.FragColor = float4(_23, _23, samp.sample(sampSmplr, (in.vUV + float2(0.100000001490116119384765625))).yy); out.FragColor = float4(in.vNormal, 1.0); out.FragColor = float4(in.vNormal + float3(1.7999999523162841796875), 1.0); out.FragColor = float4(in.vUV, in.vUV + float2(1.7999999523162841796875)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/texel-fetch-offset.1d-as-2d.frag000066400000000000000000000011031400026215700300320ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uTexture [[texture(0)]], texture2d uTexture2 [[texture(1)]], sampler uTextureSmplr [[sampler(0)]], sampler uTexture2Smplr [[sampler(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = uTexture.read(uint2(int2(gl_FragCoord.xy)) + uint2(int2(1)), 0); out.FragColor += uTexture2.read(uint2(uint(int(gl_FragCoord.x)), 0) + uint2(uint(-1), 0), 0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/texel-fetch-offset.frag000066400000000000000000000007531400026215700266350ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; int2 _22 = int2(gl_FragCoord.xy); out.FragColor = uTexture.read(uint2(_22) + uint2(int2(1)), 0); out.FragColor += uTexture.read(uint2(_22) + uint2(int2(-1, 1)), 0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/texture-cube-array.frag000066400000000000000000000014611400026215700266660ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texturecube cubeSampler [[texture(0)]], texturecube_array cubeArraySampler [[texture(1)]], texture2d_array texArraySampler [[texture(2)]], sampler cubeSamplerSmplr [[sampler(0)]], sampler cubeArraySamplerSmplr [[sampler(1)]], sampler texArraySamplerSmplr [[sampler(2)]]) { main0_out out = {}; out.FragColor = (cubeSampler.sample(cubeSamplerSmplr, in.vUV.xyz) + cubeArraySampler.sample(cubeArraySamplerSmplr, in.vUV.xyz, uint(round(in.vUV.w)))) + texArraySampler.sample(texArraySamplerSmplr, in.vUV.xyz.xy, uint(round(in.vUV.xyz.z))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/texture-cube-array.ios.emulate-cube-array.frag000066400000000000000000000034171400026215700331450ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; static inline __attribute__((always_inline)) float3 spvCubemapTo2DArrayFace(float3 P) { float3 Coords = abs(P.xyz); float CubeFace = 0; float ProjectionAxis = 0; float u = 0; float v = 0; if (Coords.x >= Coords.y && Coords.x >= Coords.z) { CubeFace = P.x >= 0 ? 0 : 1; ProjectionAxis = Coords.x; u = P.x >= 0 ? -P.z : P.z; v = -P.y; } else if (Coords.y >= Coords.x && Coords.y >= Coords.z) { CubeFace = P.y >= 0 ? 2 : 3; ProjectionAxis = Coords.y; u = P.x; v = P.y >= 0 ? P.z : -P.z; } else { CubeFace = P.z >= 0 ? 4 : 5; ProjectionAxis = Coords.z; u = P.z >= 0 ? P.x : -P.x; v = -P.y; } u = 0.5 * (u/ProjectionAxis + 1); v = 0.5 * (v/ProjectionAxis + 1); return float3(u, v, CubeFace); } fragment main0_out main0(main0_in in [[stage_in]], texturecube cubeSampler [[texture(0)]], texture2d_array cubeArraySampler [[texture(1)]], texture2d_array texArraySampler [[texture(2)]], sampler cubeSamplerSmplr [[sampler(0)]], sampler cubeArraySamplerSmplr [[sampler(1)]], sampler texArraySamplerSmplr [[sampler(2)]]) { main0_out out = {}; out.FragColor = (cubeSampler.sample(cubeSamplerSmplr, in.vUV.xyz) + cubeArraySampler.sample(cubeArraySamplerSmplr, spvCubemapTo2DArrayFace(in.vUV.xyz).xy, uint(spvCubemapTo2DArrayFace(in.vUV.xyz).z) + (uint(round(in.vUV.w)) * 6u))) + texArraySampler.sample(texArraySamplerSmplr, in.vUV.xyz.xy, uint(round(in.vUV.xyz.z))); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/texture-multisample-array.msl21.frag000066400000000000000000000007521400026215700312430ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int3 vCoord [[user(locn0)]]; int vSample [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d_ms_array uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTexture.read(uint2(in.vCoord.xy), uint(in.vCoord.z), in.vSample); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/texture-proj-shadow.frag000066400000000000000000000021061400026215700270660ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vClip3 [[user(locn0)]]; float4 vClip4 [[user(locn1)]]; float2 vClip2 [[user(locn2)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d uShadow2D [[texture(0)]], texture1d uSampler1D [[texture(1)]], texture2d uSampler2D [[texture(2)]], texture3d uSampler3D [[texture(3)]], sampler uShadow2DSmplr [[sampler(0)]], sampler uSampler1DSmplr [[sampler(1)]], sampler uSampler2DSmplr [[sampler(2)]], sampler uSampler3DSmplr [[sampler(3)]]) { main0_out out = {}; float4 _20 = in.vClip4; _20.z = in.vClip4.w; out.FragColor = uShadow2D.sample_compare(uShadow2DSmplr, _20.xy / _20.z, in.vClip4.z / _20.z); out.FragColor = uSampler1D.sample(uSampler1DSmplr, in.vClip2.x / in.vClip2.y).x; out.FragColor = uSampler2D.sample(uSampler2DSmplr, in.vClip3.xy / in.vClip3.z).x; out.FragColor = uSampler3D.sample(uSampler3DSmplr, in.vClip4.xyz / in.vClip4.w).x; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/ubo_layout.frag000066400000000000000000000010241400026215700253130ustar00rootroot00000000000000#include #include using namespace metal; struct Str { float4x4 foo; }; struct UBO1 { Str foo; }; struct Str_1 { float4x4 foo; }; struct UBO2 { Str_1 foo; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant UBO1& ubo1 [[buffer(0)]], constant UBO2& ubo0 [[buffer(1)]]) { main0_out out = {}; out.FragColor = float4(ubo1.foo.foo[0][0], ubo1.foo.foo[1][0], ubo1.foo.foo[2][0], ubo1.foo.foo[3][0]) + ubo0.foo.foo[0]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/unary-enclose.frag000066400000000000000000000004641400026215700257240ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vIn [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = in.vIn; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/vecsize-mismatch.shader-inputs.frag000066400000000000000000000032171400026215700311770ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { ushort2 a [[user(locn0)]]; uint3 b [[user(locn1)]]; ushort c_0 [[user(locn2)]]; ushort c_1 [[user(locn3)]]; uint4 e_0 [[user(locn4)]]; uint4 e_1 [[user(locn5)]]; float4 d [[user(locn6)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray c = {}; spvUnsafeArray e = {}; c[0] = in.c_0; c[1] = in.c_1; e[0] = in.e_0; e[1] = in.e_1; out.FragColor = float4(float(int(in.a.x)), float(in.b.x), float2(float(uint(c[1])), float(e[0].w)) + in.d.xy); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/frag/write-depth-in-function.frag000066400000000000000000000004761400026215700276260ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; float gl_FragDepth [[depth(any)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = 1.0; out.gl_FragDepth = 0.20000000298023223876953125; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/intel/000077500000000000000000000000001400026215700224675ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/intel/shader-integer-functions2.asm.comp000066400000000000000000000011761400026215700311240ustar00rootroot00000000000000#include #include using namespace metal; struct foo { uint a; uint b; int c; int d; }; kernel void main0(device foo& _4 [[buffer(0)]]) { _4.a = clz(_4.a); _4.a = ctz(_4.a); _4.a = absdiff(_4.c, _4.d); _4.a = absdiff(_4.a, _4.b); _4.c = addsat(_4.c, _4.d); _4.a = addsat(_4.a, _4.b); _4.c = hadd(_4.c, _4.d); _4.a = hadd(_4.a, _4.b); _4.c = rhadd(_4.c, _4.d); _4.a = rhadd(_4.a, _4.b); _4.c = subsat(_4.c, _4.d); _4.a = subsat(_4.a, _4.b); _4.c = int(short(_4.c)) * int(short(_4.d)); _4.a = uint(ushort(_4.a)) * uint(ushort(_4.b)); } spirv-cross-2021.01.15/reference/opt/shaders-msl/legacy/000077500000000000000000000000001400026215700226205ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/legacy/vert/000077500000000000000000000000001400026215700236005ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/legacy/vert/transpose.legacy.vert000066400000000000000000000011431400026215700277620ustar00rootroot00000000000000#include #include using namespace metal; struct Buffer { float4x4 MVPRowMajor; float4x4 MVPColMajor; float4x4 M; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant Buffer& _13 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = (((_13.M * (in.Position * _13.MVPRowMajor)) + (_13.M * (_13.MVPColMajor * in.Position))) + (_13.M * (_13.MVPRowMajor * in.Position))) + (_13.M * (in.Position * _13.MVPColMajor)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/000077500000000000000000000000001400026215700223125ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/basic.multi-patch.tesc000066400000000000000000000021301400026215700264750ustar00rootroot00000000000000#include #include using namespace metal; struct main0_patchOut { float3 vFoo; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { device main0_patchOut& patchOut = spvPatchOut[gl_GlobalInvocationID.x / 1]; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1]); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625); patchOut.vFoo = float3(1.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/basic.tesc000066400000000000000000000020541400026215700242540ustar00rootroot00000000000000#include #include using namespace metal; struct main0_patchOut { float3 vFoo; }; kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625); patchOut.vFoo = float3(1.0); } load-control-point-array-of-matrix.multi-patch.tesc000066400000000000000000000047361400026215700341170ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4x4 vOutputs; }; struct main0_in { float4x4 vInputs; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); spvUnsafeArray _16 = spvUnsafeArray({ gl_in[0].vInputs, gl_in[1].vInputs, gl_in[2].vInputs, gl_in[3].vInputs, gl_in[4].vInputs, gl_in[5].vInputs, gl_in[6].vInputs, gl_in[7].vInputs, gl_in[8].vInputs, gl_in[9].vInputs, gl_in[10].vInputs, gl_in[11].vInputs, gl_in[12].vInputs, gl_in[13].vInputs, gl_in[14].vInputs, gl_in[15].vInputs, gl_in[16].vInputs, gl_in[17].vInputs, gl_in[18].vInputs, gl_in[19].vInputs, gl_in[20].vInputs, gl_in[21].vInputs, gl_in[22].vInputs, gl_in[23].vInputs, gl_in[24].vInputs, gl_in[25].vInputs, gl_in[26].vInputs, gl_in[27].vInputs, gl_in[28].vInputs, gl_in[29].vInputs, gl_in[30].vInputs, gl_in[31].vInputs }); spvUnsafeArray tmp; tmp = _16; gl_out[gl_InvocationID].vOutputs = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/load-control-point-array-of-matrix.tesc000066400000000000000000000116171400026215700317440ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4x4 vOutputs; }; struct main0_in { float4 vInputs_0 [[attribute(0)]]; float4 vInputs_1 [[attribute(1)]]; float4 vInputs_2 [[attribute(2)]]; float4 vInputs_3 [[attribute(3)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; spvUnsafeArray _16 = spvUnsafeArray({ float4x4(gl_in[0].vInputs_0, gl_in[0].vInputs_1, gl_in[0].vInputs_2, gl_in[0].vInputs_3), float4x4(gl_in[1].vInputs_0, gl_in[1].vInputs_1, gl_in[1].vInputs_2, gl_in[1].vInputs_3), float4x4(gl_in[2].vInputs_0, gl_in[2].vInputs_1, gl_in[2].vInputs_2, gl_in[2].vInputs_3), float4x4(gl_in[3].vInputs_0, gl_in[3].vInputs_1, gl_in[3].vInputs_2, gl_in[3].vInputs_3), float4x4(gl_in[4].vInputs_0, gl_in[4].vInputs_1, gl_in[4].vInputs_2, gl_in[4].vInputs_3), float4x4(gl_in[5].vInputs_0, gl_in[5].vInputs_1, gl_in[5].vInputs_2, gl_in[5].vInputs_3), float4x4(gl_in[6].vInputs_0, gl_in[6].vInputs_1, gl_in[6].vInputs_2, gl_in[6].vInputs_3), float4x4(gl_in[7].vInputs_0, gl_in[7].vInputs_1, gl_in[7].vInputs_2, gl_in[7].vInputs_3), float4x4(gl_in[8].vInputs_0, gl_in[8].vInputs_1, gl_in[8].vInputs_2, gl_in[8].vInputs_3), float4x4(gl_in[9].vInputs_0, gl_in[9].vInputs_1, gl_in[9].vInputs_2, gl_in[9].vInputs_3), float4x4(gl_in[10].vInputs_0, gl_in[10].vInputs_1, gl_in[10].vInputs_2, gl_in[10].vInputs_3), float4x4(gl_in[11].vInputs_0, gl_in[11].vInputs_1, gl_in[11].vInputs_2, gl_in[11].vInputs_3), float4x4(gl_in[12].vInputs_0, gl_in[12].vInputs_1, gl_in[12].vInputs_2, gl_in[12].vInputs_3), float4x4(gl_in[13].vInputs_0, gl_in[13].vInputs_1, gl_in[13].vInputs_2, gl_in[13].vInputs_3), float4x4(gl_in[14].vInputs_0, gl_in[14].vInputs_1, gl_in[14].vInputs_2, gl_in[14].vInputs_3), float4x4(gl_in[15].vInputs_0, gl_in[15].vInputs_1, gl_in[15].vInputs_2, gl_in[15].vInputs_3), float4x4(gl_in[16].vInputs_0, gl_in[16].vInputs_1, gl_in[16].vInputs_2, gl_in[16].vInputs_3), float4x4(gl_in[17].vInputs_0, gl_in[17].vInputs_1, gl_in[17].vInputs_2, gl_in[17].vInputs_3), float4x4(gl_in[18].vInputs_0, gl_in[18].vInputs_1, gl_in[18].vInputs_2, gl_in[18].vInputs_3), float4x4(gl_in[19].vInputs_0, gl_in[19].vInputs_1, gl_in[19].vInputs_2, gl_in[19].vInputs_3), float4x4(gl_in[20].vInputs_0, gl_in[20].vInputs_1, gl_in[20].vInputs_2, gl_in[20].vInputs_3), float4x4(gl_in[21].vInputs_0, gl_in[21].vInputs_1, gl_in[21].vInputs_2, gl_in[21].vInputs_3), float4x4(gl_in[22].vInputs_0, gl_in[22].vInputs_1, gl_in[22].vInputs_2, gl_in[22].vInputs_3), float4x4(gl_in[23].vInputs_0, gl_in[23].vInputs_1, gl_in[23].vInputs_2, gl_in[23].vInputs_3), float4x4(gl_in[24].vInputs_0, gl_in[24].vInputs_1, gl_in[24].vInputs_2, gl_in[24].vInputs_3), float4x4(gl_in[25].vInputs_0, gl_in[25].vInputs_1, gl_in[25].vInputs_2, gl_in[25].vInputs_3), float4x4(gl_in[26].vInputs_0, gl_in[26].vInputs_1, gl_in[26].vInputs_2, gl_in[26].vInputs_3), float4x4(gl_in[27].vInputs_0, gl_in[27].vInputs_1, gl_in[27].vInputs_2, gl_in[27].vInputs_3), float4x4(gl_in[28].vInputs_0, gl_in[28].vInputs_1, gl_in[28].vInputs_2, gl_in[28].vInputs_3), float4x4(gl_in[29].vInputs_0, gl_in[29].vInputs_1, gl_in[29].vInputs_2, gl_in[29].vInputs_3), float4x4(gl_in[30].vInputs_0, gl_in[30].vInputs_1, gl_in[30].vInputs_2, gl_in[30].vInputs_3), float4x4(gl_in[31].vInputs_0, gl_in[31].vInputs_1, gl_in[31].vInputs_2, gl_in[31].vInputs_3) }); spvUnsafeArray tmp; tmp = _16; gl_out[gl_InvocationID].vOutputs = tmp[gl_InvocationID]; } load-control-point-array-of-struct.multi-patch.tesc000066400000000000000000000153401400026215700341300ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct VertexData { float4x4 a; spvUnsafeArray b; float4 c; }; struct main0_out { float4 vOutputs; }; struct main0_in { float4x4 VertexData_a; spvUnsafeArray VertexData_b; float4 VertexData_c; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); spvUnsafeArray _19 = spvUnsafeArray({ VertexData{ gl_in[0].VertexData_a, spvUnsafeArray({ gl_in[0].VertexData_b[0], gl_in[0].VertexData_b[1] }), gl_in[0].VertexData_c }, VertexData{ gl_in[1].VertexData_a, spvUnsafeArray({ gl_in[1].VertexData_b[0], gl_in[1].VertexData_b[1] }), gl_in[1].VertexData_c }, VertexData{ gl_in[2].VertexData_a, spvUnsafeArray({ gl_in[2].VertexData_b[0], gl_in[2].VertexData_b[1] }), gl_in[2].VertexData_c }, VertexData{ gl_in[3].VertexData_a, spvUnsafeArray({ gl_in[3].VertexData_b[0], gl_in[3].VertexData_b[1] }), gl_in[3].VertexData_c }, VertexData{ gl_in[4].VertexData_a, spvUnsafeArray({ gl_in[4].VertexData_b[0], gl_in[4].VertexData_b[1] }), gl_in[4].VertexData_c }, VertexData{ gl_in[5].VertexData_a, spvUnsafeArray({ gl_in[5].VertexData_b[0], gl_in[5].VertexData_b[1] }), gl_in[5].VertexData_c }, VertexData{ gl_in[6].VertexData_a, spvUnsafeArray({ gl_in[6].VertexData_b[0], gl_in[6].VertexData_b[1] }), gl_in[6].VertexData_c }, VertexData{ gl_in[7].VertexData_a, spvUnsafeArray({ gl_in[7].VertexData_b[0], gl_in[7].VertexData_b[1] }), gl_in[7].VertexData_c }, VertexData{ gl_in[8].VertexData_a, spvUnsafeArray({ gl_in[8].VertexData_b[0], gl_in[8].VertexData_b[1] }), gl_in[8].VertexData_c }, VertexData{ gl_in[9].VertexData_a, spvUnsafeArray({ gl_in[9].VertexData_b[0], gl_in[9].VertexData_b[1] }), gl_in[9].VertexData_c }, VertexData{ gl_in[10].VertexData_a, spvUnsafeArray({ gl_in[10].VertexData_b[0], gl_in[10].VertexData_b[1] }), gl_in[10].VertexData_c }, VertexData{ gl_in[11].VertexData_a, spvUnsafeArray({ gl_in[11].VertexData_b[0], gl_in[11].VertexData_b[1] }), gl_in[11].VertexData_c }, VertexData{ gl_in[12].VertexData_a, spvUnsafeArray({ gl_in[12].VertexData_b[0], gl_in[12].VertexData_b[1] }), gl_in[12].VertexData_c }, VertexData{ gl_in[13].VertexData_a, spvUnsafeArray({ gl_in[13].VertexData_b[0], gl_in[13].VertexData_b[1] }), gl_in[13].VertexData_c }, VertexData{ gl_in[14].VertexData_a, spvUnsafeArray({ gl_in[14].VertexData_b[0], gl_in[14].VertexData_b[1] }), gl_in[14].VertexData_c }, VertexData{ gl_in[15].VertexData_a, spvUnsafeArray({ gl_in[15].VertexData_b[0], gl_in[15].VertexData_b[1] }), gl_in[15].VertexData_c }, VertexData{ gl_in[16].VertexData_a, spvUnsafeArray({ gl_in[16].VertexData_b[0], gl_in[16].VertexData_b[1] }), gl_in[16].VertexData_c }, VertexData{ gl_in[17].VertexData_a, spvUnsafeArray({ gl_in[17].VertexData_b[0], gl_in[17].VertexData_b[1] }), gl_in[17].VertexData_c }, VertexData{ gl_in[18].VertexData_a, spvUnsafeArray({ gl_in[18].VertexData_b[0], gl_in[18].VertexData_b[1] }), gl_in[18].VertexData_c }, VertexData{ gl_in[19].VertexData_a, spvUnsafeArray({ gl_in[19].VertexData_b[0], gl_in[19].VertexData_b[1] }), gl_in[19].VertexData_c }, VertexData{ gl_in[20].VertexData_a, spvUnsafeArray({ gl_in[20].VertexData_b[0], gl_in[20].VertexData_b[1] }), gl_in[20].VertexData_c }, VertexData{ gl_in[21].VertexData_a, spvUnsafeArray({ gl_in[21].VertexData_b[0], gl_in[21].VertexData_b[1] }), gl_in[21].VertexData_c }, VertexData{ gl_in[22].VertexData_a, spvUnsafeArray({ gl_in[22].VertexData_b[0], gl_in[22].VertexData_b[1] }), gl_in[22].VertexData_c }, VertexData{ gl_in[23].VertexData_a, spvUnsafeArray({ gl_in[23].VertexData_b[0], gl_in[23].VertexData_b[1] }), gl_in[23].VertexData_c }, VertexData{ gl_in[24].VertexData_a, spvUnsafeArray({ gl_in[24].VertexData_b[0], gl_in[24].VertexData_b[1] }), gl_in[24].VertexData_c }, VertexData{ gl_in[25].VertexData_a, spvUnsafeArray({ gl_in[25].VertexData_b[0], gl_in[25].VertexData_b[1] }), gl_in[25].VertexData_c }, VertexData{ gl_in[26].VertexData_a, spvUnsafeArray({ gl_in[26].VertexData_b[0], gl_in[26].VertexData_b[1] }), gl_in[26].VertexData_c }, VertexData{ gl_in[27].VertexData_a, spvUnsafeArray({ gl_in[27].VertexData_b[0], gl_in[27].VertexData_b[1] }), gl_in[27].VertexData_c }, VertexData{ gl_in[28].VertexData_a, spvUnsafeArray({ gl_in[28].VertexData_b[0], gl_in[28].VertexData_b[1] }), gl_in[28].VertexData_c }, VertexData{ gl_in[29].VertexData_a, spvUnsafeArray({ gl_in[29].VertexData_b[0], gl_in[29].VertexData_b[1] }), gl_in[29].VertexData_c }, VertexData{ gl_in[30].VertexData_a, spvUnsafeArray({ gl_in[30].VertexData_b[0], gl_in[30].VertexData_b[1] }), gl_in[30].VertexData_c }, VertexData{ gl_in[31].VertexData_a, spvUnsafeArray({ gl_in[31].VertexData_b[0], gl_in[31].VertexData_b[1] }), gl_in[31].VertexData_c } }); spvUnsafeArray tmp; tmp = _19; int _27 = gl_InvocationID ^ 1; gl_out[gl_InvocationID].vOutputs = ((tmp[gl_InvocationID].a[1] + tmp[gl_InvocationID].b[1]) + tmp[gl_InvocationID].c) + gl_in[_27].VertexData_c; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/load-control-point-array-of-struct.tesc000066400000000000000000000231751400026215700317660ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct VertexData { float4x4 a; spvUnsafeArray b; float4 c; }; struct main0_out { float4 vOutputs; }; struct main0_in { float4 VertexData_a_0 [[attribute(0)]]; float4 VertexData_a_1 [[attribute(1)]]; float4 VertexData_a_2 [[attribute(2)]]; float4 VertexData_a_3 [[attribute(3)]]; float4 VertexData_b_0 [[attribute(4)]]; float4 VertexData_b_1 [[attribute(5)]]; float4 VertexData_c [[attribute(6)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; spvUnsafeArray _19 = spvUnsafeArray({ VertexData{ float4x4(gl_in[0].VertexData_a_0, gl_in[0].VertexData_a_1, gl_in[0].VertexData_a_2, gl_in[0].VertexData_a_3), spvUnsafeArray({ gl_in[0].VertexData_b_0, gl_in[0].VertexData_b_1 }), gl_in[0].VertexData_c }, VertexData{ float4x4(gl_in[1].VertexData_a_0, gl_in[1].VertexData_a_1, gl_in[1].VertexData_a_2, gl_in[1].VertexData_a_3), spvUnsafeArray({ gl_in[1].VertexData_b_0, gl_in[1].VertexData_b_1 }), gl_in[1].VertexData_c }, VertexData{ float4x4(gl_in[2].VertexData_a_0, gl_in[2].VertexData_a_1, gl_in[2].VertexData_a_2, gl_in[2].VertexData_a_3), spvUnsafeArray({ gl_in[2].VertexData_b_0, gl_in[2].VertexData_b_1 }), gl_in[2].VertexData_c }, VertexData{ float4x4(gl_in[3].VertexData_a_0, gl_in[3].VertexData_a_1, gl_in[3].VertexData_a_2, gl_in[3].VertexData_a_3), spvUnsafeArray({ gl_in[3].VertexData_b_0, gl_in[3].VertexData_b_1 }), gl_in[3].VertexData_c }, VertexData{ float4x4(gl_in[4].VertexData_a_0, gl_in[4].VertexData_a_1, gl_in[4].VertexData_a_2, gl_in[4].VertexData_a_3), spvUnsafeArray({ gl_in[4].VertexData_b_0, gl_in[4].VertexData_b_1 }), gl_in[4].VertexData_c }, VertexData{ float4x4(gl_in[5].VertexData_a_0, gl_in[5].VertexData_a_1, gl_in[5].VertexData_a_2, gl_in[5].VertexData_a_3), spvUnsafeArray({ gl_in[5].VertexData_b_0, gl_in[5].VertexData_b_1 }), gl_in[5].VertexData_c }, VertexData{ float4x4(gl_in[6].VertexData_a_0, gl_in[6].VertexData_a_1, gl_in[6].VertexData_a_2, gl_in[6].VertexData_a_3), spvUnsafeArray({ gl_in[6].VertexData_b_0, gl_in[6].VertexData_b_1 }), gl_in[6].VertexData_c }, VertexData{ float4x4(gl_in[7].VertexData_a_0, gl_in[7].VertexData_a_1, gl_in[7].VertexData_a_2, gl_in[7].VertexData_a_3), spvUnsafeArray({ gl_in[7].VertexData_b_0, gl_in[7].VertexData_b_1 }), gl_in[7].VertexData_c }, VertexData{ float4x4(gl_in[8].VertexData_a_0, gl_in[8].VertexData_a_1, gl_in[8].VertexData_a_2, gl_in[8].VertexData_a_3), spvUnsafeArray({ gl_in[8].VertexData_b_0, gl_in[8].VertexData_b_1 }), gl_in[8].VertexData_c }, VertexData{ float4x4(gl_in[9].VertexData_a_0, gl_in[9].VertexData_a_1, gl_in[9].VertexData_a_2, gl_in[9].VertexData_a_3), spvUnsafeArray({ gl_in[9].VertexData_b_0, gl_in[9].VertexData_b_1 }), gl_in[9].VertexData_c }, VertexData{ float4x4(gl_in[10].VertexData_a_0, gl_in[10].VertexData_a_1, gl_in[10].VertexData_a_2, gl_in[10].VertexData_a_3), spvUnsafeArray({ gl_in[10].VertexData_b_0, gl_in[10].VertexData_b_1 }), gl_in[10].VertexData_c }, VertexData{ float4x4(gl_in[11].VertexData_a_0, gl_in[11].VertexData_a_1, gl_in[11].VertexData_a_2, gl_in[11].VertexData_a_3), spvUnsafeArray({ gl_in[11].VertexData_b_0, gl_in[11].VertexData_b_1 }), gl_in[11].VertexData_c }, VertexData{ float4x4(gl_in[12].VertexData_a_0, gl_in[12].VertexData_a_1, gl_in[12].VertexData_a_2, gl_in[12].VertexData_a_3), spvUnsafeArray({ gl_in[12].VertexData_b_0, gl_in[12].VertexData_b_1 }), gl_in[12].VertexData_c }, VertexData{ float4x4(gl_in[13].VertexData_a_0, gl_in[13].VertexData_a_1, gl_in[13].VertexData_a_2, gl_in[13].VertexData_a_3), spvUnsafeArray({ gl_in[13].VertexData_b_0, gl_in[13].VertexData_b_1 }), gl_in[13].VertexData_c }, VertexData{ float4x4(gl_in[14].VertexData_a_0, gl_in[14].VertexData_a_1, gl_in[14].VertexData_a_2, gl_in[14].VertexData_a_3), spvUnsafeArray({ gl_in[14].VertexData_b_0, gl_in[14].VertexData_b_1 }), gl_in[14].VertexData_c }, VertexData{ float4x4(gl_in[15].VertexData_a_0, gl_in[15].VertexData_a_1, gl_in[15].VertexData_a_2, gl_in[15].VertexData_a_3), spvUnsafeArray({ gl_in[15].VertexData_b_0, gl_in[15].VertexData_b_1 }), gl_in[15].VertexData_c }, VertexData{ float4x4(gl_in[16].VertexData_a_0, gl_in[16].VertexData_a_1, gl_in[16].VertexData_a_2, gl_in[16].VertexData_a_3), spvUnsafeArray({ gl_in[16].VertexData_b_0, gl_in[16].VertexData_b_1 }), gl_in[16].VertexData_c }, VertexData{ float4x4(gl_in[17].VertexData_a_0, gl_in[17].VertexData_a_1, gl_in[17].VertexData_a_2, gl_in[17].VertexData_a_3), spvUnsafeArray({ gl_in[17].VertexData_b_0, gl_in[17].VertexData_b_1 }), gl_in[17].VertexData_c }, VertexData{ float4x4(gl_in[18].VertexData_a_0, gl_in[18].VertexData_a_1, gl_in[18].VertexData_a_2, gl_in[18].VertexData_a_3), spvUnsafeArray({ gl_in[18].VertexData_b_0, gl_in[18].VertexData_b_1 }), gl_in[18].VertexData_c }, VertexData{ float4x4(gl_in[19].VertexData_a_0, gl_in[19].VertexData_a_1, gl_in[19].VertexData_a_2, gl_in[19].VertexData_a_3), spvUnsafeArray({ gl_in[19].VertexData_b_0, gl_in[19].VertexData_b_1 }), gl_in[19].VertexData_c }, VertexData{ float4x4(gl_in[20].VertexData_a_0, gl_in[20].VertexData_a_1, gl_in[20].VertexData_a_2, gl_in[20].VertexData_a_3), spvUnsafeArray({ gl_in[20].VertexData_b_0, gl_in[20].VertexData_b_1 }), gl_in[20].VertexData_c }, VertexData{ float4x4(gl_in[21].VertexData_a_0, gl_in[21].VertexData_a_1, gl_in[21].VertexData_a_2, gl_in[21].VertexData_a_3), spvUnsafeArray({ gl_in[21].VertexData_b_0, gl_in[21].VertexData_b_1 }), gl_in[21].VertexData_c }, VertexData{ float4x4(gl_in[22].VertexData_a_0, gl_in[22].VertexData_a_1, gl_in[22].VertexData_a_2, gl_in[22].VertexData_a_3), spvUnsafeArray({ gl_in[22].VertexData_b_0, gl_in[22].VertexData_b_1 }), gl_in[22].VertexData_c }, VertexData{ float4x4(gl_in[23].VertexData_a_0, gl_in[23].VertexData_a_1, gl_in[23].VertexData_a_2, gl_in[23].VertexData_a_3), spvUnsafeArray({ gl_in[23].VertexData_b_0, gl_in[23].VertexData_b_1 }), gl_in[23].VertexData_c }, VertexData{ float4x4(gl_in[24].VertexData_a_0, gl_in[24].VertexData_a_1, gl_in[24].VertexData_a_2, gl_in[24].VertexData_a_3), spvUnsafeArray({ gl_in[24].VertexData_b_0, gl_in[24].VertexData_b_1 }), gl_in[24].VertexData_c }, VertexData{ float4x4(gl_in[25].VertexData_a_0, gl_in[25].VertexData_a_1, gl_in[25].VertexData_a_2, gl_in[25].VertexData_a_3), spvUnsafeArray({ gl_in[25].VertexData_b_0, gl_in[25].VertexData_b_1 }), gl_in[25].VertexData_c }, VertexData{ float4x4(gl_in[26].VertexData_a_0, gl_in[26].VertexData_a_1, gl_in[26].VertexData_a_2, gl_in[26].VertexData_a_3), spvUnsafeArray({ gl_in[26].VertexData_b_0, gl_in[26].VertexData_b_1 }), gl_in[26].VertexData_c }, VertexData{ float4x4(gl_in[27].VertexData_a_0, gl_in[27].VertexData_a_1, gl_in[27].VertexData_a_2, gl_in[27].VertexData_a_3), spvUnsafeArray({ gl_in[27].VertexData_b_0, gl_in[27].VertexData_b_1 }), gl_in[27].VertexData_c }, VertexData{ float4x4(gl_in[28].VertexData_a_0, gl_in[28].VertexData_a_1, gl_in[28].VertexData_a_2, gl_in[28].VertexData_a_3), spvUnsafeArray({ gl_in[28].VertexData_b_0, gl_in[28].VertexData_b_1 }), gl_in[28].VertexData_c }, VertexData{ float4x4(gl_in[29].VertexData_a_0, gl_in[29].VertexData_a_1, gl_in[29].VertexData_a_2, gl_in[29].VertexData_a_3), spvUnsafeArray({ gl_in[29].VertexData_b_0, gl_in[29].VertexData_b_1 }), gl_in[29].VertexData_c }, VertexData{ float4x4(gl_in[30].VertexData_a_0, gl_in[30].VertexData_a_1, gl_in[30].VertexData_a_2, gl_in[30].VertexData_a_3), spvUnsafeArray({ gl_in[30].VertexData_b_0, gl_in[30].VertexData_b_1 }), gl_in[30].VertexData_c }, VertexData{ float4x4(gl_in[31].VertexData_a_0, gl_in[31].VertexData_a_1, gl_in[31].VertexData_a_2, gl_in[31].VertexData_a_3), spvUnsafeArray({ gl_in[31].VertexData_b_0, gl_in[31].VertexData_b_1 }), gl_in[31].VertexData_c } }); spvUnsafeArray tmp; tmp = _19; int _27 = gl_InvocationID ^ 1; gl_out[gl_InvocationID].vOutputs = ((tmp[gl_InvocationID].a[1] + tmp[gl_InvocationID].b[1]) + tmp[gl_InvocationID].c) + gl_in[_27].VertexData_c; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/load-control-point-array.multi-patch.tesc000066400000000000000000000047461400026215700322730ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 vOutputs; }; struct main0_in { float4 vInputs; ushort2 m_43; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); spvUnsafeArray _15 = spvUnsafeArray({ gl_in[0].vInputs, gl_in[1].vInputs, gl_in[2].vInputs, gl_in[3].vInputs, gl_in[4].vInputs, gl_in[5].vInputs, gl_in[6].vInputs, gl_in[7].vInputs, gl_in[8].vInputs, gl_in[9].vInputs, gl_in[10].vInputs, gl_in[11].vInputs, gl_in[12].vInputs, gl_in[13].vInputs, gl_in[14].vInputs, gl_in[15].vInputs, gl_in[16].vInputs, gl_in[17].vInputs, gl_in[18].vInputs, gl_in[19].vInputs, gl_in[20].vInputs, gl_in[21].vInputs, gl_in[22].vInputs, gl_in[23].vInputs, gl_in[24].vInputs, gl_in[25].vInputs, gl_in[26].vInputs, gl_in[27].vInputs, gl_in[28].vInputs, gl_in[29].vInputs, gl_in[30].vInputs, gl_in[31].vInputs }); spvUnsafeArray tmp; tmp = _15; gl_out[gl_InvocationID].vOutputs = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/load-control-point-array.tesc000066400000000000000000000047161400026215700300420ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 vOutputs; }; struct main0_in { float4 vInputs [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; spvUnsafeArray _15 = spvUnsafeArray({ gl_in[0].vInputs, gl_in[1].vInputs, gl_in[2].vInputs, gl_in[3].vInputs, gl_in[4].vInputs, gl_in[5].vInputs, gl_in[6].vInputs, gl_in[7].vInputs, gl_in[8].vInputs, gl_in[9].vInputs, gl_in[10].vInputs, gl_in[11].vInputs, gl_in[12].vInputs, gl_in[13].vInputs, gl_in[14].vInputs, gl_in[15].vInputs, gl_in[16].vInputs, gl_in[17].vInputs, gl_in[18].vInputs, gl_in[19].vInputs, gl_in[20].vInputs, gl_in[21].vInputs, gl_in[22].vInputs, gl_in[23].vInputs, gl_in[24].vInputs, gl_in[25].vInputs, gl_in[26].vInputs, gl_in[27].vInputs, gl_in[28].vInputs, gl_in[29].vInputs, gl_in[30].vInputs, gl_in[31].vInputs }); spvUnsafeArray tmp; tmp = _15; gl_out[gl_InvocationID].vOutputs = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/matrix-output.multi-patch.tesc000066400000000000000000000035751400026215700302740ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float in_te_attr; float4x3 in_te_data0; float4x3 in_te_data1; }; struct main0_in { float3 in_tc_attr; ushort2 m_104; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 3]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 3; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1]); float _15 = float(gl_InvocationID); float3 _18 = float3(_15, 0.0, 0.0); float3 _19 = float3(0.0, _15, 0.0); float3 _20 = float3(0.0, 0.0, _15); gl_out[gl_InvocationID].in_te_data0 = float4x3(_18, _19, _20, float3(0.0)); threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); int _42 = (gl_InvocationID + 1) % 3; gl_out[gl_InvocationID].in_te_data1 = float4x3(_18 + gl_out[_42].in_te_data0[0], _19 + gl_out[_42].in_te_data0[1], _20 + gl_out[_42].in_te_data0[2], gl_out[_42].in_te_data0[3]); gl_out[gl_InvocationID].in_te_attr = gl_in[gl_InvocationID].in_tc_attr.x; spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(1.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/reload-tess-level.multi-patch.tesc000066400000000000000000000032071400026215700307510ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position; }; struct main0_in { uint3 m_82; ushort2 m_86; float4 gl_Position; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); if (gl_InvocationID == 0) { spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(4.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(5.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(mix(float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0]), float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3]), 0.5)); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(mix(float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2]), float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1]), 0.5)); } gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/reload-tess-level.tesc000066400000000000000000000031371400026215700265250ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position; }; struct main0_in { float4 gl_Position [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; if (gl_InvocationID == 0) { spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(4.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(5.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(mix(float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0]), float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3]), 0.5)); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(mix(float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2]), float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1]), 0.5)); } gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/struct-output.multi-patch.tesc000066400000000000000000000035471400026215700303130ustar00rootroot00000000000000#include #include using namespace metal; struct te_data { float a; float b; uint c; }; struct main0_out { float in_te_attr; te_data in_te_data0; te_data in_te_data1; }; struct main0_in { float3 in_tc_attr; ushort2 m_119; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 3]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 3; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1]); float _15 = float(gl_InvocationID); int _18 = gl_InvocationID + 1; float _19 = float(_18); uint _21 = uint(gl_InvocationID); gl_out[gl_InvocationID].in_te_data0 = te_data{ _15, _19, _21 }; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); int _38 = _18 % 3; gl_out[gl_InvocationID].in_te_data1 = te_data{ _15 + gl_out[_38].in_te_data0.a, _19 + gl_out[_38].in_te_data0.b, _21 + gl_out[_38].in_te_data0.c }; gl_out[gl_InvocationID].in_te_attr = gl_in[gl_InvocationID].in_tc_attr.x; spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(1.0); } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/water_tess.multi-patch.tesc000066400000000000000000000131571400026215700276070ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 uScale; float3 uCamPos; float2 uPatchSize; float2 uMaxTessLevel; float uDistanceMod; float4 uFrustum[6]; }; struct main0_patchOut { float2 vOutPatchPosBase; float4 vPatchLods; }; struct main0_in { float3 vPatchPosBase; ushort2 m_996; }; kernel void main0(constant UBO& _41 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_patchOut& patchOut = spvPatchOut[gl_GlobalInvocationID.x / 1]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1]); float2 _431 = (gl_in[0].vPatchPosBase.xy - float2(10.0)) * _41.uScale.xy; float2 _441 = ((gl_in[0].vPatchPosBase.xy + _41.uPatchSize) + float2(10.0)) * _41.uScale.xy; float3 _446 = float3(_431.x, -10.0, _431.y); float3 _451 = float3(_441.x, 10.0, _441.y); float4 _467 = float4((_446 + _451) * 0.5, 1.0); float3 _514 = float3(length(_451 - _446) * (-0.5)); bool _516 = any(float3(dot(_41.uFrustum[0], _467), dot(_41.uFrustum[1], _467), dot(_41.uFrustum[2], _467)) <= _514); bool _526; if (!_516) { _526 = any(float3(dot(_41.uFrustum[3], _467), dot(_41.uFrustum[4], _467), dot(_41.uFrustum[5], _467)) <= _514); } else { _526 = _516; } if (!(!_526)) { spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(-1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(-1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(-1.0); } else { patchOut.vOutPatchPosBase = gl_in[0].vPatchPosBase.xy; float2 _681 = (gl_in[0].vPatchPosBase.xy + (float2(-0.5) * _41.uPatchSize)) * _41.uScale.xy; float2 _710 = (gl_in[0].vPatchPosBase.xy + (float2(0.5, -0.5) * _41.uPatchSize)) * _41.uScale.xy; float _729 = fast::clamp(log2((length(_41.uCamPos - float3(_710.x, 0.0, _710.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _739 = (gl_in[0].vPatchPosBase.xy + (float2(1.5, -0.5) * _41.uPatchSize)) * _41.uScale.xy; float2 _768 = (gl_in[0].vPatchPosBase.xy + (float2(-0.5, 0.5) * _41.uPatchSize)) * _41.uScale.xy; float _787 = fast::clamp(log2((length(_41.uCamPos - float3(_768.x, 0.0, _768.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _797 = (gl_in[0].vPatchPosBase.xy + (float2(0.5) * _41.uPatchSize)) * _41.uScale.xy; float _816 = fast::clamp(log2((length(_41.uCamPos - float3(_797.x, 0.0, _797.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _826 = (gl_in[0].vPatchPosBase.xy + (float2(1.5, 0.5) * _41.uPatchSize)) * _41.uScale.xy; float _845 = fast::clamp(log2((length(_41.uCamPos - float3(_826.x, 0.0, _826.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _855 = (gl_in[0].vPatchPosBase.xy + (float2(-0.5, 1.5) * _41.uPatchSize)) * _41.uScale.xy; float2 _884 = (gl_in[0].vPatchPosBase.xy + (float2(0.5, 1.5) * _41.uPatchSize)) * _41.uScale.xy; float _903 = fast::clamp(log2((length(_41.uCamPos - float3(_884.x, 0.0, _884.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _913 = (gl_in[0].vPatchPosBase.xy + (float2(1.5) * _41.uPatchSize)) * _41.uScale.xy; float _614 = dot(float4(_787, _816, fast::clamp(log2((length(_41.uCamPos - float3(_855.x, 0.0, _855.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _903), float4(0.25)); float _620 = dot(float4(fast::clamp(log2((length(_41.uCamPos - float3(_681.x, 0.0, _681.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _729, _787, _816), float4(0.25)); float _626 = dot(float4(_729, fast::clamp(log2((length(_41.uCamPos - float3(_739.x, 0.0, _739.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _816, _845), float4(0.25)); float _632 = dot(float4(_816, _845, _903, fast::clamp(log2((length(_41.uCamPos - float3(_913.x, 0.0, _913.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x)), float4(0.25)); float4 _633 = float4(_614, _620, _626, _632); patchOut.vPatchLods = _633; float4 _940 = exp2(-fast::min(_633, _633.yzwx)) * _41.uMaxTessLevel.y; spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(_940.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(_940.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(_940.z); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(_940.w); float _948 = _41.uMaxTessLevel.y * exp2(-fast::min(fast::min(fast::min(_614, _620), fast::min(_626, _632)), _816)); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(_948); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(_948); } } spirv-cross-2021.01.15/reference/opt/shaders-msl/tesc/water_tess.tesc000066400000000000000000000132001400026215700253460ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 uScale; float3 uCamPos; float2 uPatchSize; float2 uMaxTessLevel; float uDistanceMod; float4 uFrustum[6]; }; struct main0_patchOut { float2 vOutPatchPosBase; float4 vPatchLods; }; struct main0_in { float2 vPatchPosBase [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], constant UBO& _41 [[buffer(0)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 1) return; float2 _431 = (gl_in[0].vPatchPosBase - float2(10.0)) * _41.uScale.xy; float2 _441 = ((gl_in[0].vPatchPosBase + _41.uPatchSize) + float2(10.0)) * _41.uScale.xy; float3 _446 = float3(_431.x, -10.0, _431.y); float3 _451 = float3(_441.x, 10.0, _441.y); float4 _467 = float4((_446 + _451) * 0.5, 1.0); float3 _514 = float3(length(_451 - _446) * (-0.5)); bool _516 = any(float3(dot(_41.uFrustum[0], _467), dot(_41.uFrustum[1], _467), dot(_41.uFrustum[2], _467)) <= _514); bool _526; if (!_516) { _526 = any(float3(dot(_41.uFrustum[3], _467), dot(_41.uFrustum[4], _467), dot(_41.uFrustum[5], _467)) <= _514); } else { _526 = _516; } if (!(!_526)) { spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(-1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(-1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(-1.0); } else { patchOut.vOutPatchPosBase = gl_in[0].vPatchPosBase; float2 _681 = (gl_in[0].vPatchPosBase + (float2(-0.5) * _41.uPatchSize)) * _41.uScale.xy; float2 _710 = (gl_in[0].vPatchPosBase + (float2(0.5, -0.5) * _41.uPatchSize)) * _41.uScale.xy; float _729 = fast::clamp(log2((length(_41.uCamPos - float3(_710.x, 0.0, _710.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _739 = (gl_in[0].vPatchPosBase + (float2(1.5, -0.5) * _41.uPatchSize)) * _41.uScale.xy; float2 _768 = (gl_in[0].vPatchPosBase + (float2(-0.5, 0.5) * _41.uPatchSize)) * _41.uScale.xy; float _787 = fast::clamp(log2((length(_41.uCamPos - float3(_768.x, 0.0, _768.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _797 = (gl_in[0].vPatchPosBase + (float2(0.5) * _41.uPatchSize)) * _41.uScale.xy; float _816 = fast::clamp(log2((length(_41.uCamPos - float3(_797.x, 0.0, _797.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _826 = (gl_in[0].vPatchPosBase + (float2(1.5, 0.5) * _41.uPatchSize)) * _41.uScale.xy; float _845 = fast::clamp(log2((length(_41.uCamPos - float3(_826.x, 0.0, _826.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _855 = (gl_in[0].vPatchPosBase + (float2(-0.5, 1.5) * _41.uPatchSize)) * _41.uScale.xy; float2 _884 = (gl_in[0].vPatchPosBase + (float2(0.5, 1.5) * _41.uPatchSize)) * _41.uScale.xy; float _903 = fast::clamp(log2((length(_41.uCamPos - float3(_884.x, 0.0, _884.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); float2 _913 = (gl_in[0].vPatchPosBase + (float2(1.5) * _41.uPatchSize)) * _41.uScale.xy; float _614 = dot(float4(_787, _816, fast::clamp(log2((length(_41.uCamPos - float3(_855.x, 0.0, _855.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _903), float4(0.25)); float _620 = dot(float4(fast::clamp(log2((length(_41.uCamPos - float3(_681.x, 0.0, _681.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _729, _787, _816), float4(0.25)); float _626 = dot(float4(_729, fast::clamp(log2((length(_41.uCamPos - float3(_739.x, 0.0, _739.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _816, _845), float4(0.25)); float _632 = dot(float4(_816, _845, _903, fast::clamp(log2((length(_41.uCamPos - float3(_913.x, 0.0, _913.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x)), float4(0.25)); float4 _633 = float4(_614, _620, _626, _632); patchOut.vPatchLods = _633; float4 _940 = exp2(-fast::min(_633, _633.yzwx)) * _41.uMaxTessLevel.y; spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(_940.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(_940.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(_940.z); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(_940.w); float _948 = _41.uMaxTessLevel.y * exp2(-fast::min(fast::min(fast::min(_614, _620), fast::min(_626, _632)), _816)); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(_948); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(_948); } } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/000077500000000000000000000000001400026215700223145ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/input-array.tese000066400000000000000000000010771400026215700254560ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 Floats [[attribute(0)]]; float4 Floats2 [[attribute(2)]]; }; struct main0_patchIn { patch_control_point gl_in; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; out.gl_Position = (patchIn.gl_in[0].Floats * gl_TessCoord.x) + (patchIn.gl_in[1].Floats2 * gl_TessCoord.y); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/input-types.tese000066400000000000000000000033751400026215700255070ustar00rootroot00000000000000#include #include using namespace metal; struct Block { float4 a; float4 b; }; struct PatchBlock { float4 a; float4 b; }; struct Foo { float4 a; float4 b; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vColor [[attribute(0)]]; float4 Block_a [[attribute(4)]]; float4 Block_b [[attribute(5)]]; float4 Foo_a [[attribute(14)]]; float4 Foo_b [[attribute(15)]]; }; struct main0_patchIn { float4 vColors [[attribute(1)]]; float4 PatchBlock_a [[attribute(6)]]; float4 PatchBlock_b [[attribute(7)]]; float4 Foo_a [[attribute(8)]]; float4 Foo_b [[attribute(9)]]; patch_control_point gl_in; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]]) { main0_out out = {}; PatchBlock patch_block = {}; Foo vFoo = {}; patch_block.a = patchIn.PatchBlock_a; patch_block.b = patchIn.PatchBlock_b; vFoo.a = patchIn.Foo_a; vFoo.b = patchIn.Foo_b; out.gl_Position = patchIn.gl_in[0].Block_a; out.gl_Position += patchIn.gl_in[0].Block_b; out.gl_Position += patchIn.gl_in[1].Block_a; out.gl_Position += patchIn.gl_in[1].Block_b; out.gl_Position += patch_block.a; out.gl_Position += patch_block.b; out.gl_Position += patchIn.gl_in[0].vColor; out.gl_Position += patchIn.gl_in[1].vColor; out.gl_Position += patchIn.vColors; out.gl_Position += vFoo.a; out.gl_Position += vFoo.b; Foo _204 = Foo{ patchIn.gl_in[0].Foo_a, patchIn.gl_in[0].Foo_b }; out.gl_Position += _204.a; out.gl_Position += _204.b; Foo _218 = Foo{ patchIn.gl_in[1].Foo_a, patchIn.gl_in[1].Foo_b }; out.gl_Position += _218.a; out.gl_Position += _218.b; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/load-control-point-array-of-matrix.tese000066400000000000000000000042521400026215700317450ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vInputs_0 [[attribute(0)]]; float4 vInputs_1 [[attribute(1)]]; float4 vInputs_2 [[attribute(2)]]; float4 vInputs_3 [[attribute(3)]]; }; struct main0_patchIn { float4 vBoo_0 [[attribute(4)]]; float4 vBoo_1 [[attribute(5)]]; float4 vBoo_2 [[attribute(6)]]; float4 vBoo_3 [[attribute(7)]]; int vIndex [[attribute(8)]]; patch_control_point gl_in; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]]) { main0_out out = {}; spvUnsafeArray vBoo = {}; vBoo[0] = patchIn.vBoo_0; vBoo[1] = patchIn.vBoo_1; vBoo[2] = patchIn.vBoo_2; vBoo[3] = patchIn.vBoo_3; float4x4 _57 = float4x4(patchIn.gl_in[0u].vInputs_0, patchIn.gl_in[0u].vInputs_1, patchIn.gl_in[0u].vInputs_2, patchIn.gl_in[0u].vInputs_3); float4x4 _59 = float4x4(patchIn.gl_in[1u].vInputs_0, patchIn.gl_in[1u].vInputs_1, patchIn.gl_in[1u].vInputs_2, patchIn.gl_in[1u].vInputs_3); float4x4 _47 = _57; float4x4 _48 = _59; out.gl_Position = (_47[patchIn.vIndex] + _48[patchIn.vIndex]) + vBoo[patchIn.vIndex]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/load-control-point-array.tese000066400000000000000000000033551400026215700300440ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vInputs [[attribute(0)]]; }; struct main0_patchIn { float4 vBoo_0 [[attribute(1)]]; float4 vBoo_1 [[attribute(2)]]; float4 vBoo_2 [[attribute(3)]]; float4 vBoo_3 [[attribute(4)]]; int vIndex [[attribute(5)]]; patch_control_point gl_in; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]]) { main0_out out = {}; spvUnsafeArray vBoo = {}; vBoo[0] = patchIn.vBoo_0; vBoo[1] = patchIn.vBoo_1; vBoo[2] = patchIn.vBoo_2; vBoo[3] = patchIn.vBoo_3; out.gl_Position = (patchIn.gl_in[0u].vInputs + patchIn.gl_in[1u].vInputs) + vBoo[patchIn.vIndex]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/quad.domain.tese000066400000000000000000000015121400026215700253750ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_patchIn { float2 gl_TessLevelInner [[attribute(0)]]; float4 gl_TessLevelOuter [[attribute(1)]]; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; gl_TessCoord.y = 1.0 - gl_TessCoord.y; out.gl_Position = float4(((gl_TessCoord.x * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.x) + (((1.0 - gl_TessCoord.x) * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.z), ((gl_TessCoord.y * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.w) + (((1.0 - gl_TessCoord.y) * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.y), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/quad.tese000066400000000000000000000014371400026215700241350ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_patchIn { float2 gl_TessLevelInner [[attribute(0)]]; float4 gl_TessLevelOuter [[attribute(1)]]; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; out.gl_Position = float4(((gl_TessCoord.x * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.x) + (((1.0 - gl_TessCoord.x) * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.z), ((gl_TessCoord.y * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.y) + (((1.0 - gl_TessCoord.y) * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.w), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/set-from-function.tese000066400000000000000000000021441400026215700265560ustar00rootroot00000000000000#include #include using namespace metal; struct Block { float4 a; float4 b; }; struct Foo { float4 a; float4 b; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vColor [[attribute(0)]]; float4 Block_a [[attribute(2)]]; float4 Block_b [[attribute(3)]]; }; struct main0_patchIn { float4 vColors [[attribute(1)]]; float4 Foo_a [[attribute(4)]]; float4 Foo_b [[attribute(5)]]; patch_control_point gl_in; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]]) { main0_out out = {}; Foo vFoo = {}; vFoo.a = patchIn.Foo_a; vFoo.b = patchIn.Foo_b; out.gl_Position = patchIn.gl_in[0].Block_a; out.gl_Position += patchIn.gl_in[0].Block_b; out.gl_Position += patchIn.gl_in[1].Block_a; out.gl_Position += patchIn.gl_in[1].Block_b; out.gl_Position += patchIn.gl_in[0].vColor; out.gl_Position += patchIn.gl_in[1].vColor; out.gl_Position += patchIn.vColors; out.gl_Position += vFoo.a; out.gl_Position += vFoo.b; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/triangle-tess-level.tese000066400000000000000000000035031400026215700270650ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_patchIn { float4 gl_TessLevel [[attribute(0)]]; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray gl_TessLevelInner = {}; spvUnsafeArray gl_TessLevelOuter = {}; gl_TessLevelInner[0] = patchIn.gl_TessLevel.w; gl_TessLevelOuter[0] = patchIn.gl_TessLevel.x; gl_TessLevelOuter[1] = patchIn.gl_TessLevel.y; gl_TessLevelOuter[2] = patchIn.gl_TessLevel.z; out.gl_Position = float4((gl_TessCoord.x * gl_TessLevelInner[0]) * gl_TessLevelOuter[0], (gl_TessCoord.y * gl_TessLevelInner[0]) * gl_TessLevelOuter[1], (gl_TessCoord.z * gl_TessLevelInner[0]) * gl_TessLevelOuter[2], 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/triangle.tese000066400000000000000000000004061400026215700250030ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; [[ patch(triangle, 0) ]] vertex main0_out main0() { main0_out out = {}; out.gl_Position = float4(1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/tese/water_tess.tese000066400000000000000000000032151400026215700253570ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; float4 uScale; float2 uInvScale; float3 uCamPos; float2 uPatchSize; float2 uInvHeightmapSize; }; struct main0_out { float3 vWorld [[user(locn0)]]; float4 vGradNormalTex [[user(locn1)]]; float4 gl_Position [[position]]; }; struct main0_patchIn { float2 vOutPatchPosBase [[attribute(0)]]; float4 vPatchLods [[attribute(1)]]; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant UBO& _31 [[buffer(0)]], texture2d uHeightmapDisplacement [[texture(0)]], sampler uHeightmapDisplacementSmplr [[sampler(0)]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; float2 _202 = patchIn.vOutPatchPosBase + (float3(gl_TessCoord, 0).xy * _31.uPatchSize); float2 _216 = mix(patchIn.vPatchLods.yx, patchIn.vPatchLods.zw, float2(float3(gl_TessCoord, 0).x)); float _223 = mix(_216.x, _216.y, float3(gl_TessCoord, 0).y); float _225 = floor(_223); float2 _125 = _202 * _31.uInvHeightmapSize; float2 _141 = _31.uInvHeightmapSize * exp2(_225); out.vGradNormalTex = float4(_125 + (_31.uInvHeightmapSize * 0.5), _125 * _31.uScale.zw); float3 _256 = mix(uHeightmapDisplacement.sample(uHeightmapDisplacementSmplr, (_125 + (_141 * 0.5)), level(_225)).xyz, uHeightmapDisplacement.sample(uHeightmapDisplacementSmplr, (_125 + (_141 * 1.0)), level(_225 + 1.0)).xyz, float3(_223 - _225)); float2 _171 = (_202 * _31.uScale.xy) + _256.yz; out.vWorld = float3(_171.x, _256.x, _171.y); out.gl_Position = _31.uMVP * float4(out.vWorld, 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/000077500000000000000000000000001400026215700223345ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/basic.capture.vert000066400000000000000000000014711400026215700257640ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex void main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]], uint gl_BaseVertex [[base_vertex]], uint gl_InstanceIndex [[instance_id]], uint gl_BaseInstance [[base_instance]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]]) { device main0_out& out = spvOut[(gl_InstanceIndex - gl_BaseInstance) * spvIndirectParams[0] + gl_VertexIndex - gl_BaseVertex]; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/basic.for-tess.vert000066400000000000000000000013531400026215700260620ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal; float4 gl_Position; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; kernel void main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 spvStageInputSize [[grid_size]], device main0_out* spvOut [[buffer(28)]]) { device main0_out& out = spvOut[gl_GlobalInvocationID.y * spvStageInputSize.x + gl_GlobalInvocationID.x]; if (any(gl_GlobalInvocationID >= spvStageInputSize)) return; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/basic.vert000066400000000000000000000007661400026215700243300ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/clip-distance-block.no-user-varying.vert000066400000000000000000000007121400026215700321110ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.Position; out.gl_ClipDistance[0] = in.Position.x; out.gl_ClipDistance[1] = in.Position.y; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/clip-distance-block.vert000066400000000000000000000012141400026215700270430ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; float gl_ClipDistance_0 [[user(clip0)]]; float gl_ClipDistance_1 [[user(clip1)]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.Position; out.gl_ClipDistance[0] = in.Position.x; out.gl_ClipDistance[1] = in.Position.y; out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; out.gl_ClipDistance_1 = out.gl_ClipDistance[1]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/copy.flatten.vert000066400000000000000000000016141400026215700256460ustar00rootroot00000000000000#include #include using namespace metal; struct Light { packed_float3 Position; float Radius; float4 Color; }; struct UBO { float4x4 uMVP; Light lights[4]; }; struct main0_out { float4 vColor [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _21 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _21.uMVP * in.aVertex; out.vColor = float4(0.0); for (int _96 = 0; _96 < 4; ) { float3 _68 = in.aVertex.xyz - float3(_21.lights[_96].Position); out.vColor += ((_21.lights[_96].Color * fast::clamp(1.0 - (length(_68) / _21.lights[_96].Radius), 0.0, 1.0)) * dot(in.aNormal, normalize(_68))); _96++; continue; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/dynamic.flatten.vert000066400000000000000000000016141400026215700263200ustar00rootroot00000000000000#include #include using namespace metal; struct Light { packed_float3 Position; float Radius; float4 Color; }; struct UBO { float4x4 uMVP; Light lights[4]; }; struct main0_out { float4 vColor [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _21 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _21.uMVP * in.aVertex; out.vColor = float4(0.0); for (int _82 = 0; _82 < 4; ) { float3 _54 = in.aVertex.xyz - float3(_21.lights[_82].Position); out.vColor += ((_21.lights[_82].Color * fast::clamp(1.0 - (length(_54) / _21.lights[_82].Radius), 0.0, 1.0)) * dot(in.aNormal, normalize(_54))); _82++; continue; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/float-math.invariant-float-math.vert000066400000000000000000000066641400026215700313320ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Matrices { float4x4 vpMatrix; float4x4 wMatrix; float4x3 wMatrix4x3; float3x4 wMatrix3x4; }; struct main0_out { float3 OutNormal [[user(locn0)]]; float4 OutWorldPos_0 [[user(locn1)]]; float4 OutWorldPos_1 [[user(locn2)]]; float4 OutWorldPos_2 [[user(locn3)]]; float4 OutWorldPos_3 [[user(locn4)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 InPos [[attribute(0)]]; float3 InNormal [[attribute(1)]]; }; template T spvFMul(T l, T r) { return fma(l, r, T(0)); } template vec spvFMulVectorMatrix(vec v, matrix m) { vec res = vec(0); for (uint i = Rows; i > 0; --i) { vec tmp(0); for (uint j = 0; j < Cols; ++j) { tmp[j] = m[j][i - 1]; } res = fma(tmp, vec(v[i - 1]), res); } return res; } template vec spvFMulMatrixVector(matrix m, vec v) { vec res = vec(0); for (uint i = Cols; i > 0; --i) { res = fma(m[i - 1], vec(v[i - 1]), res); } return res; } template matrix spvFMulMatrixMatrix(matrix l, matrix r) { matrix res; for (uint i = 0; i < RCols; i++) { vec tmp(0); for (uint j = 0; j < LCols; j++) { tmp = fma(vec(r[i][j]), l[j], tmp); } res[i] = tmp; } return res; } vertex main0_out main0(main0_in in [[stage_in]], constant Matrices& _22 [[buffer(0)]]) { main0_out out = {}; spvUnsafeArray OutWorldPos = {}; float4 _37 = float4(in.InPos, 1.0); out.gl_Position = spvFMulMatrixVector(spvFMulMatrixMatrix(_22.vpMatrix, _22.wMatrix), _37); OutWorldPos[0] = spvFMulMatrixVector(_22.wMatrix, _37); OutWorldPos[1] = spvFMulVectorMatrix(_37, _22.wMatrix); OutWorldPos[2] = spvFMulMatrixVector(_22.wMatrix3x4, in.InPos); OutWorldPos[3] = spvFMulVectorMatrix(in.InPos, _22.wMatrix4x3); out.OutNormal = spvFMulMatrixVector(_22.wMatrix, float4(in.InNormal, 0.0)).xyz; out.OutWorldPos_0 = OutWorldPos[0]; out.OutWorldPos_1 = OutWorldPos[1]; out.OutWorldPos_2 = OutWorldPos[2]; out.OutWorldPos_3 = OutWorldPos[3]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/float-math.vert000066400000000000000000000042031400026215700252710ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Matrices { float4x4 vpMatrix; float4x4 wMatrix; float4x3 wMatrix4x3; float3x4 wMatrix3x4; }; struct main0_out { float3 OutNormal [[user(locn0)]]; float4 OutWorldPos_0 [[user(locn1)]]; float4 OutWorldPos_1 [[user(locn2)]]; float4 OutWorldPos_2 [[user(locn3)]]; float4 OutWorldPos_3 [[user(locn4)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 InPos [[attribute(0)]]; float3 InNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant Matrices& _22 [[buffer(0)]]) { main0_out out = {}; spvUnsafeArray OutWorldPos = {}; float4 _37 = float4(in.InPos, 1.0); out.gl_Position = (_22.vpMatrix * _22.wMatrix) * _37; OutWorldPos[0] = _22.wMatrix * _37; OutWorldPos[1] = _37 * _22.wMatrix; OutWorldPos[2] = _22.wMatrix3x4 * in.InPos; OutWorldPos[3] = in.InPos * _22.wMatrix4x3; out.OutNormal = (_22.wMatrix * float4(in.InNormal, 0.0)).xyz; out.OutWorldPos_0 = OutWorldPos[0]; out.OutWorldPos_1 = OutWorldPos[1]; out.OutWorldPos_2 = OutWorldPos[2]; out.OutWorldPos_3 = OutWorldPos[3]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/functions.vert000066400000000000000000000107551400026215700252560ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4x4 uMVP; float3 rotDeg; float3 rotRad; int2 bits; }; struct main0_out { float3 vNormal [[user(locn0)]]; float3 vRotDeg [[user(locn1)]]; float3 vRotRad [[user(locn2)]]; int2 vLSB [[user(locn3)]]; int2 vMSB [[user(locn4)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; // Implementation of the GLSL radians() function template inline T radians(T d) { return d * T(0.01745329251); } // Implementation of the GLSL degrees() function template inline T degrees(T r) { return r * T(57.2957795131); } // Implementation of the GLSL findLSB() function template inline T spvFindLSB(T x) { return select(ctz(x), T(-1), x == T(0)); } // Implementation of the signed GLSL findMSB() function template inline T spvFindSMSB(T x) { T v = select(x, T(-1) - x, x < T(0)); return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0)); } // Returns the determinant of a 2x2 matrix. static inline __attribute__((always_inline)) float spvDet2x2(float a1, float a2, float b1, float b2) { return a1 * b2 - b1 * a2; } // Returns the determinant of a 3x3 matrix. static inline __attribute__((always_inline)) float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) { return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3); } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float4x4 spvInverse4x4(float4x4 m) { float4x4 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]); adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]); adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]); adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]); adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]); adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]); adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]); adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] * m[3][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = spvInverse4x4(_18.uMVP) * in.aVertex; out.vNormal = in.aNormal; out.vRotDeg = degrees(_18.rotRad); out.vRotRad = radians(_18.rotDeg); out.vLSB = spvFindLSB(_18.bits); out.vMSB = spvFindSMSB(_18.bits); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/in_out_array_mat.vert000066400000000000000000000057531400026215700266040ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct UBO { float4x4 projection; float4x4 model; float lodBias; }; struct main0_out { float3 outPos [[user(locn0)]]; float3 outNormal [[user(locn1)]]; float4 outTransModel_0 [[user(locn2)]]; float4 outTransModel_1 [[user(locn3)]]; float4 outTransModel_2 [[user(locn4)]]; float4 outTransModel_3 [[user(locn5)]]; float outLodBias [[user(locn6)]]; float4 color [[user(locn7)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 inPos [[attribute(0)]]; float4 colors_0 [[attribute(1)]]; float4 colors_1 [[attribute(2)]]; float4 colors_2 [[attribute(3)]]; float3 inNormal [[attribute(4)]]; float4 inViewMat_0 [[attribute(5)]]; float4 inViewMat_1 [[attribute(6)]]; float4 inViewMat_2 [[attribute(7)]]; float4 inViewMat_3 [[attribute(8)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& ubo [[buffer(0)]]) { main0_out out = {}; float4x4 outTransModel = {}; spvUnsafeArray colors = {}; float4x4 inViewMat = {}; colors[0] = in.colors_0; colors[1] = in.colors_1; colors[2] = in.colors_2; inViewMat[0] = in.inViewMat_0; inViewMat[1] = in.inViewMat_1; inViewMat[2] = in.inViewMat_2; inViewMat[3] = in.inViewMat_3; float4 _64 = float4(in.inPos, 1.0); out.gl_Position = (ubo.projection * ubo.model) * _64; out.outPos = float3((ubo.model * _64).xyz); out.outNormal = float3x3(float3(ubo.model[0].x, ubo.model[0].y, ubo.model[0].z), float3(ubo.model[1].x, ubo.model[1].y, ubo.model[1].z), float3(ubo.model[2].x, ubo.model[2].y, ubo.model[2].z)) * in.inNormal; out.outLodBias = ubo.lodBias; outTransModel = transpose(ubo.model) * inViewMat; outTransModel[2] = float4(in.inNormal, 1.0); outTransModel[1].y = ubo.lodBias; out.color = colors[2]; out.outTransModel_0 = outTransModel[0]; out.outTransModel_1 = outTransModel[1]; out.outTransModel_2 = outTransModel[2]; out.outTransModel_3 = outTransModel[3]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/interface-block-block-composites.frag000066400000000000000000000044401400026215700315020ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Vert { float3x3 wMatrix; float4 wTmp; spvUnsafeArray arr; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float3 vMatrix_0 [[user(locn0)]]; float3 vMatrix_1 [[user(locn1)]]; float3 vMatrix_2 [[user(locn2)]]; float3 Vert_wMatrix_0 [[user(locn4)]]; float3 Vert_wMatrix_1 [[user(locn5)]]; float3 Vert_wMatrix_2 [[user(locn6)]]; float4 Vert_wTmp [[user(locn7)]]; float Vert_arr_0 [[user(locn8)]]; float Vert_arr_1 [[user(locn9)]]; float Vert_arr_2 [[user(locn10)]]; float Vert_arr_3 [[user(locn11)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; Vert _17 = {}; float3x3 vMatrix = {}; _17.wMatrix[0] = in.Vert_wMatrix_0; _17.wMatrix[1] = in.Vert_wMatrix_1; _17.wMatrix[2] = in.Vert_wMatrix_2; _17.wTmp = in.Vert_wTmp; _17.arr[0] = in.Vert_arr_0; _17.arr[1] = in.Vert_arr_1; _17.arr[2] = in.Vert_arr_2; _17.arr[3] = in.Vert_arr_3; vMatrix[0] = in.vMatrix_0; vMatrix[1] = in.vMatrix_1; vMatrix[2] = in.vMatrix_2; out.FragColor = (_17.wMatrix[0].xxyy + _17.wTmp) + vMatrix[1].yyzz; for (int _56 = 0; _56 < 4; ) { out.FragColor += float4(_17.arr[_56]); _56++; continue; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/interface-block-block-composites.vert000066400000000000000000000047111400026215700315440ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Vert { spvUnsafeArray arr; float3x3 wMatrix; float4 wTmp; }; struct main0_out { float3 vMatrix_0 [[user(locn0)]]; float3 vMatrix_1 [[user(locn1)]]; float3 vMatrix_2 [[user(locn2)]]; float Vert_arr_0 [[user(locn4)]]; float Vert_arr_1 [[user(locn5)]]; float Vert_arr_2 [[user(locn6)]]; float3 Vert_wMatrix_0 [[user(locn7)]]; float3 Vert_wMatrix_1 [[user(locn8)]]; float3 Vert_wMatrix_2 [[user(locn9)]]; float4 Vert_wTmp [[user(locn10)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 Matrix_0 [[attribute(0)]]; float3 Matrix_1 [[attribute(1)]]; float3 Matrix_2 [[attribute(2)]]; float4 Pos [[attribute(4)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float3x3 vMatrix = {}; Vert _20 = {}; float3x3 Matrix = {}; Matrix[0] = in.Matrix_0; Matrix[1] = in.Matrix_1; Matrix[2] = in.Matrix_2; vMatrix = Matrix; _20.wMatrix = Matrix; _20.arr[0] = 1.0; _20.arr[1] = 2.0; _20.arr[2] = 3.0; _20.wTmp = in.Pos; out.gl_Position = in.Pos; out.vMatrix_0 = vMatrix[0]; out.vMatrix_1 = vMatrix[1]; out.vMatrix_2 = vMatrix[2]; out.Vert_arr_0 = _20.arr[0]; out.Vert_arr_1 = _20.arr[1]; out.Vert_arr_2 = _20.arr[2]; out.Vert_wMatrix_0 = _20.wMatrix[0]; out.Vert_wMatrix_1 = _20.wMatrix[1]; out.Vert_wMatrix_2 = _20.wMatrix[2]; out.Vert_wTmp = _20.wTmp; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/interpolation-qualifiers-block.vert000066400000000000000000000022711400026215700313610ustar00rootroot00000000000000#include #include using namespace metal; struct Output { float2 v0; float2 v1; float3 v2; float4 v3; float v4; float v5; float v6; }; struct main0_out { float2 Output_v0 [[user(locn0)]]; float2 Output_v1 [[user(locn1)]]; float3 Output_v2 [[user(locn2)]]; float4 Output_v3 [[user(locn3)]]; float Output_v4 [[user(locn4)]]; float Output_v5 [[user(locn5)]]; float Output_v6 [[user(locn6)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; Output outp = {}; outp.v0 = in.Position.xy; outp.v1 = in.Position.zw; outp.v2 = float3(in.Position.x, in.Position.z * in.Position.y, in.Position.x); outp.v3 = in.Position.xxyy; outp.v4 = in.Position.w; outp.v5 = in.Position.y; outp.v6 = in.Position.x * in.Position.w; out.gl_Position = in.Position; out.Output_v0 = outp.v0; out.Output_v1 = outp.v1; out.Output_v2 = outp.v2; out.Output_v3 = outp.v3; out.Output_v4 = outp.v4; out.Output_v5 = outp.v5; out.Output_v6 = outp.v6; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/interpolation-qualifiers.vert000066400000000000000000000014461400026215700302740ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float2 v0 [[user(locn0)]]; float2 v1 [[user(locn1)]]; float3 v2 [[user(locn2)]]; float4 v3 [[user(locn3)]]; float v4 [[user(locn4)]]; float v5 [[user(locn5)]]; float v6 [[user(locn6)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.v0 = in.Position.xy; out.v1 = in.Position.zw; out.v2 = float3(in.Position.x, in.Position.z * in.Position.y, in.Position.x); out.v3 = in.Position.xxyy; out.v4 = in.Position.w; out.v5 = in.Position.y; out.v6 = in.Position.x * in.Position.w; out.gl_Position = in.Position; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/invariant.msl21.vert000066400000000000000000000007321400026215700261700ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position, invariant]]; }; struct main0_in { float4 vInput0 [[attribute(0)]]; float4 vInput1 [[attribute(1)]]; float4 vInput2 [[attribute(2)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float4 _20 = in.vInput1 * in.vInput2; float4 _21 = in.vInput0 + _20; out.gl_Position = _21; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/leaf-function.capture.vert000066400000000000000000000014711400026215700274350ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex void main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]], uint gl_BaseVertex [[base_vertex]], uint gl_InstanceIndex [[instance_id]], uint gl_BaseInstance [[base_instance]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]]) { device main0_out& out = spvOut[(gl_InstanceIndex - gl_BaseInstance) * spvIndirectParams[0] + gl_VertexIndex - gl_BaseVertex]; out.gl_Position = _18.uMVP * in.aVertex; out.vNormal = in.aNormal; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/leaf-function.for-tess.vert000066400000000000000000000013531400026215700275330ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal; float4 gl_Position; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; kernel void main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 spvStageInputSize [[grid_size]], device main0_out* spvOut [[buffer(28)]]) { device main0_out& out = spvOut[gl_GlobalInvocationID.y * spvStageInputSize.x + gl_GlobalInvocationID.x]; if (any(gl_GlobalInvocationID >= spvStageInputSize)) return; out.gl_Position = _18.uMVP * in.aVertex; out.vNormal = in.aNormal; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/no-disable-vertex-out.frag-output.vert000066400000000000000000000011101400026215700316400ustar00rootroot00000000000000#include #include using namespace metal; struct buf { float4x4 MVP; float4 position[36]; float4 attr[36]; }; struct main0_out { float4 texcoord [[user(locn0)]]; float3 frag_pos [[user(locn1)]]; float4 gl_Position [[position]]; }; vertex main0_out main0(constant buf& ubuf [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.texcoord = ubuf.attr[int(gl_VertexIndex)]; out.gl_Position = ubuf.MVP * ubuf.position[int(gl_VertexIndex)]; out.frag_pos = out.gl_Position.xyz; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/no_stage_out.for-tess.vert000066400000000000000000000014141400026215700274650ustar00rootroot00000000000000#include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_10_12 { uint4 _RESERVED_IDENTIFIER_FIXUP_m0[1024]; }; struct main0_in { uint4 _RESERVED_IDENTIFIER_FIXUP_19 [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], device _RESERVED_IDENTIFIER_FIXUP_10_12& _RESERVED_IDENTIFIER_FIXUP_12 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 spvStageInputSize [[grid_size]], uint3 spvDispatchBase [[grid_origin]]) { if (any(gl_GlobalInvocationID >= spvStageInputSize)) return; uint gl_VertexIndex = gl_GlobalInvocationID.x + spvDispatchBase.x; _RESERVED_IDENTIFIER_FIXUP_12._RESERVED_IDENTIFIER_FIXUP_m0[int(gl_VertexIndex)] = in._RESERVED_IDENTIFIER_FIXUP_19; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/no_stage_out.vert000066400000000000000000000010301400026215700257160ustar00rootroot00000000000000#include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_10_12 { uint4 _RESERVED_IDENTIFIER_FIXUP_m0[1024]; }; struct main0_in { uint4 _RESERVED_IDENTIFIER_FIXUP_19 [[attribute(0)]]; }; vertex void main0(main0_in in [[stage_in]], device _RESERVED_IDENTIFIER_FIXUP_10_12& _RESERVED_IDENTIFIER_FIXUP_12 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { _RESERVED_IDENTIFIER_FIXUP_12._RESERVED_IDENTIFIER_FIXUP_m0[int(gl_VertexIndex)] = in._RESERVED_IDENTIFIER_FIXUP_19; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/no_stage_out.write_buff.vert000066400000000000000000000016341400026215700300630ustar00rootroot00000000000000#include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_33_35 { uint4 _RESERVED_IDENTIFIER_FIXUP_m0[1024]; }; struct _RESERVED_IDENTIFIER_FIXUP_38_40 { uint4 _RESERVED_IDENTIFIER_FIXUP_m0[1024]; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 _RESERVED_IDENTIFIER_FIXUP_14 [[attribute(0)]]; }; vertex void main0(main0_in in [[stage_in]], device _RESERVED_IDENTIFIER_FIXUP_33_35& _RESERVED_IDENTIFIER_FIXUP_35 [[buffer(0)]], constant _RESERVED_IDENTIFIER_FIXUP_38_40& _RESERVED_IDENTIFIER_FIXUP_40 [[buffer(1)]]) { main0_out out = {}; out.gl_Position = in._RESERVED_IDENTIFIER_FIXUP_14; for (int _52 = 0; _52 < 1024; ) { _RESERVED_IDENTIFIER_FIXUP_35._RESERVED_IDENTIFIER_FIXUP_m0[_52] = _RESERVED_IDENTIFIER_FIXUP_40._RESERVED_IDENTIFIER_FIXUP_m0[_52]; _52++; continue; } } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/no_stage_out.write_buff_atomic.vert000066400000000000000000000013711400026215700314150ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_19_21 { uint _RESERVED_IDENTIFIER_FIXUP_m0; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 _RESERVED_IDENTIFIER_FIXUP_14 [[attribute(0)]]; }; vertex void main0(main0_in in [[stage_in]], volatile device _RESERVED_IDENTIFIER_FIXUP_19_21& _RESERVED_IDENTIFIER_FIXUP_21 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = in._RESERVED_IDENTIFIER_FIXUP_14; uint _29 = atomic_fetch_add_explicit((volatile device atomic_uint*)&_RESERVED_IDENTIFIER_FIXUP_21._RESERVED_IDENTIFIER_FIXUP_m0, 1u, memory_order_relaxed); } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/no_stage_out.write_tex.vert000066400000000000000000000012301400026215700277310ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 _RESERVED_IDENTIFIER_FIXUP_14 [[attribute(0)]]; }; vertex void main0(main0_in in [[stage_in]], texture1d _RESERVED_IDENTIFIER_FIXUP_32 [[texture(0)]], texture1d _RESERVED_IDENTIFIER_FIXUP_35 [[texture(1)]]) { main0_out out = {}; out.gl_Position = in._RESERVED_IDENTIFIER_FIXUP_14; for (int _45 = 0; _45 < 128; ) { _RESERVED_IDENTIFIER_FIXUP_32.write(_RESERVED_IDENTIFIER_FIXUP_35.read(uint(_45)), uint(_45)); _45++; continue; } } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/out_block.vert000066400000000000000000000014531400026215700252220ustar00rootroot00000000000000#include #include using namespace metal; struct Transform { float4x4 transform; }; struct VertexOut { float4 color; float4 color2; }; struct main0_out { float4 VertexOut_color [[user(locn2)]]; float4 VertexOut_color2 [[user(locn3)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 position [[attribute(0)]]; float4 color [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant Transform& block [[buffer(0)]]) { main0_out out = {}; VertexOut outputs = {}; out.gl_Position = block.transform * float4(in.position, 1.0); outputs.color = in.color; outputs.color2 = in.color + float4(1.0); out.VertexOut_color = outputs.color; out.VertexOut_color2 = outputs.color2; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/packed-bool-to-uint.vert000066400000000000000000000013261400026215700270150ustar00rootroot00000000000000#include #include using namespace metal; struct Struct { uint flags[1]; }; struct defaultUniformsVS { Struct flags; float4 uquad[4]; float4x4 umatrix; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant defaultUniformsVS& _24 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.gl_Position = _24.umatrix * float4(_24.uquad[int(gl_VertexIndex)].x, _24.uquad[int(gl_VertexIndex)].y, in.a_position.z, in.a_position.w); if (_24.flags.flags[0] != 0u) { out.gl_Position.z = 0.0; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/packed-bool2-to-packed_uint2.vert000066400000000000000000000013311400026215700304640ustar00rootroot00000000000000#include #include using namespace metal; struct Struct { uint2 flags[1]; }; struct defaultUniformsVS { Struct flags; float4 uquad[4]; float4x4 umatrix; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant defaultUniformsVS& _25 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.gl_Position = _25.umatrix * float4(_25.uquad[int(gl_VertexIndex)].x, _25.uquad[int(gl_VertexIndex)].y, in.a_position.z, in.a_position.w); if (_25.flags.flags[0].x != 0u) { out.gl_Position.z = 0.0; } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/packed_matrix.vert000066400000000000000000000034061400026215700260540ustar00rootroot00000000000000#include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_1365_18812 { float3x4 _RESERVED_IDENTIFIER_FIXUP_m0; float3x4 _RESERVED_IDENTIFIER_FIXUP_m1; }; struct _RESERVED_IDENTIFIER_FIXUP_1126_22044 { float4x4 _RESERVED_IDENTIFIER_FIXUP_m0; float4x4 _RESERVED_IDENTIFIER_FIXUP_m1; float _RESERVED_IDENTIFIER_FIXUP_m9; char _m3_pad[12]; packed_float3 _RESERVED_IDENTIFIER_FIXUP_m10; float _RESERVED_IDENTIFIER_FIXUP_m11; packed_float3 _RESERVED_IDENTIFIER_FIXUP_m12; float _RESERVED_IDENTIFIER_FIXUP_m17; float _RESERVED_IDENTIFIER_FIXUP_m18; float _RESERVED_IDENTIFIER_FIXUP_m19; float2 _RESERVED_IDENTIFIER_FIXUP_m20; }; struct main0_out { float3 _RESERVED_IDENTIFIER_FIXUP_3976 [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 _RESERVED_IDENTIFIER_FIXUP_5275 [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant _RESERVED_IDENTIFIER_FIXUP_1365_18812& _RESERVED_IDENTIFIER_FIXUP_18812 [[buffer(0)]], constant _RESERVED_IDENTIFIER_FIXUP_1126_22044& _RESERVED_IDENTIFIER_FIXUP_22044 [[buffer(1)]]) { main0_out out = {}; float4 _70 = _RESERVED_IDENTIFIER_FIXUP_22044._RESERVED_IDENTIFIER_FIXUP_m0 * float4(float3(_RESERVED_IDENTIFIER_FIXUP_22044._RESERVED_IDENTIFIER_FIXUP_m10) + (in._RESERVED_IDENTIFIER_FIXUP_5275.xyz * (_RESERVED_IDENTIFIER_FIXUP_22044._RESERVED_IDENTIFIER_FIXUP_m17 + _RESERVED_IDENTIFIER_FIXUP_22044._RESERVED_IDENTIFIER_FIXUP_m18)), 1.0); out._RESERVED_IDENTIFIER_FIXUP_3976 = normalize(float4(in._RESERVED_IDENTIFIER_FIXUP_5275.xyz, 0.0) * _RESERVED_IDENTIFIER_FIXUP_18812._RESERVED_IDENTIFIER_FIXUP_m1); float4 _94 = _70; _94.y = -_70.y; out.gl_Position = _94; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/pointsize.vert000066400000000000000000000011201400026215700252540ustar00rootroot00000000000000#include #include using namespace metal; struct params { float4x4 mvp; float psize; }; struct main0_out { float4 color [[user(locn0)]]; float4 gl_Position [[position]]; float gl_PointSize [[point_size]]; }; struct main0_in { float4 position [[attribute(0)]]; float4 color0 [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant params& _19 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _19.mvp * in.position; out.gl_PointSize = _19.psize; out.color = in.color0; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/read-from-row-major-array.vert000066400000000000000000000016211400026215700301410ustar00rootroot00000000000000#include #include using namespace metal; struct Block { float3x4 var[3][4]; }; struct main0_out { float v_vtxResult [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant Block& _104 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = in.a_position; out.v_vtxResult = ((float(abs(_104.var[0][0][0][0] - 2.0) < 0.0500000007450580596923828125) * float(abs(_104.var[0][0][1][0] - 6.0) < 0.0500000007450580596923828125)) * float(abs(_104.var[0][0][2][0] - (-6.0)) < 0.0500000007450580596923828125)) * ((float(abs(_104.var[0][0][0][1]) < 0.0500000007450580596923828125) * float(abs(_104.var[0][0][1][1] - 5.0) < 0.0500000007450580596923828125)) * float(abs(_104.var[0][0][2][1] - 5.0) < 0.0500000007450580596923828125)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/resource-arrays-leaf.ios.vert000066400000000000000000000020221400026215700300560ustar00rootroot00000000000000#include #include using namespace metal; struct storage_block { uint4 baz; int2 quux; }; struct constant_block { float4 foo; int bar; }; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 3 #endif constant int arraySize = SPIRV_CROSS_CONSTANT_ID_0; vertex void main0(device storage_block* storage_0 [[buffer(0)]], device storage_block* storage_1 [[buffer(1)]], constant constant_block* constants_0 [[buffer(2)]], constant constant_block* constants_1 [[buffer(3)]], constant constant_block* constants_2 [[buffer(4)]], constant constant_block* constants_3 [[buffer(5)]], array, 3> images [[texture(0)]]) { device storage_block* storage[] = { storage_0, storage_1, }; constant constant_block* constants[] = { constants_0, constants_1, constants_2, constants_3, }; storage[0]->baz = uint4(constants[3]->foo); storage[1]->quux = images[2].read(uint2(int2(constants[1]->bar))).xy; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/resource-arrays.ios.vert000066400000000000000000000020221400026215700271510ustar00rootroot00000000000000#include #include using namespace metal; struct storage_block { uint4 baz; int2 quux; }; struct constant_block { float4 foo; int bar; }; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 3 #endif constant int arraySize = SPIRV_CROSS_CONSTANT_ID_0; vertex void main0(device storage_block* storage_0 [[buffer(0)]], device storage_block* storage_1 [[buffer(1)]], constant constant_block* constants_0 [[buffer(2)]], constant constant_block* constants_1 [[buffer(3)]], constant constant_block* constants_2 [[buffer(4)]], constant constant_block* constants_3 [[buffer(5)]], array, 3> images [[texture(0)]]) { device storage_block* storage[] = { storage_0, storage_1, }; constant constant_block* constants[] = { constants_0, constants_1, constants_2, constants_3, }; storage[0]->baz = uint4(constants[3]->foo); storage[1]->quux = images[2].read(uint2(int2(constants[1]->bar))).xy; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/return-array.force-native-array.vert000066400000000000000000000005161400026215700313700ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vInput1 [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = float4(10.0) + in.vInput1; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/return-array.vert000066400000000000000000000005161400026215700256730ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vInput1 [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = float4(10.0) + in.vInput1; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/set_builtin_in_func.vert000066400000000000000000000004751400026215700272660ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_PointSize [[point_size]]; }; vertex main0_out main0() { main0_out out = {}; out.gl_PointSize = 1.0; out.gl_Position = float4(out.gl_PointSize); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/sign-int-types.vert000066400000000000000000000026771400026215700261440ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4x4 uMVP; float4 uFloatVec4; float3 uFloatVec3; float2 uFloatVec2; float uFloat; int4 uIntVec4; int3 uIntVec3; int2 uIntVec2; int uInt; }; struct main0_out { float4 vFloatVec4 [[user(locn0)]]; float3 vFloatVec3 [[user(locn1)]]; float2 vFloatVec2 [[user(locn2)]]; float vFloat [[user(locn3)]]; int4 vIntVec4 [[user(locn4)]]; int3 vIntVec3 [[user(locn5)]]; int2 vIntVec2 [[user(locn6)]]; int vInt [[user(locn7)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; }; // Implementation of the GLSL sign() function for integer types template::value>::type> inline T sign(T x) { return select(select(select(x, T(0), x == T(0)), T(1), x > T(0)), T(-1), x < T(0)); } vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _21 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _21.uMVP * in.aVertex; out.vFloatVec4 = sign(_21.uFloatVec4); out.vFloatVec3 = sign(_21.uFloatVec3); out.vFloatVec2 = sign(_21.uFloatVec2); out.vFloat = sign(_21.uFloat); out.vIntVec4 = sign(_21.uIntVec4); out.vIntVec3 = sign(_21.uIntVec3); out.vIntVec2 = sign(_21.uIntVec2); out.vInt = sign(_21.uInt); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/signedness-mismatch.shader-inputs.vert000066400000000000000000000031471400026215700317750ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { ushort2 a [[attribute(0)]]; uint3 b [[attribute(1)]]; ushort c_0 [[attribute(2)]]; ushort c_1 [[attribute(3)]]; uint4 d_0 [[attribute(4)]]; uint4 d_1 [[attribute(5)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray c = {}; spvUnsafeArray d = {}; c[0] = in.c_0; c[1] = in.c_1; d[0] = in.d_0; d[1] = in.d_1; out.gl_Position = float4(float(int(in.a.x)), float(in.b.x), float(uint(c[1])), float(d[0].w)); return out; } texture_buffer.texture-buffer-native.msl21.vert000066400000000000000000000005461400026215700334040ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/vert#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0(texture_buffer uSamp [[texture(0)]], texture_buffer uSampo [[texture(1)]]) { main0_out out = {}; out.gl_Position = uSamp.read(uint(10)) + uSampo.read(uint(100)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/texture_buffer.vert000066400000000000000000000011651400026215700262720ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } vertex main0_out main0(texture2d uSamp [[texture(0)]], texture2d uSampo [[texture(1)]]) { main0_out out = {}; out.gl_Position = uSamp.read(spvTexelBufferCoord(10)) + uSampo.read(spvTexelBufferCoord(100)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/ubo.alignment.vert000066400000000000000000000013551400026215700260040ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 mvp; float2 targSize; char _m2_pad[8]; packed_float3 color; float opacity; }; struct main0_out { float3 vNormal [[user(locn0)]]; float3 vColor [[user(locn1)]]; float2 vSize [[user(locn2)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _18.mvp * in.aVertex; out.vNormal = in.aNormal; out.vColor = float3(_18.color) * _18.opacity; out.vSize = _18.targSize * _18.opacity; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vert/ubo.vert000066400000000000000000000007641400026215700240320ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 mvp; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _16.mvp * in.aVertex; out.vNormal = in.aNormal; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/000077500000000000000000000000001400026215700226545ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/frag/000077500000000000000000000000001400026215700235735ustar00rootroot00000000000000basic.multiview.no-layered.nocompat.vk.frag000066400000000000000000000033331400026215700337600ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex_0 [[user(locn1)]]; float2 vTex_1 [[user(locn2)]]; float2 vTex_2 [[user(locn3)]]; float2 vTex_3 [[user(locn4)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvViewMask [[buffer(24)]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]]) { main0_out out = {}; spvUnsafeArray vTex = {}; vTex[0] = in.vTex_0; vTex[1] = in.vTex_1; vTex[2] = in.vTex_2; vTex[3] = in.vTex_3; const uint gl_ViewIndex = spvViewMask[0]; out.FragColor = in.vColor * uTex.sample(uTexSmplr, vTex[int(gl_ViewIndex)]); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/frag/basic.multiview.nocompat.vk.frag000066400000000000000000000034021400026215700317760ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex_0 [[user(locn1)]]; float2 vTex_1 [[user(locn2)]]; float2 vTex_2 [[user(locn3)]]; float2 vTex_3 [[user(locn4)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvViewMask [[buffer(24)]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]], uint gl_ViewIndex [[render_target_array_index]]) { main0_out out = {}; spvUnsafeArray vTex = {}; vTex[0] = in.vTex_0; vTex[1] = in.vTex_1; vTex[2] = in.vTex_2; vTex[3] = in.vTex_3; gl_ViewIndex += spvViewMask[0]; out.FragColor = in.vColor * uTex.sample(uTexSmplr, vTex[int(gl_ViewIndex)]); return out; } demote-to-helper-forwarding.asm.vk.nocompat.msl23.frag000066400000000000000000000005301400026215700356410ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/frag#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; bool _15 = simd_is_helper_thread(); discard_fragment(); if (!_15) { out.FragColor = float4(1.0, 0.0, 0.0, 1.0); } return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/frag/demote-to-helper.vk.nocompat.msl23.frag000066400000000000000000000002421400026215700330010ustar00rootroot00000000000000#include #include using namespace metal; fragment void main0() { discard_fragment(); bool _9 = simd_is_helper_thread(); } demote-to-helper.vk.nocompat.msl23.ios.frag000066400000000000000000000002421400026215700335130ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/frag#include #include using namespace metal; fragment void main0() { discard_fragment(); bool _9 = simd_is_helper_thread(); } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/frag/push-constant.vk.frag000066400000000000000000000007051400026215700276630ustar00rootroot00000000000000#include #include using namespace metal; struct PushConstants { float4 value0; float4 value1; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant PushConstants& push [[buffer(0)]]) { main0_out out = {}; out.FragColor = (in.vColor + push.value0) + push.value1; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/frag/spec-constant.msl11.vk.frag000066400000000000000000000007501400026215700305720ustar00rootroot00000000000000#include #include using namespace metal; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 1.0 #endif constant float a = SPIRV_CROSS_CONSTANT_ID_1; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 2.0 #endif constant float b = SPIRV_CROSS_CONSTANT_ID_2; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(a + b); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/frag/spec-constant.vk.frag000066400000000000000000000007301400026215700276340ustar00rootroot00000000000000#include #include using namespace metal; constant float a_tmp [[function_constant(1)]]; constant float a = is_function_constant_defined(a_tmp) ? a_tmp : 1.0; constant float b_tmp [[function_constant(2)]]; constant float b = is_function_constant_defined(b_tmp) ? b_tmp : 2.0; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(a + b); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/vert/000077500000000000000000000000001400026215700236345ustar00rootroot00000000000000device-group.multiview.viewfromdev.nocompat.vk.vert000066400000000000000000000005461400026215700356730ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/vert#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0() { main0_out out = {}; const int gl_DeviceIndex = 0; const uint gl_ViewIndex = 0; out.gl_Position = float4(float(gl_DeviceIndex), float(int(gl_ViewIndex)), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/vert/device-group.nocompat.vk.vert000066400000000000000000000004411400026215700313640ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0() { main0_out out = {}; const int gl_DeviceIndex = 0; out.gl_Position = float4(float(gl_DeviceIndex)); return out; } multiview.multiview.no-layered.nocompat.vk.vert000066400000000000000000000010001400026215700350130ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/vert#include #include using namespace metal; struct MVPs { float4x4 MVP[2]; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant uint* spvViewMask [[buffer(24)]], constant MVPs& _19 [[buffer(0)]]) { main0_out out = {}; const uint gl_ViewIndex = spvViewMask[0]; out.gl_Position = _19.MVP[int(gl_ViewIndex)] * in.Position; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/vert/multiview.multiview.nocompat.vk.vert000066400000000000000000000015041400026215700330450ustar00rootroot00000000000000#include #include using namespace metal; struct MVPs { float4x4 MVP[2]; }; struct main0_out { float4 gl_Position [[position]]; uint gl_Layer [[render_target_array_index]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant uint* spvViewMask [[buffer(24)]], constant MVPs& _19 [[buffer(0)]], uint gl_InstanceIndex [[instance_id]], uint gl_BaseInstance [[base_instance]]) { main0_out out = {}; uint gl_ViewIndex = spvViewMask[0] + (gl_InstanceIndex - gl_BaseInstance) % spvViewMask[1]; gl_InstanceIndex = (gl_InstanceIndex - gl_BaseInstance) / spvViewMask[1] + gl_BaseInstance; out.gl_Position = _19.MVP[int(gl_ViewIndex)] * in.Position; out.gl_Layer = gl_ViewIndex - spvViewMask[0]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/vert/multiview.nocompat.vk.vert000066400000000000000000000011101400026215700310120ustar00rootroot00000000000000#include #include using namespace metal; struct MVPs { float4x4 MVP[2]; }; struct main0_out { float4 gl_Position [[position]]; uint gl_Layer [[render_target_array_index]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant MVPs& _19 [[buffer(0)]], uint gl_InstanceIndex [[instance_id]], uint gl_BaseInstance [[base_instance]]) { main0_out out = {}; const uint gl_ViewIndex = 0; out.gl_Position = _19.MVP[int(gl_ViewIndex)] * in.Position; return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/vert/small-storage.vk.vert000066400000000000000000000020651400026215700277320ustar00rootroot00000000000000#include #include using namespace metal; struct block { short2 a; ushort2 b; char2 c; uchar2 d; half2 e; }; struct storage { short3 f; ushort3 g; char3 h; uchar3 i; half3 j; }; struct main0_out { short4 p [[user(locn0)]]; ushort4 q [[user(locn1)]]; half4 r [[user(locn2)]]; float4 gl_Position [[position]]; }; struct main0_in { short foo [[attribute(0)]]; ushort bar [[attribute(1)]]; half baz [[attribute(2)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant block& _26 [[buffer(0)]], const device storage& _53 [[buffer(1)]]) { main0_out out = {}; out.p = short4((int4(int(in.foo)) + int4(int2(_26.a), int2(_26.c))) - int4(int3(_53.f) / int3(_53.h), 1)); out.q = ushort4((uint4(uint(in.bar)) + uint4(uint2(_26.b), uint2(_26.d))) - uint4(uint3(_53.g) / uint3(_53.i), 1u)); out.r = half4((float4(float(in.baz)) + float4(float2(_26.e), 0.0, 1.0)) - float4(float3(_53.j), 1.0)); out.gl_Position = float4(0.0, 0.0, 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-msl/vulkan/vert/vulkan-vertex.vk.vert000066400000000000000000000005711400026215700277730ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0(uint gl_VertexIndex [[vertex_id]], uint gl_InstanceIndex [[instance_id]]) { main0_out out = {}; out.gl_Position = float4(1.0, 2.0, 3.0, 4.0) * float(int(gl_VertexIndex) + int(gl_InstanceIndex)); return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/000077500000000000000000000000001400026215700212565ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/000077500000000000000000000000001400026215700220365ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag/000077500000000000000000000000001400026215700227555ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag/depth-compare.asm.frag000066400000000000000000000354511400026215700271350ustar00rootroot00000000000000#include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Globals { float3 SoftTransitionScale; float4x4 ShadowViewProjectionMatrices[6]; float InvShadowmapResolution; float ShadowFadeFraction; float ShadowSharpen; float4 LightPositionAndInvRadius; float2 ProjectionDepthBiasParameters; float4 PointLightDepthBiasAndProjParameters; }; constant float4 _453 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; fragment main0_out main0(constant type_View& View [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d SceneTexturesStruct_SceneDepthTexture [[texture(0)]], texture2d SceneTexturesStruct_GBufferATexture [[texture(1)]], texture2d SceneTexturesStruct_GBufferBTexture [[texture(2)]], texture2d SceneTexturesStruct_GBufferDTexture [[texture(3)]], depthcube ShadowDepthCubeTexture [[texture(4)]], texture2d SSProfilesTexture [[texture(5)]], sampler SceneTexturesStruct_SceneDepthTextureSampler [[sampler(0)]], sampler SceneTexturesStruct_GBufferATextureSampler [[sampler(1)]], sampler SceneTexturesStruct_GBufferBTextureSampler [[sampler(2)]], sampler SceneTexturesStruct_GBufferDTextureSampler [[sampler(3)]], sampler ShadowDepthTextureSampler [[sampler(4)]], sampler ShadowDepthCubeTextureSampler [[sampler(5)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; float2 _114 = gl_FragCoord.xy * View.View_BufferSizeAndInvSize.zw; float4 _118 = SceneTexturesStruct_SceneDepthTexture.sample(SceneTexturesStruct_SceneDepthTextureSampler, _114, level(0.0)); float _119 = _118.x; float _133 = ((_119 * View.View_InvDeviceZToWorldZTransform.x) + View.View_InvDeviceZToWorldZTransform.y) + (1.0 / ((_119 * View.View_InvDeviceZToWorldZTransform.z) - View.View_InvDeviceZToWorldZTransform.w)); float4 _147 = View.View_ScreenToWorld * float4(((_114 - View.View_ScreenPositionScaleBias.wz) / View.View_ScreenPositionScaleBias.xy) * float2(_133), _133, 1.0); float3 _148 = _147.xyz; float3 _152 = _Globals.LightPositionAndInvRadius.xyz - _148; float _158 = length(_152); bool _160 = (_158 * _Globals.LightPositionAndInvRadius.w) < 1.0; float _207; if (_160) { float3 _165 = abs(_152); float _166 = _165.x; float _167 = _165.y; float _168 = _165.z; float _170 = fast::max(_166, fast::max(_167, _168)); int _189; if (_170 == _166) { _189 = (_166 == _152.x) ? 0 : 1; } else { int _185; if (_170 == _167) { _185 = (_167 == _152.y) ? 2 : 3; } else { _185 = (_168 == _152.z) ? 4 : 5; } _189 = _185; } float4 _196 = _Globals.ShadowViewProjectionMatrices[_189] * float4(_147.xyz, 1.0); float _198 = _196.w; _207 = ShadowDepthCubeTexture.sample_compare(ShadowDepthCubeTextureSampler, (_152 / float3(_158)), (_196.z / _198) + ((-_Globals.PointLightDepthBiasAndProjParameters.x) / _198), level(0.0)); } else { _207 = 1.0; } float _213 = fast::clamp(((_207 - 0.5) * _Globals.ShadowSharpen) + 0.5, 0.0, 1.0); float _218 = sqrt(mix(1.0, _213 * _213, _Globals.ShadowFadeFraction)); float4 _219 = _453; _219.z = _218; float3 _236 = normalize((SceneTexturesStruct_GBufferATexture.sample(SceneTexturesStruct_GBufferATextureSampler, _114, level(0.0)).xyz * float3(2.0)) - float3(1.0)); uint _240 = uint(round(SceneTexturesStruct_GBufferBTexture.sample(SceneTexturesStruct_GBufferBTextureSampler, _114, level(0.0)).w * 255.0)); bool _248 = (_240 & 15u) == 5u; float _448; if (_248) { float4 _260 = SSProfilesTexture.read(uint2(int3(1, int(uint((select(float4(0.0), SceneTexturesStruct_GBufferDTexture.sample(SceneTexturesStruct_GBufferDTextureSampler, _114, level(0.0)), bool4(!(((_240 & 4294967280u) & 16u) != 0u))).x * 255.0) + 0.5)), 0).xy), 0); float _263 = _260.y * 0.5; float _274 = pow(fast::clamp(dot(-(_152 * float3(rsqrt(dot(_152, _152)))), _236), 0.0, 1.0), 1.0); float _445; if (_160) { float3 _278 = _152 / float3(_158); float3 _280 = normalize(cross(_278, float3(0.0, 0.0, 1.0))); float3 _284 = float3(_Globals.InvShadowmapResolution); float3 _285 = _280 * _284; float3 _286 = cross(_280, _278) * _284; float3 _287 = abs(_278); float _288 = _287.x; float _289 = _287.y; float _290 = _287.z; float _292 = fast::max(_288, fast::max(_289, _290)); int _311; if (_292 == _288) { _311 = (_288 == _278.x) ? 0 : 1; } else { int _307; if (_292 == _289) { _307 = (_289 == _278.y) ? 2 : 3; } else { _307 = (_290 == _278.z) ? 4 : 5; } _311 = _307; } float4 _318 = _Globals.ShadowViewProjectionMatrices[_311] * float4(_148 - (_236 * float3(_263)), 1.0); float _323 = _260.x * (10.0 / _Globals.LightPositionAndInvRadius.w); float _329 = (1.0 / (((_318.z / _318.w) * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w; float _342 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, (_278 + (_286 * float3(2.5))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; float _364 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, ((_278 + (_285 * float3(2.3776409626007080078125))) + (_286 * float3(0.77254199981689453125))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; float _387 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, ((_278 + (_285 * float3(1.46946299076080322265625))) + (_286 * float3(-2.0225429534912109375))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; float _410 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, ((_278 + (_285 * float3(-1.46946299076080322265625))) + (_286 * float3(-2.02254199981689453125))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; float _433 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, ((_278 + (_285 * float3(-2.3776409626007080078125))) + (_286 * float3(0.772543013095855712890625))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; _445 = (((((fast::clamp(abs((_342 > 0.0) ? (_342 + _263) : fast::max(0.0, (_342 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25) + (fast::clamp(abs((_364 > 0.0) ? (_364 + _263) : fast::max(0.0, (_364 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25)) + (fast::clamp(abs((_387 > 0.0) ? (_387 + _263) : fast::max(0.0, (_387 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25)) + (fast::clamp(abs((_410 > 0.0) ? (_410 + _263) : fast::max(0.0, (_410 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25)) + (fast::clamp(abs((_433 > 0.0) ? (_433 + _263) : fast::max(0.0, (_433 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25)) * 0.20000000298023223876953125; } else { _445 = 1.0; } _448 = 1.0 - (_445 * 0.20000000298023223876953125); } else { _448 = 1.0; } float4 _451 = float4(float3(1.0).x, float3(1.0).y, _219.z, float3(1.0).z); _451.w = _248 ? sqrt(_448) : _218; out.out_var_SV_Target0 = _451; return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag/global-constant-arrays.asm.frag000066400000000000000000002047161400026215700307750ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_Globals { float4 MappingPolynomial; float3 InverseGamma; float4 ColorMatrixR_ColorCurveCd1; float4 ColorMatrixG_ColorCurveCd3Cm3; float4 ColorMatrixB_ColorCurveCm2; float4 ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3; float4 ColorCurve_Ch1_Ch2; float4 ColorShadow_Luma; float4 ColorShadow_Tint1; float4 ColorShadow_Tint2; float FilmSlope; float FilmToe; float FilmShoulder; float FilmBlackClip; float FilmWhiteClip; packed_float3 ColorScale; float4 OverlayColor; float WhiteTemp; float WhiteTint; float4 ColorSaturation; float4 ColorContrast; float4 ColorGamma; float4 ColorGain; float4 ColorOffset; float4 ColorSaturationShadows; float4 ColorContrastShadows; float4 ColorGammaShadows; float4 ColorGainShadows; float4 ColorOffsetShadows; float4 ColorSaturationMidtones; float4 ColorContrastMidtones; float4 ColorGammaMidtones; float4 ColorGainMidtones; float4 ColorOffsetMidtones; float4 ColorSaturationHighlights; float4 ColorContrastHighlights; float4 ColorGammaHighlights; float4 ColorGainHighlights; float4 ColorOffsetHighlights; float ColorCorrectionShadowsMax; float ColorCorrectionHighlightsMin; uint OutputDevice; uint OutputGamut; float BlueCorrection; float ExpandGamut; }; constant spvUnsafeArray _475 = spvUnsafeArray({ -4.0, -4.0, -3.1573765277862548828125, -0.485249996185302734375, 1.84773242473602294921875, 1.84773242473602294921875 }); constant spvUnsafeArray _476 = spvUnsafeArray({ -0.718548238277435302734375, 2.0810306072235107421875, 3.66812419891357421875, 4.0, 4.0, 4.0 }); constant spvUnsafeArray _479 = spvUnsafeArray({ -4.97062206268310546875, -3.0293781757354736328125, -2.1261999607086181640625, -1.5104999542236328125, -1.0578000545501708984375, -0.4668000042438507080078125, 0.11937999725341796875, 0.7088134288787841796875, 1.2911865711212158203125, 1.2911865711212158203125 }); constant spvUnsafeArray _480 = spvUnsafeArray({ 0.80891323089599609375, 1.19108676910400390625, 1.5683000087738037109375, 1.94830000400543212890625, 2.308300018310546875, 2.63840007781982421875, 2.85949993133544921875, 2.9872608184814453125, 3.0127391815185546875, 3.0127391815185546875 }); constant spvUnsafeArray _482 = spvUnsafeArray({ -2.3010299205780029296875, -2.3010299205780029296875, -1.9312000274658203125, -1.5204999446868896484375, -1.0578000545501708984375, -0.4668000042438507080078125, 0.11937999725341796875, 0.7088134288787841796875, 1.2911865711212158203125, 1.2911865711212158203125 }); constant spvUnsafeArray _483 = spvUnsafeArray({ 0.801995217800140380859375, 1.19800484180450439453125, 1.5943000316619873046875, 1.99730002880096435546875, 2.3782999515533447265625, 2.7683999538421630859375, 3.0515000820159912109375, 3.2746293544769287109375, 3.32743072509765625, 3.32743072509765625 }); constant float3 _391 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0), center_no_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant type_Globals& _Globals [[buffer(0)]], uint gl_Layer [[render_target_array_index]]) { main0_out out = {}; float3x3 _546 = float3x3(float3(0.41245639324188232421875, 0.3575761020183563232421875, 0.180437505245208740234375), float3(0.21267290413379669189453125, 0.715152204036712646484375, 0.072175003588199615478515625), float3(0.01933390088379383087158203125, 0.119191996753215789794921875, 0.950304090976715087890625)) * float3x3(float3(1.01303005218505859375, 0.0061053098179399967193603515625, -0.014971000142395496368408203125), float3(0.0076982299797236919403076171875, 0.99816501140594482421875, -0.005032029934227466583251953125), float3(-0.0028413101099431514739990234375, 0.0046851597726345062255859375, 0.92450702190399169921875)); float3x3 _547 = _546 * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)); float3x3 _548 = float3x3(float3(0.662454187870025634765625, 0.1340042054653167724609375, 0.1561876833438873291015625), float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625), float3(-0.0055746496655046939849853515625, 0.0040607335977256298065185546875, 1.01033914089202880859375)) * float3x3(float3(0.98722398281097412109375, -0.0061132698319852352142333984375, 0.01595330052077770233154296875), float3(-0.007598360069096088409423828125, 1.00186002254486083984375, 0.0053300200961530208587646484375), float3(0.003072570078074932098388671875, -0.0050959498621523380279541015625, 1.0816800594329833984375)); float3x3 _549 = _548 * float3x3(float3(3.2409698963165283203125, -1.53738319873809814453125, -0.4986107647418975830078125), float3(-0.96924364566802978515625, 1.875967502593994140625, 0.0415550582110881805419921875), float3(0.055630080401897430419921875, -0.2039769589900970458984375, 1.05697154998779296875)); float3x3 _550 = float3x3(float3(0.952552378177642822265625, 0.0, 9.25), float3(0.3439664542675018310546875, 0.728166103363037109375, -0.07213254272937774658203125), float3(0.0, 0.0, 1.00882518291473388671875)) * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)); float3x3 _551 = float3x3(float3(0.662454187870025634765625, 0.1340042054653167724609375, 0.1561876833438873291015625), float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625), float3(-0.0055746496655046939849853515625, 0.0040607335977256298065185546875, 1.01033914089202880859375)) * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625)); float3x3 _576; for (;;) { if (_Globals.OutputGamut == 1u) { _576 = _548 * float3x3(float3(2.493396282196044921875, -0.931345880031585693359375, -0.4026944935321807861328125), float3(-0.829486787319183349609375, 1.76265966892242431640625, 0.02362460084259510040283203125), float3(0.0358506999909877777099609375, -0.076182700693607330322265625, 0.957014024257659912109375)); break; } else { if (_Globals.OutputGamut == 2u) { _576 = _548 * float3x3(float3(1.71660840511322021484375, -0.3556621074676513671875, -0.253360092639923095703125), float3(-0.666682898998260498046875, 1.61647760868072509765625, 0.01576850004494190216064453125), float3(0.017642199993133544921875, -0.04277630150318145751953125, 0.94222867488861083984375)); break; } else { if (_Globals.OutputGamut == 3u) { _576 = float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625)); break; } else { if (_Globals.OutputGamut == 4u) { _576 = float3x3(float3(1.0, 0.0, 0.0), float3(0.0, 1.0, 0.0), float3(0.0, 0.0, 1.0)); break; } else { _576 = _549; break; } } } } } float3 _577 = float4((in.in_var_TEXCOORD0 - float2(0.015625)) * float2(1.03225803375244140625), float(gl_Layer) * 0.0322580635547637939453125, 0.0).xyz; float3 _599; if (_Globals.OutputDevice >= 3u) { float3 _591 = pow(_577, float3(0.0126833133399486541748046875)); _599 = pow(fast::max(float3(0.0), _591 - float3(0.8359375)) / (float3(18.8515625) - (float3(18.6875) * _591)), float3(6.277394771575927734375)) * float3(10000.0); } else { _599 = (exp2((_577 - float3(0.434017598628997802734375)) * float3(14.0)) * float3(0.180000007152557373046875)) - float3(0.00266771926544606685638427734375); } float _602 = _Globals.WhiteTemp * 1.00055634975433349609375; float _616 = (_602 <= 7000.0) ? (0.24406300485134124755859375 + ((99.1100006103515625 + ((2967800.0 - (4604438528.0 / _Globals.WhiteTemp)) / _602)) / _602)) : (0.23703999817371368408203125 + ((247.4799957275390625 + ((1901800.0 - (2005284352.0 / _Globals.WhiteTemp)) / _602)) / _602)); float _633 = ((0.860117733478546142578125 + (0.00015411825734190642833709716796875 * _Globals.WhiteTemp)) + ((1.2864121856637211749330163002014e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)) / ((1.0 + (0.0008424202096648514270782470703125 * _Globals.WhiteTemp)) + ((7.0814513719597016461193561553955e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)); float _644 = ((0.317398726940155029296875 + (4.25 * _Globals.WhiteTemp)) + ((4.2048167614439080352894961833954e-08 * _Globals.WhiteTemp) * _Globals.WhiteTemp)) / ((1.0 - (2.8974181986995972692966461181641e-05 * _Globals.WhiteTemp)) + ((1.6145605741257895715534687042236e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)); float _649 = ((2.0 * _633) - (8.0 * _644)) + 4.0; float2 _653 = float2((3.0 * _633) / _649, (2.0 * _644) / _649); float2 _660 = normalize(float2(_633, _644)); float _665 = _633 + (((-_660.y) * _Globals.WhiteTint) * 0.0500000007450580596923828125); float _669 = _644 + ((_660.x * _Globals.WhiteTint) * 0.0500000007450580596923828125); float _674 = ((2.0 * _665) - (8.0 * _669)) + 4.0; float2 _680 = select(float2(_616, (_616 * (((-3.0) * _616) + 2.86999988555908203125)) - 0.2750000059604644775390625), _653, bool2(_Globals.WhiteTemp < 4000.0)) + (float2((3.0 * _665) / _674, (2.0 * _669) / _674) - _653); float _681 = _680.x; float _682 = _680.y; float _683 = fast::max(_682, 1.0000000133514319600180897396058e-10); float3 _685 = _391; _685.x = _681 / _683; float3 _686 = _685; _686.y = 1.0; float3 _690 = _686; _690.z = ((1.0 - _681) - _682) / _683; float3 _693 = _391; _693.x = 0.950455963611602783203125; float3 _694 = _693; _694.y = 1.0; float3 _696 = _694; _696.z = 1.0890576839447021484375; float3 _697 = _690 * float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)); float3 _698 = _696 * float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)); float3 _717 = (_599 * ((float3x3(float3(0.41245639324188232421875, 0.3575761020183563232421875, 0.180437505245208740234375), float3(0.21267290413379669189453125, 0.715152204036712646484375, 0.072175003588199615478515625), float3(0.01933390088379383087158203125, 0.119191996753215789794921875, 0.950304090976715087890625)) * ((float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)) * float3x3(float3(_698.x / _697.x, 0.0, 0.0), float3(0.0, _698.y / _697.y, 0.0), float3(0.0, 0.0, _698.z / _697.z))) * float3x3(float3(0.986992895603179931640625, -0.14705429971218109130859375, 0.15996269881725311279296875), float3(0.4323053061962127685546875, 0.518360316753387451171875, 0.049291200935840606689453125), float3(-0.00852870009839534759521484375, 0.0400427989661693572998046875, 0.968486726284027099609375)))) * float3x3(float3(3.2409698963165283203125, -1.53738319873809814453125, -0.4986107647418975830078125), float3(-0.96924364566802978515625, 1.875967502593994140625, 0.0415550582110881805419921875), float3(0.055630080401897430419921875, -0.2039769589900970458984375, 1.05697154998779296875)))) * _547; float3 _745; if (_Globals.ColorShadow_Tint2.w != 0.0) { float _724 = dot(_717, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625)); float3 _727 = (_717 / float3(_724)) - float3(1.0); _745 = mix(_717, _717 * (_549 * (float3x3(float3(0.544169127941131591796875, 0.23959259688854217529296875, 0.16669429838657379150390625), float3(0.23946559429168701171875, 0.702153027057647705078125, 0.058381401002407073974609375), float3(-0.0023439000360667705535888671875, 0.0361833982169628143310546875, 1.05521833896636962890625)) * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)))), float3((1.0 - exp2((-4.0) * dot(_727, _727))) * (1.0 - exp2((((-4.0) * _Globals.ExpandGamut) * _724) * _724)))); } else { _745 = _717; } float _746 = dot(_745, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625)); float4 _751 = _Globals.ColorSaturationShadows * _Globals.ColorSaturation; float4 _756 = _Globals.ColorContrastShadows * _Globals.ColorContrast; float4 _761 = _Globals.ColorGammaShadows * _Globals.ColorGamma; float4 _766 = _Globals.ColorGainShadows * _Globals.ColorGain; float4 _771 = _Globals.ColorOffsetShadows + _Globals.ColorOffset; float3 _772 = float3(_746); float _804 = smoothstep(0.0, _Globals.ColorCorrectionShadowsMax, _746); float4 _808 = _Globals.ColorSaturationHighlights * _Globals.ColorSaturation; float4 _811 = _Globals.ColorContrastHighlights * _Globals.ColorContrast; float4 _814 = _Globals.ColorGammaHighlights * _Globals.ColorGamma; float4 _817 = _Globals.ColorGainHighlights * _Globals.ColorGain; float4 _820 = _Globals.ColorOffsetHighlights + _Globals.ColorOffset; float _852 = smoothstep(_Globals.ColorCorrectionHighlightsMin, 1.0, _746); float4 _855 = _Globals.ColorSaturationMidtones * _Globals.ColorSaturation; float4 _858 = _Globals.ColorContrastMidtones * _Globals.ColorContrast; float4 _861 = _Globals.ColorGammaMidtones * _Globals.ColorGamma; float4 _864 = _Globals.ColorGainMidtones * _Globals.ColorGain; float4 _867 = _Globals.ColorOffsetMidtones + _Globals.ColorOffset; float3 _905 = ((((pow(pow(fast::max(float3(0.0), mix(_772, _745, _751.xyz * float3(_751.w))) * float3(5.5555553436279296875), _756.xyz * float3(_756.w)) * float3(0.180000007152557373046875), float3(1.0) / (_761.xyz * float3(_761.w))) * (_766.xyz * float3(_766.w))) + (_771.xyz + float3(_771.w))) * float3(1.0 - _804)) + (((pow(pow(fast::max(float3(0.0), mix(_772, _745, _855.xyz * float3(_855.w))) * float3(5.5555553436279296875), _858.xyz * float3(_858.w)) * float3(0.180000007152557373046875), float3(1.0) / (_861.xyz * float3(_861.w))) * (_864.xyz * float3(_864.w))) + (_867.xyz + float3(_867.w))) * float3(_804 - _852))) + (((pow(pow(fast::max(float3(0.0), mix(_772, _745, _808.xyz * float3(_808.w))) * float3(5.5555553436279296875), _811.xyz * float3(_811.w)) * float3(0.180000007152557373046875), float3(1.0) / (_814.xyz * float3(_814.w))) * (_817.xyz * float3(_817.w))) + (_820.xyz + float3(_820.w))) * float3(_852)); float3 _906 = _905 * _549; float3 _914 = float3(_Globals.BlueCorrection); float3 _916 = mix(_905, _905 * ((_551 * float3x3(float3(0.940437257289886474609375, -0.01830687932670116424560546875, 0.07786960899829864501953125), float3(0.008378696627914905548095703125, 0.82866001129150390625, 0.162961304187774658203125), float3(0.0005471261101774871349334716796875, -0.00088337459601461887359619140625, 1.00033628940582275390625))) * _550), _914) * _551; float _917 = _916.x; float _918 = _916.y; float _920 = _916.z; float _923 = fast::max(fast::max(_917, _918), _920); float _928 = (fast::max(_923, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_917, _918), _920), 1.0000000133514319600180897396058e-10)) / fast::max(_923, 0.00999999977648258209228515625); float _941 = ((_920 + _918) + _917) + (1.75 * sqrt(((_920 * (_920 - _918)) + (_918 * (_918 - _917))) + (_917 * (_917 - _920)))); float _942 = _941 * 0.3333333432674407958984375; float _943 = _928 - 0.4000000059604644775390625; float _948 = fast::max(1.0 - abs(_943 * 2.5), 0.0); float _956 = (1.0 + (float(int(sign(_943 * 5.0))) * (1.0 - (_948 * _948)))) * 0.02500000037252902984619140625; float _969; if (_942 <= 0.053333334624767303466796875) { _969 = _956; } else { float _968; if (_942 >= 0.1599999964237213134765625) { _968 = 0.0; } else { _968 = _956 * ((0.23999999463558197021484375 / _941) - 0.5); } _969 = _968; } float3 _972 = _916 * float3(1.0 + _969); float _973 = _972.x; float _974 = _972.y; float _976 = _972.z; float _990; if ((_973 == _974) && (_974 == _976)) { _990 = 0.0; } else { _990 = 57.2957763671875 * atan2(1.73205077648162841796875 * (_974 - _976), ((2.0 * _973) - _974) - _976); } float _995; if (_990 < 0.0) { _995 = _990 + 360.0; } else { _995 = _990; } float _996 = fast::clamp(_995, 0.0, 360.0); float _1001; if (_996 > 180.0) { _1001 = _996 - 360.0; } else { _1001 = _996; } float _1005 = smoothstep(0.0, 1.0, 1.0 - abs(_1001 * 0.01481481455266475677490234375)); float3 _1012 = _972; _1012.x = _973 + ((((_1005 * _1005) * _928) * (0.02999999932944774627685546875 - _973)) * 0.180000007152557373046875); float3 _1014 = fast::max(float3(0.0), _1012 * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375))); float _1023 = (1.0 + _Globals.FilmBlackClip) - _Globals.FilmToe; float _1026 = 1.0 + _Globals.FilmWhiteClip; float _1029 = _1026 - _Globals.FilmShoulder; float _1056; if (_Globals.FilmToe > 0.800000011920928955078125) { _1056 = ((0.819999992847442626953125 - _Globals.FilmToe) / _Globals.FilmSlope) + (-0.744727432727813720703125); } else { float _1035 = (0.180000007152557373046875 + _Globals.FilmBlackClip) / _1023; _1056 = (-0.744727432727813720703125) - ((0.5 * log(_1035 / (2.0 - _1035))) * (_1023 / _Globals.FilmSlope)); } float _1061 = ((1.0 - _Globals.FilmToe) / _Globals.FilmSlope) - _1056; float _1063 = (_Globals.FilmShoulder / _Globals.FilmSlope) - _1061; float3 _1067 = log(mix(float3(dot(_1014, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1014, float3(0.959999978542327880859375))) * float3(0.4342944622039794921875); float3 _1071 = float3(_Globals.FilmSlope) * (_1067 + float3(_1061)); float3 _1079 = float3(_1056); float3 _1080 = _1067 - _1079; float3 _1092 = float3(_1063); float3 _1106 = fast::clamp(_1080 / float3(_1063 - _1056), float3(0.0), float3(1.0)); float3 _1110 = select(_1106, float3(1.0) - _1106, bool3(_1063 < _1056)); float3 _1115 = mix(select(_1071, float3(-_Globals.FilmBlackClip) + (float3(2.0 * _1023) / (float3(1.0) + exp(float3(((-2.0) * _Globals.FilmSlope) / _1023) * _1080))), _1067 < _1079), select(_1071, float3(_1026) - (float3(2.0 * _1029) / (float3(1.0) + exp(float3((2.0 * _Globals.FilmSlope) / _1029) * (_1067 - _1092)))), _1067 > _1092), ((float3(3.0) - (float3(2.0) * _1110)) * _1110) * _1110); float3 _1119 = fast::max(float3(0.0), mix(float3(dot(_1115, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1115, float3(0.930000007152557373046875))); float3 _1189; if (_Globals.ColorShadow_Tint2.w == 0.0) { float3 _1131 = _391; _1131.x = dot(_906, _Globals.ColorMatrixR_ColorCurveCd1.xyz); float3 _1136 = _1131; _1136.y = dot(_906, _Globals.ColorMatrixG_ColorCurveCd3Cm3.xyz); float3 _1141 = _1136; _1141.z = dot(_906, _Globals.ColorMatrixB_ColorCurveCm2.xyz); float3 _1157 = fast::max(float3(0.0), _1141 * (_Globals.ColorShadow_Tint1.xyz + (_Globals.ColorShadow_Tint2.xyz * float3(1.0 / (dot(_906, _Globals.ColorShadow_Luma.xyz) + 1.0))))); float3 _1162 = fast::max(float3(0.0), _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.xxx - _1157); float3 _1164 = fast::max(_1157, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.zzz); _1189 = ((((_1164 * _Globals.ColorCurve_Ch1_Ch2.xxx) + _Globals.ColorCurve_Ch1_Ch2.yyy) * (float3(1.0) / (_1164 + _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.www))) + ((fast::clamp(_1157, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.xxx, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.zzz) * _Globals.ColorMatrixB_ColorCurveCm2.www) + (((_1162 * _Globals.ColorMatrixR_ColorCurveCd1.www) * (float3(1.0) / (_1162 + _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.yyy))) + _Globals.ColorMatrixG_ColorCurveCd3Cm3.www))) - float3(0.00200000009499490261077880859375); } else { _1189 = fast::max(float3(0.0), mix(_1119, _1119 * ((_551 * float3x3(float3(1.06317996978759765625, 0.02339559979736804962158203125, -0.08657260239124298095703125), float3(-0.010633699595928192138671875, 1.2063200473785400390625, -0.1956900060176849365234375), float3(-0.0005908869788981974124908447265625, 0.00105247995816171169281005859375, 0.999538004398345947265625))) * _550), _914) * _549); } float3 _1218 = pow(fast::max(float3(0.0), mix((((float3(_Globals.MappingPolynomial.x) * (_1189 * _1189)) + (float3(_Globals.MappingPolynomial.y) * _1189)) + float3(_Globals.MappingPolynomial.z)) * float3(_Globals.ColorScale), _Globals.OverlayColor.xyz, float3(_Globals.OverlayColor.w))), float3(_Globals.InverseGamma.y)); float3 _3001; if (_Globals.OutputDevice == 0u) { float _2961 = _1218.x; float _2973; for (;;) { if (_2961 < 0.00313066993840038776397705078125) { _2973 = _2961 * 12.9200000762939453125; break; } _2973 = (pow(_2961, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _2974 = _1218.y; float _2986; for (;;) { if (_2974 < 0.00313066993840038776397705078125) { _2986 = _2974 * 12.9200000762939453125; break; } _2986 = (pow(_2974, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _2987 = _1218.z; float _2999; for (;;) { if (_2987 < 0.00313066993840038776397705078125) { _2999 = _2987 * 12.9200000762939453125; break; } _2999 = (pow(_2987, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } _3001 = float3(_2973, _2986, _2999); } else { float3 _2960; if (_Globals.OutputDevice == 1u) { float3 _2953 = fast::max(float3(6.1035199905745685100555419921875e-05), (_1218 * _547) * _576); _2960 = fast::min(_2953 * float3(4.5), (pow(fast::max(_2953, float3(0.017999999225139617919921875)), float3(0.449999988079071044921875)) * float3(1.09899997711181640625)) - float3(0.098999999463558197021484375)); } else { float3 _2950; if ((_Globals.OutputDevice == 3u) || (_Globals.OutputDevice == 5u)) { float3 _2100 = (_906 * float3(1.5)) * (_546 * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625))); float _2101 = _2100.x; float _2102 = _2100.y; float _2104 = _2100.z; float _2107 = fast::max(fast::max(_2101, _2102), _2104); float _2112 = (fast::max(_2107, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_2101, _2102), _2104), 1.0000000133514319600180897396058e-10)) / fast::max(_2107, 0.00999999977648258209228515625); float _2125 = ((_2104 + _2102) + _2101) + (1.75 * sqrt(((_2104 * (_2104 - _2102)) + (_2102 * (_2102 - _2101))) + (_2101 * (_2101 - _2104)))); float _2126 = _2125 * 0.3333333432674407958984375; float _2127 = _2112 - 0.4000000059604644775390625; float _2132 = fast::max(1.0 - abs(_2127 * 2.5), 0.0); float _2140 = (1.0 + (float(int(sign(_2127 * 5.0))) * (1.0 - (_2132 * _2132)))) * 0.02500000037252902984619140625; float _2153; if (_2126 <= 0.053333334624767303466796875) { _2153 = _2140; } else { float _2152; if (_2126 >= 0.1599999964237213134765625) { _2152 = 0.0; } else { _2152 = _2140 * ((0.23999999463558197021484375 / _2125) - 0.5); } _2153 = _2152; } float3 _2156 = _2100 * float3(1.0 + _2153); float _2157 = _2156.x; float _2158 = _2156.y; float _2160 = _2156.z; float _2174; if ((_2157 == _2158) && (_2158 == _2160)) { _2174 = 0.0; } else { _2174 = 57.2957763671875 * atan2(1.73205077648162841796875 * (_2158 - _2160), ((2.0 * _2157) - _2158) - _2160); } float _2179; if (_2174 < 0.0) { _2179 = _2174 + 360.0; } else { _2179 = _2174; } float _2180 = fast::clamp(_2179, 0.0, 360.0); float _2185; if (_2180 > 180.0) { _2185 = _2180 - 360.0; } else { _2185 = _2180; } float _2235; if ((_2185 > (-67.5)) && (_2185 < 67.5)) { float _2192 = (_2185 - (-67.5)) * 0.0296296291053295135498046875; int _2193 = int(_2192); float _2195 = _2192 - float(_2193); float _2196 = _2195 * _2195; float _2197 = _2196 * _2195; float _2234; if (_2193 == 3) { _2234 = (((_2197 * (-0.16666667163372039794921875)) + (_2196 * 0.5)) + (_2195 * (-0.5))) + 0.16666667163372039794921875; } else { float _2227; if (_2193 == 2) { _2227 = ((_2197 * 0.5) + (_2196 * (-1.0))) + 0.666666686534881591796875; } else { float _2222; if (_2193 == 1) { _2222 = (((_2197 * (-0.5)) + (_2196 * 0.5)) + (_2195 * 0.5)) + 0.16666667163372039794921875; } else { float _2215; if (_2193 == 0) { _2215 = _2197 * 0.16666667163372039794921875; } else { _2215 = 0.0; } _2222 = _2215; } _2227 = _2222; } _2234 = _2227; } _2235 = _2234; } else { _2235 = 0.0; } float3 _2242 = _2156; _2242.x = _2157 + ((((_2235 * 1.5) * _2112) * (0.02999999932944774627685546875 - _2157)) * 0.180000007152557373046875); float3 _2245 = fast::clamp(fast::clamp(_2242, float3(0.0), float3(65535.0)) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)), float3(0.0), float3(65535.0)); float3 _2248 = mix(float3(dot(_2245, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _2245, float3(0.959999978542327880859375)); float _2249 = _2248.x; float _2258 = log((_2249 <= 0.0) ? 6.103515625e-05 : _2249) * 0.4342944622039794921875; float _2327; if (_2258 <= (-5.2601776123046875)) { _2327 = -4.0; } else { float _2324; if ((_2258 > (-5.2601776123046875)) && (_2258 < (-0.744727432727813720703125))) { float _2307 = (_2258 - (-5.2601776123046875)) * 0.6643855571746826171875; int _2308 = int(_2307); float _2310 = _2307 - float(_2308); _2324 = dot(float3(_2310 * _2310, _2310, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_2308], _475[_2308 + 1], _475[_2308 + 2])); } else { float _2303; if ((_2258 >= (-0.744727432727813720703125)) && (_2258 < 4.673812389373779296875)) { float _2286 = (_2258 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _2287 = int(_2286); float _2289 = _2286 - float(_2287); _2303 = dot(float3(_2289 * _2289, _2289, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_2287], _476[_2287 + 1], _476[_2287 + 2])); } else { _2303 = 4.0; } _2324 = _2303; } _2327 = _2324; } float3 _2329 = _391; _2329.x = pow(10.0, _2327); float _2330 = _2248.y; float _2334 = log((_2330 <= 0.0) ? 6.103515625e-05 : _2330) * 0.4342944622039794921875; float _2401; if (_2334 <= (-5.2601776123046875)) { _2401 = -4.0; } else { float _2398; if ((_2334 > (-5.2601776123046875)) && (_2334 < (-0.744727432727813720703125))) { float _2381 = (_2334 - (-5.2601776123046875)) * 0.6643855571746826171875; int _2382 = int(_2381); float _2384 = _2381 - float(_2382); _2398 = dot(float3(_2384 * _2384, _2384, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_2382], _475[_2382 + 1], _475[_2382 + 2])); } else { float _2377; if ((_2334 >= (-0.744727432727813720703125)) && (_2334 < 4.673812389373779296875)) { float _2360 = (_2334 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _2361 = int(_2360); float _2363 = _2360 - float(_2361); _2377 = dot(float3(_2363 * _2363, _2363, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_2361], _476[_2361 + 1], _476[_2361 + 2])); } else { _2377 = 4.0; } _2398 = _2377; } _2401 = _2398; } float3 _2403 = _2329; _2403.y = pow(10.0, _2401); float _2404 = _2248.z; float _2408 = log((_2404 <= 0.0) ? 6.103515625e-05 : _2404) * 0.4342944622039794921875; float _2475; if (_2408 <= (-5.2601776123046875)) { _2475 = -4.0; } else { float _2472; if ((_2408 > (-5.2601776123046875)) && (_2408 < (-0.744727432727813720703125))) { float _2455 = (_2408 - (-5.2601776123046875)) * 0.6643855571746826171875; int _2456 = int(_2455); float _2458 = _2455 - float(_2456); _2472 = dot(float3(_2458 * _2458, _2458, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_2456], _475[_2456 + 1], _475[_2456 + 2])); } else { float _2451; if ((_2408 >= (-0.744727432727813720703125)) && (_2408 < 4.673812389373779296875)) { float _2434 = (_2408 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _2435 = int(_2434); float _2437 = _2434 - float(_2435); _2451 = dot(float3(_2437 * _2437, _2437, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_2435], _476[_2435 + 1], _476[_2435 + 2])); } else { _2451 = 4.0; } _2472 = _2451; } _2475 = _2472; } float3 _2477 = _2403; _2477.z = pow(10.0, _2475); float3 _2479 = (_2477 * float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625))) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)); float _2612 = pow(10.0, (float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(-0.718548238277435302734375, 2.0810306072235107421875, 3.66812419891357421875)).z); float _2684 = pow(10.0, dot(float3(0.4444443881511688232421875, 0.66666662693023681640625, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(2.0810306072235107421875, 3.66812419891357421875, 4.0))); float _2685 = _2479.x; float _2688 = log((_2685 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2685); float _2689 = _2688 * 0.4342944622039794921875; float _2690 = log(pow(10.0, dot(float3(0.3600003719329833984375, 0.600000321865081787109375, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(-4.0, -4.0, -3.1573765277862548828125)))); float _2691 = _2690 * 0.4342944622039794921875; float _2768; if (_2689 <= _2691) { _2768 = (_2688 * 1.3028833866119384765625) + ((-4.0) - (_2690 * 1.3028833866119384765625)); } else { float _2698 = log(_2612) * 0.4342944622039794921875; float _2760; if ((_2689 > _2691) && (_2689 < _2698)) { float _2743 = (7.0 * (_2689 - _2691)) / (_2698 - _2691); int _2744 = int(_2743); float _2746 = _2743 - float(_2744); _2760 = dot(float3(_2746 * _2746, _2746, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_479[_2744], _479[_2744 + 1], _479[_2744 + 2])); } else { float _2705 = log(_2684); float _2706 = _2705 * 0.4342944622039794921875; float _2739; if ((_2689 >= _2698) && (_2689 < _2706)) { float _2722 = (7.0 * (_2689 - _2698)) / (_2706 - _2698); int _2723 = int(_2722); float _2725 = _2722 - float(_2723); _2739 = dot(float3(_2725 * _2725, _2725, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_480[_2723], _480[_2723 + 1], _480[_2723 + 2])); } else { _2739 = (_2688 * 0.026057668030261993408203125) + (3.0 - (_2705 * 0.026057668030261993408203125)); } _2760 = _2739; } _2768 = _2760; } float3 _2770 = _391; _2770.x = pow(10.0, _2768); float _2771 = _2479.y; float _2774 = log((_2771 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2771); float _2775 = _2774 * 0.4342944622039794921875; float _2852; if (_2775 <= _2691) { _2852 = (_2774 * 1.3028833866119384765625) + ((-4.0) - (_2690 * 1.3028833866119384765625)); } else { float _2782 = log(_2612) * 0.4342944622039794921875; float _2844; if ((_2775 > _2691) && (_2775 < _2782)) { float _2827 = (7.0 * (_2775 - _2691)) / (_2782 - _2691); int _2828 = int(_2827); float _2830 = _2827 - float(_2828); _2844 = dot(float3(_2830 * _2830, _2830, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_479[_2828], _479[_2828 + 1], _479[_2828 + 2])); } else { float _2789 = log(_2684); float _2790 = _2789 * 0.4342944622039794921875; float _2823; if ((_2775 >= _2782) && (_2775 < _2790)) { float _2806 = (7.0 * (_2775 - _2782)) / (_2790 - _2782); int _2807 = int(_2806); float _2809 = _2806 - float(_2807); _2823 = dot(float3(_2809 * _2809, _2809, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_480[_2807], _480[_2807 + 1], _480[_2807 + 2])); } else { _2823 = (_2774 * 0.026057668030261993408203125) + (3.0 - (_2789 * 0.026057668030261993408203125)); } _2844 = _2823; } _2852 = _2844; } float3 _2854 = _2770; _2854.y = pow(10.0, _2852); float _2855 = _2479.z; float _2858 = log((_2855 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2855); float _2859 = _2858 * 0.4342944622039794921875; float _2936; if (_2859 <= _2691) { _2936 = (_2858 * 1.3028833866119384765625) + ((-4.0) - (_2690 * 1.3028833866119384765625)); } else { float _2866 = log(_2612) * 0.4342944622039794921875; float _2928; if ((_2859 > _2691) && (_2859 < _2866)) { float _2911 = (7.0 * (_2859 - _2691)) / (_2866 - _2691); int _2912 = int(_2911); float _2914 = _2911 - float(_2912); _2928 = dot(float3(_2914 * _2914, _2914, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_479[_2912], _479[_2912 + 1], _479[_2912 + 2])); } else { float _2873 = log(_2684); float _2874 = _2873 * 0.4342944622039794921875; float _2907; if ((_2859 >= _2866) && (_2859 < _2874)) { float _2890 = (7.0 * (_2859 - _2866)) / (_2874 - _2866); int _2891 = int(_2890); float _2893 = _2890 - float(_2891); _2907 = dot(float3(_2893 * _2893, _2893, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_480[_2891], _480[_2891 + 1], _480[_2891 + 2])); } else { _2907 = (_2858 * 0.026057668030261993408203125) + (3.0 - (_2873 * 0.026057668030261993408203125)); } _2928 = _2907; } _2936 = _2928; } float3 _2938 = _2854; _2938.z = pow(10.0, _2936); float3 _2942 = pow(((_2938 - float3(3.5073844628641381859779357910156e-05)) * _576) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _2950 = pow((float3(0.8359375) + (float3(18.8515625) * _2942)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _2942))), float3(78.84375)); } else { float3 _2097; if ((_Globals.OutputDevice == 4u) || (_Globals.OutputDevice == 6u)) { float3 _1263 = (_906 * float3(1.5)) * (_546 * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625))); float _1264 = _1263.x; float _1265 = _1263.y; float _1267 = _1263.z; float _1270 = fast::max(fast::max(_1264, _1265), _1267); float _1275 = (fast::max(_1270, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_1264, _1265), _1267), 1.0000000133514319600180897396058e-10)) / fast::max(_1270, 0.00999999977648258209228515625); float _1288 = ((_1267 + _1265) + _1264) + (1.75 * sqrt(((_1267 * (_1267 - _1265)) + (_1265 * (_1265 - _1264))) + (_1264 * (_1264 - _1267)))); float _1289 = _1288 * 0.3333333432674407958984375; float _1290 = _1275 - 0.4000000059604644775390625; float _1295 = fast::max(1.0 - abs(_1290 * 2.5), 0.0); float _1303 = (1.0 + (float(int(sign(_1290 * 5.0))) * (1.0 - (_1295 * _1295)))) * 0.02500000037252902984619140625; float _1316; if (_1289 <= 0.053333334624767303466796875) { _1316 = _1303; } else { float _1315; if (_1289 >= 0.1599999964237213134765625) { _1315 = 0.0; } else { _1315 = _1303 * ((0.23999999463558197021484375 / _1288) - 0.5); } _1316 = _1315; } float3 _1319 = _1263 * float3(1.0 + _1316); float _1320 = _1319.x; float _1321 = _1319.y; float _1323 = _1319.z; float _1337; if ((_1320 == _1321) && (_1321 == _1323)) { _1337 = 0.0; } else { _1337 = 57.2957763671875 * atan2(1.73205077648162841796875 * (_1321 - _1323), ((2.0 * _1320) - _1321) - _1323); } float _1342; if (_1337 < 0.0) { _1342 = _1337 + 360.0; } else { _1342 = _1337; } float _1343 = fast::clamp(_1342, 0.0, 360.0); float _1348; if (_1343 > 180.0) { _1348 = _1343 - 360.0; } else { _1348 = _1343; } float _1398; if ((_1348 > (-67.5)) && (_1348 < 67.5)) { float _1355 = (_1348 - (-67.5)) * 0.0296296291053295135498046875; int _1356 = int(_1355); float _1358 = _1355 - float(_1356); float _1359 = _1358 * _1358; float _1360 = _1359 * _1358; float _1397; if (_1356 == 3) { _1397 = (((_1360 * (-0.16666667163372039794921875)) + (_1359 * 0.5)) + (_1358 * (-0.5))) + 0.16666667163372039794921875; } else { float _1390; if (_1356 == 2) { _1390 = ((_1360 * 0.5) + (_1359 * (-1.0))) + 0.666666686534881591796875; } else { float _1385; if (_1356 == 1) { _1385 = (((_1360 * (-0.5)) + (_1359 * 0.5)) + (_1358 * 0.5)) + 0.16666667163372039794921875; } else { float _1378; if (_1356 == 0) { _1378 = _1360 * 0.16666667163372039794921875; } else { _1378 = 0.0; } _1385 = _1378; } _1390 = _1385; } _1397 = _1390; } _1398 = _1397; } else { _1398 = 0.0; } float3 _1405 = _1319; _1405.x = _1320 + ((((_1398 * 1.5) * _1275) * (0.02999999932944774627685546875 - _1320)) * 0.180000007152557373046875); float3 _1408 = fast::clamp(fast::clamp(_1405, float3(0.0), float3(65535.0)) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)), float3(0.0), float3(65535.0)); float3 _1411 = mix(float3(dot(_1408, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1408, float3(0.959999978542327880859375)); float _1412 = _1411.x; float _1421 = log((_1412 <= 0.0) ? 6.103515625e-05 : _1412) * 0.4342944622039794921875; float _1490; if (_1421 <= (-5.2601776123046875)) { _1490 = -4.0; } else { float _1487; if ((_1421 > (-5.2601776123046875)) && (_1421 < (-0.744727432727813720703125))) { float _1470 = (_1421 - (-5.2601776123046875)) * 0.6643855571746826171875; int _1471 = int(_1470); float _1473 = _1470 - float(_1471); _1487 = dot(float3(_1473 * _1473, _1473, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_1471], _475[_1471 + 1], _475[_1471 + 2])); } else { float _1466; if ((_1421 >= (-0.744727432727813720703125)) && (_1421 < 4.673812389373779296875)) { float _1449 = (_1421 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _1450 = int(_1449); float _1452 = _1449 - float(_1450); _1466 = dot(float3(_1452 * _1452, _1452, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_1450], _476[_1450 + 1], _476[_1450 + 2])); } else { _1466 = 4.0; } _1487 = _1466; } _1490 = _1487; } float3 _1492 = _391; _1492.x = pow(10.0, _1490); float _1493 = _1411.y; float _1497 = log((_1493 <= 0.0) ? 6.103515625e-05 : _1493) * 0.4342944622039794921875; float _1564; if (_1497 <= (-5.2601776123046875)) { _1564 = -4.0; } else { float _1561; if ((_1497 > (-5.2601776123046875)) && (_1497 < (-0.744727432727813720703125))) { float _1544 = (_1497 - (-5.2601776123046875)) * 0.6643855571746826171875; int _1545 = int(_1544); float _1547 = _1544 - float(_1545); _1561 = dot(float3(_1547 * _1547, _1547, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_1545], _475[_1545 + 1], _475[_1545 + 2])); } else { float _1540; if ((_1497 >= (-0.744727432727813720703125)) && (_1497 < 4.673812389373779296875)) { float _1523 = (_1497 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _1524 = int(_1523); float _1526 = _1523 - float(_1524); _1540 = dot(float3(_1526 * _1526, _1526, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_1524], _476[_1524 + 1], _476[_1524 + 2])); } else { _1540 = 4.0; } _1561 = _1540; } _1564 = _1561; } float3 _1566 = _1492; _1566.y = pow(10.0, _1564); float _1567 = _1411.z; float _1571 = log((_1567 <= 0.0) ? 6.103515625e-05 : _1567) * 0.4342944622039794921875; float _1638; if (_1571 <= (-5.2601776123046875)) { _1638 = -4.0; } else { float _1635; if ((_1571 > (-5.2601776123046875)) && (_1571 < (-0.744727432727813720703125))) { float _1618 = (_1571 - (-5.2601776123046875)) * 0.6643855571746826171875; int _1619 = int(_1618); float _1621 = _1618 - float(_1619); _1635 = dot(float3(_1621 * _1621, _1621, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_1619], _475[_1619 + 1], _475[_1619 + 2])); } else { float _1614; if ((_1571 >= (-0.744727432727813720703125)) && (_1571 < 4.673812389373779296875)) { float _1597 = (_1571 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _1598 = int(_1597); float _1600 = _1597 - float(_1598); _1614 = dot(float3(_1600 * _1600, _1600, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_1598], _476[_1598 + 1], _476[_1598 + 2])); } else { _1614 = 4.0; } _1635 = _1614; } _1638 = _1635; } float3 _1640 = _1566; _1640.z = pow(10.0, _1638); float3 _1642 = (_1640 * float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625))) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)); float _1775 = pow(10.0, (float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(-0.718548238277435302734375, 2.0810306072235107421875, 3.66812419891357421875)).z); float _1847 = pow(10.0, dot(float3(0.69444429874420166015625, 0.8333332538604736328125, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(2.0810306072235107421875, 3.66812419891357421875, 4.0))); float _1848 = _1642.x; float _1851 = log((_1848 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _1848); float _1852 = _1851 * 0.4342944622039794921875; float _1854 = log(pow(10.0, dot(float3(0.3600003719329833984375, 0.600000321865081787109375, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(-4.0, -4.0, -3.1573765277862548828125)))) * 0.4342944622039794921875; float _1926; if (_1852 <= _1854) { _1926 = -2.3010299205780029296875; } else { float _1861 = log(_1775) * 0.4342944622039794921875; float _1923; if ((_1852 > _1854) && (_1852 < _1861)) { float _1906 = (7.0 * (_1852 - _1854)) / (_1861 - _1854); int _1907 = int(_1906); float _1909 = _1906 - float(_1907); _1923 = dot(float3(_1909 * _1909, _1909, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_482[_1907], _482[_1907 + 1], _482[_1907 + 2])); } else { float _1868 = log(_1847); float _1869 = _1868 * 0.4342944622039794921875; float _1902; if ((_1852 >= _1861) && (_1852 < _1869)) { float _1885 = (7.0 * (_1852 - _1861)) / (_1869 - _1861); int _1886 = int(_1885); float _1888 = _1885 - float(_1886); _1902 = dot(float3(_1888 * _1888, _1888, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_483[_1886], _483[_1886 + 1], _483[_1886 + 2])); } else { _1902 = (_1851 * 0.05211533606052398681640625) + (3.3010299205780029296875 - (_1868 * 0.05211533606052398681640625)); } _1923 = _1902; } _1926 = _1923; } float3 _1928 = _391; _1928.x = pow(10.0, _1926); float _1929 = _1642.y; float _1932 = log((_1929 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _1929); float _1933 = _1932 * 0.4342944622039794921875; float _2005; if (_1933 <= _1854) { _2005 = -2.3010299205780029296875; } else { float _1940 = log(_1775) * 0.4342944622039794921875; float _2002; if ((_1933 > _1854) && (_1933 < _1940)) { float _1985 = (7.0 * (_1933 - _1854)) / (_1940 - _1854); int _1986 = int(_1985); float _1988 = _1985 - float(_1986); _2002 = dot(float3(_1988 * _1988, _1988, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_482[_1986], _482[_1986 + 1], _482[_1986 + 2])); } else { float _1947 = log(_1847); float _1948 = _1947 * 0.4342944622039794921875; float _1981; if ((_1933 >= _1940) && (_1933 < _1948)) { float _1964 = (7.0 * (_1933 - _1940)) / (_1948 - _1940); int _1965 = int(_1964); float _1967 = _1964 - float(_1965); _1981 = dot(float3(_1967 * _1967, _1967, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_483[_1965], _483[_1965 + 1], _483[_1965 + 2])); } else { _1981 = (_1932 * 0.05211533606052398681640625) + (3.3010299205780029296875 - (_1947 * 0.05211533606052398681640625)); } _2002 = _1981; } _2005 = _2002; } float3 _2007 = _1928; _2007.y = pow(10.0, _2005); float _2008 = _1642.z; float _2011 = log((_2008 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2008); float _2012 = _2011 * 0.4342944622039794921875; float _2084; if (_2012 <= _1854) { _2084 = -2.3010299205780029296875; } else { float _2019 = log(_1775) * 0.4342944622039794921875; float _2081; if ((_2012 > _1854) && (_2012 < _2019)) { float _2064 = (7.0 * (_2012 - _1854)) / (_2019 - _1854); int _2065 = int(_2064); float _2067 = _2064 - float(_2065); _2081 = dot(float3(_2067 * _2067, _2067, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_482[_2065], _482[_2065 + 1], _482[_2065 + 2])); } else { float _2026 = log(_1847); float _2027 = _2026 * 0.4342944622039794921875; float _2060; if ((_2012 >= _2019) && (_2012 < _2027)) { float _2043 = (7.0 * (_2012 - _2019)) / (_2027 - _2019); int _2044 = int(_2043); float _2046 = _2043 - float(_2044); _2060 = dot(float3(_2046 * _2046, _2046, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_483[_2044], _483[_2044 + 1], _483[_2044 + 2])); } else { _2060 = (_2011 * 0.05211533606052398681640625) + (3.3010299205780029296875 - (_2026 * 0.05211533606052398681640625)); } _2081 = _2060; } _2084 = _2081; } float3 _2086 = _2007; _2086.z = pow(10.0, _2084); float3 _2089 = pow((_2086 * _576) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _2097 = pow((float3(0.8359375) + (float3(18.8515625) * _2089)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _2089))), float3(78.84375)); } else { float3 _1260; if (_Globals.OutputDevice == 7u) { float3 _1252 = pow(((_906 * _547) * _576) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _1260 = pow((float3(0.8359375) + (float3(18.8515625) * _1252)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _1252))), float3(78.84375)); } else { _1260 = pow((_1218 * _547) * _576, float3(_Globals.InverseGamma.z)); } _2097 = _1260; } _2950 = _2097; } _2960 = _2950; } _3001 = _2960; } float3 _3002 = _3001 * float3(0.95238101482391357421875); float4 _3004 = float4(_3002.x, _3002.y, _3002.z, float4(0.0).w); _3004.w = 0.0; out.out_var_SV_Target0 = _3004; return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag/padded-float-array-member-defef.asm.frag000066400000000000000000002110351400026215700323530ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_Globals { float4 MappingPolynomial; float3 InverseGamma; float4 ColorMatrixR_ColorCurveCd1; float4 ColorMatrixG_ColorCurveCd3Cm3; float4 ColorMatrixB_ColorCurveCm2; float4 ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3; float4 ColorCurve_Ch1_Ch2; float4 ColorShadow_Luma; float4 ColorShadow_Tint1; float4 ColorShadow_Tint2; float FilmSlope; float FilmToe; float FilmShoulder; float FilmBlackClip; float FilmWhiteClip; float4 LUTWeights[5]; float3 ColorScale; float4 OverlayColor; float WhiteTemp; float WhiteTint; float4 ColorSaturation; float4 ColorContrast; float4 ColorGamma; float4 ColorGain; float4 ColorOffset; float4 ColorSaturationShadows; float4 ColorContrastShadows; float4 ColorGammaShadows; float4 ColorGainShadows; float4 ColorOffsetShadows; float4 ColorSaturationMidtones; float4 ColorContrastMidtones; float4 ColorGammaMidtones; float4 ColorGainMidtones; float4 ColorOffsetMidtones; float4 ColorSaturationHighlights; float4 ColorContrastHighlights; float4 ColorGammaHighlights; float4 ColorGainHighlights; float4 ColorOffsetHighlights; float ColorCorrectionShadowsMax; float ColorCorrectionHighlightsMin; uint OutputDevice; uint OutputGamut; float BlueCorrection; float ExpandGamut; }; constant spvUnsafeArray _499 = spvUnsafeArray({ -4.0, -4.0, -3.1573765277862548828125, -0.485249996185302734375, 1.84773242473602294921875, 1.84773242473602294921875 }); constant spvUnsafeArray _500 = spvUnsafeArray({ -0.718548238277435302734375, 2.0810306072235107421875, 3.66812419891357421875, 4.0, 4.0, 4.0 }); constant spvUnsafeArray _503 = spvUnsafeArray({ -4.97062206268310546875, -3.0293781757354736328125, -2.1261999607086181640625, -1.5104999542236328125, -1.0578000545501708984375, -0.4668000042438507080078125, 0.11937999725341796875, 0.7088134288787841796875, 1.2911865711212158203125, 1.2911865711212158203125 }); constant spvUnsafeArray _504 = spvUnsafeArray({ 0.80891323089599609375, 1.19108676910400390625, 1.5683000087738037109375, 1.94830000400543212890625, 2.308300018310546875, 2.63840007781982421875, 2.85949993133544921875, 2.9872608184814453125, 3.0127391815185546875, 3.0127391815185546875 }); constant spvUnsafeArray _506 = spvUnsafeArray({ -2.3010299205780029296875, -2.3010299205780029296875, -1.9312000274658203125, -1.5204999446868896484375, -1.0578000545501708984375, -0.4668000042438507080078125, 0.11937999725341796875, 0.7088134288787841796875, 1.2911865711212158203125, 1.2911865711212158203125 }); constant spvUnsafeArray _507 = spvUnsafeArray({ 0.801995217800140380859375, 1.19800484180450439453125, 1.5943000316619873046875, 1.99730002880096435546875, 2.3782999515533447265625, 2.7683999538421630859375, 3.0515000820159912109375, 3.2746293544769287109375, 3.32743072509765625, 3.32743072509765625 }); constant float3 _523 = {}; constant float3 _3265 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0), center_no_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant type_Globals& _Globals [[buffer(0)]], texture2d Texture1 [[texture(0)]], sampler Texture1Sampler [[sampler(0)]], uint gl_Layer [[render_target_array_index]]) { main0_out out = {}; float3x3 _572 = float3x3(float3(0.41245639324188232421875, 0.3575761020183563232421875, 0.180437505245208740234375), float3(0.21267290413379669189453125, 0.715152204036712646484375, 0.072175003588199615478515625), float3(0.01933390088379383087158203125, 0.119191996753215789794921875, 0.950304090976715087890625)) * float3x3(float3(1.01303005218505859375, 0.0061053098179399967193603515625, -0.014971000142395496368408203125), float3(0.0076982299797236919403076171875, 0.99816501140594482421875, -0.005032029934227466583251953125), float3(-0.0028413101099431514739990234375, 0.0046851597726345062255859375, 0.92450702190399169921875)); float3x3 _573 = _572 * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)); float3x3 _574 = float3x3(float3(0.662454187870025634765625, 0.1340042054653167724609375, 0.1561876833438873291015625), float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625), float3(-0.0055746496655046939849853515625, 0.0040607335977256298065185546875, 1.01033914089202880859375)) * float3x3(float3(0.98722398281097412109375, -0.0061132698319852352142333984375, 0.01595330052077770233154296875), float3(-0.007598360069096088409423828125, 1.00186002254486083984375, 0.0053300200961530208587646484375), float3(0.003072570078074932098388671875, -0.0050959498621523380279541015625, 1.0816800594329833984375)); float3x3 _575 = _574 * float3x3(float3(3.2409698963165283203125, -1.53738319873809814453125, -0.4986107647418975830078125), float3(-0.96924364566802978515625, 1.875967502593994140625, 0.0415550582110881805419921875), float3(0.055630080401897430419921875, -0.2039769589900970458984375, 1.05697154998779296875)); float3x3 _576 = float3x3(float3(0.952552378177642822265625, 0.0, 9.25), float3(0.3439664542675018310546875, 0.728166103363037109375, -0.07213254272937774658203125), float3(0.0, 0.0, 1.00882518291473388671875)) * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)); float3x3 _577 = float3x3(float3(0.662454187870025634765625, 0.1340042054653167724609375, 0.1561876833438873291015625), float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625), float3(-0.0055746496655046939849853515625, 0.0040607335977256298065185546875, 1.01033914089202880859375)) * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625)); float3x3 _602; for (;;) { if (_Globals.OutputGamut == 1u) { _602 = _574 * float3x3(float3(2.493396282196044921875, -0.931345880031585693359375, -0.4026944935321807861328125), float3(-0.829486787319183349609375, 1.76265966892242431640625, 0.02362460084259510040283203125), float3(0.0358506999909877777099609375, -0.076182700693607330322265625, 0.957014024257659912109375)); break; } else { if (_Globals.OutputGamut == 2u) { _602 = _574 * float3x3(float3(1.71660840511322021484375, -0.3556621074676513671875, -0.253360092639923095703125), float3(-0.666682898998260498046875, 1.61647760868072509765625, 0.01576850004494190216064453125), float3(0.017642199993133544921875, -0.04277630150318145751953125, 0.94222867488861083984375)); break; } else { if (_Globals.OutputGamut == 3u) { _602 = float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625)); break; } else { if (_Globals.OutputGamut == 4u) { _602 = float3x3(float3(1.0, 0.0, 0.0), float3(0.0, 1.0, 0.0), float3(0.0, 0.0, 1.0)); break; } else { _602 = _575; break; } } } } } float3 _603 = float4((in.in_var_TEXCOORD0 - float2(0.015625)) * float2(1.03225803375244140625), float(gl_Layer) * 0.0322580635547637939453125, 0.0).xyz; float3 _625; if (_Globals.OutputDevice >= 3u) { float3 _617 = pow(_603, float3(0.0126833133399486541748046875)); _625 = pow(fast::max(float3(0.0), _617 - float3(0.8359375)) / (float3(18.8515625) - (float3(18.6875) * _617)), float3(6.277394771575927734375)) * float3(10000.0); } else { _625 = (exp2((_603 - float3(0.434017598628997802734375)) * float3(14.0)) * float3(0.180000007152557373046875)) - float3(0.00266771926544606685638427734375); } float _628 = _Globals.WhiteTemp * 1.00055634975433349609375; float _642 = (_628 <= 7000.0) ? (0.24406300485134124755859375 + ((99.1100006103515625 + ((2967800.0 - (4604438528.0 / _Globals.WhiteTemp)) / _628)) / _628)) : (0.23703999817371368408203125 + ((247.4799957275390625 + ((1901800.0 - (2005284352.0 / _Globals.WhiteTemp)) / _628)) / _628)); float _659 = ((0.860117733478546142578125 + (0.00015411825734190642833709716796875 * _Globals.WhiteTemp)) + ((1.2864121856637211749330163002014e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)) / ((1.0 + (0.0008424202096648514270782470703125 * _Globals.WhiteTemp)) + ((7.0814513719597016461193561553955e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)); float _670 = ((0.317398726940155029296875 + (4.25 * _Globals.WhiteTemp)) + ((4.2048167614439080352894961833954e-08 * _Globals.WhiteTemp) * _Globals.WhiteTemp)) / ((1.0 - (2.8974181986995972692966461181641e-05 * _Globals.WhiteTemp)) + ((1.6145605741257895715534687042236e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)); float _675 = ((2.0 * _659) - (8.0 * _670)) + 4.0; float2 _679 = float2((3.0 * _659) / _675, (2.0 * _670) / _675); float2 _686 = normalize(float2(_659, _670)); float _691 = _659 + (((-_686.y) * _Globals.WhiteTint) * 0.0500000007450580596923828125); float _695 = _670 + ((_686.x * _Globals.WhiteTint) * 0.0500000007450580596923828125); float _700 = ((2.0 * _691) - (8.0 * _695)) + 4.0; float2 _706 = select(float2(_642, (_642 * (((-3.0) * _642) + 2.86999988555908203125)) - 0.2750000059604644775390625), _679, bool2(_Globals.WhiteTemp < 4000.0)) + (float2((3.0 * _691) / _700, (2.0 * _695) / _700) - _679); float _707 = _706.x; float _708 = _706.y; float _709 = fast::max(_708, 1.0000000133514319600180897396058e-10); float3 _711 = _523; _711.x = _707 / _709; float3 _712 = _711; _712.y = 1.0; float3 _716 = _712; _716.z = ((1.0 - _707) - _708) / _709; float3 _719 = _523; _719.x = 0.950455963611602783203125; float3 _720 = _719; _720.y = 1.0; float3 _722 = _720; _722.z = 1.0890576839447021484375; float3 _723 = _716 * float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)); float3 _724 = _722 * float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)); float3 _743 = (_625 * ((float3x3(float3(0.41245639324188232421875, 0.3575761020183563232421875, 0.180437505245208740234375), float3(0.21267290413379669189453125, 0.715152204036712646484375, 0.072175003588199615478515625), float3(0.01933390088379383087158203125, 0.119191996753215789794921875, 0.950304090976715087890625)) * ((float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)) * float3x3(float3(_724.x / _723.x, 0.0, 0.0), float3(0.0, _724.y / _723.y, 0.0), float3(0.0, 0.0, _724.z / _723.z))) * float3x3(float3(0.986992895603179931640625, -0.14705429971218109130859375, 0.15996269881725311279296875), float3(0.4323053061962127685546875, 0.518360316753387451171875, 0.049291200935840606689453125), float3(-0.00852870009839534759521484375, 0.0400427989661693572998046875, 0.968486726284027099609375)))) * float3x3(float3(3.2409698963165283203125, -1.53738319873809814453125, -0.4986107647418975830078125), float3(-0.96924364566802978515625, 1.875967502593994140625, 0.0415550582110881805419921875), float3(0.055630080401897430419921875, -0.2039769589900970458984375, 1.05697154998779296875)))) * _573; float3 _771; if (_Globals.ColorShadow_Tint2.w != 0.0) { float _750 = dot(_743, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625)); float3 _753 = (_743 / float3(_750)) - float3(1.0); _771 = mix(_743, _743 * (_575 * (float3x3(float3(0.544169127941131591796875, 0.23959259688854217529296875, 0.16669429838657379150390625), float3(0.23946559429168701171875, 0.702153027057647705078125, 0.058381401002407073974609375), float3(-0.0023439000360667705535888671875, 0.0361833982169628143310546875, 1.05521833896636962890625)) * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)))), float3((1.0 - exp2((-4.0) * dot(_753, _753))) * (1.0 - exp2((((-4.0) * _Globals.ExpandGamut) * _750) * _750)))); } else { _771 = _743; } float _772 = dot(_771, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625)); float4 _777 = _Globals.ColorSaturationShadows * _Globals.ColorSaturation; float4 _782 = _Globals.ColorContrastShadows * _Globals.ColorContrast; float4 _787 = _Globals.ColorGammaShadows * _Globals.ColorGamma; float4 _792 = _Globals.ColorGainShadows * _Globals.ColorGain; float4 _797 = _Globals.ColorOffsetShadows + _Globals.ColorOffset; float3 _798 = float3(_772); float _830 = smoothstep(0.0, _Globals.ColorCorrectionShadowsMax, _772); float4 _834 = _Globals.ColorSaturationHighlights * _Globals.ColorSaturation; float4 _837 = _Globals.ColorContrastHighlights * _Globals.ColorContrast; float4 _840 = _Globals.ColorGammaHighlights * _Globals.ColorGamma; float4 _843 = _Globals.ColorGainHighlights * _Globals.ColorGain; float4 _846 = _Globals.ColorOffsetHighlights + _Globals.ColorOffset; float _878 = smoothstep(_Globals.ColorCorrectionHighlightsMin, 1.0, _772); float4 _881 = _Globals.ColorSaturationMidtones * _Globals.ColorSaturation; float4 _884 = _Globals.ColorContrastMidtones * _Globals.ColorContrast; float4 _887 = _Globals.ColorGammaMidtones * _Globals.ColorGamma; float4 _890 = _Globals.ColorGainMidtones * _Globals.ColorGain; float4 _893 = _Globals.ColorOffsetMidtones + _Globals.ColorOffset; float3 _931 = ((((pow(pow(fast::max(float3(0.0), mix(_798, _771, _777.xyz * float3(_777.w))) * float3(5.5555553436279296875), _782.xyz * float3(_782.w)) * float3(0.180000007152557373046875), float3(1.0) / (_787.xyz * float3(_787.w))) * (_792.xyz * float3(_792.w))) + (_797.xyz + float3(_797.w))) * float3(1.0 - _830)) + (((pow(pow(fast::max(float3(0.0), mix(_798, _771, _881.xyz * float3(_881.w))) * float3(5.5555553436279296875), _884.xyz * float3(_884.w)) * float3(0.180000007152557373046875), float3(1.0) / (_887.xyz * float3(_887.w))) * (_890.xyz * float3(_890.w))) + (_893.xyz + float3(_893.w))) * float3(_830 - _878))) + (((pow(pow(fast::max(float3(0.0), mix(_798, _771, _834.xyz * float3(_834.w))) * float3(5.5555553436279296875), _837.xyz * float3(_837.w)) * float3(0.180000007152557373046875), float3(1.0) / (_840.xyz * float3(_840.w))) * (_843.xyz * float3(_843.w))) + (_846.xyz + float3(_846.w))) * float3(_878)); float3 _932 = _931 * _575; float3 _940 = float3(_Globals.BlueCorrection); float3 _942 = mix(_931, _931 * ((_577 * float3x3(float3(0.940437257289886474609375, -0.01830687932670116424560546875, 0.07786960899829864501953125), float3(0.008378696627914905548095703125, 0.82866001129150390625, 0.162961304187774658203125), float3(0.0005471261101774871349334716796875, -0.00088337459601461887359619140625, 1.00033628940582275390625))) * _576), _940) * _577; float _943 = _942.x; float _944 = _942.y; float _946 = _942.z; float _949 = fast::max(fast::max(_943, _944), _946); float _954 = (fast::max(_949, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_943, _944), _946), 1.0000000133514319600180897396058e-10)) / fast::max(_949, 0.00999999977648258209228515625); float _967 = ((_946 + _944) + _943) + (1.75 * sqrt(((_946 * (_946 - _944)) + (_944 * (_944 - _943))) + (_943 * (_943 - _946)))); float _968 = _967 * 0.3333333432674407958984375; float _969 = _954 - 0.4000000059604644775390625; float _974 = fast::max(1.0 - abs(_969 * 2.5), 0.0); float _982 = (1.0 + (float(int(sign(_969 * 5.0))) * (1.0 - (_974 * _974)))) * 0.02500000037252902984619140625; float _995; if (_968 <= 0.053333334624767303466796875) { _995 = _982; } else { float _994; if (_968 >= 0.1599999964237213134765625) { _994 = 0.0; } else { _994 = _982 * ((0.23999999463558197021484375 / _967) - 0.5); } _995 = _994; } float3 _998 = _942 * float3(1.0 + _995); float _999 = _998.x; float _1000 = _998.y; float _1002 = _998.z; float _1016; if ((_999 == _1000) && (_1000 == _1002)) { _1016 = 0.0; } else { _1016 = 57.2957763671875 * atan2(1.73205077648162841796875 * (_1000 - _1002), ((2.0 * _999) - _1000) - _1002); } float _1021; if (_1016 < 0.0) { _1021 = _1016 + 360.0; } else { _1021 = _1016; } float _1022 = fast::clamp(_1021, 0.0, 360.0); float _1027; if (_1022 > 180.0) { _1027 = _1022 - 360.0; } else { _1027 = _1022; } float _1031 = smoothstep(0.0, 1.0, 1.0 - abs(_1027 * 0.01481481455266475677490234375)); float3 _1038 = _998; _1038.x = _999 + ((((_1031 * _1031) * _954) * (0.02999999932944774627685546875 - _999)) * 0.180000007152557373046875); float3 _1040 = fast::max(float3(0.0), _1038 * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375))); float _1049 = (1.0 + _Globals.FilmBlackClip) - _Globals.FilmToe; float _1052 = 1.0 + _Globals.FilmWhiteClip; float _1055 = _1052 - _Globals.FilmShoulder; float _1082; if (_Globals.FilmToe > 0.800000011920928955078125) { _1082 = ((0.819999992847442626953125 - _Globals.FilmToe) / _Globals.FilmSlope) + (-0.744727432727813720703125); } else { float _1061 = (0.180000007152557373046875 + _Globals.FilmBlackClip) / _1049; _1082 = (-0.744727432727813720703125) - ((0.5 * log(_1061 / (2.0 - _1061))) * (_1049 / _Globals.FilmSlope)); } float _1087 = ((1.0 - _Globals.FilmToe) / _Globals.FilmSlope) - _1082; float _1089 = (_Globals.FilmShoulder / _Globals.FilmSlope) - _1087; float3 _1093 = log(mix(float3(dot(_1040, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1040, float3(0.959999978542327880859375))) * float3(0.4342944622039794921875); float3 _1097 = float3(_Globals.FilmSlope) * (_1093 + float3(_1087)); float3 _1105 = float3(_1082); float3 _1106 = _1093 - _1105; float3 _1118 = float3(_1089); float3 _1132 = fast::clamp(_1106 / float3(_1089 - _1082), float3(0.0), float3(1.0)); float3 _1136 = select(_1132, float3(1.0) - _1132, bool3(_1089 < _1082)); float3 _1141 = mix(select(_1097, float3(-_Globals.FilmBlackClip) + (float3(2.0 * _1049) / (float3(1.0) + exp(float3(((-2.0) * _Globals.FilmSlope) / _1049) * _1106))), _1093 < _1105), select(_1097, float3(_1052) - (float3(2.0 * _1055) / (float3(1.0) + exp(float3((2.0 * _Globals.FilmSlope) / _1055) * (_1093 - _1118)))), _1093 > _1118), ((float3(3.0) - (float3(2.0) * _1136)) * _1136) * _1136); float3 _1145 = fast::max(float3(0.0), mix(float3(dot(_1141, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1141, float3(0.930000007152557373046875))); float3 _1215; if (_Globals.ColorShadow_Tint2.w == 0.0) { float3 _1157 = _3265; _1157.x = dot(_932, _Globals.ColorMatrixR_ColorCurveCd1.xyz); float3 _1162 = _1157; _1162.y = dot(_932, _Globals.ColorMatrixG_ColorCurveCd3Cm3.xyz); float3 _1167 = _1162; _1167.z = dot(_932, _Globals.ColorMatrixB_ColorCurveCm2.xyz); float3 _1183 = fast::max(float3(0.0), _1167 * (_Globals.ColorShadow_Tint1.xyz + (_Globals.ColorShadow_Tint2.xyz * float3(1.0 / (dot(_932, _Globals.ColorShadow_Luma.xyz) + 1.0))))); float3 _1188 = fast::max(float3(0.0), _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.xxx - _1183); float3 _1190 = fast::max(_1183, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.zzz); _1215 = ((((_1190 * _Globals.ColorCurve_Ch1_Ch2.xxx) + _Globals.ColorCurve_Ch1_Ch2.yyy) * (float3(1.0) / (_1190 + _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.www))) + ((fast::clamp(_1183, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.xxx, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.zzz) * _Globals.ColorMatrixB_ColorCurveCm2.www) + (((_1188 * _Globals.ColorMatrixR_ColorCurveCd1.www) * (float3(1.0) / (_1188 + _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.yyy))) + _Globals.ColorMatrixG_ColorCurveCd3Cm3.www))) - float3(0.00200000009499490261077880859375); } else { _1215 = fast::max(float3(0.0), mix(_1145, _1145 * ((_577 * float3x3(float3(1.06317996978759765625, 0.02339559979736804962158203125, -0.08657260239124298095703125), float3(-0.010633699595928192138671875, 1.2063200473785400390625, -0.1956900060176849365234375), float3(-0.0005908869788981974124908447265625, 0.00105247995816171169281005859375, 0.999538004398345947265625))) * _576), _940) * _575); } float3 _1216 = fast::clamp(_1215, float3(0.0), float3(1.0)); float _1217 = _1216.x; float _1229; for (;;) { if (_1217 < 0.00313066993840038776397705078125) { _1229 = _1217 * 12.9200000762939453125; break; } _1229 = (pow(_1217, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _1230 = _1216.y; float _1242; for (;;) { if (_1230 < 0.00313066993840038776397705078125) { _1242 = _1230 * 12.9200000762939453125; break; } _1242 = (pow(_1230, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _1243 = _1216.z; float _1255; for (;;) { if (_1243 < 0.00313066993840038776397705078125) { _1255 = _1243 * 12.9200000762939453125; break; } _1255 = (pow(_1243, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float3 _1256 = float3(_1229, _1242, _1255); float3 _1258 = (_1256 * float3(0.9375)) + float3(0.03125); float _1270 = (_1258.z * 16.0) - 0.5; float _1271 = floor(_1270); float _1275 = (_1258.x + _1271) * 0.0625; float _1276 = _1258.y; float4 _1279 = Texture1.sample(Texture1Sampler, float2(_1275, _1276)); float4 _1283 = Texture1.sample(Texture1Sampler, float2(_1275 + 0.0625, _1276)); float3 _1289 = fast::max(float3(6.1035199905745685100555419921875e-05), (float3(_Globals.LUTWeights[0].x) * _1256) + (float3(_Globals.LUTWeights[1].x) * mix(_1279, _1283, float4(_1270 - _1271)).xyz)); float3 _1295 = select(_1289 * float3(0.077399380505084991455078125), pow((_1289 * float3(0.94786727428436279296875)) + float3(0.0521326996386051177978515625), float3(2.400000095367431640625)), _1289 > float3(0.040449999272823333740234375)); float3 _1324 = pow(fast::max(float3(0.0), mix((((float3(_Globals.MappingPolynomial.x) * (_1295 * _1295)) + (float3(_Globals.MappingPolynomial.y) * _1295)) + float3(_Globals.MappingPolynomial.z)) * _Globals.ColorScale, _Globals.OverlayColor.xyz, float3(_Globals.OverlayColor.w))), float3(_Globals.InverseGamma.y)); float3 _3103; if (_Globals.OutputDevice == 0u) { float _3063 = _1324.x; float _3075; for (;;) { if (_3063 < 0.00313066993840038776397705078125) { _3075 = _3063 * 12.9200000762939453125; break; } _3075 = (pow(_3063, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _3076 = _1324.y; float _3088; for (;;) { if (_3076 < 0.00313066993840038776397705078125) { _3088 = _3076 * 12.9200000762939453125; break; } _3088 = (pow(_3076, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _3089 = _1324.z; float _3101; for (;;) { if (_3089 < 0.00313066993840038776397705078125) { _3101 = _3089 * 12.9200000762939453125; break; } _3101 = (pow(_3089, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } _3103 = float3(_3075, _3088, _3101); } else { float3 _3062; if (_Globals.OutputDevice == 1u) { float3 _3055 = fast::max(float3(6.1035199905745685100555419921875e-05), (_1324 * _573) * _602); _3062 = fast::min(_3055 * float3(4.5), (pow(fast::max(_3055, float3(0.017999999225139617919921875)), float3(0.449999988079071044921875)) * float3(1.09899997711181640625)) - float3(0.098999999463558197021484375)); } else { float3 _3052; if ((_Globals.OutputDevice == 3u) || (_Globals.OutputDevice == 5u)) { float3 _2204 = (_932 * float3(1.5)) * (_572 * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625))); float _2205 = _2204.x; float _2206 = _2204.y; float _2208 = _2204.z; float _2211 = fast::max(fast::max(_2205, _2206), _2208); float _2216 = (fast::max(_2211, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_2205, _2206), _2208), 1.0000000133514319600180897396058e-10)) / fast::max(_2211, 0.00999999977648258209228515625); float _2229 = ((_2208 + _2206) + _2205) + (1.75 * sqrt(((_2208 * (_2208 - _2206)) + (_2206 * (_2206 - _2205))) + (_2205 * (_2205 - _2208)))); float _2230 = _2229 * 0.3333333432674407958984375; float _2231 = _2216 - 0.4000000059604644775390625; float _2236 = fast::max(1.0 - abs(_2231 * 2.5), 0.0); float _2244 = (1.0 + (float(int(sign(_2231 * 5.0))) * (1.0 - (_2236 * _2236)))) * 0.02500000037252902984619140625; float _2257; if (_2230 <= 0.053333334624767303466796875) { _2257 = _2244; } else { float _2256; if (_2230 >= 0.1599999964237213134765625) { _2256 = 0.0; } else { _2256 = _2244 * ((0.23999999463558197021484375 / _2229) - 0.5); } _2257 = _2256; } float3 _2260 = _2204 * float3(1.0 + _2257); float _2261 = _2260.x; float _2262 = _2260.y; float _2264 = _2260.z; float _2278; if ((_2261 == _2262) && (_2262 == _2264)) { _2278 = 0.0; } else { _2278 = 57.2957763671875 * atan2(1.73205077648162841796875 * (_2262 - _2264), ((2.0 * _2261) - _2262) - _2264); } float _2283; if (_2278 < 0.0) { _2283 = _2278 + 360.0; } else { _2283 = _2278; } float _2284 = fast::clamp(_2283, 0.0, 360.0); float _2289; if (_2284 > 180.0) { _2289 = _2284 - 360.0; } else { _2289 = _2284; } float _2339; if ((_2289 > (-67.5)) && (_2289 < 67.5)) { float _2296 = (_2289 - (-67.5)) * 0.0296296291053295135498046875; int _2297 = int(_2296); float _2299 = _2296 - float(_2297); float _2300 = _2299 * _2299; float _2301 = _2300 * _2299; float _2338; if (_2297 == 3) { _2338 = (((_2301 * (-0.16666667163372039794921875)) + (_2300 * 0.5)) + (_2299 * (-0.5))) + 0.16666667163372039794921875; } else { float _2331; if (_2297 == 2) { _2331 = ((_2301 * 0.5) + (_2300 * (-1.0))) + 0.666666686534881591796875; } else { float _2326; if (_2297 == 1) { _2326 = (((_2301 * (-0.5)) + (_2300 * 0.5)) + (_2299 * 0.5)) + 0.16666667163372039794921875; } else { float _2319; if (_2297 == 0) { _2319 = _2301 * 0.16666667163372039794921875; } else { _2319 = 0.0; } _2326 = _2319; } _2331 = _2326; } _2338 = _2331; } _2339 = _2338; } else { _2339 = 0.0; } float3 _2346 = _2260; _2346.x = _2261 + ((((_2339 * 1.5) * _2216) * (0.02999999932944774627685546875 - _2261)) * 0.180000007152557373046875); float3 _2349 = fast::clamp(fast::clamp(_2346, float3(0.0), float3(65535.0)) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)), float3(0.0), float3(65535.0)); float3 _2352 = mix(float3(dot(_2349, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _2349, float3(0.959999978542327880859375)); float _2353 = _2352.x; float _2362 = log((_2353 <= 0.0) ? 6.103515625e-05 : _2353) * 0.4342944622039794921875; float _2431; if (_2362 <= (-5.2601776123046875)) { _2431 = -4.0; } else { float _2428; if ((_2362 > (-5.2601776123046875)) && (_2362 < (-0.744727432727813720703125))) { float _2411 = (_2362 - (-5.2601776123046875)) * 0.6643855571746826171875; int _2412 = int(_2411); float _2414 = _2411 - float(_2412); _2428 = dot(float3(_2414 * _2414, _2414, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_2412], _499[_2412 + 1], _499[_2412 + 2])); } else { float _2407; if ((_2362 >= (-0.744727432727813720703125)) && (_2362 < 4.673812389373779296875)) { float _2390 = (_2362 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _2391 = int(_2390); float _2393 = _2390 - float(_2391); _2407 = dot(float3(_2393 * _2393, _2393, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_2391], _500[_2391 + 1], _500[_2391 + 2])); } else { _2407 = 4.0; } _2428 = _2407; } _2431 = _2428; } float3 _2433 = _523; _2433.x = pow(10.0, _2431); float _2434 = _2352.y; float _2438 = log((_2434 <= 0.0) ? 6.103515625e-05 : _2434) * 0.4342944622039794921875; float _2505; if (_2438 <= (-5.2601776123046875)) { _2505 = -4.0; } else { float _2502; if ((_2438 > (-5.2601776123046875)) && (_2438 < (-0.744727432727813720703125))) { float _2485 = (_2438 - (-5.2601776123046875)) * 0.6643855571746826171875; int _2486 = int(_2485); float _2488 = _2485 - float(_2486); _2502 = dot(float3(_2488 * _2488, _2488, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_2486], _499[_2486 + 1], _499[_2486 + 2])); } else { float _2481; if ((_2438 >= (-0.744727432727813720703125)) && (_2438 < 4.673812389373779296875)) { float _2464 = (_2438 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _2465 = int(_2464); float _2467 = _2464 - float(_2465); _2481 = dot(float3(_2467 * _2467, _2467, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_2465], _500[_2465 + 1], _500[_2465 + 2])); } else { _2481 = 4.0; } _2502 = _2481; } _2505 = _2502; } float3 _2507 = _2433; _2507.y = pow(10.0, _2505); float _2508 = _2352.z; float _2512 = log((_2508 <= 0.0) ? 6.103515625e-05 : _2508) * 0.4342944622039794921875; float _2579; if (_2512 <= (-5.2601776123046875)) { _2579 = -4.0; } else { float _2576; if ((_2512 > (-5.2601776123046875)) && (_2512 < (-0.744727432727813720703125))) { float _2559 = (_2512 - (-5.2601776123046875)) * 0.6643855571746826171875; int _2560 = int(_2559); float _2562 = _2559 - float(_2560); _2576 = dot(float3(_2562 * _2562, _2562, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_2560], _499[_2560 + 1], _499[_2560 + 2])); } else { float _2555; if ((_2512 >= (-0.744727432727813720703125)) && (_2512 < 4.673812389373779296875)) { float _2538 = (_2512 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _2539 = int(_2538); float _2541 = _2538 - float(_2539); _2555 = dot(float3(_2541 * _2541, _2541, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_2539], _500[_2539 + 1], _500[_2539 + 2])); } else { _2555 = 4.0; } _2576 = _2555; } _2579 = _2576; } float3 _2581 = _2507; _2581.z = pow(10.0, _2579); float3 _2583 = (_2581 * float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625))) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)); float _2714 = pow(10.0, (float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(-0.718548238277435302734375, 2.0810306072235107421875, 3.66812419891357421875)).z); float _2786 = pow(10.0, dot(float3(0.4444443881511688232421875, 0.66666662693023681640625, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(2.0810306072235107421875, 3.66812419891357421875, 4.0))); float _2787 = _2583.x; float _2790 = log((_2787 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2787); float _2791 = _2790 * 0.4342944622039794921875; float _2792 = log(pow(10.0, dot(float3(0.3600003719329833984375, 0.600000321865081787109375, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(-4.0, -4.0, -3.1573765277862548828125)))); float _2793 = _2792 * 0.4342944622039794921875; float _2870; if (_2791 <= _2793) { _2870 = (_2790 * 1.3028833866119384765625) + ((-4.0) - (_2792 * 1.3028833866119384765625)); } else { float _2800 = log(_2714) * 0.4342944622039794921875; float _2862; if ((_2791 > _2793) && (_2791 < _2800)) { float _2845 = (7.0 * (_2791 - _2793)) / (_2800 - _2793); int _2846 = int(_2845); float _2848 = _2845 - float(_2846); _2862 = dot(float3(_2848 * _2848, _2848, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_503[_2846], _503[_2846 + 1], _503[_2846 + 2])); } else { float _2807 = log(_2786); float _2808 = _2807 * 0.4342944622039794921875; float _2841; if ((_2791 >= _2800) && (_2791 < _2808)) { float _2824 = (7.0 * (_2791 - _2800)) / (_2808 - _2800); int _2825 = int(_2824); float _2827 = _2824 - float(_2825); _2841 = dot(float3(_2827 * _2827, _2827, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_504[_2825], _504[_2825 + 1], _504[_2825 + 2])); } else { _2841 = (_2790 * 0.026057668030261993408203125) + (3.0 - (_2807 * 0.026057668030261993408203125)); } _2862 = _2841; } _2870 = _2862; } float3 _2872 = _523; _2872.x = pow(10.0, _2870); float _2873 = _2583.y; float _2876 = log((_2873 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2873); float _2877 = _2876 * 0.4342944622039794921875; float _2954; if (_2877 <= _2793) { _2954 = (_2876 * 1.3028833866119384765625) + ((-4.0) - (_2792 * 1.3028833866119384765625)); } else { float _2884 = log(_2714) * 0.4342944622039794921875; float _2946; if ((_2877 > _2793) && (_2877 < _2884)) { float _2929 = (7.0 * (_2877 - _2793)) / (_2884 - _2793); int _2930 = int(_2929); float _2932 = _2929 - float(_2930); _2946 = dot(float3(_2932 * _2932, _2932, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_503[_2930], _503[_2930 + 1], _503[_2930 + 2])); } else { float _2891 = log(_2786); float _2892 = _2891 * 0.4342944622039794921875; float _2925; if ((_2877 >= _2884) && (_2877 < _2892)) { float _2908 = (7.0 * (_2877 - _2884)) / (_2892 - _2884); int _2909 = int(_2908); float _2911 = _2908 - float(_2909); _2925 = dot(float3(_2911 * _2911, _2911, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_504[_2909], _504[_2909 + 1], _504[_2909 + 2])); } else { _2925 = (_2876 * 0.026057668030261993408203125) + (3.0 - (_2891 * 0.026057668030261993408203125)); } _2946 = _2925; } _2954 = _2946; } float3 _2956 = _2872; _2956.y = pow(10.0, _2954); float _2957 = _2583.z; float _2960 = log((_2957 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2957); float _2961 = _2960 * 0.4342944622039794921875; float _3038; if (_2961 <= _2793) { _3038 = (_2960 * 1.3028833866119384765625) + ((-4.0) - (_2792 * 1.3028833866119384765625)); } else { float _2968 = log(_2714) * 0.4342944622039794921875; float _3030; if ((_2961 > _2793) && (_2961 < _2968)) { float _3013 = (7.0 * (_2961 - _2793)) / (_2968 - _2793); int _3014 = int(_3013); float _3016 = _3013 - float(_3014); _3030 = dot(float3(_3016 * _3016, _3016, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_503[_3014], _503[_3014 + 1], _503[_3014 + 2])); } else { float _2975 = log(_2786); float _2976 = _2975 * 0.4342944622039794921875; float _3009; if ((_2961 >= _2968) && (_2961 < _2976)) { float _2992 = (7.0 * (_2961 - _2968)) / (_2976 - _2968); int _2993 = int(_2992); float _2995 = _2992 - float(_2993); _3009 = dot(float3(_2995 * _2995, _2995, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_504[_2993], _504[_2993 + 1], _504[_2993 + 2])); } else { _3009 = (_2960 * 0.026057668030261993408203125) + (3.0 - (_2975 * 0.026057668030261993408203125)); } _3030 = _3009; } _3038 = _3030; } float3 _3040 = _2956; _3040.z = pow(10.0, _3038); float3 _3044 = pow(((_3040 - float3(3.5073844628641381859779357910156e-05)) * _602) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _3052 = pow((float3(0.8359375) + (float3(18.8515625) * _3044)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _3044))), float3(78.84375)); } else { float3 _2201; if ((_Globals.OutputDevice == 4u) || (_Globals.OutputDevice == 6u)) { float3 _1369 = (_932 * float3(1.5)) * (_572 * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625))); float _1370 = _1369.x; float _1371 = _1369.y; float _1373 = _1369.z; float _1376 = fast::max(fast::max(_1370, _1371), _1373); float _1381 = (fast::max(_1376, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_1370, _1371), _1373), 1.0000000133514319600180897396058e-10)) / fast::max(_1376, 0.00999999977648258209228515625); float _1394 = ((_1373 + _1371) + _1370) + (1.75 * sqrt(((_1373 * (_1373 - _1371)) + (_1371 * (_1371 - _1370))) + (_1370 * (_1370 - _1373)))); float _1395 = _1394 * 0.3333333432674407958984375; float _1396 = _1381 - 0.4000000059604644775390625; float _1401 = fast::max(1.0 - abs(_1396 * 2.5), 0.0); float _1409 = (1.0 + (float(int(sign(_1396 * 5.0))) * (1.0 - (_1401 * _1401)))) * 0.02500000037252902984619140625; float _1422; if (_1395 <= 0.053333334624767303466796875) { _1422 = _1409; } else { float _1421; if (_1395 >= 0.1599999964237213134765625) { _1421 = 0.0; } else { _1421 = _1409 * ((0.23999999463558197021484375 / _1394) - 0.5); } _1422 = _1421; } float3 _1425 = _1369 * float3(1.0 + _1422); float _1426 = _1425.x; float _1427 = _1425.y; float _1429 = _1425.z; float _1443; if ((_1426 == _1427) && (_1427 == _1429)) { _1443 = 0.0; } else { _1443 = 57.2957763671875 * atan2(1.73205077648162841796875 * (_1427 - _1429), ((2.0 * _1426) - _1427) - _1429); } float _1448; if (_1443 < 0.0) { _1448 = _1443 + 360.0; } else { _1448 = _1443; } float _1449 = fast::clamp(_1448, 0.0, 360.0); float _1454; if (_1449 > 180.0) { _1454 = _1449 - 360.0; } else { _1454 = _1449; } float _1504; if ((_1454 > (-67.5)) && (_1454 < 67.5)) { float _1461 = (_1454 - (-67.5)) * 0.0296296291053295135498046875; int _1462 = int(_1461); float _1464 = _1461 - float(_1462); float _1465 = _1464 * _1464; float _1466 = _1465 * _1464; float _1503; if (_1462 == 3) { _1503 = (((_1466 * (-0.16666667163372039794921875)) + (_1465 * 0.5)) + (_1464 * (-0.5))) + 0.16666667163372039794921875; } else { float _1496; if (_1462 == 2) { _1496 = ((_1466 * 0.5) + (_1465 * (-1.0))) + 0.666666686534881591796875; } else { float _1491; if (_1462 == 1) { _1491 = (((_1466 * (-0.5)) + (_1465 * 0.5)) + (_1464 * 0.5)) + 0.16666667163372039794921875; } else { float _1484; if (_1462 == 0) { _1484 = _1466 * 0.16666667163372039794921875; } else { _1484 = 0.0; } _1491 = _1484; } _1496 = _1491; } _1503 = _1496; } _1504 = _1503; } else { _1504 = 0.0; } float3 _1511 = _1425; _1511.x = _1426 + ((((_1504 * 1.5) * _1381) * (0.02999999932944774627685546875 - _1426)) * 0.180000007152557373046875); float3 _1514 = fast::clamp(fast::clamp(_1511, float3(0.0), float3(65535.0)) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)), float3(0.0), float3(65535.0)); float3 _1517 = mix(float3(dot(_1514, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1514, float3(0.959999978542327880859375)); float _1518 = _1517.x; float _1527 = log((_1518 <= 0.0) ? 6.103515625e-05 : _1518) * 0.4342944622039794921875; float _1596; if (_1527 <= (-5.2601776123046875)) { _1596 = -4.0; } else { float _1593; if ((_1527 > (-5.2601776123046875)) && (_1527 < (-0.744727432727813720703125))) { float _1576 = (_1527 - (-5.2601776123046875)) * 0.6643855571746826171875; int _1577 = int(_1576); float _1579 = _1576 - float(_1577); _1593 = dot(float3(_1579 * _1579, _1579, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_1577], _499[_1577 + 1], _499[_1577 + 2])); } else { float _1572; if ((_1527 >= (-0.744727432727813720703125)) && (_1527 < 4.673812389373779296875)) { float _1555 = (_1527 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _1556 = int(_1555); float _1558 = _1555 - float(_1556); _1572 = dot(float3(_1558 * _1558, _1558, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_1556], _500[_1556 + 1], _500[_1556 + 2])); } else { _1572 = 4.0; } _1593 = _1572; } _1596 = _1593; } float3 _1598 = _523; _1598.x = pow(10.0, _1596); float _1599 = _1517.y; float _1603 = log((_1599 <= 0.0) ? 6.103515625e-05 : _1599) * 0.4342944622039794921875; float _1670; if (_1603 <= (-5.2601776123046875)) { _1670 = -4.0; } else { float _1667; if ((_1603 > (-5.2601776123046875)) && (_1603 < (-0.744727432727813720703125))) { float _1650 = (_1603 - (-5.2601776123046875)) * 0.6643855571746826171875; int _1651 = int(_1650); float _1653 = _1650 - float(_1651); _1667 = dot(float3(_1653 * _1653, _1653, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_1651], _499[_1651 + 1], _499[_1651 + 2])); } else { float _1646; if ((_1603 >= (-0.744727432727813720703125)) && (_1603 < 4.673812389373779296875)) { float _1629 = (_1603 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _1630 = int(_1629); float _1632 = _1629 - float(_1630); _1646 = dot(float3(_1632 * _1632, _1632, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_1630], _500[_1630 + 1], _500[_1630 + 2])); } else { _1646 = 4.0; } _1667 = _1646; } _1670 = _1667; } float3 _1672 = _1598; _1672.y = pow(10.0, _1670); float _1673 = _1517.z; float _1677 = log((_1673 <= 0.0) ? 6.103515625e-05 : _1673) * 0.4342944622039794921875; float _1744; if (_1677 <= (-5.2601776123046875)) { _1744 = -4.0; } else { float _1741; if ((_1677 > (-5.2601776123046875)) && (_1677 < (-0.744727432727813720703125))) { float _1724 = (_1677 - (-5.2601776123046875)) * 0.6643855571746826171875; int _1725 = int(_1724); float _1727 = _1724 - float(_1725); _1741 = dot(float3(_1727 * _1727, _1727, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_1725], _499[_1725 + 1], _499[_1725 + 2])); } else { float _1720; if ((_1677 >= (-0.744727432727813720703125)) && (_1677 < 4.673812389373779296875)) { float _1703 = (_1677 - (-0.744727432727813720703125)) * 0.55365467071533203125; int _1704 = int(_1703); float _1706 = _1703 - float(_1704); _1720 = dot(float3(_1706 * _1706, _1706, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_1704], _500[_1704 + 1], _500[_1704 + 2])); } else { _1720 = 4.0; } _1741 = _1720; } _1744 = _1741; } float3 _1746 = _1672; _1746.z = pow(10.0, _1744); float3 _1748 = (_1746 * float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625))) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)); float _1879 = pow(10.0, (float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(-0.718548238277435302734375, 2.0810306072235107421875, 3.66812419891357421875)).z); float _1951 = pow(10.0, dot(float3(0.69444429874420166015625, 0.8333332538604736328125, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(2.0810306072235107421875, 3.66812419891357421875, 4.0))); float _1952 = _1748.x; float _1955 = log((_1952 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _1952); float _1956 = _1955 * 0.4342944622039794921875; float _1958 = log(pow(10.0, dot(float3(0.3600003719329833984375, 0.600000321865081787109375, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(-4.0, -4.0, -3.1573765277862548828125)))) * 0.4342944622039794921875; float _2030; if (_1956 <= _1958) { _2030 = -2.3010299205780029296875; } else { float _1965 = log(_1879) * 0.4342944622039794921875; float _2027; if ((_1956 > _1958) && (_1956 < _1965)) { float _2010 = (7.0 * (_1956 - _1958)) / (_1965 - _1958); int _2011 = int(_2010); float _2013 = _2010 - float(_2011); _2027 = dot(float3(_2013 * _2013, _2013, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_506[_2011], _506[_2011 + 1], _506[_2011 + 2])); } else { float _1972 = log(_1951); float _1973 = _1972 * 0.4342944622039794921875; float _2006; if ((_1956 >= _1965) && (_1956 < _1973)) { float _1989 = (7.0 * (_1956 - _1965)) / (_1973 - _1965); int _1990 = int(_1989); float _1992 = _1989 - float(_1990); _2006 = dot(float3(_1992 * _1992, _1992, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_507[_1990], _507[_1990 + 1], _507[_1990 + 2])); } else { _2006 = (_1955 * 0.05211533606052398681640625) + (3.3010299205780029296875 - (_1972 * 0.05211533606052398681640625)); } _2027 = _2006; } _2030 = _2027; } float3 _2032 = _523; _2032.x = pow(10.0, _2030); float _2033 = _1748.y; float _2036 = log((_2033 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2033); float _2037 = _2036 * 0.4342944622039794921875; float _2109; if (_2037 <= _1958) { _2109 = -2.3010299205780029296875; } else { float _2044 = log(_1879) * 0.4342944622039794921875; float _2106; if ((_2037 > _1958) && (_2037 < _2044)) { float _2089 = (7.0 * (_2037 - _1958)) / (_2044 - _1958); int _2090 = int(_2089); float _2092 = _2089 - float(_2090); _2106 = dot(float3(_2092 * _2092, _2092, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_506[_2090], _506[_2090 + 1], _506[_2090 + 2])); } else { float _2051 = log(_1951); float _2052 = _2051 * 0.4342944622039794921875; float _2085; if ((_2037 >= _2044) && (_2037 < _2052)) { float _2068 = (7.0 * (_2037 - _2044)) / (_2052 - _2044); int _2069 = int(_2068); float _2071 = _2068 - float(_2069); _2085 = dot(float3(_2071 * _2071, _2071, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_507[_2069], _507[_2069 + 1], _507[_2069 + 2])); } else { _2085 = (_2036 * 0.05211533606052398681640625) + (3.3010299205780029296875 - (_2051 * 0.05211533606052398681640625)); } _2106 = _2085; } _2109 = _2106; } float3 _2111 = _2032; _2111.y = pow(10.0, _2109); float _2112 = _1748.z; float _2115 = log((_2112 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2112); float _2116 = _2115 * 0.4342944622039794921875; float _2188; if (_2116 <= _1958) { _2188 = -2.3010299205780029296875; } else { float _2123 = log(_1879) * 0.4342944622039794921875; float _2185; if ((_2116 > _1958) && (_2116 < _2123)) { float _2168 = (7.0 * (_2116 - _1958)) / (_2123 - _1958); int _2169 = int(_2168); float _2171 = _2168 - float(_2169); _2185 = dot(float3(_2171 * _2171, _2171, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_506[_2169], _506[_2169 + 1], _506[_2169 + 2])); } else { float _2130 = log(_1951); float _2131 = _2130 * 0.4342944622039794921875; float _2164; if ((_2116 >= _2123) && (_2116 < _2131)) { float _2147 = (7.0 * (_2116 - _2123)) / (_2131 - _2123); int _2148 = int(_2147); float _2150 = _2147 - float(_2148); _2164 = dot(float3(_2150 * _2150, _2150, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_507[_2148], _507[_2148 + 1], _507[_2148 + 2])); } else { _2164 = (_2115 * 0.05211533606052398681640625) + (3.3010299205780029296875 - (_2130 * 0.05211533606052398681640625)); } _2185 = _2164; } _2188 = _2185; } float3 _2190 = _2111; _2190.z = pow(10.0, _2188); float3 _2193 = pow((_2190 * _602) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _2201 = pow((float3(0.8359375) + (float3(18.8515625) * _2193)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _2193))), float3(78.84375)); } else { float3 _1366; if (_Globals.OutputDevice == 7u) { float3 _1358 = pow(((_932 * _573) * _602) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _1366 = pow((float3(0.8359375) + (float3(18.8515625) * _1358)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _1358))), float3(78.84375)); } else { _1366 = pow((_1324 * _573) * _602, float3(_Globals.InverseGamma.z)); } _2201 = _1366; } _3052 = _2201; } _3062 = _3052; } _3103 = _3062; } float3 _3104 = _3103 * float3(0.95238101482391357421875); float4 _3106 = float4(_3104.x, _3104.y, _3104.z, float4(0.0).w); _3106.w = 0.0; out.out_var_SV_Target0 = _3106; return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag/sample-mask-not-array.asm.frag000066400000000000000000000602421400026215700305250ustar00rootroot00000000000000#include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; struct type_TranslucentBasePass { uint TranslucentBasePass_Shared_Forward_NumLocalLights; uint TranslucentBasePass_Shared_Forward_NumReflectionCaptures; uint TranslucentBasePass_Shared_Forward_HasDirectionalLight; uint TranslucentBasePass_Shared_Forward_NumGridCells; packed_int3 TranslucentBasePass_Shared_Forward_CulledGridSize; uint TranslucentBasePass_Shared_Forward_MaxCulledLightsPerCell; uint TranslucentBasePass_Shared_Forward_LightGridPixelSizeShift; uint PrePadding_TranslucentBasePass_Shared_Forward_36; uint PrePadding_TranslucentBasePass_Shared_Forward_40; uint PrePadding_TranslucentBasePass_Shared_Forward_44; packed_float3 TranslucentBasePass_Shared_Forward_LightGridZParams; float PrePadding_TranslucentBasePass_Shared_Forward_60; packed_float3 TranslucentBasePass_Shared_Forward_DirectionalLightDirection; float PrePadding_TranslucentBasePass_Shared_Forward_76; packed_float3 TranslucentBasePass_Shared_Forward_DirectionalLightColor; float TranslucentBasePass_Shared_Forward_DirectionalLightVolumetricScatteringIntensity; uint TranslucentBasePass_Shared_Forward_DirectionalLightShadowMapChannelMask; uint PrePadding_TranslucentBasePass_Shared_Forward_100; float2 TranslucentBasePass_Shared_Forward_DirectionalLightDistanceFadeMAD; uint TranslucentBasePass_Shared_Forward_NumDirectionalLightCascades; uint PrePadding_TranslucentBasePass_Shared_Forward_116; uint PrePadding_TranslucentBasePass_Shared_Forward_120; uint PrePadding_TranslucentBasePass_Shared_Forward_124; float4 TranslucentBasePass_Shared_Forward_CascadeEndDepths; float4x4 TranslucentBasePass_Shared_Forward_DirectionalLightWorldToShadowMatrix[4]; float4 TranslucentBasePass_Shared_Forward_DirectionalLightShadowmapMinMax[4]; float4 TranslucentBasePass_Shared_Forward_DirectionalLightShadowmapAtlasBufferSize; float TranslucentBasePass_Shared_Forward_DirectionalLightDepthBias; uint TranslucentBasePass_Shared_Forward_DirectionalLightUseStaticShadowing; uint PrePadding_TranslucentBasePass_Shared_Forward_488; uint PrePadding_TranslucentBasePass_Shared_Forward_492; float4 TranslucentBasePass_Shared_Forward_DirectionalLightStaticShadowBufferSize; float4x4 TranslucentBasePass_Shared_Forward_DirectionalLightWorldToStaticShadow; float PrePadding_TranslucentBasePass_Shared_ForwardISR_576; float PrePadding_TranslucentBasePass_Shared_ForwardISR_580; float PrePadding_TranslucentBasePass_Shared_ForwardISR_584; float PrePadding_TranslucentBasePass_Shared_ForwardISR_588; float PrePadding_TranslucentBasePass_Shared_ForwardISR_592; float PrePadding_TranslucentBasePass_Shared_ForwardISR_596; float PrePadding_TranslucentBasePass_Shared_ForwardISR_600; float PrePadding_TranslucentBasePass_Shared_ForwardISR_604; float PrePadding_TranslucentBasePass_Shared_ForwardISR_608; float PrePadding_TranslucentBasePass_Shared_ForwardISR_612; float PrePadding_TranslucentBasePass_Shared_ForwardISR_616; float PrePadding_TranslucentBasePass_Shared_ForwardISR_620; float PrePadding_TranslucentBasePass_Shared_ForwardISR_624; float PrePadding_TranslucentBasePass_Shared_ForwardISR_628; float PrePadding_TranslucentBasePass_Shared_ForwardISR_632; float PrePadding_TranslucentBasePass_Shared_ForwardISR_636; uint TranslucentBasePass_Shared_ForwardISR_NumLocalLights; uint TranslucentBasePass_Shared_ForwardISR_NumReflectionCaptures; uint TranslucentBasePass_Shared_ForwardISR_HasDirectionalLight; uint TranslucentBasePass_Shared_ForwardISR_NumGridCells; packed_int3 TranslucentBasePass_Shared_ForwardISR_CulledGridSize; uint TranslucentBasePass_Shared_ForwardISR_MaxCulledLightsPerCell; uint TranslucentBasePass_Shared_ForwardISR_LightGridPixelSizeShift; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_676; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_680; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_684; packed_float3 TranslucentBasePass_Shared_ForwardISR_LightGridZParams; float PrePadding_TranslucentBasePass_Shared_ForwardISR_700; packed_float3 TranslucentBasePass_Shared_ForwardISR_DirectionalLightDirection; float PrePadding_TranslucentBasePass_Shared_ForwardISR_716; packed_float3 TranslucentBasePass_Shared_ForwardISR_DirectionalLightColor; float TranslucentBasePass_Shared_ForwardISR_DirectionalLightVolumetricScatteringIntensity; uint TranslucentBasePass_Shared_ForwardISR_DirectionalLightShadowMapChannelMask; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_740; float2 TranslucentBasePass_Shared_ForwardISR_DirectionalLightDistanceFadeMAD; uint TranslucentBasePass_Shared_ForwardISR_NumDirectionalLightCascades; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_756; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_760; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_764; float4 TranslucentBasePass_Shared_ForwardISR_CascadeEndDepths; float4x4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightWorldToShadowMatrix[4]; float4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightShadowmapMinMax[4]; float4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightShadowmapAtlasBufferSize; float TranslucentBasePass_Shared_ForwardISR_DirectionalLightDepthBias; uint TranslucentBasePass_Shared_ForwardISR_DirectionalLightUseStaticShadowing; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_1128; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_1132; float4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightStaticShadowBufferSize; float4x4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightWorldToStaticShadow; float PrePadding_TranslucentBasePass_Shared_Reflection_1216; float PrePadding_TranslucentBasePass_Shared_Reflection_1220; float PrePadding_TranslucentBasePass_Shared_Reflection_1224; float PrePadding_TranslucentBasePass_Shared_Reflection_1228; float PrePadding_TranslucentBasePass_Shared_Reflection_1232; float PrePadding_TranslucentBasePass_Shared_Reflection_1236; float PrePadding_TranslucentBasePass_Shared_Reflection_1240; float PrePadding_TranslucentBasePass_Shared_Reflection_1244; float PrePadding_TranslucentBasePass_Shared_Reflection_1248; float PrePadding_TranslucentBasePass_Shared_Reflection_1252; float PrePadding_TranslucentBasePass_Shared_Reflection_1256; float PrePadding_TranslucentBasePass_Shared_Reflection_1260; float PrePadding_TranslucentBasePass_Shared_Reflection_1264; float PrePadding_TranslucentBasePass_Shared_Reflection_1268; float PrePadding_TranslucentBasePass_Shared_Reflection_1272; float PrePadding_TranslucentBasePass_Shared_Reflection_1276; float4 TranslucentBasePass_Shared_Reflection_SkyLightParameters; float TranslucentBasePass_Shared_Reflection_SkyLightCubemapBrightness; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1300; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1304; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1308; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1312; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1316; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1320; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1324; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1328; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1332; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1336; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1340; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1344; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1348; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1352; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1356; float4 TranslucentBasePass_Shared_PlanarReflection_ReflectionPlane; float4 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionOrigin; float4 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionXAxis; float4 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionYAxis; float3x4 TranslucentBasePass_Shared_PlanarReflection_InverseTransposeMirrorMatrix; packed_float3 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionParameters; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1484; float2 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionParameters2; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1496; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1500; float4x4 TranslucentBasePass_Shared_PlanarReflection_ProjectionWithExtraFOV[2]; float4 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionScreenScaleBias[2]; float2 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionScreenBound; uint TranslucentBasePass_Shared_PlanarReflection_bIsStereo; float PrePadding_TranslucentBasePass_Shared_Fog_1676; float PrePadding_TranslucentBasePass_Shared_Fog_1680; float PrePadding_TranslucentBasePass_Shared_Fog_1684; float PrePadding_TranslucentBasePass_Shared_Fog_1688; float PrePadding_TranslucentBasePass_Shared_Fog_1692; float4 TranslucentBasePass_Shared_Fog_ExponentialFogParameters; float4 TranslucentBasePass_Shared_Fog_ExponentialFogParameters2; float4 TranslucentBasePass_Shared_Fog_ExponentialFogColorParameter; float4 TranslucentBasePass_Shared_Fog_ExponentialFogParameters3; float4 TranslucentBasePass_Shared_Fog_InscatteringLightDirection; float4 TranslucentBasePass_Shared_Fog_DirectionalInscatteringColor; float2 TranslucentBasePass_Shared_Fog_SinCosInscatteringColorCubemapRotation; float PrePadding_TranslucentBasePass_Shared_Fog_1800; float PrePadding_TranslucentBasePass_Shared_Fog_1804; packed_float3 TranslucentBasePass_Shared_Fog_FogInscatteringTextureParameters; float TranslucentBasePass_Shared_Fog_ApplyVolumetricFog; float PrePadding_TranslucentBasePass_1824; float PrePadding_TranslucentBasePass_1828; float PrePadding_TranslucentBasePass_1832; float PrePadding_TranslucentBasePass_1836; float PrePadding_TranslucentBasePass_1840; float PrePadding_TranslucentBasePass_1844; float PrePadding_TranslucentBasePass_1848; float PrePadding_TranslucentBasePass_1852; float PrePadding_TranslucentBasePass_1856; float PrePadding_TranslucentBasePass_1860; float PrePadding_TranslucentBasePass_1864; float PrePadding_TranslucentBasePass_1868; float PrePadding_TranslucentBasePass_1872; float PrePadding_TranslucentBasePass_1876; float PrePadding_TranslucentBasePass_1880; float PrePadding_TranslucentBasePass_1884; float PrePadding_TranslucentBasePass_1888; float PrePadding_TranslucentBasePass_1892; float PrePadding_TranslucentBasePass_1896; float PrePadding_TranslucentBasePass_1900; float PrePadding_TranslucentBasePass_1904; float PrePadding_TranslucentBasePass_1908; float PrePadding_TranslucentBasePass_1912; float PrePadding_TranslucentBasePass_1916; float PrePadding_TranslucentBasePass_1920; float PrePadding_TranslucentBasePass_1924; float PrePadding_TranslucentBasePass_1928; float PrePadding_TranslucentBasePass_1932; float PrePadding_TranslucentBasePass_1936; float PrePadding_TranslucentBasePass_1940; float PrePadding_TranslucentBasePass_1944; float PrePadding_TranslucentBasePass_1948; float PrePadding_TranslucentBasePass_1952; float PrePadding_TranslucentBasePass_1956; float PrePadding_TranslucentBasePass_1960; float PrePadding_TranslucentBasePass_1964; float PrePadding_TranslucentBasePass_1968; float PrePadding_TranslucentBasePass_1972; float PrePadding_TranslucentBasePass_1976; float PrePadding_TranslucentBasePass_1980; float PrePadding_TranslucentBasePass_1984; float PrePadding_TranslucentBasePass_1988; float PrePadding_TranslucentBasePass_1992; float PrePadding_TranslucentBasePass_1996; float PrePadding_TranslucentBasePass_2000; float PrePadding_TranslucentBasePass_2004; float PrePadding_TranslucentBasePass_2008; float PrePadding_TranslucentBasePass_2012; float PrePadding_TranslucentBasePass_2016; float PrePadding_TranslucentBasePass_2020; float PrePadding_TranslucentBasePass_2024; float PrePadding_TranslucentBasePass_2028; float PrePadding_TranslucentBasePass_2032; float PrePadding_TranslucentBasePass_2036; float PrePadding_TranslucentBasePass_2040; float PrePadding_TranslucentBasePass_2044; float PrePadding_TranslucentBasePass_2048; float PrePadding_TranslucentBasePass_2052; float PrePadding_TranslucentBasePass_2056; float PrePadding_TranslucentBasePass_2060; float PrePadding_TranslucentBasePass_2064; float PrePadding_TranslucentBasePass_2068; float PrePadding_TranslucentBasePass_2072; float PrePadding_TranslucentBasePass_2076; float PrePadding_TranslucentBasePass_2080; float PrePadding_TranslucentBasePass_2084; float PrePadding_TranslucentBasePass_2088; float PrePadding_TranslucentBasePass_2092; float PrePadding_TranslucentBasePass_2096; float PrePadding_TranslucentBasePass_2100; float PrePadding_TranslucentBasePass_2104; float PrePadding_TranslucentBasePass_2108; float PrePadding_TranslucentBasePass_2112; float PrePadding_TranslucentBasePass_2116; float PrePadding_TranslucentBasePass_2120; float PrePadding_TranslucentBasePass_2124; float PrePadding_TranslucentBasePass_2128; float PrePadding_TranslucentBasePass_2132; float PrePadding_TranslucentBasePass_2136; float PrePadding_TranslucentBasePass_2140; float4 TranslucentBasePass_HZBUvFactorAndInvFactor; float4 TranslucentBasePass_PrevScreenPositionScaleBias; float TranslucentBasePass_PrevSceneColorPreExposureInv; }; struct type_Material { float4 Material_VectorExpressions[2]; float4 Material_ScalarExpressions[1]; }; constant float _108 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[user(locn0)]]; float4 in_var_TEXCOORD11_centroid [[user(locn1)]]; uint in_var_PRIMITIVE_ID [[user(locn2)]]; float4 in_var_TEXCOORD7 [[user(locn3)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], const device type_StructuredBuffer_v4float& View_PrimitiveSceneData [[buffer(1)]], constant type_TranslucentBasePass& TranslucentBasePass [[buffer(2)]], constant type_Material& Material [[buffer(3)]], texture3d TranslucentBasePass_Shared_Fog_IntegratedLightScattering [[texture(0)]], sampler View_SharedBilinearClampedSampler [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleMaskIn [[sample_mask]]) { main0_out out = {}; float4 _137 = View.View_SVPositionToTranslatedWorld * float4(gl_FragCoord.xyz, 1.0); float3 _142 = (_137.xyz / float3(_137.w)) - float3(View.View_PreViewTranslation); bool _165 = TranslucentBasePass.TranslucentBasePass_Shared_Fog_ApplyVolumetricFog > 0.0; float4 _215; if (_165) { float4 _172 = View.View_WorldToClip * float4(_142, 1.0); float _173 = _172.w; float4 _202; if (_165) { _202 = TranslucentBasePass_Shared_Fog_IntegratedLightScattering.sample(View_SharedBilinearClampedSampler, float3(((_172.xy / float2(_173)).xy * float2(0.5, -0.5)) + float2(0.5), (log2((_173 * View.View_VolumetricFogGridZParams[0]) + View.View_VolumetricFogGridZParams[1]) * View.View_VolumetricFogGridZParams[2]) * View.View_VolumetricFogInvGridSize[2]), level(0.0)); } else { _202 = float4(0.0, 0.0, 0.0, 1.0); } _215 = float4(_202.xyz + (in.in_var_TEXCOORD7.xyz * float3(_202.w)), _202.w * in.in_var_TEXCOORD7.w); } else { _215 = in.in_var_TEXCOORD7; } float3 _216 = fast::max(Material.Material_VectorExpressions[1].xyz * float3(((1.0 + dot(float3(-0.2857142984867095947265625, -0.4285714328289031982421875, 0.857142865657806396484375), normalize(float3x3(in.in_var_TEXCOORD10_centroid.xyz, cross(in.in_var_TEXCOORD11_centroid.xyz, in.in_var_TEXCOORD10_centroid.xyz) * float3(in.in_var_TEXCOORD11_centroid.w), in.in_var_TEXCOORD11_centroid.xyz) * normalize((float3(0.0, 0.0, 1.0) * float3(View.View_NormalOverrideParameter.w)) + View.View_NormalOverrideParameter.xyz)))) * 0.5) + 0.20000000298023223876953125), float3(0.0)); float3 _246; if (View.View_OutOfBoundsMask > 0.0) { uint _222 = in.in_var_PRIMITIVE_ID * 26u; float3 _245; if (any(abs(_142 - View_PrimitiveSceneData._m0[_222 + 5u].xyz) > (View_PrimitiveSceneData._m0[_222 + 19u].xyz + float3(1.0)))) { _245 = mix(float3(1.0, 1.0, 0.0), float3(0.0, 1.0, 1.0), select(float3(0.0), float3(1.0), float3(fract(dot(_142, float3(0.57700002193450927734375)) * 0.00200000009499490261077880859375)) > float3(0.5))); } else { _245 = _216; } _246 = _245; } else { _246 = _216; } float4 _256 = float4((_246 * float3(_215.w)) + _215.xyz, _108); _256.w = 1.0; float4 _268; uint _269; if (View.View_NumSceneColorMSAASamples > 1) { _268 = _256 * float4(float(View.View_NumSceneColorMSAASamples) * 0.25); _269 = gl_SampleMaskIn & 15u; } else { _268 = _256; _269 = gl_SampleMaskIn; } out.out_var_SV_Target0 = _268; out.gl_SampleMask = _269; return out; } subpass-input.ios.framebuffer-fetch.asm.frag000066400000000000000000000207101400026215700332760ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag#include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Globals { float3 SoftTransitionScale; float4 ShadowBufferSize; float ShadowFadeFraction; float ShadowSharpen; float4 LightPositionAndInvRadius; float4x4 ScreenToShadowMatrix; float2 ProjectionDepthBiasParameters; float4 ModulatedShadowColor; float4 ShadowTileOffsetAndSize; }; constant float4 _58 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; fragment main0_out main0(constant type_View& View [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], float4 _RESERVED_IDENTIFIER_FIXUP_gl_LastFragData [[color(0)]], texture2d ShadowDepthTexture [[texture(0)]], sampler ShadowDepthTextureSampler [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float4 _67 = _RESERVED_IDENTIFIER_FIXUP_gl_LastFragData; float _68 = _67.w; float4 _82 = _Globals.ScreenToShadowMatrix * float4((((gl_FragCoord.xy * View.View_BufferSizeAndInvSize.zw) - View.View_ScreenPositionScaleBias.wz) / View.View_ScreenPositionScaleBias.xy) * float2(_68), _68, 1.0); float _118 = fast::clamp(((fast::clamp((ShadowDepthTexture.sample(ShadowDepthTextureSampler, (((_82.xyz / float3(_82.w)).xy * _Globals.ShadowTileOffsetAndSize.zw).xy + _Globals.ShadowTileOffsetAndSize.xy).xy, level(0.0)).xxx * float3(_Globals.SoftTransitionScale.z)) - float3((fast::min(_82.z, 0.999989986419677734375) * _Globals.SoftTransitionScale.z) - 1.0), float3(0.0), float3(1.0)).x - 0.5) * _Globals.ShadowSharpen) + 0.5, 0.0, 1.0); float3 _127 = mix(_Globals.ModulatedShadowColor.xyz, float3(1.0), float3(mix(1.0, _118 * _118, _Globals.ShadowFadeFraction))); float4 _129 = float4(_127.x, _127.y, _127.z, _58.w); _129.w = 0.0; out.out_var_SV_Target0 = _129; return out; } subpass-input.msl23.framebuffer-fetch.asm.frag000066400000000000000000000207101400026215700334440ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag#include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Globals { float3 SoftTransitionScale; float4 ShadowBufferSize; float ShadowFadeFraction; float ShadowSharpen; float4 LightPositionAndInvRadius; float4x4 ScreenToShadowMatrix; float2 ProjectionDepthBiasParameters; float4 ModulatedShadowColor; float4 ShadowTileOffsetAndSize; }; constant float4 _58 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; fragment main0_out main0(constant type_View& View [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], float4 _RESERVED_IDENTIFIER_FIXUP_gl_LastFragData [[color(0)]], texture2d ShadowDepthTexture [[texture(0)]], sampler ShadowDepthTextureSampler [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float4 _67 = _RESERVED_IDENTIFIER_FIXUP_gl_LastFragData; float _68 = _67.w; float4 _82 = _Globals.ScreenToShadowMatrix * float4((((gl_FragCoord.xy * View.View_BufferSizeAndInvSize.zw) - View.View_ScreenPositionScaleBias.wz) / View.View_ScreenPositionScaleBias.xy) * float2(_68), _68, 1.0); float _118 = fast::clamp(((fast::clamp((ShadowDepthTexture.sample(ShadowDepthTextureSampler, (((_82.xyz / float3(_82.w)).xy * _Globals.ShadowTileOffsetAndSize.zw).xy + _Globals.ShadowTileOffsetAndSize.xy).xy, level(0.0)).xxx * float3(_Globals.SoftTransitionScale.z)) - float3((fast::min(_82.z, 0.999989986419677734375) * _Globals.SoftTransitionScale.z) - 1.0), float3(0.0), float3(1.0)).x - 0.5) * _Globals.ShadowSharpen) + 0.5, 0.0, 1.0); float3 _127 = mix(_Globals.ModulatedShadowColor.xyz, float3(1.0), float3(mix(1.0, _118 * _118, _Globals.ShadowFadeFraction))); float4 _129 = float4(_127.x, _127.y, _127.z, _58.w); _129.w = 0.0; out.out_var_SV_Target0 = _129; return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag/texture-atomics.asm.argument.msl2.frag000066400000000000000000000116351400026215700322350ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; struct spvDescriptorSetBuffer0 { const device type_StructuredBuffer_v4float* CulledObjectBoxBounds [[id(0)]]; constant type_Globals* _Globals [[id(1)]]; texture2d RWShadowTileNumCulledObjects [[id(2)]]; device atomic_uint* RWShadowTileNumCulledObjects_atomic [[id(3)]]; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float(((*spvDescriptorSet0._Globals).ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2((*spvDescriptorSet0._Globals).ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _107 = _103 + 1u; if (all((*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_107].xy > _96.xy) && all((*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103].xyz < _102)) { float3 _121 = float3(0.5) * ((*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103].xyz + (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_107].xyz); float _122 = _96.x; float _123 = _96.y; float _126 = _100.x; float _129 = _100.y; float3 _166 = float3(_122, _123, -1000.0) - _121; float3 _170 = float3(dot(_166, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 2u].xyz), dot(_166, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 3u].xyz), dot(_166, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 4u].xyz)); float3 _189 = float3(_126, _123, -1000.0) - _121; float3 _193 = float3(dot(_189, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 2u].xyz), dot(_189, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 3u].xyz), dot(_189, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 4u].xyz)); float3 _205 = float3(_122, _129, -1000.0) - _121; float3 _209 = float3(dot(_205, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 2u].xyz), dot(_205, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 3u].xyz), dot(_205, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 4u].xyz)); float3 _221 = float3(_126, _129, -1000.0) - _121; float3 _225 = float3(dot(_221, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 2u].xyz), dot(_221, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 3u].xyz), dot(_221, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 4u].xyz)); float3 _237 = float3(_122, _123, 1.0) - _121; float3 _241 = float3(dot(_237, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 2u].xyz), dot(_237, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 3u].xyz), dot(_237, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 4u].xyz)); float3 _253 = float3(_126, _123, 1.0) - _121; float3 _257 = float3(dot(_253, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 2u].xyz), dot(_253, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 3u].xyz), dot(_253, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 4u].xyz)); float3 _269 = float3(_122, _129, 1.0) - _121; float3 _273 = float3(dot(_269, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 2u].xyz), dot(_269, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 3u].xyz), dot(_269, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 4u].xyz)); float3 _285 = float3(_126, _129, 1.0) - _121; float3 _289 = float3(dot(_285, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 2u].xyz), dot(_285, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 3u].xyz), dot(_285, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 4u].xyz)); if (all(fast::min(fast::min(fast::min(fast::min(fast::min(fast::min(fast::min(fast::min(float3(500000.0), _170), _193), _209), _225), _241), _257), _273), _289) < float3(1.0)) && all(fast::max(fast::max(fast::max(fast::max(fast::max(fast::max(fast::max(fast::max(float3(-500000.0), _170), _193), _209), _225), _241), _257), _273), _289) > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&spvDescriptorSet0.RWShadowTileNumCulledObjects_atomic[(_78 * (*spvDescriptorSet0._Globals).ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag/texture-atomics.asm.frag000066400000000000000000000102311400026215700275270ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device type_StructuredBuffer_v4float& CulledObjectBoxBounds [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d RWShadowTileNumCulledObjects [[texture(0)]], device atomic_uint* RWShadowTileNumCulledObjects_atomic [[buffer(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float((_Globals.ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2(_Globals.ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _107 = _103 + 1u; if (all(CulledObjectBoxBounds._m0[_107].xy > _96.xy) && all(CulledObjectBoxBounds._m0[_103].xyz < _102)) { float3 _121 = float3(0.5) * (CulledObjectBoxBounds._m0[_103].xyz + CulledObjectBoxBounds._m0[_107].xyz); float _122 = _96.x; float _123 = _96.y; float _126 = _100.x; float _129 = _100.y; float3 _166 = float3(_122, _123, -1000.0) - _121; float3 _170 = float3(dot(_166, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); float3 _189 = float3(_126, _123, -1000.0) - _121; float3 _193 = float3(dot(_189, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_189, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_189, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); float3 _205 = float3(_122, _129, -1000.0) - _121; float3 _209 = float3(dot(_205, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_205, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_205, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); float3 _221 = float3(_126, _129, -1000.0) - _121; float3 _225 = float3(dot(_221, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_221, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_221, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); float3 _237 = float3(_122, _123, 1.0) - _121; float3 _241 = float3(dot(_237, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_237, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_237, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); float3 _253 = float3(_126, _123, 1.0) - _121; float3 _257 = float3(dot(_253, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_253, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_253, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); float3 _269 = float3(_122, _129, 1.0) - _121; float3 _273 = float3(dot(_269, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_269, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_269, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); float3 _285 = float3(_126, _129, 1.0) - _121; float3 _289 = float3(dot(_285, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_285, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_285, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); if (all(fast::min(fast::min(fast::min(fast::min(fast::min(fast::min(fast::min(fast::min(float3(500000.0), _170), _193), _209), _225), _241), _257), _273), _289) < float3(1.0)) && all(fast::max(fast::max(fast::max(fast::max(fast::max(fast::max(fast::max(fast::max(float3(-500000.0), _170), _193), _209), _225), _241), _257), _273), _289) > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&RWShadowTileNumCulledObjects_atomic[(_78 * _Globals.ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } texture-atomics.asm.graphics-robust-access.frag000066400000000000000000000157741400026215700340430ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/frag#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvBufferSizeConstants [[buffer(25)]], const device type_StructuredBuffer_v4float& CulledObjectBoxBounds [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d RWShadowTileNumCulledObjects [[texture(0)]], device atomic_uint* RWShadowTileNumCulledObjects_atomic [[buffer(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; constant uint& CulledObjectBoxBoundsBufferSize = spvBufferSizeConstants[0]; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float((_Globals.ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2(_Globals.ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _310 = uint(clamp(int(_103 + 1u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u)))); if (all(CulledObjectBoxBounds._m0[_310].xy > _96.xy) && all(CulledObjectBoxBounds._m0[uint(clamp(int(_103), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz < _102)) { float3 _121 = float3(0.5) * (CulledObjectBoxBounds._m0[uint(clamp(int(_103), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz + CulledObjectBoxBounds._m0[_310].xyz); float _122 = _96.x; float _123 = _96.y; float _126 = _100.x; float _129 = _100.y; float3 _166 = float3(_122, _123, -1000.0) - _121; float3 _170 = float3(dot(_166, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 2u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_166, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 3u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_166, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 4u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz)); float3 _189 = float3(_126, _123, -1000.0) - _121; float3 _193 = float3(dot(_189, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 2u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_189, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 3u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_189, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 4u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz)); float3 _205 = float3(_122, _129, -1000.0) - _121; float3 _209 = float3(dot(_205, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 2u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_205, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 3u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_205, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 4u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz)); float3 _221 = float3(_126, _129, -1000.0) - _121; float3 _225 = float3(dot(_221, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 2u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_221, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 3u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_221, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 4u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz)); float3 _237 = float3(_122, _123, 1.0) - _121; float3 _241 = float3(dot(_237, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 2u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_237, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 3u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_237, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 4u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz)); float3 _253 = float3(_126, _123, 1.0) - _121; float3 _257 = float3(dot(_253, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 2u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_253, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 3u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_253, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 4u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz)); float3 _269 = float3(_122, _129, 1.0) - _121; float3 _273 = float3(dot(_269, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 2u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_269, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 3u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_269, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 4u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz)); float3 _285 = float3(_126, _129, 1.0) - _121; float3 _289 = float3(dot(_285, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 2u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_285, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 3u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz), dot(_285, CulledObjectBoxBounds._m0[uint(clamp(int(_103 + 4u), int(0u), int(min((((CulledObjectBoxBoundsBufferSize - 0) / 16) - 1u), 2147483647u))))].xyz)); if (all(fast::min(fast::min(fast::min(fast::min(fast::min(fast::min(fast::min(fast::min(float3(500000.0), _170), _193), _209), _225), _241), _257), _273), _289) < float3(1.0)) && all(fast::max(fast::max(fast::max(fast::max(fast::max(fast::max(fast::max(fast::max(float3(-500000.0), _170), _193), _209), _225), _241), _257), _273), _289) > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&RWShadowTileNumCulledObjects_atomic[(_78 * _Globals.ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tesc/000077500000000000000000000000001400026215700227745ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tesc/hs-incorrect-base-type.asm.tesc000066400000000000000000000611051400026215700307250ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct FVertexFactoryInterpolantsVSToPS { float4 TangentToWorld0; float4 TangentToWorld2; float4 Color; spvUnsafeArray TexCoords; float4 LightMapCoordinate; uint PrimitiveId; uint LightmapDataIndex; }; struct FVertexFactoryInterpolantsVSToDS { FVertexFactoryInterpolantsVSToPS InterpolantsVSToPS; }; struct FSharedBasePassInterpolants { }; struct FBasePassInterpolantsVSToDS { FSharedBasePassInterpolants _m0; }; struct FBasePassVSToDS { FVertexFactoryInterpolantsVSToDS FactoryInterpolants; FBasePassInterpolantsVSToDS BasePassInterpolants; float4 Position; }; struct FPNTessellationHSToDS { FBasePassVSToDS PassSpecificData; spvUnsafeArray WorldPosition; float3 DisplacementScale; float TessellationMultiplier; float WorldDisplacementMultiplier; }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; constant float4 _602 = {}; struct main0_out { float4 out_var_COLOR0; uint out_var_LIGHTMAP_ID; float3 out_var_PN_DisplacementScales; spvUnsafeArray out_var_PN_POSITION; float out_var_PN_TessellationMultiplier; float out_var_PN_WorldDisplacementMultiplier; uint out_var_PRIMITIVE_ID; spvUnsafeArray out_var_TEXCOORD0; float4 out_var_TEXCOORD10_centroid; float4 out_var_TEXCOORD11_centroid; float4 out_var_TEXCOORD4; float4 out_var_VS_To_DS_Position; }; struct main0_patchOut { float4 out_var_PN_POSITION9; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[attribute(0)]]; float4 in_var_TEXCOORD11_centroid [[attribute(1)]]; float4 in_var_COLOR0 [[attribute(2)]]; float4 in_var_TEXCOORD0_0 [[attribute(3)]]; float4 in_var_TEXCOORD4 [[attribute(4)]]; uint in_var_PRIMITIVE_ID [[attribute(5)]]; uint in_var_LIGHTMAP_ID [[attribute(6)]]; float4 in_var_VS_To_DS_Position [[attribute(7)]]; }; kernel void main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], const device type_StructuredBuffer_v4float& View_PrimitiveSceneData [[buffer(1)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { threadgroup FPNTessellationHSToDS temp_var_hullMainRetVal[3]; device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 3) return; spvUnsafeArray _144 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD10_centroid, gl_in[1].in_var_TEXCOORD10_centroid, gl_in[2].in_var_TEXCOORD10_centroid, gl_in[3].in_var_TEXCOORD10_centroid, gl_in[4].in_var_TEXCOORD10_centroid, gl_in[5].in_var_TEXCOORD10_centroid, gl_in[6].in_var_TEXCOORD10_centroid, gl_in[7].in_var_TEXCOORD10_centroid, gl_in[8].in_var_TEXCOORD10_centroid, gl_in[9].in_var_TEXCOORD10_centroid, gl_in[10].in_var_TEXCOORD10_centroid, gl_in[11].in_var_TEXCOORD10_centroid }); spvUnsafeArray _145 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD11_centroid, gl_in[1].in_var_TEXCOORD11_centroid, gl_in[2].in_var_TEXCOORD11_centroid, gl_in[3].in_var_TEXCOORD11_centroid, gl_in[4].in_var_TEXCOORD11_centroid, gl_in[5].in_var_TEXCOORD11_centroid, gl_in[6].in_var_TEXCOORD11_centroid, gl_in[7].in_var_TEXCOORD11_centroid, gl_in[8].in_var_TEXCOORD11_centroid, gl_in[9].in_var_TEXCOORD11_centroid, gl_in[10].in_var_TEXCOORD11_centroid, gl_in[11].in_var_TEXCOORD11_centroid }); spvUnsafeArray _146 = spvUnsafeArray({ gl_in[0].in_var_COLOR0, gl_in[1].in_var_COLOR0, gl_in[2].in_var_COLOR0, gl_in[3].in_var_COLOR0, gl_in[4].in_var_COLOR0, gl_in[5].in_var_COLOR0, gl_in[6].in_var_COLOR0, gl_in[7].in_var_COLOR0, gl_in[8].in_var_COLOR0, gl_in[9].in_var_COLOR0, gl_in[10].in_var_COLOR0, gl_in[11].in_var_COLOR0 }); spvUnsafeArray, 12> _147 = spvUnsafeArray, 12>({ spvUnsafeArray({ gl_in[0].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[1].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[2].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[3].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[4].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[5].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[6].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[7].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[8].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[9].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[10].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[11].in_var_TEXCOORD0_0 }) }); spvUnsafeArray _148 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD4, gl_in[1].in_var_TEXCOORD4, gl_in[2].in_var_TEXCOORD4, gl_in[3].in_var_TEXCOORD4, gl_in[4].in_var_TEXCOORD4, gl_in[5].in_var_TEXCOORD4, gl_in[6].in_var_TEXCOORD4, gl_in[7].in_var_TEXCOORD4, gl_in[8].in_var_TEXCOORD4, gl_in[9].in_var_TEXCOORD4, gl_in[10].in_var_TEXCOORD4, gl_in[11].in_var_TEXCOORD4 }); spvUnsafeArray _149 = spvUnsafeArray({ gl_in[0].in_var_PRIMITIVE_ID, gl_in[1].in_var_PRIMITIVE_ID, gl_in[2].in_var_PRIMITIVE_ID, gl_in[3].in_var_PRIMITIVE_ID, gl_in[4].in_var_PRIMITIVE_ID, gl_in[5].in_var_PRIMITIVE_ID, gl_in[6].in_var_PRIMITIVE_ID, gl_in[7].in_var_PRIMITIVE_ID, gl_in[8].in_var_PRIMITIVE_ID, gl_in[9].in_var_PRIMITIVE_ID, gl_in[10].in_var_PRIMITIVE_ID, gl_in[11].in_var_PRIMITIVE_ID }); spvUnsafeArray _150 = spvUnsafeArray({ gl_in[0].in_var_LIGHTMAP_ID, gl_in[1].in_var_LIGHTMAP_ID, gl_in[2].in_var_LIGHTMAP_ID, gl_in[3].in_var_LIGHTMAP_ID, gl_in[4].in_var_LIGHTMAP_ID, gl_in[5].in_var_LIGHTMAP_ID, gl_in[6].in_var_LIGHTMAP_ID, gl_in[7].in_var_LIGHTMAP_ID, gl_in[8].in_var_LIGHTMAP_ID, gl_in[9].in_var_LIGHTMAP_ID, gl_in[10].in_var_LIGHTMAP_ID, gl_in[11].in_var_LIGHTMAP_ID }); spvUnsafeArray _259 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_Position, gl_in[1].in_var_VS_To_DS_Position, gl_in[2].in_var_VS_To_DS_Position, gl_in[3].in_var_VS_To_DS_Position, gl_in[4].in_var_VS_To_DS_Position, gl_in[5].in_var_VS_To_DS_Position, gl_in[6].in_var_VS_To_DS_Position, gl_in[7].in_var_VS_To_DS_Position, gl_in[8].in_var_VS_To_DS_Position, gl_in[9].in_var_VS_To_DS_Position, gl_in[10].in_var_VS_To_DS_Position, gl_in[11].in_var_VS_To_DS_Position }); spvUnsafeArray _284 = spvUnsafeArray({ FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[0], _145[0], _146[0], _147[0], _148[0], _149[0], _150[0] } }, FBasePassInterpolantsVSToDS{ { } }, _259[0] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[1], _145[1], _146[1], _147[1], _148[1], _149[1], _150[1] } }, FBasePassInterpolantsVSToDS{ { } }, _259[1] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[2], _145[2], _146[2], _147[2], _148[2], _149[2], _150[2] } }, FBasePassInterpolantsVSToDS{ { } }, _259[2] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[3], _145[3], _146[3], _147[3], _148[3], _149[3], _150[3] } }, FBasePassInterpolantsVSToDS{ { } }, _259[3] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[4], _145[4], _146[4], _147[4], _148[4], _149[4], _150[4] } }, FBasePassInterpolantsVSToDS{ { } }, _259[4] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[5], _145[5], _146[5], _147[5], _148[5], _149[5], _150[5] } }, FBasePassInterpolantsVSToDS{ { } }, _259[5] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[6], _145[6], _146[6], _147[6], _148[6], _149[6], _150[6] } }, FBasePassInterpolantsVSToDS{ { } }, _259[6] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[7], _145[7], _146[7], _147[7], _148[7], _149[7], _150[7] } }, FBasePassInterpolantsVSToDS{ { } }, _259[7] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[8], _145[8], _146[8], _147[8], _148[8], _149[8], _150[8] } }, FBasePassInterpolantsVSToDS{ { } }, _259[8] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[9], _145[9], _146[9], _147[9], _148[9], _149[9], _150[9] } }, FBasePassInterpolantsVSToDS{ { } }, _259[9] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[10], _145[10], _146[10], _147[10], _148[10], _149[10], _150[10] } }, FBasePassInterpolantsVSToDS{ { } }, _259[10] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[11], _145[11], _146[11], _147[11], _148[11], _149[11], _150[11] } }, FBasePassInterpolantsVSToDS{ { } }, _259[11] } }); spvUnsafeArray param_var_I; param_var_I = _284; float4 _301 = float4(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float3 _310 = View_PrimitiveSceneData._m0[(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.PrimitiveId * 26u) + 22u].xyz * float3x3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz, cross(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz) * float3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.w), param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz); uint _313 = (gl_InvocationID < 2u) ? (gl_InvocationID + 1u) : 0u; uint _314 = 2u * gl_InvocationID; uint _315 = 3u + _314; uint _316 = _314 + 4u; float4 _328 = float4(param_var_I[_313].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _336 = float4(param_var_I[_315].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _344 = float4(param_var_I[_316].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); spvUnsafeArray _392 = spvUnsafeArray({ param_var_I[gl_InvocationID].Position, ((((float4(2.0) * param_var_I[gl_InvocationID].Position) + param_var_I[_313].Position) - (float4(dot(param_var_I[_313].Position - param_var_I[gl_InvocationID].Position, _301)) * _301)) + (((float4(2.0) * param_var_I[_315].Position) + param_var_I[_316].Position) - (float4(dot(param_var_I[_316].Position - param_var_I[_315].Position, _336)) * _336))) * float4(0.16666667163372039794921875), ((((float4(2.0) * param_var_I[_313].Position) + param_var_I[gl_InvocationID].Position) - (float4(dot(param_var_I[gl_InvocationID].Position - param_var_I[_313].Position, _328)) * _328)) + (((float4(2.0) * param_var_I[_316].Position) + param_var_I[_315].Position) - (float4(dot(param_var_I[_315].Position - param_var_I[_316].Position, _344)) * _344))) * float4(0.16666667163372039794921875) }); gl_out[gl_InvocationID].out_var_TEXCOORD10_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; gl_out[gl_InvocationID].out_var_TEXCOORD11_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; gl_out[gl_InvocationID].out_var_COLOR0 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.Color; gl_out[gl_InvocationID].out_var_TEXCOORD0 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TexCoords; gl_out[gl_InvocationID].out_var_TEXCOORD4 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.LightMapCoordinate; gl_out[gl_InvocationID].out_var_PRIMITIVE_ID = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.PrimitiveId; gl_out[gl_InvocationID].out_var_LIGHTMAP_ID = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.LightmapDataIndex; gl_out[gl_InvocationID].out_var_VS_To_DS_Position = param_var_I[gl_InvocationID].Position; gl_out[gl_InvocationID].out_var_PN_POSITION = _392; gl_out[gl_InvocationID].out_var_PN_DisplacementScales = _310; gl_out[gl_InvocationID].out_var_PN_TessellationMultiplier = 1.0; gl_out[gl_InvocationID].out_var_PN_WorldDisplacementMultiplier = 1.0; temp_var_hullMainRetVal[gl_InvocationID] = FPNTessellationHSToDS{ param_var_I[gl_InvocationID], _392, _310, 1.0, 1.0 }; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0u) { float4 _450 = (((((temp_var_hullMainRetVal[0u].WorldPosition[1] + temp_var_hullMainRetVal[0u].WorldPosition[2]) + temp_var_hullMainRetVal[1u].WorldPosition[1]) + temp_var_hullMainRetVal[1u].WorldPosition[2]) + temp_var_hullMainRetVal[2u].WorldPosition[1]) + temp_var_hullMainRetVal[2u].WorldPosition[2]) * float4(0.16666667163372039794921875); float4 _463 = _602; _463.x = 0.5 * (temp_var_hullMainRetVal[1u].TessellationMultiplier + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _469 = _463; _469.y = 0.5 * (temp_var_hullMainRetVal[2u].TessellationMultiplier + temp_var_hullMainRetVal[0u].TessellationMultiplier); float4 _474 = _469; _474.z = 0.5 * (temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier); float4 _481 = _474; _481.w = 0.333000004291534423828125 * ((temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier) + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _589; for (;;) { float4 _489 = View.View_ViewToClip * float4(0.0); float4 _494 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[0u].WorldPosition[0].xyz, 1.0); float3 _495 = _494.xyz; float3 _496 = _489.xyz; float _498 = _494.w; float _499 = _489.w; float4 _516 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[1u].WorldPosition[0].xyz, 1.0); float3 _517 = _516.xyz; float _519 = _516.w; float4 _537 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[2u].WorldPosition[0].xyz, 1.0); float3 _538 = _537.xyz; float _540 = _537.w; if (any((((select(int3(0), int3(1), (_495 - _496) < float3(_498 + _499)) + (int3(2) * select(int3(0), int3(1), (_495 + _496) > float3((-_498) - _499)))) | (select(int3(0), int3(1), (_517 - _496) < float3(_519 + _499)) + (int3(2) * select(int3(0), int3(1), (_517 + _496) > float3((-_519) - _499))))) | (select(int3(0), int3(1), (_538 - _496) < float3(_540 + _499)) + (int3(2) * select(int3(0), int3(1), (_538 + _496) > float3((-_540) - _499))))) != int3(3))) { _589 = float4(0.0); break; } float3 _558 = temp_var_hullMainRetVal[0u].WorldPosition[0].xyz - temp_var_hullMainRetVal[1u].WorldPosition[0].xyz; float3 _559 = temp_var_hullMainRetVal[1u].WorldPosition[0].xyz - temp_var_hullMainRetVal[2u].WorldPosition[0].xyz; float3 _560 = temp_var_hullMainRetVal[2u].WorldPosition[0].xyz - temp_var_hullMainRetVal[0u].WorldPosition[0].xyz; float3 _563 = (float3(0.5) * (temp_var_hullMainRetVal[0u].WorldPosition[0].xyz + temp_var_hullMainRetVal[1u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _566 = (float3(0.5) * (temp_var_hullMainRetVal[1u].WorldPosition[0].xyz + temp_var_hullMainRetVal[2u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _569 = (float3(0.5) * (temp_var_hullMainRetVal[2u].WorldPosition[0].xyz + temp_var_hullMainRetVal[0u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float _573 = sqrt(dot(_559, _559) / dot(_566, _566)); float _577 = sqrt(dot(_560, _560) / dot(_569, _569)); float _581 = sqrt(dot(_558, _558) / dot(_563, _563)); float4 _586 = float4(_573, _577, _581, 1.0); _586.w = 0.333000004291534423828125 * ((_573 + _577) + _581); _589 = float4(View.View_AdaptiveTessellationFactor) * _586; break; } float4 _591 = fast::clamp(_481 * _589, float4(1.0), float4(15.0)); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0u] = half(_591.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1u] = half(_591.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2u] = half(_591.z); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_591.w); patchOut.out_var_PN_POSITION9 = _450 + ((_450 - (((temp_var_hullMainRetVal[2u].WorldPosition[0] + temp_var_hullMainRetVal[1u].WorldPosition[0]) + temp_var_hullMainRetVal[0u].WorldPosition[0]) * float4(0.3333333432674407958984375))) * float4(0.5)); } } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tesc/hs-input-array-access.asm.tesc000066400000000000000000000616551400026215700305720ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct FVertexFactoryInterpolantsVSToPS { float4 TangentToWorld0; float4 TangentToWorld2; }; struct FVertexFactoryInterpolantsVSToDS { FVertexFactoryInterpolantsVSToPS InterpolantsVSToPS; }; struct FHitProxyVSToDS { FVertexFactoryInterpolantsVSToDS FactoryInterpolants; float4 Position; uint VertexID; }; struct FHullShaderConstantDominantVertexData { float2 UV; float4 Normal; float3 Tangent; }; struct FHullShaderConstantDominantEdgeData { float2 UV0; float2 UV1; float4 Normal0; float4 Normal1; float3 Tangent0; float3 Tangent1; }; struct FPNTessellationHSToDS { FHitProxyVSToDS PassSpecificData; spvUnsafeArray WorldPosition; float3 DisplacementScale; float TessellationMultiplier; float WorldDisplacementMultiplier; FHullShaderConstantDominantVertexData DominantVertex; FHullShaderConstantDominantEdgeData DominantEdge; }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_DrawsVelocity; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; uint Primitive_LightingChannelMask; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightmapDataIndex; packed_float3 Primitive_PreSkinnedLocalBounds; int Primitive_SingleCaptureIndex; uint Primitive_OutputVelocity; uint PrePadding_Primitive_420; uint PrePadding_Primitive_424; uint PrePadding_Primitive_428; float4 Primitive_CustomPrimitiveData[4]; }; constant float4 _613 = {}; struct main0_out { float3 out_var_PN_DisplacementScales; float2 out_var_PN_DominantEdge; float2 out_var_PN_DominantEdge1; float4 out_var_PN_DominantEdge2; float4 out_var_PN_DominantEdge3; float3 out_var_PN_DominantEdge4; float3 out_var_PN_DominantEdge5; float2 out_var_PN_DominantVertex; float4 out_var_PN_DominantVertex1; float3 out_var_PN_DominantVertex2; spvUnsafeArray out_var_PN_POSITION; float out_var_PN_TessellationMultiplier; float out_var_PN_WorldDisplacementMultiplier; float4 out_var_TEXCOORD10_centroid; float4 out_var_TEXCOORD11_centroid; float4 out_var_VS_To_DS_Position; uint out_var_VS_To_DS_VertexID; }; struct main0_patchOut { float4 out_var_PN_POSITION9; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[attribute(0)]]; float4 in_var_TEXCOORD11_centroid [[attribute(1)]]; float4 in_var_VS_To_DS_Position [[attribute(2)]]; uint in_var_VS_To_DS_VertexID [[attribute(3)]]; }; kernel void main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_Primitive& Primitive [[buffer(1)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { threadgroup FPNTessellationHSToDS temp_var_hullMainRetVal[3]; device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 3) return; spvUnsafeArray _142 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD10_centroid, gl_in[1].in_var_TEXCOORD10_centroid, gl_in[2].in_var_TEXCOORD10_centroid, gl_in[3].in_var_TEXCOORD10_centroid, gl_in[4].in_var_TEXCOORD10_centroid, gl_in[5].in_var_TEXCOORD10_centroid, gl_in[6].in_var_TEXCOORD10_centroid, gl_in[7].in_var_TEXCOORD10_centroid, gl_in[8].in_var_TEXCOORD10_centroid, gl_in[9].in_var_TEXCOORD10_centroid, gl_in[10].in_var_TEXCOORD10_centroid, gl_in[11].in_var_TEXCOORD10_centroid }); spvUnsafeArray _143 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD11_centroid, gl_in[1].in_var_TEXCOORD11_centroid, gl_in[2].in_var_TEXCOORD11_centroid, gl_in[3].in_var_TEXCOORD11_centroid, gl_in[4].in_var_TEXCOORD11_centroid, gl_in[5].in_var_TEXCOORD11_centroid, gl_in[6].in_var_TEXCOORD11_centroid, gl_in[7].in_var_TEXCOORD11_centroid, gl_in[8].in_var_TEXCOORD11_centroid, gl_in[9].in_var_TEXCOORD11_centroid, gl_in[10].in_var_TEXCOORD11_centroid, gl_in[11].in_var_TEXCOORD11_centroid }); spvUnsafeArray _192 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_Position, gl_in[1].in_var_VS_To_DS_Position, gl_in[2].in_var_VS_To_DS_Position, gl_in[3].in_var_VS_To_DS_Position, gl_in[4].in_var_VS_To_DS_Position, gl_in[5].in_var_VS_To_DS_Position, gl_in[6].in_var_VS_To_DS_Position, gl_in[7].in_var_VS_To_DS_Position, gl_in[8].in_var_VS_To_DS_Position, gl_in[9].in_var_VS_To_DS_Position, gl_in[10].in_var_VS_To_DS_Position, gl_in[11].in_var_VS_To_DS_Position }); spvUnsafeArray _193 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_VertexID, gl_in[1].in_var_VS_To_DS_VertexID, gl_in[2].in_var_VS_To_DS_VertexID, gl_in[3].in_var_VS_To_DS_VertexID, gl_in[4].in_var_VS_To_DS_VertexID, gl_in[5].in_var_VS_To_DS_VertexID, gl_in[6].in_var_VS_To_DS_VertexID, gl_in[7].in_var_VS_To_DS_VertexID, gl_in[8].in_var_VS_To_DS_VertexID, gl_in[9].in_var_VS_To_DS_VertexID, gl_in[10].in_var_VS_To_DS_VertexID, gl_in[11].in_var_VS_To_DS_VertexID }); spvUnsafeArray _230 = spvUnsafeArray({ FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[0], _143[0] } }, _192[0], _193[0] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[1], _143[1] } }, _192[1], _193[1] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[2], _143[2] } }, _192[2], _193[2] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[3], _143[3] } }, _192[3], _193[3] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[4], _143[4] } }, _192[4], _193[4] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[5], _143[5] } }, _192[5], _193[5] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[6], _143[6] } }, _192[6], _193[6] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[7], _143[7] } }, _192[7], _193[7] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[8], _143[8] } }, _192[8], _193[8] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[9], _143[9] } }, _192[9], _193[9] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[10], _143[10] } }, _192[10], _193[10] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[11], _143[11] } }, _192[11], _193[11] } }); spvUnsafeArray param_var_I; param_var_I = _230; float4 _247 = float4(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float3 _251 = Primitive.Primitive_NonUniformScale.xyz * float3x3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz, cross(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz) * float3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.w), param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz); uint _254 = (gl_InvocationID < 2u) ? (gl_InvocationID + 1u) : 0u; uint _255 = 2u * gl_InvocationID; uint _256 = 3u + _255; uint _257 = _255 + 4u; uint _264 = (_254 < 2u) ? (_254 + 1u) : 0u; uint _265 = 2u * _254; uint _266 = 3u + _265; uint _267 = _265 + 4u; float4 _279 = float4(param_var_I[9u + gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _315; float4 _316; float4 _317; float4 _318; if ((param_var_I[_266].VertexID < param_var_I[_254].VertexID) || ((param_var_I[_266].VertexID == param_var_I[_254].VertexID) && (param_var_I[_267].VertexID < param_var_I[_264].VertexID))) { _315 = param_var_I[_267].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; _316 = param_var_I[_267].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; _317 = param_var_I[_266].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; _318 = param_var_I[_266].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; } else { _315 = param_var_I[_264].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; _316 = param_var_I[_264].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; _317 = param_var_I[_254].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; _318 = param_var_I[_254].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; } float4 _324 = float4(_318.xyz, 0.0); float4 _328 = float4(_316.xyz, 0.0); float4 _336 = float4(param_var_I[_254].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _344 = float4(param_var_I[_256].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _352 = float4(param_var_I[_257].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); spvUnsafeArray _402 = spvUnsafeArray({ param_var_I[gl_InvocationID].Position, ((((float4(2.0) * param_var_I[gl_InvocationID].Position) + param_var_I[_254].Position) - (float4(dot(param_var_I[_254].Position - param_var_I[gl_InvocationID].Position, _247)) * _247)) + (((float4(2.0) * param_var_I[_256].Position) + param_var_I[_257].Position) - (float4(dot(param_var_I[_257].Position - param_var_I[_256].Position, _344)) * _344))) * float4(0.16666667163372039794921875), ((((float4(2.0) * param_var_I[_254].Position) + param_var_I[gl_InvocationID].Position) - (float4(dot(param_var_I[gl_InvocationID].Position - param_var_I[_254].Position, _336)) * _336)) + (((float4(2.0) * param_var_I[_257].Position) + param_var_I[_256].Position) - (float4(dot(param_var_I[_256].Position - param_var_I[_257].Position, _352)) * _352))) * float4(0.16666667163372039794921875) }); gl_out[gl_InvocationID].out_var_TEXCOORD10_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; gl_out[gl_InvocationID].out_var_TEXCOORD11_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; gl_out[gl_InvocationID].out_var_VS_To_DS_Position = param_var_I[gl_InvocationID].Position; gl_out[gl_InvocationID].out_var_VS_To_DS_VertexID = param_var_I[gl_InvocationID].VertexID; gl_out[gl_InvocationID].out_var_PN_POSITION = _402; gl_out[gl_InvocationID].out_var_PN_DisplacementScales = _251; gl_out[gl_InvocationID].out_var_PN_TessellationMultiplier = 1.0; gl_out[gl_InvocationID].out_var_PN_WorldDisplacementMultiplier = 1.0; gl_out[gl_InvocationID].out_var_PN_DominantVertex = float2(0.0); gl_out[gl_InvocationID].out_var_PN_DominantVertex1 = _279; gl_out[gl_InvocationID].out_var_PN_DominantVertex2 = param_var_I[9u + gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz; gl_out[gl_InvocationID].out_var_PN_DominantEdge = float2(0.0); gl_out[gl_InvocationID].out_var_PN_DominantEdge1 = float2(0.0); gl_out[gl_InvocationID].out_var_PN_DominantEdge2 = _324; gl_out[gl_InvocationID].out_var_PN_DominantEdge3 = _328; gl_out[gl_InvocationID].out_var_PN_DominantEdge4 = _317.xyz; gl_out[gl_InvocationID].out_var_PN_DominantEdge5 = _315.xyz; temp_var_hullMainRetVal[gl_InvocationID] = FPNTessellationHSToDS{ param_var_I[gl_InvocationID], _402, _251, 1.0, 1.0, FHullShaderConstantDominantVertexData{ float2(0.0), _279, param_var_I[9u + gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz }, FHullShaderConstantDominantEdgeData{ float2(0.0), float2(0.0), _324, _328, _317.xyz, _315.xyz } }; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0u) { float4 _461 = (((((temp_var_hullMainRetVal[0u].WorldPosition[1] + temp_var_hullMainRetVal[0u].WorldPosition[2]) + temp_var_hullMainRetVal[1u].WorldPosition[1]) + temp_var_hullMainRetVal[1u].WorldPosition[2]) + temp_var_hullMainRetVal[2u].WorldPosition[1]) + temp_var_hullMainRetVal[2u].WorldPosition[2]) * float4(0.16666667163372039794921875); float4 _474 = _613; _474.x = 0.5 * (temp_var_hullMainRetVal[1u].TessellationMultiplier + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _480 = _474; _480.y = 0.5 * (temp_var_hullMainRetVal[2u].TessellationMultiplier + temp_var_hullMainRetVal[0u].TessellationMultiplier); float4 _485 = _480; _485.z = 0.5 * (temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier); float4 _492 = _485; _492.w = 0.333000004291534423828125 * ((temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier) + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _600; for (;;) { float4 _500 = View.View_ViewToClip * float4(0.0); float4 _505 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[0u].WorldPosition[0].xyz, 1.0); float3 _506 = _505.xyz; float3 _507 = _500.xyz; float _509 = _505.w; float _510 = _500.w; float4 _527 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[1u].WorldPosition[0].xyz, 1.0); float3 _528 = _527.xyz; float _530 = _527.w; float4 _548 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[2u].WorldPosition[0].xyz, 1.0); float3 _549 = _548.xyz; float _551 = _548.w; if (any((((select(int3(0), int3(1), (_506 - _507) < float3(_509 + _510)) + (int3(2) * select(int3(0), int3(1), (_506 + _507) > float3((-_509) - _510)))) | (select(int3(0), int3(1), (_528 - _507) < float3(_530 + _510)) + (int3(2) * select(int3(0), int3(1), (_528 + _507) > float3((-_530) - _510))))) | (select(int3(0), int3(1), (_549 - _507) < float3(_551 + _510)) + (int3(2) * select(int3(0), int3(1), (_549 + _507) > float3((-_551) - _510))))) != int3(3))) { _600 = float4(0.0); break; } float3 _569 = temp_var_hullMainRetVal[0u].WorldPosition[0].xyz - temp_var_hullMainRetVal[1u].WorldPosition[0].xyz; float3 _570 = temp_var_hullMainRetVal[1u].WorldPosition[0].xyz - temp_var_hullMainRetVal[2u].WorldPosition[0].xyz; float3 _571 = temp_var_hullMainRetVal[2u].WorldPosition[0].xyz - temp_var_hullMainRetVal[0u].WorldPosition[0].xyz; float3 _574 = (float3(0.5) * (temp_var_hullMainRetVal[0u].WorldPosition[0].xyz + temp_var_hullMainRetVal[1u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _577 = (float3(0.5) * (temp_var_hullMainRetVal[1u].WorldPosition[0].xyz + temp_var_hullMainRetVal[2u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _580 = (float3(0.5) * (temp_var_hullMainRetVal[2u].WorldPosition[0].xyz + temp_var_hullMainRetVal[0u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float _584 = sqrt(dot(_570, _570) / dot(_577, _577)); float _588 = sqrt(dot(_571, _571) / dot(_580, _580)); float _592 = sqrt(dot(_569, _569) / dot(_574, _574)); float4 _597 = float4(_584, _588, _592, 1.0); _597.w = 0.333000004291534423828125 * ((_584 + _588) + _592); _600 = float4(View.View_AdaptiveTessellationFactor) * _597; break; } float4 _602 = fast::clamp(_492 * _600, float4(1.0), float4(15.0)); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0u] = half(_602.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1u] = half(_602.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2u] = half(_602.z); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_602.w); patchOut.out_var_PN_POSITION9 = _461 + ((_461 - (((temp_var_hullMainRetVal[2u].WorldPosition[0] + temp_var_hullMainRetVal[1u].WorldPosition[0]) + temp_var_hullMainRetVal[0u].WorldPosition[0]) * float4(0.3333333432674407958984375))) * float4(0.5)); } } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tesc/hs-texcoord-array.asm.tesc000066400000000000000000000567231400026215700300230ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct FVertexFactoryInterpolantsVSToPS { float4 TangentToWorld0; float4 TangentToWorld2; float4 Color; spvUnsafeArray TexCoords; }; struct FVertexFactoryInterpolantsVSToDS { FVertexFactoryInterpolantsVSToPS InterpolantsVSToPS; }; struct FHitProxyVSToDS { FVertexFactoryInterpolantsVSToDS FactoryInterpolants; float4 Position; }; struct FPNTessellationHSToDS { FHitProxyVSToDS PassSpecificData; spvUnsafeArray WorldPosition; float3 DisplacementScale; float TessellationMultiplier; float WorldDisplacementMultiplier; }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_DrawsVelocity; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; uint Primitive_LightingChannelMask; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightmapDataIndex; packed_float3 Primitive_PreSkinnedLocalBounds; int Primitive_SingleCaptureIndex; uint Primitive_OutputVelocity; uint PrePadding_Primitive_420; uint PrePadding_Primitive_424; uint PrePadding_Primitive_428; float4 Primitive_CustomPrimitiveData[4]; }; constant float4 _537 = {}; struct main0_out { float4 out_var_COLOR0; float3 out_var_PN_DisplacementScales; spvUnsafeArray out_var_PN_POSITION; float out_var_PN_TessellationMultiplier; float out_var_PN_WorldDisplacementMultiplier; spvUnsafeArray out_var_TEXCOORD0; float4 out_var_TEXCOORD10_centroid; float4 out_var_TEXCOORD11_centroid; float4 out_var_VS_To_DS_Position; }; struct main0_patchOut { float4 out_var_PN_POSITION9; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[attribute(0)]]; float4 in_var_TEXCOORD11_centroid [[attribute(1)]]; float4 in_var_COLOR0 [[attribute(2)]]; float2 in_var_TEXCOORD0_0 [[attribute(3)]]; float2 in_var_TEXCOORD0_1 [[attribute(4)]]; float4 in_var_VS_To_DS_Position [[attribute(5)]]; }; kernel void main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_Primitive& Primitive [[buffer(1)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { threadgroup FPNTessellationHSToDS temp_var_hullMainRetVal[3]; device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 3) return; spvUnsafeArray _129 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD10_centroid, gl_in[1].in_var_TEXCOORD10_centroid, gl_in[2].in_var_TEXCOORD10_centroid, gl_in[3].in_var_TEXCOORD10_centroid, gl_in[4].in_var_TEXCOORD10_centroid, gl_in[5].in_var_TEXCOORD10_centroid, gl_in[6].in_var_TEXCOORD10_centroid, gl_in[7].in_var_TEXCOORD10_centroid, gl_in[8].in_var_TEXCOORD10_centroid, gl_in[9].in_var_TEXCOORD10_centroid, gl_in[10].in_var_TEXCOORD10_centroid, gl_in[11].in_var_TEXCOORD10_centroid }); spvUnsafeArray _130 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD11_centroid, gl_in[1].in_var_TEXCOORD11_centroid, gl_in[2].in_var_TEXCOORD11_centroid, gl_in[3].in_var_TEXCOORD11_centroid, gl_in[4].in_var_TEXCOORD11_centroid, gl_in[5].in_var_TEXCOORD11_centroid, gl_in[6].in_var_TEXCOORD11_centroid, gl_in[7].in_var_TEXCOORD11_centroid, gl_in[8].in_var_TEXCOORD11_centroid, gl_in[9].in_var_TEXCOORD11_centroid, gl_in[10].in_var_TEXCOORD11_centroid, gl_in[11].in_var_TEXCOORD11_centroid }); spvUnsafeArray _131 = spvUnsafeArray({ gl_in[0].in_var_COLOR0, gl_in[1].in_var_COLOR0, gl_in[2].in_var_COLOR0, gl_in[3].in_var_COLOR0, gl_in[4].in_var_COLOR0, gl_in[5].in_var_COLOR0, gl_in[6].in_var_COLOR0, gl_in[7].in_var_COLOR0, gl_in[8].in_var_COLOR0, gl_in[9].in_var_COLOR0, gl_in[10].in_var_COLOR0, gl_in[11].in_var_COLOR0 }); spvUnsafeArray, 12> _132 = spvUnsafeArray, 12>({ spvUnsafeArray({ gl_in[0].in_var_TEXCOORD0_0, gl_in[0].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[1].in_var_TEXCOORD0_0, gl_in[1].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[2].in_var_TEXCOORD0_0, gl_in[2].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[3].in_var_TEXCOORD0_0, gl_in[3].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[4].in_var_TEXCOORD0_0, gl_in[4].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[5].in_var_TEXCOORD0_0, gl_in[5].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[6].in_var_TEXCOORD0_0, gl_in[6].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[7].in_var_TEXCOORD0_0, gl_in[7].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[8].in_var_TEXCOORD0_0, gl_in[8].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[9].in_var_TEXCOORD0_0, gl_in[9].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[10].in_var_TEXCOORD0_0, gl_in[10].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[11].in_var_TEXCOORD0_0, gl_in[11].in_var_TEXCOORD0_1 }) }); spvUnsafeArray _205 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_Position, gl_in[1].in_var_VS_To_DS_Position, gl_in[2].in_var_VS_To_DS_Position, gl_in[3].in_var_VS_To_DS_Position, gl_in[4].in_var_VS_To_DS_Position, gl_in[5].in_var_VS_To_DS_Position, gl_in[6].in_var_VS_To_DS_Position, gl_in[7].in_var_VS_To_DS_Position, gl_in[8].in_var_VS_To_DS_Position, gl_in[9].in_var_VS_To_DS_Position, gl_in[10].in_var_VS_To_DS_Position, gl_in[11].in_var_VS_To_DS_Position }); spvUnsafeArray _230 = spvUnsafeArray({ FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[0], _130[0], _131[0], _132[0] } }, _205[0] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[1], _130[1], _131[1], _132[1] } }, _205[1] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[2], _130[2], _131[2], _132[2] } }, _205[2] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[3], _130[3], _131[3], _132[3] } }, _205[3] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[4], _130[4], _131[4], _132[4] } }, _205[4] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[5], _130[5], _131[5], _132[5] } }, _205[5] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[6], _130[6], _131[6], _132[6] } }, _205[6] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[7], _130[7], _131[7], _132[7] } }, _205[7] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[8], _130[8], _131[8], _132[8] } }, _205[8] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[9], _130[9], _131[9], _132[9] } }, _205[9] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[10], _130[10], _131[10], _132[10] } }, _205[10] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[11], _130[11], _131[11], _132[11] } }, _205[11] } }); spvUnsafeArray param_var_I; param_var_I = _230; float4 _247 = float4(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float3 _251 = Primitive.Primitive_NonUniformScale.xyz * float3x3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz, cross(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz) * float3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.w), param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz); uint _254 = (gl_InvocationID < 2u) ? (gl_InvocationID + 1u) : 0u; uint _255 = 2u * gl_InvocationID; uint _256 = 3u + _255; uint _257 = _255 + 4u; float4 _269 = float4(param_var_I[_254].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _277 = float4(param_var_I[_256].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _285 = float4(param_var_I[_257].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); spvUnsafeArray _333 = spvUnsafeArray({ param_var_I[gl_InvocationID].Position, ((((float4(2.0) * param_var_I[gl_InvocationID].Position) + param_var_I[_254].Position) - (float4(dot(param_var_I[_254].Position - param_var_I[gl_InvocationID].Position, _247)) * _247)) + (((float4(2.0) * param_var_I[_256].Position) + param_var_I[_257].Position) - (float4(dot(param_var_I[_257].Position - param_var_I[_256].Position, _277)) * _277))) * float4(0.16666667163372039794921875), ((((float4(2.0) * param_var_I[_254].Position) + param_var_I[gl_InvocationID].Position) - (float4(dot(param_var_I[gl_InvocationID].Position - param_var_I[_254].Position, _269)) * _269)) + (((float4(2.0) * param_var_I[_257].Position) + param_var_I[_256].Position) - (float4(dot(param_var_I[_256].Position - param_var_I[_257].Position, _285)) * _285))) * float4(0.16666667163372039794921875) }); gl_out[gl_InvocationID].out_var_TEXCOORD10_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; gl_out[gl_InvocationID].out_var_TEXCOORD11_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; gl_out[gl_InvocationID].out_var_COLOR0 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.Color; gl_out[gl_InvocationID].out_var_TEXCOORD0 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TexCoords; gl_out[gl_InvocationID].out_var_VS_To_DS_Position = param_var_I[gl_InvocationID].Position; gl_out[gl_InvocationID].out_var_PN_POSITION = _333; gl_out[gl_InvocationID].out_var_PN_DisplacementScales = _251; gl_out[gl_InvocationID].out_var_PN_TessellationMultiplier = 1.0; gl_out[gl_InvocationID].out_var_PN_WorldDisplacementMultiplier = 1.0; temp_var_hullMainRetVal[gl_InvocationID] = FPNTessellationHSToDS{ param_var_I[gl_InvocationID], _333, _251, 1.0, 1.0 }; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0u) { float4 _385 = (((((temp_var_hullMainRetVal[0u].WorldPosition[1] + temp_var_hullMainRetVal[0u].WorldPosition[2]) + temp_var_hullMainRetVal[1u].WorldPosition[1]) + temp_var_hullMainRetVal[1u].WorldPosition[2]) + temp_var_hullMainRetVal[2u].WorldPosition[1]) + temp_var_hullMainRetVal[2u].WorldPosition[2]) * float4(0.16666667163372039794921875); float4 _398 = _537; _398.x = 0.5 * (temp_var_hullMainRetVal[1u].TessellationMultiplier + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _404 = _398; _404.y = 0.5 * (temp_var_hullMainRetVal[2u].TessellationMultiplier + temp_var_hullMainRetVal[0u].TessellationMultiplier); float4 _409 = _404; _409.z = 0.5 * (temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier); float4 _416 = _409; _416.w = 0.333000004291534423828125 * ((temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier) + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _524; for (;;) { float4 _424 = View.View_ViewToClip * float4(0.0); float4 _429 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[0u].WorldPosition[0].xyz, 1.0); float3 _430 = _429.xyz; float3 _431 = _424.xyz; float _433 = _429.w; float _434 = _424.w; float4 _451 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[1u].WorldPosition[0].xyz, 1.0); float3 _452 = _451.xyz; float _454 = _451.w; float4 _472 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[2u].WorldPosition[0].xyz, 1.0); float3 _473 = _472.xyz; float _475 = _472.w; if (any((((select(int3(0), int3(1), (_430 - _431) < float3(_433 + _434)) + (int3(2) * select(int3(0), int3(1), (_430 + _431) > float3((-_433) - _434)))) | (select(int3(0), int3(1), (_452 - _431) < float3(_454 + _434)) + (int3(2) * select(int3(0), int3(1), (_452 + _431) > float3((-_454) - _434))))) | (select(int3(0), int3(1), (_473 - _431) < float3(_475 + _434)) + (int3(2) * select(int3(0), int3(1), (_473 + _431) > float3((-_475) - _434))))) != int3(3))) { _524 = float4(0.0); break; } float3 _493 = temp_var_hullMainRetVal[0u].WorldPosition[0].xyz - temp_var_hullMainRetVal[1u].WorldPosition[0].xyz; float3 _494 = temp_var_hullMainRetVal[1u].WorldPosition[0].xyz - temp_var_hullMainRetVal[2u].WorldPosition[0].xyz; float3 _495 = temp_var_hullMainRetVal[2u].WorldPosition[0].xyz - temp_var_hullMainRetVal[0u].WorldPosition[0].xyz; float3 _498 = (float3(0.5) * (temp_var_hullMainRetVal[0u].WorldPosition[0].xyz + temp_var_hullMainRetVal[1u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _501 = (float3(0.5) * (temp_var_hullMainRetVal[1u].WorldPosition[0].xyz + temp_var_hullMainRetVal[2u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _504 = (float3(0.5) * (temp_var_hullMainRetVal[2u].WorldPosition[0].xyz + temp_var_hullMainRetVal[0u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float _508 = sqrt(dot(_494, _494) / dot(_501, _501)); float _512 = sqrt(dot(_495, _495) / dot(_504, _504)); float _516 = sqrt(dot(_493, _493) / dot(_498, _498)); float4 _521 = float4(_508, _512, _516, 1.0); _521.w = 0.333000004291534423828125 * ((_508 + _512) + _516); _524 = float4(View.View_AdaptiveTessellationFactor) * _521; break; } float4 _526 = fast::clamp(_416 * _524, float4(1.0), float4(15.0)); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0u] = half(_526.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1u] = half(_526.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2u] = half(_526.z); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_526.w); patchOut.out_var_PN_POSITION9 = _385 + ((_385 - (((temp_var_hullMainRetVal[2u].WorldPosition[0] + temp_var_hullMainRetVal[1u].WorldPosition[0]) + temp_var_hullMainRetVal[0u].WorldPosition[0]) * float4(0.3333333432674407958984375))) * float4(0.5)); } } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tesc/tess-factor-must-be-threadgroup.asm.tesc000066400000000000000000000174331400026215700325710ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct FVertexFactoryInterpolantsVSToPS { float4 TangentToWorld0; float4 TangentToWorld2; }; struct FVertexFactoryInterpolantsVSToDS { FVertexFactoryInterpolantsVSToPS InterpolantsVSToPS; }; struct FSharedBasePassInterpolants { }; struct FBasePassInterpolantsVSToDS { FSharedBasePassInterpolants _m0; }; struct FBasePassVSToDS { FVertexFactoryInterpolantsVSToDS FactoryInterpolants; FBasePassInterpolantsVSToDS BasePassInterpolants; float4 Position; }; struct FFlatTessellationHSToDS { FBasePassVSToDS PassSpecificData; float3 DisplacementScale; float TessellationMultiplier; float WorldDisplacementMultiplier; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_DrawsVelocity; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; uint Primitive_LightingChannelMask; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightmapDataIndex; packed_float3 Primitive_PreSkinnedLocalBounds; int Primitive_SingleCaptureIndex; uint Primitive_OutputVelocity; uint PrePadding_Primitive_420; uint PrePadding_Primitive_424; uint PrePadding_Primitive_428; float4 Primitive_CustomPrimitiveData[4]; }; struct type_Material { float4 Material_VectorExpressions[3]; float4 Material_ScalarExpressions[1]; }; constant float4 _182 = {}; struct main0_out { float3 out_var_Flat_DisplacementScales; float out_var_Flat_TessellationMultiplier; float out_var_Flat_WorldDisplacementMultiplier; float4 out_var_TEXCOORD10_centroid; float4 out_var_TEXCOORD11_centroid; float4 out_var_VS_To_DS_Position; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[attribute(0)]]; float4 in_var_TEXCOORD11_centroid [[attribute(1)]]; float4 in_var_VS_To_DS_Position [[attribute(2)]]; }; kernel void main0(main0_in in [[stage_in]], constant type_Primitive& Primitive [[buffer(0)]], constant type_Material& Material [[buffer(1)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { threadgroup FFlatTessellationHSToDS temp_var_hullMainRetVal[3]; device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 3) return; spvUnsafeArray _90 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD10_centroid, gl_in[1].in_var_TEXCOORD10_centroid, gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _91 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD11_centroid, gl_in[1].in_var_TEXCOORD11_centroid, gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray _104 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_Position, gl_in[1].in_var_VS_To_DS_Position, gl_in[2].in_var_VS_To_DS_Position }); spvUnsafeArray _111 = spvUnsafeArray({ FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _90[0], _91[0] } }, FBasePassInterpolantsVSToDS{ { } }, _104[0] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _90[1], _91[1] } }, FBasePassInterpolantsVSToDS{ { } }, _104[1] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _90[2], _91[2] } }, FBasePassInterpolantsVSToDS{ { } }, _104[2] } }); spvUnsafeArray param_var_I; param_var_I = _111; float3 _128 = Primitive.Primitive_NonUniformScale.xyz * float3x3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz, cross(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz) * float3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.w), param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz); gl_out[gl_InvocationID].out_var_TEXCOORD10_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; gl_out[gl_InvocationID].out_var_TEXCOORD11_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; gl_out[gl_InvocationID].out_var_VS_To_DS_Position = param_var_I[gl_InvocationID].Position; gl_out[gl_InvocationID].out_var_Flat_DisplacementScales = _128; gl_out[gl_InvocationID].out_var_Flat_TessellationMultiplier = Material.Material_ScalarExpressions[0].x; gl_out[gl_InvocationID].out_var_Flat_WorldDisplacementMultiplier = 1.0; temp_var_hullMainRetVal[gl_InvocationID] = FFlatTessellationHSToDS{ param_var_I[gl_InvocationID], _128, Material.Material_ScalarExpressions[0].x, 1.0 }; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0u) { float4 _154 = _182; _154.x = 0.5 * (temp_var_hullMainRetVal[1u].TessellationMultiplier + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _160 = _154; _160.y = 0.5 * (temp_var_hullMainRetVal[2u].TessellationMultiplier + temp_var_hullMainRetVal[0u].TessellationMultiplier); float4 _165 = _160; _165.z = 0.5 * (temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier); float4 _172 = _165; _172.w = 0.333000004291534423828125 * ((temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier) + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _173 = fast::clamp(_172, float4(1.0), float4(15.0)); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0u] = half(_173.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1u] = half(_173.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2u] = half(_173.z); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_173.w); } } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tese/000077500000000000000000000000001400026215700227765ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tese/ds-double-gl-in-deref.asm.tese000066400000000000000000000446541400026215700304210ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_ShadowDepthPass { float PrePadding_ShadowDepthPass_LPV_0; float PrePadding_ShadowDepthPass_LPV_4; float PrePadding_ShadowDepthPass_LPV_8; float PrePadding_ShadowDepthPass_LPV_12; float PrePadding_ShadowDepthPass_LPV_16; float PrePadding_ShadowDepthPass_LPV_20; float PrePadding_ShadowDepthPass_LPV_24; float PrePadding_ShadowDepthPass_LPV_28; float PrePadding_ShadowDepthPass_LPV_32; float PrePadding_ShadowDepthPass_LPV_36; float PrePadding_ShadowDepthPass_LPV_40; float PrePadding_ShadowDepthPass_LPV_44; float PrePadding_ShadowDepthPass_LPV_48; float PrePadding_ShadowDepthPass_LPV_52; float PrePadding_ShadowDepthPass_LPV_56; float PrePadding_ShadowDepthPass_LPV_60; float PrePadding_ShadowDepthPass_LPV_64; float PrePadding_ShadowDepthPass_LPV_68; float PrePadding_ShadowDepthPass_LPV_72; float PrePadding_ShadowDepthPass_LPV_76; float PrePadding_ShadowDepthPass_LPV_80; float PrePadding_ShadowDepthPass_LPV_84; float PrePadding_ShadowDepthPass_LPV_88; float PrePadding_ShadowDepthPass_LPV_92; float PrePadding_ShadowDepthPass_LPV_96; float PrePadding_ShadowDepthPass_LPV_100; float PrePadding_ShadowDepthPass_LPV_104; float PrePadding_ShadowDepthPass_LPV_108; float PrePadding_ShadowDepthPass_LPV_112; float PrePadding_ShadowDepthPass_LPV_116; float PrePadding_ShadowDepthPass_LPV_120; float PrePadding_ShadowDepthPass_LPV_124; float PrePadding_ShadowDepthPass_LPV_128; float PrePadding_ShadowDepthPass_LPV_132; float PrePadding_ShadowDepthPass_LPV_136; float PrePadding_ShadowDepthPass_LPV_140; float PrePadding_ShadowDepthPass_LPV_144; float PrePadding_ShadowDepthPass_LPV_148; float PrePadding_ShadowDepthPass_LPV_152; float PrePadding_ShadowDepthPass_LPV_156; float PrePadding_ShadowDepthPass_LPV_160; float PrePadding_ShadowDepthPass_LPV_164; float PrePadding_ShadowDepthPass_LPV_168; float PrePadding_ShadowDepthPass_LPV_172; float PrePadding_ShadowDepthPass_LPV_176; float PrePadding_ShadowDepthPass_LPV_180; float PrePadding_ShadowDepthPass_LPV_184; float PrePadding_ShadowDepthPass_LPV_188; float PrePadding_ShadowDepthPass_LPV_192; float PrePadding_ShadowDepthPass_LPV_196; float PrePadding_ShadowDepthPass_LPV_200; float PrePadding_ShadowDepthPass_LPV_204; float PrePadding_ShadowDepthPass_LPV_208; float PrePadding_ShadowDepthPass_LPV_212; float PrePadding_ShadowDepthPass_LPV_216; float PrePadding_ShadowDepthPass_LPV_220; float PrePadding_ShadowDepthPass_LPV_224; float PrePadding_ShadowDepthPass_LPV_228; float PrePadding_ShadowDepthPass_LPV_232; float PrePadding_ShadowDepthPass_LPV_236; float PrePadding_ShadowDepthPass_LPV_240; float PrePadding_ShadowDepthPass_LPV_244; float PrePadding_ShadowDepthPass_LPV_248; float PrePadding_ShadowDepthPass_LPV_252; float PrePadding_ShadowDepthPass_LPV_256; float PrePadding_ShadowDepthPass_LPV_260; float PrePadding_ShadowDepthPass_LPV_264; float PrePadding_ShadowDepthPass_LPV_268; float4x4 ShadowDepthPass_LPV_mRsmToWorld; float4 ShadowDepthPass_LPV_mLightColour; float4 ShadowDepthPass_LPV_GeometryVolumeCaptureLightDirection; float4 ShadowDepthPass_LPV_mEyePos; packed_int3 ShadowDepthPass_LPV_mOldGridOffset; int PrePadding_ShadowDepthPass_LPV_396; packed_int3 ShadowDepthPass_LPV_mLpvGridOffset; float ShadowDepthPass_LPV_ClearMultiplier; float ShadowDepthPass_LPV_LpvScale; float ShadowDepthPass_LPV_OneOverLpvScale; float ShadowDepthPass_LPV_DirectionalOcclusionIntensity; float ShadowDepthPass_LPV_DirectionalOcclusionRadius; float ShadowDepthPass_LPV_RsmAreaIntensityMultiplier; float ShadowDepthPass_LPV_RsmPixelToTexcoordMultiplier; float ShadowDepthPass_LPV_SecondaryOcclusionStrength; float ShadowDepthPass_LPV_SecondaryBounceStrength; float ShadowDepthPass_LPV_VplInjectionBias; float ShadowDepthPass_LPV_GeometryVolumeInjectionBias; float ShadowDepthPass_LPV_EmissiveInjectionMultiplier; int ShadowDepthPass_LPV_PropagationIndex; float4x4 ShadowDepthPass_ProjectionMatrix; float4x4 ShadowDepthPass_ViewMatrix; float4 ShadowDepthPass_ShadowParams; float ShadowDepthPass_bClampToNearPlane; float PrePadding_ShadowDepthPass_612; float PrePadding_ShadowDepthPass_616; float PrePadding_ShadowDepthPass_620; float4x4 ShadowDepthPass_ShadowViewProjectionMatrices[6]; float4x4 ShadowDepthPass_ShadowViewMatrices[6]; }; constant float4 _113 = {}; struct main0_out { float4 out_var_TEXCOORD10_centroid [[user(locn0)]]; float4 out_var_TEXCOORD11_centroid [[user(locn1)]]; float4 out_var_COLOR0 [[user(locn2)]]; float4 out_var_TEXCOORD0_0 [[user(locn3)]]; uint out_var_PRIMITIVE_ID [[user(locn4)]]; float out_var_TEXCOORD6 [[user(locn5)]]; float out_var_TEXCOORD8 [[user(locn6)]]; float3 out_var_TEXCOORD7 [[user(locn7)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_COLOR0 [[attribute(0)]]; float4 in_var_PN_POSITION_0 [[attribute(2)]]; float4 in_var_PN_POSITION_1 [[attribute(3)]]; float4 in_var_PN_POSITION_2 [[attribute(4)]]; float in_var_PN_WorldDisplacementMultiplier [[attribute(7)]]; uint in_var_PRIMITIVE_ID [[attribute(8)]]; float4 in_var_TEXCOORD0_0 [[attribute(9)]]; float4 in_var_TEXCOORD10_centroid [[attribute(10)]]; float4 in_var_TEXCOORD11_centroid [[attribute(11)]]; }; struct main0_patchIn { float4 in_var_PN_POSITION9 [[attribute(5)]]; patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant type_View& View [[buffer(0)]], constant type_ShadowDepthPass& ShadowDepthPass [[buffer(1)]], texture2d Material_Texture2D_3 [[texture(0)]], sampler Material_Texture2D_3Sampler [[sampler(0)]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray out_var_TEXCOORD0 = {}; spvUnsafeArray _117 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD10_centroid, patchIn.gl_in[1].in_var_TEXCOORD10_centroid, patchIn.gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _118 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD11_centroid, patchIn.gl_in[1].in_var_TEXCOORD11_centroid, patchIn.gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray _119 = spvUnsafeArray({ patchIn.gl_in[0].in_var_COLOR0, patchIn.gl_in[1].in_var_COLOR0, patchIn.gl_in[2].in_var_COLOR0 }); spvUnsafeArray, 3> _120 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD0_0 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_TEXCOORD0_0 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_TEXCOORD0_0 }) }); spvUnsafeArray, 3> _135 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_POSITION_0, patchIn.gl_in[0].in_var_PN_POSITION_1, patchIn.gl_in[0].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_PN_POSITION_0, patchIn.gl_in[1].in_var_PN_POSITION_1, patchIn.gl_in[1].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_PN_POSITION_0, patchIn.gl_in[2].in_var_PN_POSITION_1, patchIn.gl_in[2].in_var_PN_POSITION_2 }) }); spvUnsafeArray _136 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_WorldDisplacementMultiplier, patchIn.gl_in[1].in_var_PN_WorldDisplacementMultiplier, patchIn.gl_in[2].in_var_PN_WorldDisplacementMultiplier }); float _157 = gl_TessCoord.x * gl_TessCoord.x; float _158 = gl_TessCoord.y * gl_TessCoord.y; float _159 = gl_TessCoord.z * gl_TessCoord.z; float4 _165 = float4(gl_TessCoord.x); float4 _169 = float4(gl_TessCoord.y); float4 _174 = float4(gl_TessCoord.z); float4 _177 = float4(_157 * 3.0); float4 _181 = float4(_158 * 3.0); float4 _188 = float4(_159 * 3.0); float4 _202 = ((((((((((_135[0][0] * float4(_157)) * _165) + ((_135[1][0] * float4(_158)) * _169)) + ((_135[2][0] * float4(_159)) * _174)) + ((_135[0][1] * _177) * _169)) + ((_135[0][2] * _181) * _165)) + ((_135[1][1] * _181) * _174)) + ((_135[1][2] * _188) * _169)) + ((_135[2][1] * _188) * _165)) + ((_135[2][2] * _177) * _174)) + ((((patchIn.in_var_PN_POSITION9 * float4(6.0)) * _174) * _165) * _169); float3 _226 = ((_117[0].xyz * float3(gl_TessCoord.x)) + (_117[1].xyz * float3(gl_TessCoord.y))).xyz + (_117[2].xyz * float3(gl_TessCoord.z)); float4 _229 = ((_118[0] * _165) + (_118[1] * _169)) + (_118[2] * _174); float4 _231 = ((_119[0] * _165) + (_119[1] * _169)) + (_119[2] * _174); float4 _233 = ((_120[0][0] * _165) + (_120[1][0] * _169)) + (_120[2][0] * _174); spvUnsafeArray _234 = spvUnsafeArray({ _233 }); float3 _236 = _229.xyz; float3 _264 = _202.xyz + (((float3((Material_Texture2D_3.sample(Material_Texture2D_3Sampler, (float2(View.View_GameTime * 0.20000000298023223876953125, View.View_GameTime * (-0.699999988079071044921875)) + (_233.zw * float2(1.0, 2.0))), level(-1.0)).x * 10.0) * (1.0 - _231.x)) * _236) * float3(0.5)) * float3(((_136[0] * gl_TessCoord.x) + (_136[1] * gl_TessCoord.y)) + (_136[2] * gl_TessCoord.z))); float4 _270 = ShadowDepthPass.ShadowDepthPass_ProjectionMatrix * float4(_264.x, _264.y, _264.z, _202.w); float4 _281; if ((ShadowDepthPass.ShadowDepthPass_bClampToNearPlane > 0.0) && (_270.z < 0.0)) { float4 _279 = _270; _279.z = 9.9999999747524270787835121154785e-07; float4 _280 = _279; _280.w = 1.0; _281 = _280; } else { _281 = _270; } float _290 = abs(dot(float3(ShadowDepthPass.ShadowDepthPass_ViewMatrix[0].z, ShadowDepthPass.ShadowDepthPass_ViewMatrix[1].z, ShadowDepthPass.ShadowDepthPass_ViewMatrix[2].z), _236)); out.out_var_TEXCOORD10_centroid = float4(_226.x, _226.y, _226.z, _113.w); out.out_var_TEXCOORD11_centroid = _229; out.out_var_COLOR0 = _231; out_var_TEXCOORD0 = _234; out.out_var_PRIMITIVE_ID = patchIn.gl_in[0u].in_var_PRIMITIVE_ID; out.out_var_TEXCOORD6 = _281.z; out.out_var_TEXCOORD8 = (ShadowDepthPass.ShadowDepthPass_ShadowParams.y * fast::clamp((abs(_290) > 0.0) ? (sqrt(fast::clamp(1.0 - (_290 * _290), 0.0, 1.0)) / _290) : ShadowDepthPass.ShadowDepthPass_ShadowParams.z, 0.0, ShadowDepthPass.ShadowDepthPass_ShadowParams.z)) + ShadowDepthPass.ShadowDepthPass_ShadowParams.x; out.out_var_TEXCOORD7 = _264.xyz; out.gl_Position = _281; out.out_var_TEXCOORD0_0 = out_var_TEXCOORD0[0]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tese/ds-patch-input-fixes.asm.tese000066400000000000000000000476211400026215700304250ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; float PrePadding_View_3048; float PrePadding_View_3052; float4x4 View_WorldToVirtualTexture; float4 View_VirtualTextureParams; float4 View_XRPassthroughCameraUVs[2]; }; struct type_Material { float4 Material_VectorExpressions[5]; float4 Material_ScalarExpressions[2]; }; constant float4 _118 = {}; struct main0_out { float4 out_var_TEXCOORD6 [[user(locn0)]]; float4 out_var_TEXCOORD7 [[user(locn1)]]; float4 out_var_TEXCOORD10_centroid [[user(locn2)]]; float4 out_var_TEXCOORD11_centroid [[user(locn3)]]; float gl_ClipDistance [[clip_distance]] [1]; float gl_ClipDistance_0 [[user(clip0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_PN_DominantEdge2 [[attribute(3)]]; float4 in_var_PN_DominantEdge3 [[attribute(4)]]; float3 in_var_PN_DominantEdge4 [[attribute(5)]]; float3 in_var_PN_DominantEdge5 [[attribute(6)]]; float4 in_var_PN_DominantVertex1 [[attribute(8)]]; float3 in_var_PN_DominantVertex2 [[attribute(9)]]; float4 in_var_PN_POSITION_0 [[attribute(10)]]; float4 in_var_PN_POSITION_1 [[attribute(11)]]; float4 in_var_PN_POSITION_2 [[attribute(12)]]; float in_var_PN_WorldDisplacementMultiplier [[attribute(15)]]; float4 in_var_TEXCOORD10_centroid [[attribute(16)]]; float4 in_var_TEXCOORD11_centroid [[attribute(17)]]; float4 in_var_TEXCOORD6 [[attribute(18)]]; float4 in_var_TEXCOORD8 [[attribute(19)]]; }; struct main0_patchIn { float4 in_var_PN_POSITION9 [[attribute(13)]]; patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant type_View& View [[buffer(0)]], constant type_Material& Material [[buffer(1)]], texture3d View_GlobalDistanceFieldTexture0 [[texture(0)]], texture3d View_GlobalDistanceFieldTexture1 [[texture(1)]], texture3d View_GlobalDistanceFieldTexture2 [[texture(2)]], texture3d View_GlobalDistanceFieldTexture3 [[texture(3)]], sampler View_GlobalDistanceFieldSampler0 [[sampler(0)]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray _120 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD6, patchIn.gl_in[1].in_var_TEXCOORD6, patchIn.gl_in[2].in_var_TEXCOORD6 }); spvUnsafeArray _121 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD8, patchIn.gl_in[1].in_var_TEXCOORD8, patchIn.gl_in[2].in_var_TEXCOORD8 }); spvUnsafeArray _128 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD10_centroid, patchIn.gl_in[1].in_var_TEXCOORD10_centroid, patchIn.gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _129 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD11_centroid, patchIn.gl_in[1].in_var_TEXCOORD11_centroid, patchIn.gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray, 3> _136 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_POSITION_0, patchIn.gl_in[0].in_var_PN_POSITION_1, patchIn.gl_in[0].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_PN_POSITION_0, patchIn.gl_in[1].in_var_PN_POSITION_1, patchIn.gl_in[1].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_PN_POSITION_0, patchIn.gl_in[2].in_var_PN_POSITION_1, patchIn.gl_in[2].in_var_PN_POSITION_2 }) }); spvUnsafeArray _137 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_WorldDisplacementMultiplier, patchIn.gl_in[1].in_var_PN_WorldDisplacementMultiplier, patchIn.gl_in[2].in_var_PN_WorldDisplacementMultiplier }); spvUnsafeArray _138 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantVertex1, patchIn.gl_in[1].in_var_PN_DominantVertex1, patchIn.gl_in[2].in_var_PN_DominantVertex1 }); spvUnsafeArray _139 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantVertex2, patchIn.gl_in[1].in_var_PN_DominantVertex2, patchIn.gl_in[2].in_var_PN_DominantVertex2 }); spvUnsafeArray _146 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantEdge2, patchIn.gl_in[1].in_var_PN_DominantEdge2, patchIn.gl_in[2].in_var_PN_DominantEdge2 }); spvUnsafeArray _147 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantEdge3, patchIn.gl_in[1].in_var_PN_DominantEdge3, patchIn.gl_in[2].in_var_PN_DominantEdge3 }); spvUnsafeArray _148 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantEdge4, patchIn.gl_in[1].in_var_PN_DominantEdge4, patchIn.gl_in[2].in_var_PN_DominantEdge4 }); spvUnsafeArray _149 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantEdge5, patchIn.gl_in[1].in_var_PN_DominantEdge5, patchIn.gl_in[2].in_var_PN_DominantEdge5 }); float _190 = gl_TessCoord.x * gl_TessCoord.x; float _191 = gl_TessCoord.y * gl_TessCoord.y; float _192 = gl_TessCoord.z * gl_TessCoord.z; float4 _198 = float4(gl_TessCoord.x); float4 _202 = float4(gl_TessCoord.y); float4 _207 = float4(gl_TessCoord.z); float4 _210 = float4(_190 * 3.0); float4 _214 = float4(_191 * 3.0); float4 _221 = float4(_192 * 3.0); float4 _235 = ((((((((((_136[0][0] * float4(_190)) * _198) + ((_136[1][0] * float4(_191)) * _202)) + ((_136[2][0] * float4(_192)) * _207)) + ((_136[0][1] * _210) * _202)) + ((_136[0][2] * _214) * _198)) + ((_136[1][1] * _214) * _207)) + ((_136[1][2] * _221) * _202)) + ((_136[2][1] * _221) * _198)) + ((_136[2][2] * _210) * _207)) + ((((patchIn.in_var_PN_POSITION9 * float4(6.0)) * _207) * _198) * _202); float3 _237 = float3(gl_TessCoord.x); float3 _240 = float3(gl_TessCoord.y); float3 _254 = float3(gl_TessCoord.z); float3 _256 = ((_128[0].xyz * _237) + (_128[1].xyz * _240)).xyz + (_128[2].xyz * _254); float4 _259 = ((_129[0] * _198) + (_129[1] * _202)) + (_129[2] * _207); float3 _264 = _235.xyz; float3 _265 = _256.xyz; float3 _266 = _259.xyz; float3 _272 = _264 + float3(View.View_WorldCameraOrigin); float _279 = float(int(gl_TessCoord.x == 0.0)); float _282 = float(int(gl_TessCoord.y == 0.0)); float _285 = float(int(gl_TessCoord.z == 0.0)); float _286 = _279 + _282; float _287 = _286 + _285; float4 _387; float3 _388; if (float(int(_287 == 2.0)) == 1.0) { float _363 = float(int((_282 + _285) == 2.0)); float _367 = float(int((_285 + _279) == 2.0)); float _370 = float(int(_286 == 2.0)); _387 = ((float4(_363) * _138[0]) + (float4(_367) * _138[1])) + (float4(_370) * _138[2]); _388 = ((float3(_363) * _139[0]) + (float3(_367) * _139[1])) + (float3(_370) * _139[2]); } else { float4 _358; float3 _359; if (float(int(_287 == 1.0)) != 0.0) { float4 _304 = float4(_279); float4 _306 = float4(_282); float4 _309 = float4(_285); float4 _311 = ((_304 * _146[0]) + (_306 * _146[1])) + (_309 * _146[2]); float4 _316 = ((_304 * _147[0]) + (_306 * _147[1])) + (_309 * _147[2]); float3 _331 = float3(_279); float3 _333 = float3(_282); float3 _336 = float3(_285); float3 _338 = ((_331 * _148[0]) + (_333 * _148[1])) + (_336 * _148[2]); float3 _343 = ((_331 * _149[0]) + (_333 * _149[1])) + (_336 * _149[2]); _358 = ((_304 * ((_202 * _311) + (_207 * _316))) + (_306 * ((_207 * _311) + (_198 * _316)))) + (_309 * ((_198 * _311) + (_202 * _316))); _359 = ((_331 * ((_240 * _338) + (_254 * _343))) + (_333 * ((_254 * _338) + (_237 * _343)))) + (_336 * ((_237 * _338) + (_240 * _343))); } else { _358 = float4(_259.xyz, 0.0); _359 = _265; } _387 = _358; _388 = _359; } float3x3 _398; if (float(int(_287 == 0.0)) == 0.0) { _398 = float3x3(_388, cross(_387.xyz, _388) * float3(_387.w), _387.xyz); } else { _398 = float3x3(_265, cross(_266, _265) * float3(_259.w), _266); } float3 _411 = fast::min(fast::max((_272 - View.View_GlobalVolumeCenterAndExtent[0].xyz) + View.View_GlobalVolumeCenterAndExtent[0].www, float3(0.0)), fast::max((View.View_GlobalVolumeCenterAndExtent[0].xyz + View.View_GlobalVolumeCenterAndExtent[0].www) - _272, float3(0.0))); float _547; if (fast::min(_411.x, fast::min(_411.y, _411.z)) > (View.View_GlobalVolumeCenterAndExtent[0].w * View.View_GlobalVolumeTexelSize)) { _547 = View_GlobalDistanceFieldTexture0.sample(View_GlobalDistanceFieldSampler0, ((_272 * View.View_GlobalVolumeWorldToUVAddAndMul[0u].www) + View.View_GlobalVolumeWorldToUVAddAndMul[0u].xyz), level(0.0)).x; } else { float3 _436 = fast::min(fast::max((_272 - View.View_GlobalVolumeCenterAndExtent[1].xyz) + View.View_GlobalVolumeCenterAndExtent[1].www, float3(0.0)), fast::max((View.View_GlobalVolumeCenterAndExtent[1].xyz + View.View_GlobalVolumeCenterAndExtent[1].www) - _272, float3(0.0))); float _535; if (fast::min(_436.x, fast::min(_436.y, _436.z)) > (View.View_GlobalVolumeCenterAndExtent[1].w * View.View_GlobalVolumeTexelSize)) { _535 = View_GlobalDistanceFieldTexture1.sample(View_GlobalDistanceFieldSampler0, ((_272 * View.View_GlobalVolumeWorldToUVAddAndMul[1u].www) + View.View_GlobalVolumeWorldToUVAddAndMul[1u].xyz), level(0.0)).x; } else { float3 _459 = fast::min(fast::max((_272 - View.View_GlobalVolumeCenterAndExtent[2].xyz) + View.View_GlobalVolumeCenterAndExtent[2].www, float3(0.0)), fast::max((View.View_GlobalVolumeCenterAndExtent[2].xyz + View.View_GlobalVolumeCenterAndExtent[2].www) - _272, float3(0.0))); float3 _475 = fast::min(fast::max((_272 - View.View_GlobalVolumeCenterAndExtent[3].xyz) + View.View_GlobalVolumeCenterAndExtent[3].www, float3(0.0)), fast::max((View.View_GlobalVolumeCenterAndExtent[3].xyz + View.View_GlobalVolumeCenterAndExtent[3].www) - _272, float3(0.0))); float _480 = fast::min(_475.x, fast::min(_475.y, _475.z)); float _523; if (fast::min(_459.x, fast::min(_459.y, _459.z)) > (View.View_GlobalVolumeCenterAndExtent[2].w * View.View_GlobalVolumeTexelSize)) { _523 = View_GlobalDistanceFieldTexture2.sample(View_GlobalDistanceFieldSampler0, ((_272 * View.View_GlobalVolumeWorldToUVAddAndMul[2u].www) + View.View_GlobalVolumeWorldToUVAddAndMul[2u].xyz), level(0.0)).x; } else { float _511; if (_480 > (View.View_GlobalVolumeCenterAndExtent[3].w * View.View_GlobalVolumeTexelSize)) { _511 = mix(View.View_MaxGlobalDistance, View_GlobalDistanceFieldTexture3.sample(View_GlobalDistanceFieldSampler0, ((_272 * View.View_GlobalVolumeWorldToUVAddAndMul[3u].www) + View.View_GlobalVolumeWorldToUVAddAndMul[3u].xyz), level(0.0)).x, fast::clamp((_480 * 10.0) * View.View_GlobalVolumeWorldToUVAddAndMul[3].w, 0.0, 1.0)); } else { _511 = View.View_MaxGlobalDistance; } _523 = _511; } _535 = _523; } _547 = _535; } float3 _565 = _264 + ((_398[2] * float3(fast::min(_547 + Material.Material_ScalarExpressions[0].z, 0.0) * Material.Material_ScalarExpressions[0].w)) * float3(((_137[0] * gl_TessCoord.x) + (_137[1] * gl_TessCoord.y)) + (_137[2] * gl_TessCoord.z))); float4 _574 = View.View_TranslatedWorldToClip * float4(_565.x, _565.y, _565.z, _235.w); float4 _579 = _574; _579.z = _574.z + (0.001000000047497451305389404296875 * _574.w); out.gl_Position = _579; out.out_var_TEXCOORD6 = ((_120[0] * _198) + (_120[1] * _202)) + (_120[2] * _207); out.out_var_TEXCOORD7 = ((_121[0] * _198) + (_121[1] * _202)) + (_121[2] * _207); out.out_var_TEXCOORD10_centroid = float4(_256.x, _256.y, _256.z, _118.w); out.out_var_TEXCOORD11_centroid = _259; out.gl_ClipDistance[0u] = dot(View.View_GlobalClippingPlane, float4(_565.xyz - float3(View.View_PreViewTranslation), 1.0)); out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tese/ds-patch-inputs.asm.tese000066400000000000000000000230241400026215700274630ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_ShadowDepthPass { float PrePadding_ShadowDepthPass_LPV_0; float PrePadding_ShadowDepthPass_LPV_4; float PrePadding_ShadowDepthPass_LPV_8; float PrePadding_ShadowDepthPass_LPV_12; float PrePadding_ShadowDepthPass_LPV_16; float PrePadding_ShadowDepthPass_LPV_20; float PrePadding_ShadowDepthPass_LPV_24; float PrePadding_ShadowDepthPass_LPV_28; float PrePadding_ShadowDepthPass_LPV_32; float PrePadding_ShadowDepthPass_LPV_36; float PrePadding_ShadowDepthPass_LPV_40; float PrePadding_ShadowDepthPass_LPV_44; float PrePadding_ShadowDepthPass_LPV_48; float PrePadding_ShadowDepthPass_LPV_52; float PrePadding_ShadowDepthPass_LPV_56; float PrePadding_ShadowDepthPass_LPV_60; float PrePadding_ShadowDepthPass_LPV_64; float PrePadding_ShadowDepthPass_LPV_68; float PrePadding_ShadowDepthPass_LPV_72; float PrePadding_ShadowDepthPass_LPV_76; float PrePadding_ShadowDepthPass_LPV_80; float PrePadding_ShadowDepthPass_LPV_84; float PrePadding_ShadowDepthPass_LPV_88; float PrePadding_ShadowDepthPass_LPV_92; float PrePadding_ShadowDepthPass_LPV_96; float PrePadding_ShadowDepthPass_LPV_100; float PrePadding_ShadowDepthPass_LPV_104; float PrePadding_ShadowDepthPass_LPV_108; float PrePadding_ShadowDepthPass_LPV_112; float PrePadding_ShadowDepthPass_LPV_116; float PrePadding_ShadowDepthPass_LPV_120; float PrePadding_ShadowDepthPass_LPV_124; float PrePadding_ShadowDepthPass_LPV_128; float PrePadding_ShadowDepthPass_LPV_132; float PrePadding_ShadowDepthPass_LPV_136; float PrePadding_ShadowDepthPass_LPV_140; float PrePadding_ShadowDepthPass_LPV_144; float PrePadding_ShadowDepthPass_LPV_148; float PrePadding_ShadowDepthPass_LPV_152; float PrePadding_ShadowDepthPass_LPV_156; float PrePadding_ShadowDepthPass_LPV_160; float PrePadding_ShadowDepthPass_LPV_164; float PrePadding_ShadowDepthPass_LPV_168; float PrePadding_ShadowDepthPass_LPV_172; float PrePadding_ShadowDepthPass_LPV_176; float PrePadding_ShadowDepthPass_LPV_180; float PrePadding_ShadowDepthPass_LPV_184; float PrePadding_ShadowDepthPass_LPV_188; float PrePadding_ShadowDepthPass_LPV_192; float PrePadding_ShadowDepthPass_LPV_196; float PrePadding_ShadowDepthPass_LPV_200; float PrePadding_ShadowDepthPass_LPV_204; float PrePadding_ShadowDepthPass_LPV_208; float PrePadding_ShadowDepthPass_LPV_212; float PrePadding_ShadowDepthPass_LPV_216; float PrePadding_ShadowDepthPass_LPV_220; float PrePadding_ShadowDepthPass_LPV_224; float PrePadding_ShadowDepthPass_LPV_228; float PrePadding_ShadowDepthPass_LPV_232; float PrePadding_ShadowDepthPass_LPV_236; float PrePadding_ShadowDepthPass_LPV_240; float PrePadding_ShadowDepthPass_LPV_244; float PrePadding_ShadowDepthPass_LPV_248; float PrePadding_ShadowDepthPass_LPV_252; float PrePadding_ShadowDepthPass_LPV_256; float PrePadding_ShadowDepthPass_LPV_260; float PrePadding_ShadowDepthPass_LPV_264; float PrePadding_ShadowDepthPass_LPV_268; float4x4 ShadowDepthPass_LPV_mRsmToWorld; float4 ShadowDepthPass_LPV_mLightColour; float4 ShadowDepthPass_LPV_GeometryVolumeCaptureLightDirection; float4 ShadowDepthPass_LPV_mEyePos; packed_int3 ShadowDepthPass_LPV_mOldGridOffset; int PrePadding_ShadowDepthPass_LPV_396; packed_int3 ShadowDepthPass_LPV_mLpvGridOffset; float ShadowDepthPass_LPV_ClearMultiplier; float ShadowDepthPass_LPV_LpvScale; float ShadowDepthPass_LPV_OneOverLpvScale; float ShadowDepthPass_LPV_DirectionalOcclusionIntensity; float ShadowDepthPass_LPV_DirectionalOcclusionRadius; float ShadowDepthPass_LPV_RsmAreaIntensityMultiplier; float ShadowDepthPass_LPV_RsmPixelToTexcoordMultiplier; float ShadowDepthPass_LPV_SecondaryOcclusionStrength; float ShadowDepthPass_LPV_SecondaryBounceStrength; float ShadowDepthPass_LPV_VplInjectionBias; float ShadowDepthPass_LPV_GeometryVolumeInjectionBias; float ShadowDepthPass_LPV_EmissiveInjectionMultiplier; int ShadowDepthPass_LPV_PropagationIndex; float4x4 ShadowDepthPass_ProjectionMatrix; float4x4 ShadowDepthPass_ViewMatrix; float4 ShadowDepthPass_ShadowParams; float ShadowDepthPass_bClampToNearPlane; float PrePadding_ShadowDepthPass_612; float PrePadding_ShadowDepthPass_616; float PrePadding_ShadowDepthPass_620; float4x4 ShadowDepthPass_ShadowViewProjectionMatrices[6]; float4x4 ShadowDepthPass_ShadowViewMatrices[6]; }; constant float4 _90 = {}; struct main0_out { float4 out_var_TEXCOORD10_centroid [[user(locn0)]]; float4 out_var_TEXCOORD11_centroid [[user(locn1)]]; float out_var_TEXCOORD6 [[user(locn2)]]; float3 out_var_TEXCOORD7 [[user(locn3)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_PN_POSITION_0 [[attribute(10)]]; float4 in_var_PN_POSITION_1 [[attribute(11)]]; float4 in_var_PN_POSITION_2 [[attribute(12)]]; float4 in_var_TEXCOORD10_centroid [[attribute(16)]]; float4 in_var_TEXCOORD11_centroid [[attribute(17)]]; }; struct main0_patchIn { float4 in_var_PN_POSITION9 [[attribute(13)]]; patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant type_ShadowDepthPass& ShadowDepthPass [[buffer(0)]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray _93 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD10_centroid, patchIn.gl_in[1].in_var_TEXCOORD10_centroid, patchIn.gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _94 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD11_centroid, patchIn.gl_in[1].in_var_TEXCOORD11_centroid, patchIn.gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray, 3> _101 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_POSITION_0, patchIn.gl_in[0].in_var_PN_POSITION_1, patchIn.gl_in[0].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_PN_POSITION_0, patchIn.gl_in[1].in_var_PN_POSITION_1, patchIn.gl_in[1].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_PN_POSITION_0, patchIn.gl_in[2].in_var_PN_POSITION_1, patchIn.gl_in[2].in_var_PN_POSITION_2 }) }); float _119 = gl_TessCoord.x * gl_TessCoord.x; float _120 = gl_TessCoord.y * gl_TessCoord.y; float _121 = gl_TessCoord.z * gl_TessCoord.z; float4 _127 = float4(gl_TessCoord.x); float4 _131 = float4(gl_TessCoord.y); float4 _136 = float4(gl_TessCoord.z); float4 _139 = float4(_119 * 3.0); float4 _143 = float4(_120 * 3.0); float4 _150 = float4(_121 * 3.0); float4 _164 = ((((((((((_101[0][0] * float4(_119)) * _127) + ((_101[1][0] * float4(_120)) * _131)) + ((_101[2][0] * float4(_121)) * _136)) + ((_101[0][1] * _139) * _131)) + ((_101[0][2] * _143) * _127)) + ((_101[1][1] * _143) * _136)) + ((_101[1][2] * _150) * _131)) + ((_101[2][1] * _150) * _127)) + ((_101[2][2] * _139) * _136)) + ((((patchIn.in_var_PN_POSITION9 * float4(6.0)) * _136) * _127) * _131); float3 _179 = ((_93[0].xyz * float3(gl_TessCoord.x)) + (_93[1].xyz * float3(gl_TessCoord.y))).xyz + (_93[2].xyz * float3(gl_TessCoord.z)); float4 _182 = ((_94[0] * _127) + (_94[1] * _131)) + (_94[2] * _136); float4 _189 = ShadowDepthPass.ShadowDepthPass_ProjectionMatrix * float4(_164.x, _164.y, _164.z, _164.w); float4 _200; if ((ShadowDepthPass.ShadowDepthPass_bClampToNearPlane > 0.0) && (_189.z < 0.0)) { float4 _198 = _189; _198.z = 9.9999999747524270787835121154785e-07; float4 _199 = _198; _199.w = 1.0; _200 = _199; } else { _200 = _189; } float _209 = abs(dot(float3(ShadowDepthPass.ShadowDepthPass_ViewMatrix[0].z, ShadowDepthPass.ShadowDepthPass_ViewMatrix[1].z, ShadowDepthPass.ShadowDepthPass_ViewMatrix[2].z), _182.xyz)); float4 _234 = _200; _234.z = ((_200.z * ShadowDepthPass.ShadowDepthPass_ShadowParams.w) + ((ShadowDepthPass.ShadowDepthPass_ShadowParams.y * fast::clamp((abs(_209) > 0.0) ? (sqrt(fast::clamp(1.0 - (_209 * _209), 0.0, 1.0)) / _209) : ShadowDepthPass.ShadowDepthPass_ShadowParams.z, 0.0, ShadowDepthPass.ShadowDepthPass_ShadowParams.z)) + ShadowDepthPass.ShadowDepthPass_ShadowParams.x)) * _200.w; out.out_var_TEXCOORD10_centroid = float4(_179.x, _179.y, _179.z, _90.w); out.out_var_TEXCOORD11_centroid = _182; out.out_var_TEXCOORD6 = 0.0; out.out_var_TEXCOORD7 = _164.xyz; out.gl_Position = _234; return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/tese/ds-texcoord-array.asm.tese000066400000000000000000000301611400026215700300070ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; float PrePadding_View_3048; float PrePadding_View_3052; float4x4 View_WorldToVirtualTexture; float4 View_VirtualTextureParams; float4 View_XRPassthroughCameraUVs[2]; }; constant float4 _68 = {}; struct main0_out { float4 out_var_TEXCOORD10_centroid [[user(locn0)]]; float4 out_var_TEXCOORD11_centroid [[user(locn1)]]; float4 out_var_TEXCOORD0_0 [[user(locn2)]]; float4 out_var_COLOR1 [[user(locn3)]]; float4 out_var_COLOR2 [[user(locn4)]]; float4 out_var_TEXCOORD6 [[user(locn5)]]; float3 out_var_TEXCOORD7 [[user(locn6)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_COLOR1 [[attribute(0)]]; float4 in_var_COLOR2 [[attribute(1)]]; float4 in_var_TEXCOORD0_0 [[attribute(5)]]; float4 in_var_TEXCOORD10_centroid [[attribute(6)]]; float4 in_var_TEXCOORD11_centroid [[attribute(7)]]; float3 in_var_TEXCOORD7 [[attribute(8)]]; float4 in_var_VS_To_DS_Position [[attribute(9)]]; }; struct main0_patchIn { patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant type_View& View [[buffer(0)]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray out_var_TEXCOORD0 = {}; spvUnsafeArray _77 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD10_centroid, patchIn.gl_in[1].in_var_TEXCOORD10_centroid, patchIn.gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _78 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD11_centroid, patchIn.gl_in[1].in_var_TEXCOORD11_centroid, patchIn.gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray, 3> _79 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD0_0 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_TEXCOORD0_0 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_TEXCOORD0_0 }) }); spvUnsafeArray _80 = spvUnsafeArray({ patchIn.gl_in[0].in_var_COLOR1, patchIn.gl_in[1].in_var_COLOR1, patchIn.gl_in[2].in_var_COLOR1 }); spvUnsafeArray _81 = spvUnsafeArray({ patchIn.gl_in[0].in_var_COLOR2, patchIn.gl_in[1].in_var_COLOR2, patchIn.gl_in[2].in_var_COLOR2 }); spvUnsafeArray _97 = spvUnsafeArray({ patchIn.gl_in[0].in_var_VS_To_DS_Position, patchIn.gl_in[1].in_var_VS_To_DS_Position, patchIn.gl_in[2].in_var_VS_To_DS_Position }); spvUnsafeArray _98 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD7, patchIn.gl_in[1].in_var_TEXCOORD7, patchIn.gl_in[2].in_var_TEXCOORD7 }); float4 _111 = float4(gl_TessCoord.x); float4 _113 = float4(gl_TessCoord.y); float4 _116 = float4(gl_TessCoord.z); float4 _118 = ((_97[0] * _111) + (_97[1] * _113)) + (_97[2] * _116); spvUnsafeArray _72; _72 = _79[0]; spvUnsafeArray _71; _71 = _79[1]; float3 _120 = float3(gl_TessCoord.x); float3 _123 = float3(gl_TessCoord.y); spvUnsafeArray _73; for (int _133 = 0; _133 < 1; ) { _73[_133] = (_72[_133] * _111) + (_71[_133] * _113); _133++; continue; } spvUnsafeArray _75; _75 = _73; spvUnsafeArray _74; _74 = _79[2]; float3 _155 = float3(gl_TessCoord.z); float3 _157 = ((_77[0].xyz * _120) + (_77[1].xyz * _123)).xyz + (_77[2].xyz * _155); spvUnsafeArray _76; for (int _164 = 0; _164 < 1; ) { _76[_164] = _75[_164] + (_74[_164] * _116); _164++; continue; } float4 _181 = float4(_118.x, _118.y, _118.z, _118.w); out.out_var_TEXCOORD10_centroid = float4(_157.x, _157.y, _157.z, _68.w); out.out_var_TEXCOORD11_centroid = ((_78[0] * _111) + (_78[1] * _113)) + (_78[2] * _116); out_var_TEXCOORD0 = _76; out.out_var_COLOR1 = ((_80[0] * _111) + (_80[1] * _113)) + (_80[2] * _116); out.out_var_COLOR2 = ((_81[0] * _111) + (_81[1] * _113)) + (_81[2] * _116); out.out_var_TEXCOORD6 = _181; out.out_var_TEXCOORD7 = ((_98[0] * _120) + (_98[1] * _123)) + (_98[2] * _155); out.gl_Position = View.View_TranslatedWorldToClip * _181; out.out_var_TEXCOORD0_0 = out_var_TEXCOORD0[0]; return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/vert/000077500000000000000000000000001400026215700230165ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/vert/array-missing-copies.asm.vert000066400000000000000000000455341400026215700305570ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_MobileBasePass { float4 MobileBasePass_Fog_ExponentialFogParameters; float4 MobileBasePass_Fog_ExponentialFogParameters2; float4 MobileBasePass_Fog_ExponentialFogColorParameter; float4 MobileBasePass_Fog_ExponentialFogParameters3; float4 MobileBasePass_Fog_InscatteringLightDirection; float4 MobileBasePass_Fog_DirectionalInscatteringColor; float2 MobileBasePass_Fog_SinCosInscatteringColorCubemapRotation; float PrePadding_MobileBasePass_Fog_104; float PrePadding_MobileBasePass_Fog_108; packed_float3 MobileBasePass_Fog_FogInscatteringTextureParameters; float MobileBasePass_Fog_ApplyVolumetricFog; float PrePadding_MobileBasePass_PlanarReflection_128; float PrePadding_MobileBasePass_PlanarReflection_132; float PrePadding_MobileBasePass_PlanarReflection_136; float PrePadding_MobileBasePass_PlanarReflection_140; float PrePadding_MobileBasePass_PlanarReflection_144; float PrePadding_MobileBasePass_PlanarReflection_148; float PrePadding_MobileBasePass_PlanarReflection_152; float PrePadding_MobileBasePass_PlanarReflection_156; float4 MobileBasePass_PlanarReflection_ReflectionPlane; float4 MobileBasePass_PlanarReflection_PlanarReflectionOrigin; float4 MobileBasePass_PlanarReflection_PlanarReflectionXAxis; float4 MobileBasePass_PlanarReflection_PlanarReflectionYAxis; float3x4 MobileBasePass_PlanarReflection_InverseTransposeMirrorMatrix; packed_float3 MobileBasePass_PlanarReflection_PlanarReflectionParameters; float PrePadding_MobileBasePass_PlanarReflection_284; float2 MobileBasePass_PlanarReflection_PlanarReflectionParameters2; float PrePadding_MobileBasePass_PlanarReflection_296; float PrePadding_MobileBasePass_PlanarReflection_300; float4x4 MobileBasePass_PlanarReflection_ProjectionWithExtraFOV[2]; float4 MobileBasePass_PlanarReflection_PlanarReflectionScreenScaleBias[2]; float2 MobileBasePass_PlanarReflection_PlanarReflectionScreenBound; uint MobileBasePass_PlanarReflection_bIsStereo; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_UseEditorDepthTest; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; float PrePadding_Primitive_380; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightingChannelMask; uint Primitive_LightmapDataIndex; int Primitive_SingleCaptureIndex; }; struct type_LandscapeParameters { float4 LandscapeParameters_HeightmapUVScaleBias; float4 LandscapeParameters_WeightmapUVScaleBias; float4 LandscapeParameters_LandscapeLightmapScaleBias; float4 LandscapeParameters_SubsectionSizeVertsLayerUVPan; float4 LandscapeParameters_SubsectionOffsetParams; float4 LandscapeParameters_LightmapSubsectionOffsetParams; float4x4 LandscapeParameters_LocalToWorldNoScaling; }; struct type_Globals { float4 LodBias; float4 LodValues; float4 SectionLods; float4 NeighborSectionLod[4]; }; struct main0_out { float2 out_var_TEXCOORD0 [[user(locn0)]]; float2 out_var_TEXCOORD1 [[user(locn1)]]; float4 out_var_TEXCOORD2 [[user(locn2)]]; float4 out_var_TEXCOORD3 [[user(locn3)]]; float4 out_var_TEXCOORD8 [[user(locn4)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_ATTRIBUTE0 [[attribute(0)]]; float4 in_var_ATTRIBUTE1_0 [[attribute(1)]]; float4 in_var_ATTRIBUTE1_1 [[attribute(2)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_MobileBasePass& MobileBasePass [[buffer(1)]], constant type_Primitive& Primitive [[buffer(2)]], constant type_LandscapeParameters& LandscapeParameters [[buffer(3)]], constant type_Globals& _Globals [[buffer(4)]]) { main0_out out = {}; spvUnsafeArray in_var_ATTRIBUTE1 = {}; in_var_ATTRIBUTE1[0] = in.in_var_ATTRIBUTE1_0; in_var_ATTRIBUTE1[1] = in.in_var_ATTRIBUTE1_1; float4 _115 = in.in_var_ATTRIBUTE0 * float4(255.0); float2 _116 = _115.zw; float2 _119 = fract(_116 * float2(0.5)) * float2(2.0); float2 _121 = (_116 - _119) * float2(0.0039215688593685626983642578125); float2 _122 = _115.xy; float2 _126 = _122 * float2(_Globals.LodValues.w); float _127 = _126.y; float _128 = _126.x; float4 _132 = float4(_127, _128, 1.0 - _128, 1.0 - _127) * float4(2.0); float4 _186; if (_119.y > 0.5) { float4 _161; if (_119.x > 0.5) { _161 = (_132 * float4(_Globals.SectionLods.w)) + ((float4(1.0) - _132) * _Globals.NeighborSectionLod[3]); } else { _161 = (_132 * float4(_Globals.SectionLods.z)) + ((float4(1.0) - _132) * _Globals.NeighborSectionLod[2]); } _186 = _161; } else { float4 _185; if (_119.x > 0.5) { _185 = (_132 * float4(_Globals.SectionLods.y)) + ((float4(1.0) - _132) * _Globals.NeighborSectionLod[1]); } else { _185 = (_132 * float4(_Globals.SectionLods.x)) + ((float4(1.0) - _132) * _Globals.NeighborSectionLod[0]); } _186 = _185; } float _206; if ((_128 + _127) > 1.0) { float _198; if (_128 < _127) { _198 = _186.w; } else { _198 = _186.z; } _206 = _198; } else { float _205; if (_128 < _127) { _205 = _186.y; } else { _205 = _186.x; } _206 = _205; } float _207 = floor(_206); float _220 = _121.x; float3 _235 = select(select(select(select(select(float3(0.03125, _121.yy), float3(0.0625, _220, _121.y), bool3(_207 < 5.0)), float3(0.125, in_var_ATTRIBUTE1[1].w, _220), bool3(_207 < 4.0)), float3(0.25, in_var_ATTRIBUTE1[1].zw), bool3(_207 < 3.0)), float3(0.5, in_var_ATTRIBUTE1[1].yz), bool3(_207 < 2.0)), float3(1.0, in_var_ATTRIBUTE1[1].xy), bool3(_207 < 1.0)); float _236 = _235.x; float _245 = (((in_var_ATTRIBUTE1[0].x * 65280.0) + (in_var_ATTRIBUTE1[0].y * 255.0)) - 32768.0) * 0.0078125; float _252 = (((in_var_ATTRIBUTE1[0].z * 65280.0) + (in_var_ATTRIBUTE1[0].w * 255.0)) - 32768.0) * 0.0078125; float2 _257 = floor(_122 * float2(_236)); float2 _271 = float2((LandscapeParameters.LandscapeParameters_SubsectionSizeVertsLayerUVPan.x * _236) - 1.0, fast::max((LandscapeParameters.LandscapeParameters_SubsectionSizeVertsLayerUVPan.x * 0.5) * _236, 2.0) - 1.0) * float2(LandscapeParameters.LandscapeParameters_SubsectionSizeVertsLayerUVPan.y); float3 _287 = mix(float3(_257 / float2(_271.x), mix(_245, _252, _235.y)), float3(floor(_257 * float2(0.5)) / float2(_271.y), mix(_245, _252, _235.z)), float3(_206 - _207)); float2 _288 = _119.xy; float2 _292 = _288 * LandscapeParameters.LandscapeParameters_SubsectionOffsetParams.ww; float3 _296 = _287 + float3(_292, 0.0); float4 _322 = float4((((Primitive.Primitive_LocalToWorld[0u].xyz * _296.xxx) + (Primitive.Primitive_LocalToWorld[1u].xyz * _296.yyy)) + (Primitive.Primitive_LocalToWorld[2u].xyz * _296.zzz)) + (Primitive.Primitive_LocalToWorld[3u].xyz + float3(View.View_PreViewTranslation)), 1.0); float2 _323 = _287.xy; float4 _338 = float4(_322.x, _322.y, _322.z, _322.w); float4 _339 = View.View_TranslatedWorldToClip * _338; float3 _341 = _322.xyz - float3(View.View_TranslatedWorldCameraOrigin); float _345 = dot(_341, _341); float _346 = rsqrt(_345); float _347 = _345 * _346; float _354 = _341.z; float _357 = fast::max(0.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters.w); float _393; float _394; float _395; float _396; if (_357 > 0.0) { float _361 = _357 * _346; float _362 = _361 * _354; float _365 = View.View_WorldCameraOrigin[2] + _362; _393 = (1.0 - _361) * _347; _394 = MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.z * exp2(-fast::max(-127.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.y * (_365 - MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.w))); _395 = MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters3.x * exp2(-fast::max(-127.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters.y * (_365 - MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters3.y))); _396 = _354 - _362; } else { _393 = _347; _394 = MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.x; _395 = MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters.x; _396 = _354; } float _400 = fast::max(-127.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters.y * _396); float _417 = fast::max(-127.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.y * _396); float _428 = (_395 * ((abs(_400) > 0.00999999977648258209228515625) ? ((1.0 - exp2(-_400)) / _400) : (0.693147182464599609375 - (0.2402265071868896484375 * _400)))) + (_394 * ((abs(_417) > 0.00999999977648258209228515625) ? ((1.0 - exp2(-_417)) / _417) : (0.693147182464599609375 - (0.2402265071868896484375 * _417)))); float3 _459; if (MobileBasePass.MobileBasePass_Fog_InscatteringLightDirection.w >= 0.0) { _459 = (MobileBasePass.MobileBasePass_Fog_DirectionalInscatteringColor.xyz * float3(pow(fast::clamp(dot(_341 * float3(_346), MobileBasePass.MobileBasePass_Fog_InscatteringLightDirection.xyz), 0.0, 1.0), MobileBasePass.MobileBasePass_Fog_DirectionalInscatteringColor.w))) * float3(1.0 - fast::clamp(exp2(-(_428 * fast::max(_393 - MobileBasePass.MobileBasePass_Fog_InscatteringLightDirection.w, 0.0))), 0.0, 1.0)); } else { _459 = float3(0.0); } bool _468 = (MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters3.w > 0.0) && (_347 > MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters3.w); float _471 = _468 ? 1.0 : fast::max(fast::clamp(exp2(-(_428 * _393)), 0.0, 1.0), MobileBasePass.MobileBasePass_Fog_ExponentialFogColorParameter.w); float4 _479 = float4((MobileBasePass.MobileBasePass_Fog_ExponentialFogColorParameter.xyz * float3(1.0 - _471)) + select(_459, float3(0.0), bool3(_468)), _471); float4 _482 = _338; _482.w = _339.w; out.out_var_TEXCOORD0 = ((_323 + LandscapeParameters.LandscapeParameters_SubsectionSizeVertsLayerUVPan.zw) + _292).xy; out.out_var_TEXCOORD1 = ((_323 * LandscapeParameters.LandscapeParameters_WeightmapUVScaleBias.xy) + LandscapeParameters.LandscapeParameters_WeightmapUVScaleBias.zw) + (_288 * LandscapeParameters.LandscapeParameters_SubsectionOffsetParams.zz); out.out_var_TEXCOORD2 = float4(float4(0.0).x, float4(0.0).y, _479.x, _479.y); out.out_var_TEXCOORD3 = float4(float4(0.0).x, float4(0.0).y, _479.z, _479.w); out.out_var_TEXCOORD8 = _482; out.gl_Position = _339; return out; } spirv-cross-2021.01.15/reference/opt/shaders-ue4/asm/vert/texture-buffer.asm.vert000066400000000000000000000415211400026215700274510ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_UseEditorDepthTest; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; float PrePadding_Primitive_380; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightingChannelMask; uint Primitive_LightmapDataIndex; int Primitive_SingleCaptureIndex; }; struct type_MobileShadowDepthPass { float PrePadding_MobileShadowDepthPass_0; float PrePadding_MobileShadowDepthPass_4; float PrePadding_MobileShadowDepthPass_8; float PrePadding_MobileShadowDepthPass_12; float PrePadding_MobileShadowDepthPass_16; float PrePadding_MobileShadowDepthPass_20; float PrePadding_MobileShadowDepthPass_24; float PrePadding_MobileShadowDepthPass_28; float PrePadding_MobileShadowDepthPass_32; float PrePadding_MobileShadowDepthPass_36; float PrePadding_MobileShadowDepthPass_40; float PrePadding_MobileShadowDepthPass_44; float PrePadding_MobileShadowDepthPass_48; float PrePadding_MobileShadowDepthPass_52; float PrePadding_MobileShadowDepthPass_56; float PrePadding_MobileShadowDepthPass_60; float PrePadding_MobileShadowDepthPass_64; float PrePadding_MobileShadowDepthPass_68; float PrePadding_MobileShadowDepthPass_72; float PrePadding_MobileShadowDepthPass_76; float4x4 MobileShadowDepthPass_ProjectionMatrix; float2 MobileShadowDepthPass_ShadowParams; float MobileShadowDepthPass_bClampToNearPlane; float PrePadding_MobileShadowDepthPass_156; float4x4 MobileShadowDepthPass_ShadowViewProjectionMatrices[6]; }; struct type_EmitterDynamicUniforms { float2 EmitterDynamicUniforms_LocalToWorldScale; float EmitterDynamicUniforms_EmitterInstRandom; float PrePadding_EmitterDynamicUniforms_12; float4 EmitterDynamicUniforms_AxisLockRight; float4 EmitterDynamicUniforms_AxisLockUp; float4 EmitterDynamicUniforms_DynamicColor; float4 EmitterDynamicUniforms_MacroUVParameters; }; struct type_EmitterUniforms { float4 EmitterUniforms_ColorCurve; float4 EmitterUniforms_ColorScale; float4 EmitterUniforms_ColorBias; float4 EmitterUniforms_MiscCurve; float4 EmitterUniforms_MiscScale; float4 EmitterUniforms_MiscBias; float4 EmitterUniforms_SizeBySpeed; float4 EmitterUniforms_SubImageSize; float4 EmitterUniforms_TangentSelector; packed_float3 EmitterUniforms_CameraFacingBlend; float EmitterUniforms_RemoveHMDRoll; float EmitterUniforms_RotationRateScale; float EmitterUniforms_RotationBias; float EmitterUniforms_CameraMotionBlurAmount; float PrePadding_EmitterUniforms_172; float2 EmitterUniforms_PivotOffset; }; struct type_Globals { uint ParticleIndicesOffset; }; struct main0_out { float out_var_TEXCOORD6 [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float2 in_var_ATTRIBUTE0 [[attribute(0)]]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } vertex main0_out main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_Primitive& Primitive [[buffer(1)]], constant type_MobileShadowDepthPass& MobileShadowDepthPass [[buffer(2)]], constant type_EmitterDynamicUniforms& EmitterDynamicUniforms [[buffer(3)]], constant type_EmitterUniforms& EmitterUniforms [[buffer(4)]], constant type_Globals& _Globals [[buffer(5)]], texture2d ParticleIndices [[texture(0)]], texture2d PositionTexture [[texture(1)]], texture2d VelocityTexture [[texture(2)]], texture2d AttributesTexture [[texture(3)]], texture2d CurveTexture [[texture(4)]], sampler PositionTextureSampler [[sampler(0)]], sampler VelocityTextureSampler [[sampler(1)]], sampler AttributesTextureSampler [[sampler(2)]], sampler CurveTextureSampler [[sampler(3)]], uint gl_VertexIndex [[vertex_id]], uint gl_InstanceIndex [[instance_id]]) { main0_out out = {}; float2 _133 = ParticleIndices.read(spvTexelBufferCoord((_Globals.ParticleIndicesOffset + ((gl_InstanceIndex * 16u) + (gl_VertexIndex / 4u))))).xy; float4 _137 = PositionTexture.sample(PositionTextureSampler, _133, level(0.0)); float4 _145 = AttributesTexture.sample(AttributesTextureSampler, _133, level(0.0)); float _146 = _137.w; float3 _158 = float3x3(Primitive.Primitive_LocalToWorld[0].xyz, Primitive.Primitive_LocalToWorld[1].xyz, Primitive.Primitive_LocalToWorld[2].xyz) * VelocityTexture.sample(VelocityTextureSampler, _133, level(0.0)).xyz; float3 _160 = normalize(_158 + float3(0.0, 0.0, 9.9999997473787516355514526367188e-05)); float2 _204 = ((((_145.xy + float2((_145.x < 0.5) ? 0.0 : (-0.5), (_145.y < 0.5) ? 0.0 : (-0.5))) * float2(2.0)) * (((CurveTexture.sample(CurveTextureSampler, (EmitterUniforms.EmitterUniforms_MiscCurve.xy + (EmitterUniforms.EmitterUniforms_MiscCurve.zw * float2(_146))), level(0.0)) * EmitterUniforms.EmitterUniforms_MiscScale) + EmitterUniforms.EmitterUniforms_MiscBias).xy * EmitterDynamicUniforms.EmitterDynamicUniforms_LocalToWorldScale)) * fast::min(fast::max(EmitterUniforms.EmitterUniforms_SizeBySpeed.xy * float2(length(_158)), float2(1.0)), EmitterUniforms.EmitterUniforms_SizeBySpeed.zw)) * float2(step(_146, 1.0)); float3 _239 = float4((((Primitive.Primitive_LocalToWorld[0u].xyz * _137.xxx) + (Primitive.Primitive_LocalToWorld[1u].xyz * _137.yyy)) + (Primitive.Primitive_LocalToWorld[2u].xyz * _137.zzz)) + (Primitive.Primitive_LocalToWorld[3u].xyz + float3(View.View_PreViewTranslation)), 1.0).xyz; float3 _242 = float3(EmitterUniforms.EmitterUniforms_RemoveHMDRoll); float3 _251 = mix(mix(float3(View.View_ViewRight), float3(View.View_HMDViewNoRollRight), _242), EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockRight.xyz, float3(EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockRight.w)); float3 _259 = mix(-mix(float3(View.View_ViewUp), float3(View.View_HMDViewNoRollUp), _242), EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockUp.xyz, float3(EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockUp.w)); float3 _260 = float3(View.View_TranslatedWorldCameraOrigin) - _239; float _261 = dot(_260, _260); float3 _265 = _260 / float3(sqrt(fast::max(_261, 0.00999999977648258209228515625))); float3 _335; float3 _336; if (EmitterUniforms.EmitterUniforms_CameraFacingBlend[0] > 0.0) { float3 _279 = cross(_265, float3(0.0, 0.0, 1.0)); float3 _284 = _279 / float3(sqrt(fast::max(dot(_279, _279), 0.00999999977648258209228515625))); float3 _286 = float3(fast::clamp((_261 * EmitterUniforms.EmitterUniforms_CameraFacingBlend[1]) - EmitterUniforms.EmitterUniforms_CameraFacingBlend[2], 0.0, 1.0)); _335 = normalize(mix(_251, _284, _286)); _336 = normalize(mix(_259, cross(_265, _284), _286)); } else { float3 _333; float3 _334; if (EmitterUniforms.EmitterUniforms_TangentSelector.y > 0.0) { float3 _297 = cross(_265, _160); _333 = _297 / float3(sqrt(fast::max(dot(_297, _297), 0.00999999977648258209228515625))); _334 = -_160; } else { float3 _331; float3 _332; if (EmitterUniforms.EmitterUniforms_TangentSelector.z > 0.0) { float3 _310 = cross(EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockRight.xyz, _265); _331 = EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockRight.xyz; _332 = -(_310 / float3(sqrt(fast::max(dot(_310, _310), 0.00999999977648258209228515625)))); } else { float3 _329; float3 _330; if (EmitterUniforms.EmitterUniforms_TangentSelector.w > 0.0) { float3 _322 = cross(_265, float3(0.0, 0.0, 1.0)); float3 _327 = _322 / float3(sqrt(fast::max(dot(_322, _322), 0.00999999977648258209228515625))); _329 = _327; _330 = cross(_265, _327); } else { _329 = _251; _330 = _259; } _331 = _329; _332 = _330; } _333 = _331; _334 = _332; } _335 = _333; _336 = _334; } float _339 = ((_145.z + ((_145.w * EmitterUniforms.EmitterUniforms_RotationRateScale) * _146)) * 6.283185482025146484375) + EmitterUniforms.EmitterUniforms_RotationBias; float3 _342 = float3(sin(_339)); float3 _344 = float3(cos(_339)); float4 _371 = float4(_239 + ((float3(_204.x * (in.in_var_ATTRIBUTE0.x + EmitterUniforms.EmitterUniforms_PivotOffset.x)) * ((_342 * _336) + (_344 * _335))) + (float3(_204.y * (in.in_var_ATTRIBUTE0.y + EmitterUniforms.EmitterUniforms_PivotOffset.y)) * ((_344 * _336) - (_342 * _335)))), 1.0); float4 _375 = MobileShadowDepthPass.MobileShadowDepthPass_ProjectionMatrix * float4(_371.x, _371.y, _371.z, _371.w); float4 _386; if ((MobileShadowDepthPass.MobileShadowDepthPass_bClampToNearPlane > 0.0) && (_375.z < 0.0)) { float4 _384 = _375; _384.z = 9.9999999747524270787835121154785e-07; float4 _385 = _384; _385.w = 1.0; _386 = _385; } else { _386 = _375; } float4 _396 = _386; _396.z = ((_386.z * MobileShadowDepthPass.MobileShadowDepthPass_ShadowParams.y) + MobileShadowDepthPass.MobileShadowDepthPass_ShadowParams.x) * _386.w; out.out_var_TEXCOORD6 = 0.0; out.gl_Position = _396; return out; } spirv-cross-2021.01.15/reference/opt/shaders/000077500000000000000000000000001400026215700205635ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/amd/000077500000000000000000000000001400026215700213245ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/amd/gcn_shader.comp000066400000000000000000000002651400026215700243040ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require #extension GL_AMD_gcn_shader : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; void main() { } spirv-cross-2021.01.15/reference/opt/shaders/amd/shader_ballot.comp000066400000000000000000000012501400026215700250050ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require #extension GL_ARB_shader_ballot : require #extension GL_AMD_shader_ballot : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer inputData { float inputDataArray[]; } _12; layout(binding = 1, std430) buffer outputData { float outputDataArray[]; } _74; void main() { bool _31 = _12.inputDataArray[gl_LocalInvocationID.x] > 0.0; uvec4 _37 = uvec4(unpackUint2x32(ballotARB(_31)), 0u, 0u); uint _44 = mbcntAMD(packUint2x32(uvec2(_37.xy))); if (_31) { _74.outputDataArray[_44] = _12.inputDataArray[gl_LocalInvocationID.x]; } } spirv-cross-2021.01.15/reference/opt/shaders/amd/shader_group_vote.comp000066400000000000000000000004431400026215700257240ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_group_vote : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer inputData { float inputDataArray[]; } _12; void main() { bool _31 = _12.inputDataArray[gl_LocalInvocationID.x] > 0.0; } spirv-cross-2021.01.15/reference/opt/shaders/amd/shader_trinary_minmax.comp000066400000000000000000000002231400026215700265700ustar00rootroot00000000000000#version 450 #extension GL_AMD_shader_trinary_minmax : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; void main() { } spirv-cross-2021.01.15/reference/opt/shaders/asm/000077500000000000000000000000001400026215700213435ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/000077500000000000000000000000001400026215700223015ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/atomic-decrement.asm.comp000066400000000000000000000006021400026215700271560ustar00rootroot00000000000000#version 450 layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer u0_counters { uint c; } u0_counter; layout(binding = 0, r32ui) uniform writeonly uimageBuffer u0; void main() { uint _29 = atomicAdd(u0_counter.c, uint(-1)); imageStore(u0, floatBitsToInt(uintBitsToFloat(_29)), uvec4(uint(int(gl_GlobalInvocationID.x)))); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/atomic-increment.asm.comp000066400000000000000000000005741400026215700272040ustar00rootroot00000000000000#version 450 layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer u0_counters { uint c; } u0_counter; layout(binding = 0, r32ui) uniform writeonly uimageBuffer u0; void main() { uint _29 = atomicAdd(u0_counter.c, 1u); imageStore(u0, floatBitsToInt(uintBitsToFloat(_29)), uvec4(uint(int(gl_GlobalInvocationID.x)))); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/bitcast_iadd.asm.comp000066400000000000000000000010551400026215700263530ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) restrict buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) restrict buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { _6._m0 = _5._m1 + uvec4(_5._m0); _6._m0 = uvec4(_5._m0) + _5._m1; _6._m0 = _5._m1 + _5._m1; _6._m0 = uvec4(_5._m0 + _5._m0); _6._m1 = ivec4(_5._m1 + _5._m1); _6._m1 = _5._m0 + _5._m0; _6._m1 = ivec4(_5._m1) + _5._m0; _6._m1 = _5._m0 + ivec4(_5._m1); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/bitcast_icmp.asm.comp000066400000000000000000000015731400026215700264070ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) restrict buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) restrict buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { _6._m0 = mix(uvec4(0u), uvec4(1u), lessThan(ivec4(_5._m1), _5._m0)); _6._m0 = mix(uvec4(0u), uvec4(1u), lessThanEqual(ivec4(_5._m1), _5._m0)); _6._m0 = mix(uvec4(0u), uvec4(1u), lessThan(_5._m1, uvec4(_5._m0))); _6._m0 = mix(uvec4(0u), uvec4(1u), lessThanEqual(_5._m1, uvec4(_5._m0))); _6._m0 = mix(uvec4(0u), uvec4(1u), greaterThan(ivec4(_5._m1), _5._m0)); _6._m0 = mix(uvec4(0u), uvec4(1u), greaterThanEqual(ivec4(_5._m1), _5._m0)); _6._m0 = mix(uvec4(0u), uvec4(1u), greaterThan(_5._m1, uvec4(_5._m0))); _6._m0 = mix(uvec4(0u), uvec4(1u), greaterThanEqual(_5._m1, uvec4(_5._m0))); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/bitcast_iequal.asm.comp000066400000000000000000000014431400026215700267330ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { ivec4 _30 = _5._m0; uvec4 _31 = _5._m1; bvec4 _34 = equal(ivec4(_31), _30); bvec4 _35 = equal(_30, ivec4(_31)); bvec4 _36 = equal(_31, _31); bvec4 _37 = equal(_30, _30); _6._m0 = mix(uvec4(0u), uvec4(1u), _34); _6._m0 = mix(uvec4(0u), uvec4(1u), _35); _6._m0 = mix(uvec4(0u), uvec4(1u), _36); _6._m0 = mix(uvec4(0u), uvec4(1u), _37); _6._m1 = mix(ivec4(0), ivec4(1), _34); _6._m1 = mix(ivec4(0), ivec4(1), _35); _6._m1 = mix(ivec4(0), ivec4(1), _36); _6._m1 = mix(ivec4(0), ivec4(1), _37); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/bitcast_sar.asm.comp000066400000000000000000000011151400026215700262340ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { ivec4 _22 = _5._m0; uvec4 _23 = _5._m1; _6._m0 = uvec4(ivec4(_23) >> _22); _6._m0 = uvec4(_22 >> ivec4(_23)); _6._m0 = uvec4(ivec4(_23) >> ivec4(_23)); _6._m0 = uvec4(_22 >> _22); _6._m1 = ivec4(_23) >> ivec4(_23); _6._m1 = _22 >> _22; _6._m1 = ivec4(_23) >> _22; _6._m1 = _22 >> ivec4(_23); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/bitcast_sdiv.asm.comp000066400000000000000000000011051400026215700264130ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { ivec4 _22 = _5._m0; uvec4 _23 = _5._m1; _6._m0 = uvec4(ivec4(_23) / _22); _6._m0 = uvec4(_22 / ivec4(_23)); _6._m0 = uvec4(ivec4(_23) / ivec4(_23)); _6._m0 = uvec4(_22 / _22); _6._m1 = ivec4(_23) / ivec4(_23); _6._m1 = _22 / _22; _6._m1 = ivec4(_23) / _22; _6._m1 = _22 / ivec4(_23); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/bitcast_slr.asm.comp000066400000000000000000000011151400026215700262470ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { ivec4 _22 = _5._m0; uvec4 _23 = _5._m1; _6._m0 = _23 >> uvec4(_22); _6._m0 = uvec4(_22) >> _23; _6._m0 = _23 >> _23; _6._m0 = uvec4(_22) >> uvec4(_22); _6._m1 = ivec4(_23 >> _23); _6._m1 = ivec4(uvec4(_22) >> uvec4(_22)); _6._m1 = ivec4(_23 >> uvec4(_22)); _6._m1 = ivec4(uvec4(_22) >> _23); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/block-name-alias-global.asm.comp000066400000000000000000000013011400026215700302700ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct A { int a; int b; }; layout(binding = 1, std430) buffer C1 { A Data[]; } C1_1; layout(binding = 2, std140) uniform C2 { A Data[1024]; } C2_1; layout(binding = 0, std430) buffer B { A Data[]; } C3; layout(binding = 3, std140) uniform B { A Data[1024]; } C4; void main() { C1_1.Data[gl_GlobalInvocationID.x].a = C2_1.Data[gl_GlobalInvocationID.x].a; C1_1.Data[gl_GlobalInvocationID.x].b = C2_1.Data[gl_GlobalInvocationID.x].b; C3.Data[gl_GlobalInvocationID.x].a = C4.Data[gl_GlobalInvocationID.x].a; C3.Data[gl_GlobalInvocationID.x].b = C4.Data[gl_GlobalInvocationID.x].b; } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/builtin-compute-bitcast.asm.comp000066400000000000000000000003471400026215700305130ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer BUF { int values[]; } _6; void main() { _6.values[int(gl_WorkGroupID.y)] = int(gl_GlobalInvocationID.z); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/decoration-group.asm.comp000066400000000000000000000014131400026215700272200ustar00rootroot00000000000000#version 430 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 5, std430) buffer _6_15 { float _m0[]; } _15; layout(binding = 0, std430) buffer _7_16 { float _m0[]; } _16; layout(binding = 1, std430) buffer _8_17 { float _m0[]; } _17; layout(binding = 2, std430) restrict readonly buffer _9_18 { float _m0[]; } _18; layout(binding = 3, std430) restrict readonly buffer _10_19 { float _m0[]; } _19; layout(binding = 4, std430) restrict readonly buffer _11_20 { float _m0[]; } _20; void main() { _15._m0[gl_GlobalInvocationID.x] = (((_16._m0[gl_GlobalInvocationID.x] + _17._m0[gl_GlobalInvocationID.x]) + _18._m0[gl_GlobalInvocationID.x]) + _19._m0[gl_GlobalInvocationID.x]) + _20._m0[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/global-parameter-name-alias.asm.comp000066400000000000000000000001401400026215700311560ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; void main() { } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/hlsl-functionality.asm.comp000066400000000000000000000005061400026215700275710ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer Buf { vec4 _data[]; } Buf_1; layout(binding = 1, std430) buffer Buf_count { int _count; } Buf_count_1; void main() { int _33 = atomicAdd(Buf_count_1._count, 1); Buf_1._data[_33] = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/logical.asm.comp000066400000000000000000000001431400026215700253500ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; void main() { } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/multiple-entry.asm.comp000066400000000000000000000010551400026215700267330ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) restrict buffer _6_8 { ivec4 _m0; uvec4 _m1; } _8; layout(binding = 1, std430) restrict buffer _7_9 { uvec4 _m0; ivec4 _m1; } _9; void main() { _9._m0 = _8._m1 + uvec4(_8._m0); _9._m0 = uvec4(_8._m0) + _8._m1; _9._m0 = _8._m1 + _8._m1; _9._m0 = uvec4(_8._m0 + _8._m0); _9._m1 = ivec4(_8._m1 + _8._m1); _9._m1 = _8._m0 + _8._m0; _9._m1 = ivec4(_8._m1) + _8._m0; _9._m1 = _8._m0 + ivec4(_8._m1); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/nmin-max-clamp.asm.comp000066400000000000000000000036611400026215700265640ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { float a1; vec2 a2; vec3 a3; vec4 a4; float b1; vec2 b2; vec3 b3; vec4 b4; float c1; vec2 c2; vec3 c3; vec4 c4; } _4; void main() { _4.a1 = isnan(_4.c1) ? _4.b1 : (isnan(_4.b1) ? _4.c1 : min(_4.b1, _4.c1)); _4.a2 = mix(mix(min(_4.b2, _4.c2), _4.c2, isnan(_4.b2)), _4.b2, isnan(_4.c2)); _4.a3 = mix(mix(min(_4.b3, _4.c3), _4.c3, isnan(_4.b3)), _4.b3, isnan(_4.c3)); _4.a4 = mix(mix(min(_4.b4, _4.c4), _4.c4, isnan(_4.b4)), _4.b4, isnan(_4.c4)); _4.a1 = isnan(_4.c1) ? _4.b1 : (isnan(_4.b1) ? _4.c1 : max(_4.b1, _4.c1)); _4.a2 = mix(mix(max(_4.b2, _4.c2), _4.c2, isnan(_4.b2)), _4.b2, isnan(_4.c2)); _4.a3 = mix(mix(max(_4.b3, _4.c3), _4.c3, isnan(_4.b3)), _4.b3, isnan(_4.c3)); _4.a4 = mix(mix(max(_4.b4, _4.c4), _4.c4, isnan(_4.b4)), _4.b4, isnan(_4.c4)); float _180 = isnan(_4.b1) ? _4.a1 : (isnan(_4.a1) ? _4.b1 : max(_4.a1, _4.b1)); _4.a1 = isnan(_4.c1) ? _180 : (isnan(_180) ? _4.c1 : min(_180, _4.c1)); vec2 _191 = mix(mix(max(_4.a2, _4.b2), _4.b2, isnan(_4.a2)), _4.a2, isnan(_4.b2)); _4.a2 = mix(mix(min(_191, _4.c2), _4.c2, isnan(_191)), _191, isnan(_4.c2)); vec3 _202 = mix(mix(max(_4.a3, _4.b3), _4.b3, isnan(_4.a3)), _4.a3, isnan(_4.b3)); _4.a3 = mix(mix(min(_202, _4.c3), _4.c3, isnan(_202)), _202, isnan(_4.c3)); vec4 _213 = mix(mix(max(_4.a4, _4.b4), _4.b4, isnan(_4.a4)), _4.a4, isnan(_4.b4)); _4.a4 = mix(mix(min(_213, _4.c4), _4.c4, isnan(_213)), _213, isnan(_4.c4)); for (int _139 = 0; _139 < 2; ) { _4.a2 = mix(mix(min(_4.b2, _4.c2), _4.c2, isnan(_4.b2)), _4.b2, isnan(_4.c2)); float _229 = isnan(_4.b2.x) ? _4.a1 : (isnan(_4.a1) ? _4.b2.x : max(_4.a1, _4.b2.x)); _4.a1 = isnan(_4.b2.y) ? _229 : (isnan(_229) ? _4.b2.y : min(_229, _4.b2.y)); _139++; continue; } } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/op-phi-swap.asm.comp000066400000000000000000000011711400026215700261040ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_4 { float _m0[]; } _4; layout(binding = 1, std430) buffer _3_5 { float _m0[]; } _5; void main() { bool _34; float _35; float _35_copy; float _36; _34 = true; _35 = _4._m0[gl_GlobalInvocationID.x]; _36 = 8.5; for (;;) { if (_34) { _34 = false; _35_copy = _35; _35 = _36; _36 = _35_copy; } else { break; } } _5._m0[gl_GlobalInvocationID.x] = _35 - _36; } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/quantize.asm.comp000066400000000000000000000011101400026215700255710ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO0 { float scalar; vec2 vec2_val; vec3 vec3_val; vec4 vec4_val; } _4; void main() { _4.scalar = unpackHalf2x16(packHalf2x16(vec2(_4.scalar))).x; _4.vec2_val = unpackHalf2x16(packHalf2x16(_4.vec2_val)); _4.vec3_val = vec3(unpackHalf2x16(packHalf2x16(_4.vec3_val.xy)), unpackHalf2x16(packHalf2x16(_4.vec3_val.zz)).x); _4.vec4_val = vec4(unpackHalf2x16(packHalf2x16(_4.vec4_val.xy)), unpackHalf2x16(packHalf2x16(_4.vec4_val.zw))); } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/recompile-block-naming.asm.comp000066400000000000000000000016551400026215700302650ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer MyFirstBuffer { uint _data[]; } MyFirstBuffer_1; layout(binding = 0, std430) buffer MySecondBuffer { uint _data[]; } MySecondBuffer_1; layout(binding = 0, std430) buffer MyThirdBuffer { uint _data[]; } MyThirdBuffer_1; void main() { uint _106 = MyFirstBuffer_1._data[0]; uint _110 = MyFirstBuffer_1._data[1]; uint _114 = MyFirstBuffer_1._data[2]; uint _118 = MyFirstBuffer_1._data[3]; uint _123 = MySecondBuffer_1._data[1]; uint _127 = MySecondBuffer_1._data[2]; uint _131 = MySecondBuffer_1._data[3]; uint _135 = MySecondBuffer_1._data[4]; uvec4 _141 = uvec4(_106, _110, _114, _118) + uvec4(_123, _127, _131, _135); MyThirdBuffer_1._data[0] = _141.x; MyThirdBuffer_1._data[1] = _141.y; MyThirdBuffer_1._data[2] = _141.z; MyThirdBuffer_1._data[3] = _141.w; } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/specialization-constant-workgroup.asm.comp000066400000000000000000000006071400026215700326450ustar00rootroot00000000000000#version 310 es #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 9u #endif #ifndef SPIRV_CROSS_CONSTANT_ID_12 #define SPIRV_CROSS_CONSTANT_ID_12 4u #endif layout(local_size_x = SPIRV_CROSS_CONSTANT_ID_10, local_size_y = 20, local_size_z = SPIRV_CROSS_CONSTANT_ID_12) in; layout(binding = 0, std430) buffer SSBO { float a; } _4; void main() { _4.a += 1.0; } spirv-cross-2021.01.15/reference/opt/shaders/asm/comp/switch-break-ladder.asm.comp000066400000000000000000000027011400026215700275540ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer BUF { int a; int b; int d; } o; void main() { int _44; _44 = o.a; int _41; for (;;) { int _48; bool _22_ladder_break = false; switch (_44) { case 5: { for (;;) { bool _30_ladder_break = false; switch (o.d) { case 10: case 20: { _30_ladder_break = true; break; } default: { continue; } } if (_30_ladder_break) { break; } } _48 = _44 + _44; break; } case 1: case 2: case 3: { _22_ladder_break = true; break; } default: { _48 = _44; break; } } if (_22_ladder_break) { break; } _41 = _48 + 1; _44 = _41; continue; } o.b = _44; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/000077500000000000000000000000001400026215700222625ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/combined-sampler-reuse.vk.asm.frag000066400000000000000000000004611400026215700306640ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_CombineduTexuSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; void main() { FragColor = texture(SPIRV_Cross_CombineduTexuSampler, vUV); FragColor += textureOffset(SPIRV_Cross_CombineduTexuSampler, vUV, ivec2(1)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/combined-sampler-reuse.vk.asm.frag.vk000066400000000000000000000005331400026215700313030ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 1) uniform texture2D uTex; layout(set = 0, binding = 0) uniform sampler uSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; void main() { FragColor = texture(sampler2D(uTex, uSampler), vUV); FragColor += textureOffset(sampler2D(uTex, uSampler), vUV, ivec2(1)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/complex-name-workarounds.asm.frag000066400000000000000000000003151400026215700306420ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 _; layout(location = 1) in vec4 a; layout(location = 0) out vec4 b; void main() { vec4 _28 = (_ + a) + _; b = _28; b = _; b = _28; b = _; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/composite-construct-struct-no-swizzle.asm.frag000066400000000000000000000002661400026215700333730ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) in vec2 foo; layout(location = 0) out float FooOut; void main() { FooOut = foo.x + foo.y; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/default-member-names.asm.frag000066400000000000000000000001421400026215700276710ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 _3; float _49; void main() { _3 = vec4(_49); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/do-while-statement-fallback.asm.frag000066400000000000000000000001371400026215700311520ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; void main() { FragColor = 5.0; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/empty-struct.asm.frag000066400000000000000000000000371400026215700263620ustar00rootroot00000000000000#version 450 void main() { } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/for-loop-phi-only-continue.asm.frag000066400000000000000000000003451400026215700310200ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { float _19; _19 = 0.0; for (int _22 = 0; _22 < 16; ) { _19 += 1.0; _22++; continue; } FragColor = vec4(_19); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/frem.asm.frag000066400000000000000000000003461400026215700246360ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in vec4 vB; void main() { FragColor = vA - vB * trunc(vA / vB); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/function-overload-alias.asm.frag000066400000000000000000000002261400026215700304270ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(10.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/hlsl-sample-cmp-level-zero-cube.asm.frag000066400000000000000000000006211400026215700316750ustar00rootroot00000000000000#version 450 uniform samplerCubeShadow SPIRV_Cross_CombinedpointLightShadowMapshadowSamplerPCF; layout(location = 0) out float _entryPointOutput; void main() { _entryPointOutput = textureGrad(SPIRV_Cross_CombinedpointLightShadowMapshadowSamplerPCF, vec4(vec4(0.100000001490116119384765625, 0.100000001490116119384765625, 0.100000001490116119384765625, 0.5).xyz, 0.5), vec3(0.0), vec3(0.0)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/hlsl-sample-cmp-level-zero.asm.frag000066400000000000000000000007121400026215700307620ustar00rootroot00000000000000#version 450 uniform sampler2DArrayShadow SPIRV_Cross_CombinedShadowMapShadowSamplerPCF; layout(location = 0) in vec2 texCoords; layout(location = 1) in float cascadeIndex; layout(location = 2) in float fragDepth; layout(location = 0) out vec4 _entryPointOutput; void main() { _entryPointOutput = vec4(textureGrad(SPIRV_Cross_CombinedShadowMapShadowSamplerPCF, vec4(vec4(texCoords, cascadeIndex, fragDepth).xyz, fragDepth), vec2(0.0), vec2(0.0))); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/image-extract-reuse.asm.frag000066400000000000000000000002661400026215700275610ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uTexture; layout(location = 0) out ivec2 Size; void main() { Size = textureSize(uTexture, 0) + textureSize(uTexture, 1); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/image-fetch-no-sampler.asm.vk.frag000066400000000000000000000011651400026215700305500ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler; uniform sampler2D SPIRV_Cross_CombinedSampledImageSampler; layout(location = 0) out vec4 _entryPointOutput; void main() { ivec2 _154 = ivec3(int(gl_FragCoord.x * 1280.0), int(gl_FragCoord.y * 720.0), 0).xy; _entryPointOutput = ((texelFetch(SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler, _154, 0) + texelFetch(SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler, _154, 0)) + texture(SPIRV_Cross_CombinedSampledImageSampler, gl_FragCoord.xy)) + texture(SPIRV_Cross_CombinedSampledImageSampler, gl_FragCoord.xy); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/image-fetch-no-sampler.asm.vk.frag.vk000066400000000000000000000010651400026215700311660ustar00rootroot00000000000000#version 450 #extension GL_EXT_samplerless_texture_functions : require layout(set = 0, binding = 0) uniform sampler Sampler; layout(set = 0, binding = 0) uniform texture2D SampledImage; layout(location = 0) out vec4 _entryPointOutput; void main() { ivec2 _154 = ivec3(int(gl_FragCoord.x * 1280.0), int(gl_FragCoord.y * 720.0), 0).xy; _entryPointOutput = ((texelFetch(SampledImage, _154, 0) + texelFetch(SampledImage, _154, 0)) + texture(sampler2D(SampledImage, Sampler), gl_FragCoord.xy)) + texture(sampler2D(SampledImage, Sampler), gl_FragCoord.xy); } image-fetch-no-sampler.no-samplerless.asm.vk.frag000066400000000000000000000011651400026215700334340ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/frag#version 450 uniform sampler2D SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler; uniform sampler2D SPIRV_Cross_CombinedSampledImageSampler; layout(location = 0) out vec4 _entryPointOutput; void main() { ivec2 _154 = ivec3(int(gl_FragCoord.x * 1280.0), int(gl_FragCoord.y * 720.0), 0).xy; _entryPointOutput = ((texelFetch(SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler, _154, 0) + texelFetch(SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler, _154, 0)) + texture(SPIRV_Cross_CombinedSampledImageSampler, gl_FragCoord.xy)) + texture(SPIRV_Cross_CombinedSampledImageSampler, gl_FragCoord.xy); } image-fetch-no-sampler.no-samplerless.asm.vk.frag.vk000066400000000000000000000012141400026215700340460ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/frag#version 450 layout(set = 0, binding = 0) uniform sampler Sampler; layout(set = 0, binding = 0) uniform texture2D SampledImage; layout(set = 0, binding = 0) uniform sampler SPIRV_Cross_DummySampler; layout(location = 0) out vec4 _entryPointOutput; void main() { ivec2 _154 = ivec3(int(gl_FragCoord.x * 1280.0), int(gl_FragCoord.y * 720.0), 0).xy; _entryPointOutput = ((texelFetch(sampler2D(SampledImage, SPIRV_Cross_DummySampler), _154, 0) + texelFetch(sampler2D(SampledImage, SPIRV_Cross_DummySampler), _154, 0)) + texture(sampler2D(SampledImage, Sampler), gl_FragCoord.xy)) + texture(sampler2D(SampledImage, Sampler), gl_FragCoord.xy); } image-query-no-sampler.no-samplerless.vk.asm.frag000066400000000000000000000000371400026215700335050ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/frag#version 450 void main() { } image-query-no-sampler.no-samplerless.vk.asm.frag.vk000066400000000000000000000000371400026215700341240ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/frag#version 450 void main() { } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/image-query-no-sampler.vk.asm.frag000066400000000000000000000000371400026215700306210ustar00rootroot00000000000000#version 450 void main() { } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/image-query-no-sampler.vk.asm.frag.vk000066400000000000000000000000371400026215700312400ustar00rootroot00000000000000#version 450 void main() { } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/implicit-read-dep-phi.asm.frag000066400000000000000000000012701400026215700277510ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uImage; layout(location = 0) in vec4 v0; layout(location = 0) out vec4 FragColor; void main() { float phi; vec4 _36; int _51; _51 = 0; phi = 1.0; _36 = vec4(1.0, 2.0, 1.0, 2.0); for (;;) { FragColor = _36; if (_51 < 4) { if (v0[_51] > 0.0) { vec2 _48 = vec2(phi); _51++; phi += 2.0; _36 = textureLod(uImage, _48, 0.0); continue; } else { break; } } else { break; } } } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/inf-nan-constant-double.asm.frag000066400000000000000000000005111400026215700303240ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require layout(location = 0) out vec3 FragColor; layout(location = 0) flat in double vTmp; void main() { FragColor = vec3(dvec3(uint64BitsToDouble(0x7ff0000000000000ul), uint64BitsToDouble(0xfff0000000000000ul), uint64BitsToDouble(0x7ff8000000000000ul)) + dvec3(vTmp)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/inf-nan-constant.asm.frag000066400000000000000000000003601400026215700270560ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out highp vec3 FragColor; void main() { FragColor = vec3(uintBitsToFloat(0x7f800000u), uintBitsToFloat(0xff800000u), uintBitsToFloat(0x7fc00000u)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/invalidation.asm.frag000066400000000000000000000002561400026215700263660ustar00rootroot00000000000000#version 450 layout(location = 0) in float v0; layout(location = 1) in float v1; layout(location = 0) out float FragColor; void main() { FragColor = (v0 + v1) * v1; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/line-directive.line.asm.frag000066400000000000000000000027661400026215700275460ustar00rootroot00000000000000#version 450 #extension GL_GOOGLE_cpp_style_line_directive : require layout(location = 0) out float FragColor; layout(location = 0) in float vColor; #line 8 "test.frag" void main() { #line 8 "test.frag" FragColor = 1.0; #line 9 "test.frag" FragColor = 2.0; #line 10 "test.frag" if (vColor < 0.0) { #line 12 "test.frag" FragColor = 3.0; } else { #line 16 "test.frag" FragColor = 4.0; } #line 19 "test.frag" for (int _127 = 0; float(_127) < (40.0 + vColor); ) { #line 21 "test.frag" FragColor += 0.20000000298023223876953125; #line 22 "test.frag" FragColor += 0.300000011920928955078125; #line 19 "test.frag" _127 += (int(vColor) + 5); continue; } #line 25 "test.frag" switch (int(vColor)) { case 0: { #line 28 "test.frag" FragColor += 0.20000000298023223876953125; #line 29 "test.frag" break; } case 1: { #line 32 "test.frag" FragColor += 0.4000000059604644775390625; #line 33 "test.frag" break; } default: { #line 36 "test.frag" FragColor += 0.800000011920928955078125; #line 37 "test.frag" break; } } for (;;) { #line 42 "test.frag" FragColor += (10.0 + vColor); #line 43 "test.frag" #line 42 "test.frag" #line 43 "test.frag" if (FragColor < 100.0) { } else { break; } } #line 48 "test.frag" } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/locations-components.asm.frag000066400000000000000000000011331400026215700300560ustar00rootroot00000000000000#version 450 layout(location = 1) in vec2 _2; layout(location = 1, component = 2) in float _3; layout(location = 2) flat in float _4; layout(location = 2, component = 1) flat in uint _5; layout(location = 2, component = 2) flat in uint _6; layout(location = 0) out vec4 o0; vec4 v1; vec4 v2; void main() { v1 = vec4(_2.x, _2.y, v1.z, v1.w); v1.z = _3; v2.x = _4; v2.y = uintBitsToFloat(_5); v2.z = uintBitsToFloat(_6); o0.y = float(floatBitsToUint(intBitsToFloat(floatBitsToInt(v2.y) + floatBitsToInt(v2.z)))); o0.x = v1.y + v2.x; o0 = vec4(o0.x, o0.y, v1.z, v1.x); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/loop-body-dominator-continue-access.asm.frag000066400000000000000000000034531400026215700326660ustar00rootroot00000000000000#version 450 layout(binding = 0, std140) uniform Foo { layout(row_major) mat4 lightVP[64]; uint shadowCascadesNum; int test; } _11; layout(location = 0) in vec3 fragWorld; layout(location = 0) out int _entryPointOutput; int _231; mat4 spvWorkaroundRowMajor(mat4 wrap) { return wrap; } void main() { int _228; do { bool _225; int _229; uint _222 = 0u; for (;;) { if (_222 < _11.shadowCascadesNum) { mat4 _223; do { if (_11.test == 0) { _223 = mat4(vec4(0.5, 0.0, 0.0, 0.0), vec4(0.0, 0.5, 0.0, 0.0), vec4(0.0, 0.0, 0.5, 0.0), vec4(0.0, 0.0, 0.0, 1.0)); break; } _223 = mat4(vec4(1.0, 0.0, 0.0, 0.0), vec4(0.0, 1.0, 0.0, 0.0), vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0)); break; } while(false); vec4 _170 = (_223 * spvWorkaroundRowMajor(_11.lightVP[_222])) * vec4(fragWorld, 1.0); float _172 = _170.z; float _179 = _170.x; float _181 = _170.y; if ((((_172 >= 0.0) && (_172 <= 1.0)) && (max(_179, _181) <= 1.0)) && (min(_179, _181) >= 0.0)) { _229 = int(_222); _225 = true; break; } _222++; continue; } else { _229 = _231; _225 = false; break; } } if (_225) { _228 = _229; break; } _228 = -1; break; } while(false); _entryPointOutput = _228; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/loop-header-to-continue.asm.frag000066400000000000000000000021401400026215700303400ustar00rootroot00000000000000#version 450 struct Params { vec4 TextureSize; vec4 Params1; vec4 Params2; vec4 Params3; vec4 Params4; vec4 Bloom; }; layout(binding = 1, std140) uniform CB1 { Params CB1; } _8; uniform sampler2D SPIRV_Cross_CombinedmapTexturemapSampler; layout(location = 0) in vec2 IN_uv; layout(location = 0) out vec4 _entryPointOutput; void main() { vec2 _45 = vec2(0.0, _8.CB1.TextureSize.w); vec4 _49 = texture(SPIRV_Cross_CombinedmapTexturemapSampler, IN_uv); float _50 = _49.y; float _53 = clamp(_50 * 0.06399999558925628662109375, 7.999999797903001308441162109375e-05, 0.008000000379979610443115234375); float _55; float _58; _55 = 0.0; _58 = 0.0; for (int _60 = -3; _60 <= 3; ) { float _64 = float(_60); vec4 _72 = texture(SPIRV_Cross_CombinedmapTexturemapSampler, IN_uv + (_45 * _64)); float _78 = exp(((-_64) * _64) * 0.2222220003604888916015625) * float(abs(_72.y - _50) < _53); _55 += (_72.x * _78); _58 += _78; _60++; continue; } _entryPointOutput = vec4(_55 / _58, _50, 0.0, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/lut-promotion-initializer.asm.frag000066400000000000000000000016331400026215700310560ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; const float _46[16] = float[](1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0); const vec4 _76[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); layout(location = 0) out float FragColor; layout(location = 0) flat in mediump int index; void main() { vec4 foobar[4] = _76; vec4 baz[4] = _76; FragColor = _46[index]; if (index < 10) { FragColor += _46[index ^ 1]; } else { FragColor += _46[index & 1]; } bool _99 = index > 30; if (_99) { FragColor += _76[index & 3].y; } else { FragColor += _76[index & 1].x; } if (_99) { foobar[1].z = 20.0; } mediump int _37 = index & 3; FragColor += foobar[_37].z; baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0)); FragColor += baz[_37].z; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/multi-for-loop-init.asm.frag000066400000000000000000000007171400026215700275350ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int counter; void main() { FragColor = vec4(0.0); mediump int _53 = 0; mediump uint _54 = 1u; for (; (_53 < 10) && (int(_54) < int(20u)); ) { FragColor += vec4(float(_53)); FragColor += vec4(float(_54)); _54 += uint(counter); _53 += counter; continue; } } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/op-constant-null.asm.frag000066400000000000000000000002201400026215700271110ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out float FragColor; void main() { FragColor = 0.0; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/op-phi-swap-continue-block.asm.frag000066400000000000000000000007031400026215700307600ustar00rootroot00000000000000#version 450 layout(binding = 0, std140) uniform UBO { int uCount; int uJ; int uK; } _5; layout(location = 0) out float FragColor; void main() { int _23; int _23_copy; int _24; _23 = _5.uK; _24 = _5.uJ; for (int _26 = 0; _26 < _5.uCount; ) { _23_copy = _23; _23 = _24; _24 = _23_copy; _26++; continue; } FragColor = float(_24 - _23) * float(_5.uJ * _5.uK); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/pack-and-unpack-uint2.asm.frag000066400000000000000000000004001400026215700276700ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require layout(location = 0) out vec4 FragColor; void main() { uvec2 unpacked = unpackUint2x32(packUint2x32(uvec2(18u, 52u))); FragColor = vec4(float(unpacked.x), float(unpacked.y), 1.0, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/pass-by-value.asm.frag000066400000000000000000000002641400026215700263740ustar00rootroot00000000000000#version 450 struct Registers { float foo; }; uniform Registers registers; layout(location = 0) out float FragColor; void main() { FragColor = 10.0 + registers.foo; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/phi-loop-variable.asm.frag000066400000000000000000000000371400026215700272140ustar00rootroot00000000000000#version 450 void main() { } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/sample-and-compare.asm.frag000066400000000000000000000006761400026215700273600ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_Combinedg_Textureg_Sampler; uniform sampler2DShadow SPIRV_Cross_Combinedg_Textureg_CompareSampler; layout(location = 0) in vec2 in_var_TEXCOORD0; layout(location = 0) out float out_var_SV_Target; void main() { out_var_SV_Target = texture(SPIRV_Cross_Combinedg_Textureg_Sampler, in_var_TEXCOORD0).x + textureLod(SPIRV_Cross_Combinedg_Textureg_CompareSampler, vec3(in_var_TEXCOORD0, 0.5), 0.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/sampler-buffer-array-without-sampler.asm.frag000066400000000000000000000010161400026215700330700ustar00rootroot00000000000000#version 450 struct Registers { int index; }; uniform Registers registers; uniform sampler2D SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler[4]; layout(location = 0) out vec4 FragColor; void main() { FragColor = (texelFetch(SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler[registers.index], ivec2(10), 0) + texelFetch(SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler[registers.index], ivec2(4), 0)) + texelFetch(SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler[registers.index], ivec2(4), 0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/sampler-buffer-without-sampler.asm.frag000066400000000000000000000004451400026215700317610ustar00rootroot00000000000000#version 450 layout(binding = 0, rgba32f) uniform writeonly imageBuffer RWTex; layout(binding = 1) uniform samplerBuffer Tex; layout(location = 0) out vec4 _entryPointOutput; void main() { imageStore(RWTex, 20, vec4(1.0, 2.0, 3.0, 4.0)); _entryPointOutput = texelFetch(Tex, 10); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/single-function-private-lut.asm.frag000066400000000000000000000005751400026215700312670ustar00rootroot00000000000000#version 460 struct myType { float data; }; const myType _21[5] = myType[](myType(0.0), myType(1.0), myType(0.0), myType(1.0), myType(0.0)); layout(location = 0) out vec4 o_color; void main() { if (_21[int(mod(gl_FragCoord.x, 4.0))].data > 0.0) { o_color = vec4(0.0, 1.0, 0.0, 1.0); } else { o_color = vec4(1.0, 0.0, 0.0, 1.0); } } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/srem.asm.frag000066400000000000000000000003631400026215700246520ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in ivec4 vA; layout(location = 1) flat in ivec4 vB; void main() { FragColor = vec4(vA - vB * (vA / vB)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/storage-class-output-initializer.asm.frag000066400000000000000000000004171400026215700323320ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColors[2]; layout(location = 2) out vec4 FragColor; const vec4 _3_init[2] = vec4[](vec4(1.0, 2.0, 3.0, 4.0), vec4(10.0)); const vec4 _4_init = vec4(5.0); void main() { FragColors = _3_init; FragColor = _4_init; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/struct-composite-extract-swizzle.asm.frag000066400000000000000000000004531400026215700324050ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct Foo { float var1; float var2; }; layout(binding = 0) uniform mediump sampler2D uSampler; layout(location = 0) out vec4 FragColor; Foo _22; void main() { FragColor = texture(uSampler, vec2(_22.var1, _22.var2)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/switch-label-shared-block.asm.frag000066400000000000000000000007611400026215700306200ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) flat in mediump int vIndex; layout(location = 0) out float FragColor; void main() { highp float _19; switch (vIndex) { case 0: case 2: { _19 = 1.0; break; } default: { _19 = 3.0; break; } case 8: { _19 = 8.0; break; } } FragColor = _19; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/temporary-name-alias.asm.frag000066400000000000000000000000371400026215700277310ustar00rootroot00000000000000#version 450 void main() { } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/temporary-phi-hoisting.asm.frag000066400000000000000000000006221400026215700303240ustar00rootroot00000000000000#version 450 struct MyStruct { vec4 color; }; layout(binding = 0, std140) uniform MyStruct_CB { MyStruct g_MyStruct[4]; } _6; layout(location = 0) out vec4 _entryPointOutput; void main() { vec3 _28; _28 = vec3(0.0); for (int _31 = 0; _31 < 4; ) { _28 += _6.g_MyStruct[_31].color.xyz; _31++; continue; } _entryPointOutput = vec4(_28, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/texel-fetch-no-lod.asm.frag000066400000000000000000000002731400026215700273020ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uTexture; layout(location = 0) out vec4 FragColor; void main() { FragColor = texelFetch(uTexture, ivec2(gl_FragCoord.xy), 0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/texture-sampling-fp16.asm.vk.frag000066400000000000000000000006521400026215700304060ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_NV_gpu_shader5) #extension GL_NV_gpu_shader5 : require #else #error No extension available for FP16. #endif layout(binding = 0) uniform sampler2D uTexture; layout(location = 0) out f16vec4 FragColor; layout(location = 0) in f16vec2 UV; void main() { FragColor = f16vec4(texture(uTexture, UV)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/texture-sampling-fp16.asm.vk.frag.vk000066400000000000000000000010401400026215700310150ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_EXT_shader_explicit_arithmetic_types_float16) #extension GL_EXT_shader_explicit_arithmetic_types_float16 : require #else #error No extension available for FP16. #endif #extension GL_EXT_shader_16bit_storage : require layout(set = 0, binding = 0) uniform sampler2D uTexture; layout(location = 0) out f16vec4 FragColor; layout(location = 0) in f16vec2 UV; void main() { FragColor = f16vec4(texture(uTexture, UV)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/undef-variable-store.asm.frag000066400000000000000000000002031400026215700277130ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 _entryPointOutput; void main() { _entryPointOutput = vec4(1.0, 1.0, 0.0, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/unknown-depth-state.asm.vk.frag000066400000000000000000000005341400026215700302420ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2DShadow uShadow; uniform sampler2DShadow SPIRV_Cross_CombineduTextureuSampler; layout(location = 0) in vec3 vUV; layout(location = 0) out float FragColor; void main() { FragColor = texture(uShadow, vec3(vUV.xy, vUV.z)) + texture(SPIRV_Cross_CombineduTextureuSampler, vec3(vUV.xy, vUV.z)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/unknown-depth-state.asm.vk.frag.vk000066400000000000000000000006341400026215700306620ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform sampler2DShadow uShadow; layout(set = 0, binding = 1) uniform texture2D uTexture; layout(set = 0, binding = 2) uniform samplerShadow uSampler; layout(location = 0) in vec3 vUV; layout(location = 0) out float FragColor; void main() { FragColor = texture(uShadow, vec3(vUV.xy, vUV.z)) + texture(sampler2DShadow(uTexture, uSampler), vec3(vUV.xy, vUV.z)); } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/unreachable.asm.frag000066400000000000000000000005411400026215700261530ustar00rootroot00000000000000#version 450 layout(location = 0) flat in int counter; layout(location = 0) out vec4 FragColor; void main() { vec4 _33; for (;;) { if (counter == 10) { _33 = vec4(10.0); break; } else { _33 = vec4(30.0); break; } } FragColor = _33; } spirv-cross-2021.01.15/reference/opt/shaders/asm/frag/vector-shuffle-oom.asm.frag000066400000000000000000000173631400026215700274400ustar00rootroot00000000000000#version 450 struct _28 { vec4 _m0; }; layout(binding = 0, std140) uniform _6_7 { vec4 _m0; float _m1; vec4 _m2; } _7; layout(binding = 2, std140) uniform _10_11 { vec3 _m0; vec3 _m1; float _m2; vec3 _m3; float _m4; vec3 _m5; float _m6; vec3 _m7; float _m8; vec3 _m9; float _m10; vec3 _m11; float _m12; vec2 _m13; vec2 _m14; vec3 _m15; float _m16; float _m17; float _m18; float _m19; float _m20; vec4 _m21; vec4 _m22; layout(row_major) mat4 _m23; vec4 _m24; } _11; layout(binding = 1, std140) uniform _18_19 { layout(row_major) mat4 _m0; layout(row_major) mat4 _m1; layout(row_major) mat4 _m2; layout(row_major) mat4 _m3; vec4 _m4; vec4 _m5; float _m6; float _m7; float _m8; float _m9; vec3 _m10; float _m11; vec3 _m12; float _m13; vec3 _m14; float _m15; vec3 _m16; float _m17; float _m18; float _m19; vec2 _m20; vec2 _m21; vec2 _m22; vec4 _m23; vec2 _m24; vec2 _m25; vec2 _m26; vec3 _m27; float _m28; float _m29; float _m30; float _m31; float _m32; vec2 _m33; float _m34; float _m35; vec3 _m36; layout(row_major) mat4 _m37[2]; vec4 _m38[2]; } _19; uniform sampler2D SPIRV_Cross_Combined; uniform sampler2D SPIRV_Cross_Combined_1; uniform sampler2D SPIRV_Cross_Combined_2; layout(location = 0) out vec4 _5; _28 _74; void main() { vec2 _82 = gl_FragCoord.xy * _19._m23.xy; vec4 _88 = _7._m2 * _7._m0.xyxy; vec2 _95 = _88.xy; vec2 _96 = _88.zw; vec2 _97 = clamp(_82 + (vec2(0.0, -2.0) * _7._m0.xy), _95, _96); vec3 _109 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _97, 0.0).w * _7._m1, 0.0, 1.0); vec4 _113 = textureLod(SPIRV_Cross_Combined_1, _97, 0.0); float _114 = _113.y; vec3 _129; if (_114 > 0.0) { _129 = _109 + (textureLod(SPIRV_Cross_Combined_2, _97, 0.0).xyz * clamp(_114 * _113.z, 0.0, 1.0)); } else { _129 = _109; } vec2 _144 = clamp(_82 + (vec2(-1.0) * _7._m0.xy), _95, _96); vec3 _156 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _144, 0.0).w * _7._m1, 0.0, 1.0); vec4 _160 = textureLod(SPIRV_Cross_Combined_1, _144, 0.0); float _161 = _160.y; vec3 _176; if (_161 > 0.0) { _176 = _156 + (textureLod(SPIRV_Cross_Combined_2, _144, 0.0).xyz * clamp(_161 * _160.z, 0.0, 1.0)); } else { _176 = _156; } vec2 _191 = clamp(_82 + (vec2(0.0, -1.0) * _7._m0.xy), _95, _96); vec3 _203 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _191, 0.0).w * _7._m1, 0.0, 1.0); vec4 _207 = textureLod(SPIRV_Cross_Combined_1, _191, 0.0); float _208 = _207.y; vec3 _223; if (_208 > 0.0) { _223 = _203 + (textureLod(SPIRV_Cross_Combined_2, _191, 0.0).xyz * clamp(_208 * _207.z, 0.0, 1.0)); } else { _223 = _203; } vec2 _238 = clamp(_82 + (vec2(1.0, -1.0) * _7._m0.xy), _95, _96); vec3 _250 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _238, 0.0).w * _7._m1, 0.0, 1.0); vec4 _254 = textureLod(SPIRV_Cross_Combined_1, _238, 0.0); float _255 = _254.y; vec3 _270; if (_255 > 0.0) { _270 = _250 + (textureLod(SPIRV_Cross_Combined_2, _238, 0.0).xyz * clamp(_255 * _254.z, 0.0, 1.0)); } else { _270 = _250; } vec2 _285 = clamp(_82 + (vec2(-2.0, 0.0) * _7._m0.xy), _95, _96); vec3 _297 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _285, 0.0).w * _7._m1, 0.0, 1.0); vec4 _301 = textureLod(SPIRV_Cross_Combined_1, _285, 0.0); float _302 = _301.y; vec3 _317; if (_302 > 0.0) { _317 = _297 + (textureLod(SPIRV_Cross_Combined_2, _285, 0.0).xyz * clamp(_302 * _301.z, 0.0, 1.0)); } else { _317 = _297; } vec2 _332 = clamp(_82 + (vec2(-1.0, 0.0) * _7._m0.xy), _95, _96); vec3 _344 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _332, 0.0).w * _7._m1, 0.0, 1.0); vec4 _348 = textureLod(SPIRV_Cross_Combined_1, _332, 0.0); float _349 = _348.y; vec3 _364; if (_349 > 0.0) { _364 = _344 + (textureLod(SPIRV_Cross_Combined_2, _332, 0.0).xyz * clamp(_349 * _348.z, 0.0, 1.0)); } else { _364 = _344; } vec2 _379 = clamp(_82, _95, _96); vec3 _391 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _379, 0.0).w * _7._m1, 0.0, 1.0); vec4 _395 = textureLod(SPIRV_Cross_Combined_1, _379, 0.0); float _396 = _395.y; vec3 _411; if (_396 > 0.0) { _411 = _391 + (textureLod(SPIRV_Cross_Combined_2, _379, 0.0).xyz * clamp(_396 * _395.z, 0.0, 1.0)); } else { _411 = _391; } vec2 _426 = clamp(_82 + (vec2(1.0, 0.0) * _7._m0.xy), _95, _96); vec3 _438 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _426, 0.0).w * _7._m1, 0.0, 1.0); vec4 _442 = textureLod(SPIRV_Cross_Combined_1, _426, 0.0); float _443 = _442.y; vec3 _458; if (_443 > 0.0) { _458 = _438 + (textureLod(SPIRV_Cross_Combined_2, _426, 0.0).xyz * clamp(_443 * _442.z, 0.0, 1.0)); } else { _458 = _438; } vec2 _473 = clamp(_82 + (vec2(2.0, 0.0) * _7._m0.xy), _95, _96); vec3 _485 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _473, 0.0).w * _7._m1, 0.0, 1.0); vec4 _489 = textureLod(SPIRV_Cross_Combined_1, _473, 0.0); float _490 = _489.y; vec3 _505; if (_490 > 0.0) { _505 = _485 + (textureLod(SPIRV_Cross_Combined_2, _473, 0.0).xyz * clamp(_490 * _489.z, 0.0, 1.0)); } else { _505 = _485; } vec2 _520 = clamp(_82 + (vec2(-1.0, 1.0) * _7._m0.xy), _95, _96); vec3 _532 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _520, 0.0).w * _7._m1, 0.0, 1.0); vec4 _536 = textureLod(SPIRV_Cross_Combined_1, _520, 0.0); float _537 = _536.y; vec3 _552; if (_537 > 0.0) { _552 = _532 + (textureLod(SPIRV_Cross_Combined_2, _520, 0.0).xyz * clamp(_537 * _536.z, 0.0, 1.0)); } else { _552 = _532; } vec2 _567 = clamp(_82 + (vec2(0.0, 1.0) * _7._m0.xy), _95, _96); vec3 _579 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _567, 0.0).w * _7._m1, 0.0, 1.0); vec4 _583 = textureLod(SPIRV_Cross_Combined_1, _567, 0.0); float _584 = _583.y; vec3 _599; if (_584 > 0.0) { _599 = _579 + (textureLod(SPIRV_Cross_Combined_2, _567, 0.0).xyz * clamp(_584 * _583.z, 0.0, 1.0)); } else { _599 = _579; } vec2 _614 = clamp(_82 + _7._m0.xy, _95, _96); vec3 _626 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _614, 0.0).w * _7._m1, 0.0, 1.0); vec4 _630 = textureLod(SPIRV_Cross_Combined_1, _614, 0.0); float _631 = _630.y; vec3 _646; if (_631 > 0.0) { _646 = _626 + (textureLod(SPIRV_Cross_Combined_2, _614, 0.0).xyz * clamp(_631 * _630.z, 0.0, 1.0)); } else { _646 = _626; } vec2 _661 = clamp(_82 + (vec2(0.0, 2.0) * _7._m0.xy), _95, _96); vec3 _673 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _661, 0.0).w * _7._m1, 0.0, 1.0); vec4 _677 = textureLod(SPIRV_Cross_Combined_1, _661, 0.0); float _678 = _677.y; vec3 _693; if (_678 > 0.0) { _693 = _673 + (textureLod(SPIRV_Cross_Combined_2, _661, 0.0).xyz * clamp(_678 * _677.z, 0.0, 1.0)); } else { _693 = _673; } vec3 _702 = (((((((((((((_129 * 0.5).xyz + (_176 * 0.5)).xyz + (_223 * 0.75)).xyz + (_270 * 0.5)).xyz + (_317 * 0.5)).xyz + (_364 * 0.75)).xyz + (_411 * 1.0)).xyz + (_458 * 0.75)).xyz + (_505 * 0.5)).xyz + (_552 * 0.5)).xyz + (_599 * 0.75)).xyz + (_646 * 0.5)).xyz + (_693 * 0.5)).xyz * vec3(0.125); _28 _704 = _74; _704._m0 = vec4(_702.x, _702.y, _702.z, vec4(0.0).w); _28 _705 = _704; _705._m0.w = 1.0; _5 = _705._m0; } spirv-cross-2021.01.15/reference/opt/shaders/asm/geom/000077500000000000000000000000001400026215700222725ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/geom/block-name-namespace.asm.geom000066400000000000000000000010161400026215700276620ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(max_vertices = 4, triangle_strip) out; layout(binding = 0, std140) uniform VertexInput { vec4 a; } VertexInput_1; layout(binding = 0, std430) buffer VertexInput { vec4 b; } VertexInput_2; layout(location = 0) out VertexInput { vec4 vColor; } VertexInput_3; layout(location = 0) in VertexInput { vec4 vColor; } vin[3]; void main() { gl_Position = (vec4(1.0) + VertexInput_1.a) + VertexInput_2.b; VertexInput_3.vColor = vin[0].vColor; EmitVertex(); } spirv-cross-2021.01.15/reference/opt/shaders/asm/geom/inout-split-access-chain-handle.asm.geom000066400000000000000000000002131400026215700317550ustar00rootroot00000000000000#version 440 layout(triangles) in; layout(max_vertices = 5, triangle_strip) out; void main() { gl_Position = gl_in[0].gl_Position; } spirv-cross-2021.01.15/reference/opt/shaders/asm/geom/split-access-chain-input.asm.geom000066400000000000000000000002131400026215700305250ustar00rootroot00000000000000#version 440 layout(triangles) in; layout(max_vertices = 3, triangle_strip) out; void main() { gl_Position = gl_in[0].gl_Position; } spirv-cross-2021.01.15/reference/opt/shaders/asm/geom/unroll-glposition-load.asm.geom000066400000000000000000000006321400026215700303400ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(max_vertices = 3, triangle_strip) out; void main() { vec4 _35_unrolled[3]; for (int i = 0; i < int(3); i++) { _35_unrolled[i] = gl_in[i].gl_Position; } vec4 param[3] = _35_unrolled; for (int _74 = 0; _74 < 3; ) { gl_Position = param[_74]; EmitVertex(); _74++; continue; } EndPrimitive(); } spirv-cross-2021.01.15/reference/opt/shaders/asm/tese/000077500000000000000000000000001400026215700223035ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/tese/unroll-input-array-load.asm.tese000066400000000000000000000005231400026215700304450ustar00rootroot00000000000000#version 450 layout(quads) in; struct ControlPoint { vec4 baz; }; layout(location = 0) patch in vec4 input_foo; layout(location = 1) patch in vec4 input_bar; layout(location = 2) in ControlPoint CPData[]; void main() { gl_Position = (((input_foo + input_bar) + vec2(gl_TessCoord.xy).xyxy) + CPData[0u].baz) + CPData[3u].baz; } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/000077500000000000000000000000001400026215700223235ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/empty-io.asm.vert000066400000000000000000000003131400026215700255440ustar00rootroot00000000000000#version 450 struct VSOutput { int empty_struct_member; }; layout(location = 0) in vec4 position; layout(location = 0) out VSOutput _entryPointOutput; void main() { gl_Position = position; } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/extract-transposed-matrix-from-struct.asm.vert000066400000000000000000000014041400026215700334220ustar00rootroot00000000000000#version 450 #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif struct InstanceData { mat4 MATRIX_MVP; vec4 Color; }; layout(binding = 0, std430) readonly buffer gInstanceData { layout(row_major) InstanceData _data[]; } gInstanceData_1; layout(location = 0) in vec3 PosL; #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif layout(location = 0) out vec4 _entryPointOutput_Color; void main() { gl_Position = gInstanceData_1._data[uint((gl_InstanceID + SPIRV_Cross_BaseInstance))].MATRIX_MVP * vec4(PosL, 1.0); _entryPointOutput_Color = gInstanceData_1._data[uint((gl_InstanceID + SPIRV_Cross_BaseInstance))].Color; } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/global-builtin.sso.asm.vert000066400000000000000000000003341400026215700275130ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; }; struct VSOut { float a; }; layout(location = 0) out VSOut _entryPointOutput; void main() { _entryPointOutput.a = 40.0; gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/invariant-block.asm.vert000066400000000000000000000001241400026215700270640ustar00rootroot00000000000000#version 450 invariant gl_Position; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/invariant-block.sso.asm.vert000066400000000000000000000003251400026215700276720ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; float gl_PointSize; float gl_ClipDistance[1]; float gl_CullDistance[1]; }; invariant gl_Position; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/invariant.asm.vert000066400000000000000000000001241400026215700257740ustar00rootroot00000000000000#version 450 invariant gl_Position; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/invariant.sso.asm.vert000066400000000000000000000002011400026215700265730ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; }; invariant gl_Position; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/spec-constant-op-composite.asm.vk.vert000066400000000000000000000013111400026215700316140ustar00rootroot00000000000000#version 450 #ifndef SPIRV_CROSS_CONSTANT_ID_201 #define SPIRV_CROSS_CONSTANT_ID_201 -10 #endif const int _7 = SPIRV_CROSS_CONSTANT_ID_201; const int _20 = (_7 + 2); #ifndef SPIRV_CROSS_CONSTANT_ID_202 #define SPIRV_CROSS_CONSTANT_ID_202 100u #endif const uint _8 = SPIRV_CROSS_CONSTANT_ID_202; const uint _25 = (_8 % 5u); const ivec4 _30 = ivec4(20, 30, _20, _20); const ivec2 _32 = ivec2(_30.y, _30.x); const int _33 = _30.y; layout(location = 0) flat out int _4; void main() { vec4 _63 = vec4(0.0); _63.y = float(_20); vec4 _66 = _63; _66.z = float(_25); vec4 _52 = _66 + vec4(_30); vec2 _56 = _52.xy + vec2(_32); gl_Position = vec4(_56.x, _56.y, _52.z, _52.w); _4 = _33; } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/spec-constant-op-composite.asm.vk.vert.vk000066400000000000000000000010471400026215700322410ustar00rootroot00000000000000#version 450 layout(constant_id = 201) const int _7 = -10; const int _20 = (_7 + 2); layout(constant_id = 202) const uint _8 = 100u; const uint _25 = (_8 % 5u); const ivec4 _30 = ivec4(20, 30, _20, _20); const ivec2 _32 = ivec2(_30.y, _30.x); const int _33 = _30.y; layout(location = 0) flat out int _4; void main() { vec4 _63 = vec4(0.0); _63.y = float(_20); vec4 _66 = _63; _66.z = float(_25); vec4 _52 = _66 + vec4(_30); vec2 _56 = _52.xy + vec2(_32); gl_Position = vec4(_56.x, _56.y, _52.z, _52.w); _4 = _33; } spirv-cross-2021.01.15/reference/opt/shaders/asm/vert/uint-vertex-id-instance-id.asm.vert000066400000000000000000000005571400026215700310730ustar00rootroot00000000000000#version 450 #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif void main() { gl_Position = vec4(float(uint(gl_VertexID) + uint((gl_InstanceID + SPIRV_Cross_BaseInstance)))); } spirv-cross-2021.01.15/reference/opt/shaders/comp/000077500000000000000000000000001400026215700215215ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/comp/atomic.comp000066400000000000000000000035411400026215700236600ustar00rootroot00000000000000#version 310 es #extension GL_OES_shader_image_atomic : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 2, std430) buffer SSBO { uint u32; int i32; } ssbo; layout(binding = 0, r32ui) uniform highp uimage2D uImage; layout(binding = 1, r32i) uniform highp iimage2D iImage; void main() { uint _19 = imageAtomicAdd(uImage, ivec2(1, 5), 1u); uint _27 = imageAtomicAdd(uImage, ivec2(1, 5), 1u); imageStore(iImage, ivec2(1, 6), ivec4(int(_27))); uint _32 = imageAtomicOr(uImage, ivec2(1, 5), 1u); uint _34 = imageAtomicXor(uImage, ivec2(1, 5), 1u); uint _36 = imageAtomicAnd(uImage, ivec2(1, 5), 1u); uint _38 = imageAtomicMin(uImage, ivec2(1, 5), 1u); uint _40 = imageAtomicMax(uImage, ivec2(1, 5), 1u); uint _44 = imageAtomicCompSwap(uImage, ivec2(1, 5), 10u, 2u); int _47 = imageAtomicAdd(iImage, ivec2(1, 6), 1); int _49 = imageAtomicOr(iImage, ivec2(1, 6), 1); int _51 = imageAtomicXor(iImage, ivec2(1, 6), 1); int _53 = imageAtomicAnd(iImage, ivec2(1, 6), 1); int _55 = imageAtomicMin(iImage, ivec2(1, 6), 1); int _57 = imageAtomicMax(iImage, ivec2(1, 6), 1); int _61 = imageAtomicCompSwap(iImage, ivec2(1, 5), 10, 2); uint _68 = atomicAdd(ssbo.u32, 1u); uint _70 = atomicOr(ssbo.u32, 1u); uint _72 = atomicXor(ssbo.u32, 1u); uint _74 = atomicAnd(ssbo.u32, 1u); uint _76 = atomicMin(ssbo.u32, 1u); uint _78 = atomicMax(ssbo.u32, 1u); uint _80 = atomicExchange(ssbo.u32, 1u); uint _82 = atomicCompSwap(ssbo.u32, 10u, 2u); int _85 = atomicAdd(ssbo.i32, 1); int _87 = atomicOr(ssbo.i32, 1); int _89 = atomicXor(ssbo.i32, 1); int _91 = atomicAnd(ssbo.i32, 1); int _93 = atomicMin(ssbo.i32, 1); int _95 = atomicMax(ssbo.i32, 1); int _97 = atomicExchange(ssbo.i32, 1); int _99 = atomicCompSwap(ssbo.i32, 10, 2); } spirv-cross-2021.01.15/reference/opt/shaders/comp/bake_gradient.comp000066400000000000000000000026741400026215700251710ustar00rootroot00000000000000#version 310 es layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in; layout(binding = 4, std140) uniform UBO { vec4 uInvSize; vec4 uScale; } _46; layout(binding = 0) uniform mediump sampler2D uHeight; layout(binding = 1) uniform mediump sampler2D uDisplacement; layout(binding = 2, rgba16f) uniform writeonly mediump image2D iHeightDisplacement; layout(binding = 3, rgba16f) uniform writeonly mediump image2D iGradJacobian; void main() { vec4 _59 = (vec2(gl_GlobalInvocationID.xy) * _46.uInvSize.xy).xyxy + (_46.uInvSize * 0.5); vec2 _67 = _59.xy; vec2 _128 = _59.zw; vec2 _157 = ((textureLodOffset(uDisplacement, _128, 0.0, ivec2(1, 0)).xy - textureLodOffset(uDisplacement, _128, 0.0, ivec2(-1, 0)).xy) * 0.60000002384185791015625) * _46.uScale.z; vec2 _161 = ((textureLodOffset(uDisplacement, _128, 0.0, ivec2(0, 1)).xy - textureLodOffset(uDisplacement, _128, 0.0, ivec2(0, -1)).xy) * 0.60000002384185791015625) * _46.uScale.z; ivec2 _172 = ivec2(gl_GlobalInvocationID.xy); imageStore(iHeightDisplacement, _172, vec4(textureLod(uHeight, _67, 0.0).x, 0.0, 0.0, 0.0)); imageStore(iGradJacobian, _172, vec4((_46.uScale.xy * 0.5) * vec2(textureLodOffset(uHeight, _67, 0.0, ivec2(1, 0)).x - textureLodOffset(uHeight, _67, 0.0, ivec2(-1, 0)).x, textureLodOffset(uHeight, _67, 0.0, ivec2(0, 1)).x - textureLodOffset(uHeight, _67, 0.0, ivec2(0, -1)).x), ((1.0 + _157.x) * (1.0 + _161.y)) - (_157.y * _161.x), 0.0)); } spirv-cross-2021.01.15/reference/opt/shaders/comp/barriers.comp000066400000000000000000000006401400026215700242120ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; void main() { memoryBarrierShared(); memoryBarrier(); memoryBarrierImage(); memoryBarrierBuffer(); groupMemoryBarrier(); barrier(); memoryBarrier(); barrier(); memoryBarrierImage(); barrier(); memoryBarrierBuffer(); barrier(); groupMemoryBarrier(); barrier(); barrier(); } spirv-cross-2021.01.15/reference/opt/shaders/comp/basic.comp000066400000000000000000000010371400026215700234630ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { vec4 in_data[]; } _23; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _45; layout(binding = 2, std430) buffer SSBO3 { uint counter; } _48; void main() { vec4 _29 = _23.in_data[gl_GlobalInvocationID.x]; if (dot(_29, vec4(1.0, 5.0, 6.0, 2.0)) > 8.19999980926513671875) { uint _52 = atomicAdd(_48.counter, 1u); _45.out_data[_52] = _29; } } spirv-cross-2021.01.15/reference/opt/shaders/comp/casts.comp000066400000000000000000000006041400026215700235160ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) buffer SSBO1 { ivec4 outputs[]; } _21; layout(binding = 0, std430) buffer SSBO0 { ivec4 inputs[]; } _27; void main() { _21.outputs[gl_GlobalInvocationID.x] = mix(ivec4(0), ivec4(1), notEqual((_27.inputs[gl_GlobalInvocationID.x] & ivec4(3)), ivec4(uvec4(0u)))); } spirv-cross-2021.01.15/reference/opt/shaders/comp/cfg-preserve-parameter.comp000066400000000000000000000001431400026215700267450ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; void main() { } spirv-cross-2021.01.15/reference/opt/shaders/comp/cfg.comp000066400000000000000000000012161400026215700231400ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { float data; } _11; float _188; void main() { if (!(_11.data == 0.0)) { _11.data = 10.0; } else { _11.data = 15.0; } switch (int(_11.data)) { case 0: { _11.data = 20.0; break; } case 1: { _11.data = 30.0; break; } } float _185; _185 = _188; for (int _184 = 0; _184 < 20; ) { _185 += 10.0; _184++; continue; } _11.data = _185; } spirv-cross-2021.01.15/reference/opt/shaders/comp/coherent-block.comp000066400000000000000000000003351400026215700253010ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) coherent restrict writeonly buffer SSBO { vec4 value; } _10; void main() { _10.value = vec4(20.0); } spirv-cross-2021.01.15/reference/opt/shaders/comp/coherent-image.comp000066400000000000000000000005071400026215700252720ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) coherent restrict writeonly buffer SSBO { ivec4 value; } _10; layout(binding = 3, r32i) uniform coherent restrict readonly mediump iimage2D uImage; void main() { _10.value = imageLoad(uImage, ivec2(10)); } spirv-cross-2021.01.15/reference/opt/shaders/comp/composite-array-initialization.comp000066400000000000000000000012241400026215700305430ustar00rootroot00000000000000#version 310 es layout(local_size_x = 2, local_size_y = 1, local_size_z = 1) in; struct Data { float a; float b; }; const Data _25[2] = Data[](Data(1.0, 2.0), Data(3.0, 4.0)); #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 4.0 #endif const float X = SPIRV_CROSS_CONSTANT_ID_0; layout(binding = 0, std430) buffer SSBO { Data outdata[]; } _53; void main() { Data data2[2] = Data[](Data(X, 2.0), Data(3.0, 5.0)); _53.outdata[gl_WorkGroupID.x].a = _25[gl_LocalInvocationID.x].a + data2[gl_LocalInvocationID.x].a; _53.outdata[gl_WorkGroupID.x].b = _25[gl_LocalInvocationID.x].b + data2[gl_LocalInvocationID.x].b; } spirv-cross-2021.01.15/reference/opt/shaders/comp/composite-construct.comp000066400000000000000000000006031400026215700264240ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO0 { vec4 as[]; } _41; layout(binding = 1, std430) buffer SSBO1 { vec4 bs[]; } _55; void main() { _41.as[gl_GlobalInvocationID.x] = ((_41.as[gl_GlobalInvocationID.x] + _55.bs[gl_GlobalInvocationID.x]) + _55.bs[gl_GlobalInvocationID.x]) + vec4(10.0); } spirv-cross-2021.01.15/reference/opt/shaders/comp/culling.comp000066400000000000000000000007551400026215700240450ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { float in_data[]; } _22; layout(binding = 1, std430) writeonly buffer SSBO2 { float out_data[]; } _38; layout(binding = 2, std430) buffer SSBO3 { uint count; } _41; void main() { float _28 = _22.in_data[gl_GlobalInvocationID.x]; if (_28 > 12.0) { uint _45 = atomicAdd(_41.count, 1u); _38.out_data[_45] = _28; } } spirv-cross-2021.01.15/reference/opt/shaders/comp/defer-parens.comp000066400000000000000000000006461400026215700247620ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { vec4 data; int index; } _13; void main() { vec4 _17 = _13.data; vec2 _28 = _17.yz + vec2(10.0); _13.data = vec4(_17.x, _28, _17.w); _13.data = (_17 + _17) + _17; _13.data = _28.xxyy; _13.data = vec4(_28.y); _13.data = vec4((_17.zw + vec2(10.0))[_13.index]); } spirv-cross-2021.01.15/reference/opt/shaders/comp/dowhile.comp000066400000000000000000000012061400026215700240330ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; } _28; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _52; void main() { vec4 _59; int _60; _60 = 0; _59 = _28.in_data[gl_GlobalInvocationID.x]; vec4 _42; for (;;) { _42 = _28.mvp * _59; int _44 = _60 + 1; if (_44 < 16) { _60 = _44; _59 = _42; } else { break; } } _52.out_data[gl_GlobalInvocationID.x] = _42; } spirv-cross-2021.01.15/reference/opt/shaders/comp/generate_height.comp000066400000000000000000000027151400026215700255300ustar00rootroot00000000000000#version 310 es layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer Distribution { vec2 distribution[]; } _137; layout(binding = 2, std140) uniform UBO { vec4 uModTime; } _166; layout(binding = 1, std430) writeonly buffer HeightmapFFT { uint heights[]; } _225; void main() { uvec2 _265 = uvec2(64u, 1u) * gl_NumWorkGroups.xy; uvec2 _270 = _265 - gl_GlobalInvocationID.xy; bvec2 _272 = equal(gl_GlobalInvocationID.xy, uvec2(0u)); uint _460; if (_272.x) { _460 = 0u; } else { _460 = _270.x; } uint _461; if (_272.y) { _461 = 0u; } else { _461 = _270.y; } uint _277 = _265.x; uint _281 = (gl_GlobalInvocationID.y * _277) + gl_GlobalInvocationID.x; uint _291 = (_461 * _277) + _460; vec2 _298 = vec2(gl_GlobalInvocationID.xy); vec2 _300 = vec2(_265); float _310 = sqrt(9.81000041961669921875 * length(_166.uModTime.xy * mix(_298, _298 - _300, greaterThan(_298, _300 * 0.5)))) * _166.uModTime.z; vec2 _317 = vec2(cos(_310), sin(_310)); vec2 _391 = _317.xx; vec2 _396 = _317.yy; vec2 _399 = _396 * _137.distribution[_281].yx; vec2 _426 = _396 * _137.distribution[_291].yx; vec2 _434 = (_137.distribution[_291] * _391) + vec2(-_426.x, _426.y); _225.heights[_281] = packHalf2x16(((_137.distribution[_281] * _391) + vec2(-_399.x, _399.y)) + vec2(_434.x, -_434.y)); } spirv-cross-2021.01.15/reference/opt/shaders/comp/image.comp000066400000000000000000000005631400026215700234670ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, rgba8) uniform readonly mediump image2D uImageIn; layout(binding = 1, rgba8) uniform writeonly mediump image2D uImageOut; void main() { ivec2 _23 = ivec2(gl_GlobalInvocationID.xy); imageStore(uImageOut, _23, imageLoad(uImageIn, _23 + imageSize(uImageIn))); } spirv-cross-2021.01.15/reference/opt/shaders/comp/insert.comp000066400000000000000000000006741400026215700237140ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) writeonly buffer SSBO { vec4 out_data[]; } _27; vec4 _53; void main() { vec4 _46 = _53; _46.x = 10.0; vec4 _48 = _46; _48.y = 30.0; vec4 _50 = _48; _50.z = 70.0; vec4 _52 = _50; _52.w = 90.0; _27.out_data[gl_GlobalInvocationID.x] = _52; _27.out_data[gl_GlobalInvocationID.x].y = 20.0; } spirv-cross-2021.01.15/reference/opt/shaders/comp/mat3.comp000066400000000000000000000004131400026215700232430ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) writeonly buffer SSBO2 { mat3 out_data[]; } _22; void main() { _22.out_data[gl_GlobalInvocationID.x] = mat3(vec3(10.0), vec3(20.0), vec3(40.0)); } spirv-cross-2021.01.15/reference/opt/shaders/comp/mod.comp000066400000000000000000000013311400026215700231560ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { vec4 in_data[]; } _23; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _33; void main() { _33.out_data[gl_GlobalInvocationID.x] = mod(_23.in_data[gl_GlobalInvocationID.x], _33.out_data[gl_GlobalInvocationID.x]); _33.out_data[gl_GlobalInvocationID.x] = uintBitsToFloat(floatBitsToUint(_23.in_data[gl_GlobalInvocationID.x]) % floatBitsToUint(_33.out_data[gl_GlobalInvocationID.x])); _33.out_data[gl_GlobalInvocationID.x] = intBitsToFloat(floatBitsToInt(_23.in_data[gl_GlobalInvocationID.x]) % floatBitsToInt(_33.out_data[gl_GlobalInvocationID.x])); } spirv-cross-2021.01.15/reference/opt/shaders/comp/modf.comp000066400000000000000000000005771400026215700233370ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { vec4 in_data[]; } _23; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _35; void main() { vec4 i; vec4 _31 = modf(_23.in_data[gl_GlobalInvocationID.x], i); _35.out_data[gl_GlobalInvocationID.x] = _31; } spirv-cross-2021.01.15/reference/opt/shaders/comp/outer-product.comp000066400000000000000000000014301400026215700252130ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) writeonly buffer SSBO { mat2 m22; mat2x3 m23; mat2x4 m24; mat3x2 m32; mat3 m33; mat3x4 m34; mat4x2 m42; mat4x3 m43; mat4 m44; } _21; layout(binding = 1, std430) readonly buffer ReadSSBO { vec2 v2; vec3 v3; vec4 v4; } _26; void main() { _21.m22 = outerProduct(_26.v2, _26.v2); _21.m23 = outerProduct(_26.v3, _26.v2); _21.m24 = outerProduct(_26.v4, _26.v2); _21.m32 = outerProduct(_26.v2, _26.v3); _21.m33 = outerProduct(_26.v3, _26.v3); _21.m34 = outerProduct(_26.v4, _26.v3); _21.m42 = outerProduct(_26.v2, _26.v4); _21.m43 = outerProduct(_26.v3, _26.v4); _21.m44 = outerProduct(_26.v4, _26.v4); } spirv-cross-2021.01.15/reference/opt/shaders/comp/read-write-only.comp000066400000000000000000000007171400026215700254300ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 2, std430) restrict writeonly buffer SSBO2 { vec4 data4; vec4 data5; } _10; layout(binding = 0, std430) readonly buffer SSBO0 { vec4 data0; vec4 data1; } _15; layout(binding = 1, std430) restrict buffer SSBO1 { vec4 data2; vec4 data3; } _21; void main() { _10.data4 = _15.data0 + _21.data2; _10.data5 = _15.data1 + _21.data3; } spirv-cross-2021.01.15/reference/opt/shaders/comp/rmw-matrix.comp000066400000000000000000000004501400026215700245070ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { float a; vec4 b; mat4 c; float a1; vec4 b1; mat4 c1; } _11; void main() { _11.a *= _11.a1; _11.b *= _11.b1; _11.c = _11.c * _11.c1; } spirv-cross-2021.01.15/reference/opt/shaders/comp/rmw-opt.comp000066400000000000000000000005301400026215700240040ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { int a; } _9; void main() { _9.a += 10; _9.a -= 10; _9.a *= 10; _9.a /= 10; _9.a = _9.a << 2; _9.a = _9.a >> 3; _9.a &= 40; _9.a ^= 10; _9.a %= 40; _9.a |= 1; _9.a = 0; } spirv-cross-2021.01.15/reference/opt/shaders/comp/scalar-std450-distance-length-normalize.comp000066400000000000000000000004501400026215700317330ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { float a; float b; float c; float d; float e; } _9; void main() { _9.c = distance(_9.a, _9.b); _9.d = length(_9.a); _9.e = normalize(_9.a); } spirv-cross-2021.01.15/reference/opt/shaders/comp/shared.comp000066400000000000000000000007171400026215700236540ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { float in_data[]; } _22; layout(binding = 1, std430) writeonly buffer SSBO2 { float out_data[]; } _44; shared float sShared[4]; void main() { sShared[gl_LocalInvocationIndex] = _22.in_data[gl_GlobalInvocationID.x]; barrier(); _44.out_data[gl_GlobalInvocationID.x] = sShared[3u - gl_LocalInvocationIndex]; } spirv-cross-2021.01.15/reference/opt/shaders/comp/ssbo-array-length.comp000066400000000000000000000003401400026215700257370ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std140) buffer SSBO { uint size; float v[]; } _11; void main() { _11.size = uint(int(uint(_11.v.length()))); } spirv-cross-2021.01.15/reference/opt/shaders/comp/ssbo-array.comp000066400000000000000000000004001400026215700244550ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { vec4 data[]; } ssbos[2]; void main() { ssbos[1].data[gl_GlobalInvocationID.x] = ssbos[0].data[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/reference/opt/shaders/comp/struct-layout.comp000066400000000000000000000006361400026215700252450ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct Foo { mat4 m; }; layout(binding = 1, std430) writeonly buffer SSBO2 { Foo out_data[]; } _23; layout(binding = 0, std430) readonly buffer SSBO { Foo in_data[]; } _30; void main() { _23.out_data[gl_GlobalInvocationID.x].m = _30.in_data[gl_GlobalInvocationID.x].m * _30.in_data[gl_GlobalInvocationID.x].m; } spirv-cross-2021.01.15/reference/opt/shaders/comp/struct-packing.comp000066400000000000000000000046051400026215700253440ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct S0 { vec2 a[1]; float b; }; struct S1 { vec3 a; float b; }; struct S2 { vec3 a[1]; float b; }; struct S3 { vec2 a; float b; }; struct S4 { vec2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; S4 m3s[8]; }; layout(binding = 1, std430) restrict buffer SSBO1 { Content content; Content content1[2]; Content content2; mat2 m0; mat2 m1; mat2x3 m2[4]; mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_430; layout(binding = 0, std140) restrict buffer SSBO0 { Content content; Content content1[2]; Content content2; mat2 m0; mat2 m1; mat2x3 m2[4]; mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_140; void main() { ssbo_430.content.m0s[0].a[0] = ssbo_140.content.m0s[0].a[0]; ssbo_430.content.m0s[0].b = ssbo_140.content.m0s[0].b; ssbo_430.content.m1s[0].a = ssbo_140.content.m1s[0].a; ssbo_430.content.m1s[0].b = ssbo_140.content.m1s[0].b; ssbo_430.content.m2s[0].a[0] = ssbo_140.content.m2s[0].a[0]; ssbo_430.content.m2s[0].b = ssbo_140.content.m2s[0].b; ssbo_430.content.m0.a[0] = ssbo_140.content.m0.a[0]; ssbo_430.content.m0.b = ssbo_140.content.m0.b; ssbo_430.content.m1.a = ssbo_140.content.m1.a; ssbo_430.content.m1.b = ssbo_140.content.m1.b; ssbo_430.content.m2.a[0] = ssbo_140.content.m2.a[0]; ssbo_430.content.m2.b = ssbo_140.content.m2.b; ssbo_430.content.m3.a = ssbo_140.content.m3.a; ssbo_430.content.m3.b = ssbo_140.content.m3.b; ssbo_430.content.m4 = ssbo_140.content.m4; ssbo_430.content.m3s[0].c = ssbo_140.content.m3s[0].c; ssbo_430.content.m3s[1].c = ssbo_140.content.m3s[1].c; ssbo_430.content.m3s[2].c = ssbo_140.content.m3s[2].c; ssbo_430.content.m3s[3].c = ssbo_140.content.m3s[3].c; ssbo_430.content.m3s[4].c = ssbo_140.content.m3s[4].c; ssbo_430.content.m3s[5].c = ssbo_140.content.m3s[5].c; ssbo_430.content.m3s[6].c = ssbo_140.content.m3s[6].c; ssbo_430.content.m3s[7].c = ssbo_140.content.m3s[7].c; } spirv-cross-2021.01.15/reference/opt/shaders/comp/torture-loop.comp000066400000000000000000000014041400026215700250530ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; } _24; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _89; void main() { vec4 _101; _101 = _24.in_data[gl_GlobalInvocationID.x]; for (int _95 = 0; (_95 + 1) < 10; ) { _101 *= 2.0; _95 += 2; continue; } vec4 _100; _100 = _101; vec4 _105; for (uint _96 = 0u; _96 < 16u; _100 = _105, _96++) { _105 = _100; for (uint _102 = 0u; _102 < 30u; ) { _105 = _24.mvp * _105; _102++; continue; } } _89.out_data[gl_GlobalInvocationID.x] = _100; } spirv-cross-2021.01.15/reference/opt/shaders/comp/type-alias.comp000066400000000000000000000007301400026215700244510ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct S0 { vec4 a; }; struct S1 { vec4 a; }; layout(binding = 0, std430) buffer SSBO0 { S0 s0s[]; } _36; layout(binding = 1, std430) buffer SSBO1 { S1 s1s[]; } _55; layout(binding = 2, std430) buffer SSBO2 { vec4 outputs[]; } _66; void main() { _66.outputs[gl_GlobalInvocationID.x] = _36.s0s[gl_GlobalInvocationID.x].a + _55.s1s[gl_GlobalInvocationID.x].a; } spirv-cross-2021.01.15/reference/opt/shaders/comp/udiv.comp000066400000000000000000000005051400026215700233500ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO2 { uint outputs[]; } _10; layout(binding = 0, std430) buffer SSBO { uint inputs[]; } _23; void main() { _10.outputs[gl_GlobalInvocationID.x] = _23.inputs[gl_GlobalInvocationID.x] / 29u; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/000077500000000000000000000000001400026215700232135ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/comp/000077500000000000000000000000001400026215700241515ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/comp/enhanced-layouts.comp000066400000000000000000000013271400026215700302770ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct Foo { int a; int b; int c; }; layout(binding = 1, std140) buffer SSBO1 { layout(offset = 4) int a; layout(offset = 8) int b; layout(offset = 16) Foo foo; layout(offset = 48) int c[8]; } ssbo1; layout(binding = 2, std430) buffer SSBO2 { layout(offset = 4) int a; layout(offset = 8) int b; layout(offset = 16) Foo foo; layout(offset = 48) int c[8]; } ssbo2; layout(binding = 0, std140) uniform UBO { layout(offset = 4) int a; layout(offset = 8) int b; layout(offset = 16) Foo foo; layout(offset = 48) int c[8]; } ubo; void main() { ssbo1.a = ssbo2.a; ssbo1.b = ubo.b; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/comp/extended-arithmetic.desktop.comp000066400000000000000000000053161400026215700324350ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct ResType { uint _m0; uint _m1; }; struct ResType_1 { uvec2 _m0; uvec2 _m1; }; struct ResType_2 { uvec3 _m0; uvec3 _m1; }; struct ResType_3 { uvec4 _m0; uvec4 _m1; }; struct ResType_4 { int _m0; int _m1; }; struct ResType_5 { ivec2 _m0; ivec2 _m1; }; struct ResType_6 { ivec3 _m0; ivec3 _m1; }; struct ResType_7 { ivec4 _m0; ivec4 _m1; }; layout(binding = 0, std430) buffer SSBOUint { uint a; uint b; uint c; uint d; uvec2 a2; uvec2 b2; uvec2 c2; uvec2 d2; uvec3 a3; uvec3 b3; uvec3 c3; uvec3 d3; uvec4 a4; uvec4 b4; uvec4 c4; uvec4 d4; } u; layout(binding = 1, std430) buffer SSBOInt { int a; int b; int c; int d; ivec2 a2; ivec2 b2; ivec2 c2; ivec2 d2; ivec3 a3; ivec3 b3; ivec3 c3; ivec3 d3; ivec4 a4; ivec4 b4; ivec4 c4; ivec4 d4; } i; void main() { ResType _25; _25._m0 = uaddCarry(u.a, u.b, _25._m1); u.d = _25._m1; u.c = _25._m0; ResType_1 _40; _40._m0 = uaddCarry(u.a2, u.b2, _40._m1); u.d2 = _40._m1; u.c2 = _40._m0; ResType_2 _55; _55._m0 = uaddCarry(u.a3, u.b3, _55._m1); u.d3 = _55._m1; u.c3 = _55._m0; ResType_3 _70; _70._m0 = uaddCarry(u.a4, u.b4, _70._m1); u.d4 = _70._m1; u.c4 = _70._m0; ResType _79; _79._m0 = usubBorrow(u.a, u.b, _79._m1); u.d = _79._m1; u.c = _79._m0; ResType_1 _88; _88._m0 = usubBorrow(u.a2, u.b2, _88._m1); u.d2 = _88._m1; u.c2 = _88._m0; ResType_2 _97; _97._m0 = usubBorrow(u.a3, u.b3, _97._m1); u.d3 = _97._m1; u.c3 = _97._m0; ResType_3 _106; _106._m0 = usubBorrow(u.a4, u.b4, _106._m1); u.d4 = _106._m1; u.c4 = _106._m0; ResType _116; umulExtended(u.a, u.b, _116._m1, _116._m0); u.d = _116._m0; u.c = _116._m1; ResType_1 _125; umulExtended(u.a2, u.b2, _125._m1, _125._m0); u.d2 = _125._m0; u.c2 = _125._m1; ResType_2 _134; umulExtended(u.a3, u.b3, _134._m1, _134._m0); u.d3 = _134._m0; u.c3 = _134._m1; ResType_3 _143; umulExtended(u.a4, u.b4, _143._m1, _143._m0); u.d4 = _143._m0; u.c4 = _143._m1; ResType_4 _160; imulExtended(i.a, i.b, _160._m1, _160._m0); i.d = _160._m0; i.c = _160._m1; ResType_5 _171; imulExtended(i.a2, i.b2, _171._m1, _171._m0); i.d2 = _171._m0; i.c2 = _171._m1; ResType_6 _182; imulExtended(i.a3, i.b3, _182._m1, _182._m0); i.d3 = _182._m0; i.c3 = _182._m1; ResType_7 _193; imulExtended(i.a4, i.b4, _193._m1, _193._m0); i.d4 = _193._m0; i.c4 = _193._m1; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/comp/fp64.desktop.comp000066400000000000000000000022741400026215700272650ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct M0 { double v; dvec2 b[2]; dmat2x3 c; dmat3x2 d; }; layout(binding = 0, std430) buffer SSBO0 { dvec4 a; M0 m0; dmat4 b; } ssbo_0; layout(binding = 1, std430) buffer SSBO1 { dmat4 a; dvec4 b; M0 m0; } ssbo_1; layout(binding = 2, std430) buffer SSBO2 { double a[4]; dvec2 b[4]; } ssbo_2; layout(binding = 3, std140) buffer SSBO3 { double a[4]; dvec2 b[4]; } ssbo_3; void main() { ssbo_0.a += dvec4(10.0lf, 20.0lf, 30.0lf, 40.0lf); ssbo_0.a += dvec4(20.0lf); dvec4 _40 = ssbo_0.a; ssbo_0.a = abs(_40); ssbo_0.a = sign(_40); ssbo_0.a = floor(_40); ssbo_0.a = trunc(_40); ssbo_0.a = round(_40); ssbo_0.a = roundEven(_40); ssbo_0.a = ceil(_40); ssbo_0.a = fract(_40); ssbo_0.a = mod(_40, dvec4(20.0lf)); ssbo_0.a = mod(_40, _40); ssbo_0.a = min(_40, _40); ssbo_0.a = max(_40, _40); ssbo_0.a = clamp(_40, _40, _40); ssbo_0.a = mix(_40, _40, _40); ssbo_0.a = step(_40, _40); ssbo_0.a = smoothstep(_40, _40, _40); ssbo_1.b.x += 1.0lf; ssbo_2.b[0].x += 1.0lf; ssbo_3.b[0].x += 1.0lf; } image-formats.desktop.noeliminate.comp000066400000000000000000000001401400026215700334530ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/comp#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; void main() { } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/comp/int64.desktop.comp000066400000000000000000000021221400026215700274420ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct M0 { int64_t v; i64vec2 b[2]; uint64_t c; uint64_t d[5]; }; layout(binding = 0, std430) buffer SSBO0 { i64vec4 a; M0 m0; } ssbo_0; layout(binding = 1, std430) buffer SSBO1 { u64vec4 b; M0 m0; } ssbo_1; layout(binding = 2, std430) buffer SSBO2 { int64_t a[4]; i64vec2 b[4]; } ssbo_2; layout(binding = 3, std140) buffer SSBO3 { int64_t a[4]; i64vec2 b[4]; } ssbo_3; void main() { ssbo_0.a += i64vec4(10l, 20l, 30l, 40l); ssbo_1.b += u64vec4(999999999999999999ul, 8888888888888888ul, 77777777777777777ul, 6666666666666666ul); ssbo_0.a += i64vec4(20l); ssbo_0.a = abs(ssbo_0.a + i64vec4(ssbo_1.b)); ssbo_0.a += i64vec4(1l); ssbo_1.b += u64vec4(i64vec4(1l)); ssbo_0.a -= i64vec4(1l); ssbo_1.b -= u64vec4(i64vec4(1l)); ssbo_1.b = doubleBitsToUint64(int64BitsToDouble(ssbo_0.a)); ssbo_0.a = doubleBitsToInt64(uint64BitsToDouble(ssbo_1.b)); ssbo_2.a[0] += 1l; ssbo_3.a[0] += 2l; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/000077500000000000000000000000001400026215700241325ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/clip-cull-distance.desktop.frag000066400000000000000000000002761400026215700321240ustar00rootroot00000000000000#version 450 in float gl_ClipDistance[4]; in float gl_CullDistance[3]; layout(location = 0) out float FragColor; void main() { FragColor = gl_ClipDistance[0] + gl_CullDistance[0]; } control-dependent-in-branch.desktop.frag000066400000000000000000000016121400026215700336470ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag#version 450 layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vInput; void main() { FragColor = vInput; vec4 _23 = texture(uSampler, vInput.xy); vec4 _26 = dFdx(vInput); vec4 _29 = dFdy(vInput); vec4 _32 = fwidth(vInput); vec4 _35 = dFdxCoarse(vInput); vec4 _38 = dFdyCoarse(vInput); vec4 _41 = fwidthCoarse(vInput); vec4 _44 = dFdxFine(vInput); vec4 _47 = dFdyFine(vInput); vec4 _50 = fwidthFine(vInput); vec2 _56 = textureQueryLod(uSampler, vInput.zw); if (vInput.y > 10.0) { FragColor += _23; FragColor += _26; FragColor += _29; FragColor += _32; FragColor += _35; FragColor += _38; FragColor += _41; FragColor += _44; FragColor += _47; FragColor += _50; FragColor += _56.xyxy; } } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/depth-greater-than.desktop.frag000066400000000000000000000002061400026215700321240ustar00rootroot00000000000000#version 450 layout(depth_greater) out float gl_FragDepth; layout(early_fragment_tests) in; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/depth-less-than.desktop.frag000066400000000000000000000002031400026215700314360ustar00rootroot00000000000000#version 450 layout(depth_less) out float gl_FragDepth; layout(early_fragment_tests) in; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/dual-source-blending.desktop.frag000066400000000000000000000003021400026215700324410ustar00rootroot00000000000000#version 450 layout(location = 0, index = 0) out vec4 FragColor0; layout(location = 0, index = 1) out vec4 FragColor1; void main() { FragColor0 = vec4(1.0); FragColor1 = vec4(2.0); } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/hlsl-uav-block-alias.asm.frag000066400000000000000000000004461400026215700314700ustar00rootroot00000000000000#version 450 layout(binding = 0, std430) buffer Foobar { vec4 _data[]; } Foobar_1; layout(binding = 1, std430) buffer Foobaz { vec4 _data[]; } Foobaz_1; layout(location = 0) out vec4 _entryPointOutput; void main() { _entryPointOutput = Foobar_1._data[0] + Foobaz_1._data[0]; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/image-ms.desktop.frag000066400000000000000000000005161400026215700301440ustar00rootroot00000000000000#version 450 layout(binding = 0, rgba8) uniform image2DMS uImage; layout(binding = 1, rgba8) uniform image2DMSArray uImageArray; void main() { vec4 _29 = imageLoad(uImageArray, ivec3(1, 2, 4), 3); imageStore(uImage, ivec2(2, 3), 1, imageLoad(uImage, ivec2(1, 2), 2)); imageStore(uImageArray, ivec3(2, 3, 7), 1, _29); } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/image-query.desktop.frag000066400000000000000000000000371400026215700306700ustar00rootroot00000000000000#version 450 void main() { } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/image-size.frag000066400000000000000000000004401400026215700270230ustar00rootroot00000000000000#version 450 layout(binding = 0, r32f) uniform readonly writeonly image2D uImage1; layout(binding = 1, r32f) uniform readonly writeonly image2D uImage2; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(vec2(imageSize(uImage1)), vec2(imageSize(uImage2))); } image-size.no-qualifier-deduction.frag000066400000000000000000000003721400026215700333160ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag#version 450 layout(binding = 0, r32f) uniform image2D uImage1; layout(binding = 1, r32f) uniform image2D uImage2; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(vec2(imageSize(uImage1)), vec2(imageSize(uImage2))); } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/in-block-qualifiers.frag000066400000000000000000000007221400026215700306340ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in VertexData { flat float f; centroid vec4 g; flat int h; float i; } vin; layout(location = 4) flat in float f; layout(location = 5) centroid in vec4 g; layout(location = 6) flat in int h; layout(location = 7) sample in float i; void main() { FragColor = ((((((vec4(vin.f) + vin.g) + vec4(float(vin.h))) + vec4(vin.i)) + vec4(f)) + g) + vec4(float(h))) + vec4(i); } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/layout-component.desktop.frag000066400000000000000000000004401400026215700317560ustar00rootroot00000000000000#version 450 layout(location = 0) out vec2 FragColor; layout(location = 0, component = 0) in vec2 v0; layout(location = 0, component = 2) in float v1; in Vertex { layout(location = 1, component = 2) float v3; } _20; void main() { FragColor = (v0 + vec2(v1)) + vec2(_20.v3); } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/query-levels.desktop.frag000066400000000000000000000002651400026215700311030ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(textureQueryLevels(uSampler))); } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/query-lod.desktop.frag000066400000000000000000000003351400026215700303650ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTexCoord; void main() { FragColor = textureQueryLod(uSampler, vTexCoord).xyxy; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/sampler-ms-query.desktop.frag000066400000000000000000000007401400026215700316670ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2DMS uSampler; layout(binding = 1) uniform sampler2DMSArray uSamplerArray; layout(binding = 2, rgba8) uniform readonly writeonly image2DMS uImage; layout(binding = 3, rgba8) uniform readonly writeonly image2DMSArray uImageArray; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(((textureSamples(uSampler) + textureSamples(uSamplerArray)) + imageSamples(uImage)) + imageSamples(uImageArray))); } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/stencil-export.desktop.frag000066400000000000000000000003651400026215700314270ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_stencil_export : require layout(location = 0) out vec4 MRT0; layout(location = 1) out vec4 MRT1; void main() { MRT0 = vec4(1.0); MRT1 = vec4(1.0, 0.0, 1.0, 1.0); gl_FragStencilRefARB = 100; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/frag/texture-proj-shadow.desktop.frag000066400000000000000000000015031400026215700323750ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1DShadow uShadow1D; layout(binding = 1) uniform sampler2DShadow uShadow2D; layout(binding = 2) uniform sampler1D uSampler1D; layout(binding = 3) uniform sampler2D uSampler2D; layout(binding = 4) uniform sampler3D uSampler3D; layout(location = 0) out float FragColor; layout(location = 1) in vec4 vClip4; layout(location = 2) in vec2 vClip2; layout(location = 0) in vec3 vClip3; void main() { vec4 _20 = vClip4; _20.y = vClip4.w; FragColor = textureProj(uShadow1D, vec4(_20.x, 0.0, vClip4.z, _20.y)); vec4 _30 = vClip4; _30.z = vClip4.w; FragColor = textureProj(uShadow2D, vec4(_30.xy, vClip4.z, _30.z)); FragColor = textureProj(uSampler1D, vClip2).x; FragColor = textureProj(uSampler2D, vClip3).x; FragColor = textureProj(uSampler3D, vClip4).x; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/geom/000077500000000000000000000000001400026215700241425ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/geom/basic.desktop.sso.geom000066400000000000000000000012571400026215700303540ustar00rootroot00000000000000#version 450 layout(invocations = 4, triangles) in; layout(max_vertices = 3, triangle_strip) out; in gl_PerVertex { vec4 gl_Position; } gl_in[]; out gl_PerVertex { vec4 gl_Position; }; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[3]; void main() { gl_Position = gl_in[0].gl_Position; float _37 = float(gl_InvocationID); vNormal = vin[0].normal + vec3(_37); EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal + vec3(4.0 * _37); EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal + vec3(2.0 * _37); EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/geom/viewport-index.desktop.geom000066400000000000000000000001751400026215700314520ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(max_vertices = 4, triangle_strip) out; void main() { gl_ViewportIndex = 1; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/tesc/000077500000000000000000000000001400026215700241515ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/tesc/basic.desktop.sso.tesc000066400000000000000000000011601400026215700303630ustar00rootroot00000000000000#version 450 layout(vertices = 1) out; in gl_PerVertex { vec4 gl_Position; } gl_in[]; out gl_PerVertex { vec4 gl_Position; } gl_out[1]; layout(location = 0) patch out vec3 vFoo; void main() { gl_TessLevelInner[0] = 8.8999996185302734375; gl_TessLevelInner[1] = 6.900000095367431640625; gl_TessLevelOuter[0] = 8.8999996185302734375; gl_TessLevelOuter[1] = 6.900000095367431640625; gl_TessLevelOuter[2] = 3.900000095367431640625; gl_TessLevelOuter[3] = 4.900000095367431640625; vFoo = vec3(1.0); gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/tese/000077500000000000000000000000001400026215700241535ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/tese/triangle.desktop.sso.tese000066400000000000000000000005041400026215700311140ustar00rootroot00000000000000#version 450 layout(triangles, cw, fractional_even_spacing) in; in gl_PerVertex { vec4 gl_Position; } gl_in[]; out gl_PerVertex { vec4 gl_Position; }; void main() { gl_Position = ((gl_in[0].gl_Position * gl_TessCoord.x) + (gl_in[1].gl_Position * gl_TessCoord.y)) + (gl_in[2].gl_Position * gl_TessCoord.z); } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/vert/000077500000000000000000000000001400026215700241735ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/vert/basic.desktop.sso.vert000066400000000000000000000004761400026215700304400ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; }; layout(binding = 0, std140) uniform UBO { mat4 uMVP; } _16; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec3 vNormal; layout(location = 1) in vec3 aNormal; void main() { gl_Position = _16.uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/vert/clip-cull-distance.desktop.sso.vert000066400000000000000000000005231400026215700330240ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; float gl_PointSize; float gl_ClipDistance[4]; float gl_CullDistance[3]; }; void main() { gl_Position = vec4(1.0); gl_ClipDistance[0] = 0.0; gl_ClipDistance[1] = 0.0; gl_ClipDistance[2] = 0.0; gl_ClipDistance[3] = 0.0; gl_CullDistance[1] = 4.0; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/vert/clip-cull-distance.desktop.vert000066400000000000000000000004171400026215700322230ustar00rootroot00000000000000#version 450 out float gl_ClipDistance[4]; out float gl_CullDistance[3]; void main() { gl_Position = vec4(1.0); gl_ClipDistance[0] = 0.0; gl_ClipDistance[1] = 0.0; gl_ClipDistance[2] = 0.0; gl_ClipDistance[3] = 0.0; gl_CullDistance[1] = 4.0; } spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/vert/out-block-qualifiers.vert000066400000000000000000000006671400026215700311470ustar00rootroot00000000000000#version 450 layout(location = 0) out VertexData { flat float f; centroid vec4 g; flat int h; float i; } vout; layout(location = 4) flat out float f; layout(location = 5) centroid out vec4 g; layout(location = 6) flat out int h; layout(location = 7) out float i; void main() { vout.f = 10.0; vout.g = vec4(20.0); vout.h = 20; vout.i = 30.0; f = 10.0; g = vec4(20.0); h = 20; i = 30.0; } shader-draw-parameters-450.desktop.vk.vert000066400000000000000000000011461400026215700337570ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/vert#version 450 #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseVertex gl_BaseVertexARB #else uniform int SPIRV_Cross_BaseVertex; #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif #ifndef GL_ARB_shader_draw_parameters #error GL_ARB_shader_draw_parameters is not supported. #endif void main() { gl_Position = vec4(float(SPIRV_Cross_BaseVertex), float(SPIRV_Cross_BaseInstance), float(gl_DrawIDARB), 1.0); } shader-draw-parameters-450.desktop.vk.vert.vk000066400000000000000000000002701400026215700343730ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/vert#version 450 #extension GL_ARB_shader_draw_parameters : require void main() { gl_Position = vec4(float(gl_BaseVertexARB), float(gl_BaseInstanceARB), float(gl_DrawIDARB), 1.0); } shader-draw-parameters.desktop.vk.vert000066400000000000000000000011461400026215700334510ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/vert#version 460 #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseVertex gl_BaseVertexARB #else uniform int SPIRV_Cross_BaseVertex; #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif #ifndef GL_ARB_shader_draw_parameters #error GL_ARB_shader_draw_parameters is not supported. #endif void main() { gl_Position = vec4(float(SPIRV_Cross_BaseVertex), float(SPIRV_Cross_BaseInstance), float(gl_DrawIDARB), 1.0); } shader-draw-parameters.desktop.vk.vert.vk000066400000000000000000000001741400026215700340700ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/desktop-only/vert#version 460 void main() { gl_Position = vec4(float(gl_BaseVertex), float(gl_BaseInstance), float(gl_DrawID), 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/flatten/000077500000000000000000000000001400026215700222205ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/flatten/array.flatten.vert000066400000000000000000000003351400026215700256750ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[56]; layout(location = 0) in vec4 aVertex; void main() { gl_Position = ((mat4(UBO[40], UBO[41], UBO[42], UBO[43]) * aVertex) + UBO[55]) + ((UBO[50] + UBO[45]) + vec4(UBO[54].x)); } spirv-cross-2021.01.15/reference/opt/shaders/flatten/basic.flatten.vert000066400000000000000000000004041400026215700256350ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[4]; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec3 vNormal; layout(location = 1) in vec3 aNormal; void main() { gl_Position = mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/reference/opt/shaders/flatten/copy.flatten.vert000066400000000000000000000013011400026215700255230ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; uniform vec4 UBO[12]; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec4 vColor; layout(location = 1) in vec3 aNormal; void main() { gl_Position = mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex; vColor = vec4(0.0); for (int _96 = 0; _96 < 4; ) { vec3 _68 = aVertex.xyz - Light(UBO[_96 * 2 + 4].xyz, UBO[_96 * 2 + 4].w, UBO[_96 * 2 + 5]).Position; vColor += ((UBO[_96 * 2 + 5] * clamp(1.0 - (length(_68) / Light(UBO[_96 * 2 + 4].xyz, UBO[_96 * 2 + 4].w, UBO[_96 * 2 + 5]).Radius), 0.0, 1.0)) * dot(aNormal, normalize(_68))); _96++; continue; } } spirv-cross-2021.01.15/reference/opt/shaders/flatten/dynamic.flatten.vert000066400000000000000000000011251400026215700262010ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; uniform vec4 UBO[12]; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec4 vColor; layout(location = 1) in vec3 aNormal; void main() { gl_Position = mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex; vColor = vec4(0.0); for (int _82 = 0; _82 < 4; ) { vec3 _54 = aVertex.xyz - UBO[_82 * 2 + 4].xyz; vColor += ((UBO[_82 * 2 + 5] * clamp(1.0 - (length(_54) / UBO[_82 * 2 + 4].w), 0.0, 1.0)) * dot(aNormal, normalize(_54))); _82++; continue; } } spirv-cross-2021.01.15/reference/opt/shaders/flatten/matrix-conversion.flatten.frag000066400000000000000000000004631400026215700302070ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform vec4 UBO[4]; layout(location = 0) out vec3 FragColor; layout(location = 0) flat in vec3 vNormal; void main() { mat4 _19 = mat4(UBO[0], UBO[1], UBO[2], UBO[3]); FragColor = mat3(_19[0].xyz, _19[1].xyz, _19[2].xyz) * vNormal; } spirv-cross-2021.01.15/reference/opt/shaders/flatten/matrixindex.flatten.vert000066400000000000000000000007141400026215700271140ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[14]; layout(location = 0) out vec4 oA; layout(location = 1) out vec4 oB; layout(location = 2) out vec4 oC; layout(location = 3) out vec4 oD; layout(location = 4) out vec4 oE; void main() { gl_Position = vec4(0.0); oA = UBO[1]; oB = vec4(UBO[4].y, UBO[5].y, UBO[6].y, UBO[7].y); oC = UBO[9]; oD = vec4(UBO[10].x, UBO[11].x, UBO[12].x, UBO[13].x); oE = vec4(UBO[1].z, UBO[6].y, UBO[9].z, UBO[12].y); } spirv-cross-2021.01.15/reference/opt/shaders/flatten/multiindex.flatten.vert000066400000000000000000000002271400026215700267410ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[15]; layout(location = 0) in ivec2 aIndex; void main() { gl_Position = UBO[aIndex.x * 5 + aIndex.y * 1 + 0]; } spirv-cross-2021.01.15/reference/opt/shaders/flatten/push-constant.flatten.vert000066400000000000000000000004661400026215700273720ustar00rootroot00000000000000#version 310 es uniform vec4 PushMe[6]; layout(location = 1) in vec4 Pos; layout(location = 0) out vec2 vRot; layout(location = 0) in vec2 Rot; void main() { gl_Position = mat4(PushMe[0], PushMe[1], PushMe[2], PushMe[3]) * Pos; vRot = (mat2(PushMe[4].xy, PushMe[4].zw) * Rot) + vec2(PushMe[5].z); } spirv-cross-2021.01.15/reference/opt/shaders/flatten/rowmajor.flatten.vert000066400000000000000000000003261400026215700264170ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[12]; layout(location = 0) in vec4 aVertex; void main() { gl_Position = (mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex) + (aVertex * mat4(UBO[4], UBO[5], UBO[6], UBO[7])); } spirv-cross-2021.01.15/reference/opt/shaders/flatten/struct.flatten.vert000066400000000000000000000007401400026215700261030ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; uniform vec4 UBO[6]; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec4 vColor; layout(location = 1) in vec3 aNormal; void main() { gl_Position = mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex; vColor = vec4(0.0); vec3 _39 = aVertex.xyz - UBO[4].xyz; vColor += ((UBO[5] * clamp(1.0 - (length(_39) / UBO[4].w), 0.0, 1.0)) * dot(aNormal, normalize(_39))); } spirv-cross-2021.01.15/reference/opt/shaders/flatten/struct.rowmajor.flatten.vert000066400000000000000000000006721400026215700277460ustar00rootroot00000000000000#version 310 es struct Foo { mat3x4 MVP0; mat3x4 MVP1; }; uniform vec4 UBO[8]; layout(location = 0) in vec4 v0; layout(location = 1) in vec4 v1; layout(location = 0) out vec3 V0; layout(location = 1) out vec3 V1; void main() { Foo _20 = Foo(transpose(mat4x3(UBO[0].xyz, UBO[1].xyz, UBO[2].xyz, UBO[3].xyz)), transpose(mat4x3(UBO[4].xyz, UBO[5].xyz, UBO[6].xyz, UBO[7].xyz))); V0 = v0 * _20.MVP0; V1 = v1 * _20.MVP1; } spirv-cross-2021.01.15/reference/opt/shaders/flatten/swizzle.flatten.vert000066400000000000000000000010061400026215700262620ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[8]; layout(location = 0) out vec4 oA; layout(location = 1) out vec4 oB; layout(location = 2) out vec4 oC; layout(location = 3) out vec4 oD; layout(location = 4) out vec4 oE; layout(location = 5) out vec4 oF; void main() { gl_Position = vec4(0.0); oA = UBO[0]; oB = vec4(UBO[1].xy, UBO[1].zw); oC = vec4(UBO[2].x, UBO[3].xyz); oD = vec4(UBO[4].xyz, UBO[4].w); oE = vec4(UBO[5].x, UBO[5].y, UBO[5].z, UBO[5].w); oF = vec4(UBO[6].x, UBO[6].zw, UBO[7].x); } spirv-cross-2021.01.15/reference/opt/shaders/flatten/types.flatten.frag000066400000000000000000000004711400026215700256630ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump ivec4 UBO1[2]; uniform mediump uvec4 UBO2[2]; uniform vec4 UBO0[2]; layout(location = 0) out vec4 FragColor; void main() { FragColor = ((((vec4(UBO1[0]) + vec4(UBO1[1])) + vec4(UBO2[0])) + vec4(UBO2[1])) + UBO0[0]) + UBO0[1]; } spirv-cross-2021.01.15/reference/opt/shaders/frag/000077500000000000000000000000001400026215700215025ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/frag/array-lut-no-loop-variable.frag000066400000000000000000000005241400026215700274300ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; const float _17[5] = float[](1.0, 2.0, 3.0, 4.0, 5.0); layout(location = 0) out vec4 FragColor; void main() { for (mediump int _46 = 0; _46 < 4; ) { mediump int _33 = _46 + 1; FragColor += vec4(_17[_33]); _46 = _33; continue; } } spirv-cross-2021.01.15/reference/opt/shaders/frag/avoid-expression-lowering-to-loop.frag000066400000000000000000000010621400026215700310540ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 1, std140) uniform Count { float count; } _44; layout(binding = 0) uniform mediump sampler2D tex; layout(location = 0) in highp vec4 vertex; layout(location = 0) out vec4 fragColor; void main() { highp float _24 = 1.0 / float(textureSize(tex, 0).x); highp float _34 = dFdx(vertex.x); float _62; _62 = 0.0; for (float _61 = 0.0; _61 < _44.count; ) { _62 += (_24 * _34); _61 += 1.0; continue; } fragColor = vec4(_62); } spirv-cross-2021.01.15/reference/opt/shaders/frag/barycentric-nv.frag000066400000000000000000000010451400026215700252710ustar00rootroot00000000000000#version 450 #extension GL_NV_fragment_shader_barycentric : require layout(binding = 0, std430) readonly buffer Vertices { vec2 uvs[]; } _19; layout(location = 0) out vec2 value; void main() { int _23 = 3 * gl_PrimitiveID; int _32 = _23 + 1; int _39 = _23 + 2; value = ((_19.uvs[_23] * gl_BaryCoordNV.x) + (_19.uvs[_32] * gl_BaryCoordNV.y)) + (_19.uvs[_39] * gl_BaryCoordNV.z); value += (((_19.uvs[_23] * gl_BaryCoordNoPerspNV.x) + (_19.uvs[_32] * gl_BaryCoordNoPerspNV.y)) + (_19.uvs[_39] * gl_BaryCoordNoPerspNV.z)); } spirv-cross-2021.01.15/reference/opt/shaders/frag/basic.frag000066400000000000000000000004451400026215700234270ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uTex; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; void main() { FragColor = vColor * texture(uTex, vTex); } spirv-cross-2021.01.15/reference/opt/shaders/frag/complex-expression-in-access-chain.frag000066400000000000000000000007761400026215700311440ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0, std430) buffer UBO { vec4 results[1024]; } _34; layout(binding = 1) uniform highp isampler2D Buf; layout(location = 0) flat in mediump int vIn; layout(location = 1) flat in mediump int vIn2; layout(location = 0) out vec4 FragColor; void main() { mediump int _40 = texelFetch(Buf, ivec2(gl_FragCoord.xy), 0).x % 16; FragColor = (_34.results[_40] + _34.results[_40]) + _34.results[(vIn * vIn) + (vIn2 * vIn2)]; } spirv-cross-2021.01.15/reference/opt/shaders/frag/composite-extract-forced-temporary.frag000066400000000000000000000004761400026215700313040ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D Texture; layout(location = 0) in vec2 vTexCoord; layout(location = 0) out vec4 FragColor; void main() { vec4 _19 = texture(Texture, vTexCoord); float _22 = _19.x; FragColor = vec4(_22 * _22); } spirv-cross-2021.01.15/reference/opt/shaders/frag/constant-array.frag000066400000000000000000000010451400026215700253100ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct Foobar { float a; float b; }; const vec4 _37[3] = vec4[](vec4(1.0), vec4(2.0), vec4(3.0)); const vec4 _55[2][2] = vec4[][](vec4[](vec4(1.0), vec4(2.0)), vec4[](vec4(8.0), vec4(10.0))); const Foobar _75[2] = Foobar[](Foobar(10.0, 40.0), Foobar(90.0, 70.0)); layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int index; void main() { FragColor = ((_37[index] + _55[index][index + 1]) + vec4(30.0)) + vec4(_75[index].a + _75[index].b); } spirv-cross-2021.01.15/reference/opt/shaders/frag/constant-composites.frag000066400000000000000000000006331400026215700263610ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; const float _16[4] = float[](1.0, 4.0, 3.0, 2.0); struct Foo { float a; float b; }; const Foo _28[2] = Foo[](Foo(10.0, 20.0), Foo(30.0, 40.0)); layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int line; void main() { FragColor = vec4(_16[line]); FragColor += vec4(_28[line].a * _28[1 - line].a); } spirv-cross-2021.01.15/reference/opt/shaders/frag/false-loop-init.frag000066400000000000000000000005051400026215700253450ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 result; layout(location = 0) in vec4 accum; void main() { result = vec4(0.0); for (mediump int _48 = 0; _48 < 4; ) { result += accum; _48 += int((accum.y > 10.0) ? 40u : 30u); continue; } } spirv-cross-2021.01.15/reference/opt/shaders/frag/flush_params.frag000066400000000000000000000002261400026215700250270ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(10.0); } spirv-cross-2021.01.15/reference/opt/shaders/frag/for-loop-continue-control-flow.frag000066400000000000000000000003301400026215700303410ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(0.0); for (int _43 = 0; _43 < 3; ) { FragColor[_43] += float(_43); _43++; continue; } } spirv-cross-2021.01.15/reference/opt/shaders/frag/for-loop-init.frag000066400000000000000000000025431400026215700250450ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out mediump int FragColor; void main() { do { FragColor = 16; for (mediump int _143 = 0; _143 < 25; ) { FragColor += 10; _143++; continue; } for (mediump int _144 = 1; _144 < 30; ) { FragColor += 11; _144++; continue; } mediump int _145; _145 = 0; for (; _145 < 20; ) { FragColor += 12; _145++; continue; } mediump int _62 = _145 + 3; FragColor += _62; if (_62 == 40) { for (mediump int _149 = 0; _149 < 40; ) { FragColor += 13; _149++; continue; } break; } FragColor += _62; mediump ivec2 _146; _146 = ivec2(0); for (; _146.x < 10; ) { FragColor += _146.y; mediump ivec2 _142 = _146; _142.x = _146.x + 4; _146 = _142; continue; } for (mediump int _148 = _62; _148 < 40; ) { FragColor += _148; _148++; continue; } FragColor += _62; break; } while(false); } spirv-cross-2021.01.15/reference/opt/shaders/frag/frexp-modf.frag000066400000000000000000000011021400026215700244040ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct ResType { highp float _m0; int _m1; }; struct ResType_1 { highp vec2 _m0; ivec2 _m1; }; layout(location = 0) in float v0; layout(location = 1) in vec2 v1; layout(location = 0) out float FragColor; void main() { ResType _22; _22._m0 = frexp(v0 + 1.0, _22._m1); ResType_1 _35; _35._m0 = frexp(v1, _35._m1); float r0; float _41 = modf(v0, r0); vec2 r1; vec2 _45 = modf(v1, r1); FragColor = ((((_22._m0 + _35._m0.x) + _35._m0.y) + _41) + _45.x) + _45.y; } spirv-cross-2021.01.15/reference/opt/shaders/frag/front-facing.frag000066400000000000000000000004451400026215700247230ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in vec4 vB; void main() { if (gl_FrontFacing) { FragColor = vA; } else { FragColor = vB; } } spirv-cross-2021.01.15/reference/opt/shaders/frag/gather-dref.frag000066400000000000000000000004071400026215700245340ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2DShadow uT; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec3 vUV; void main() { FragColor = textureGather(uT, vUV.xy, vUV.z); } spirv-cross-2021.01.15/reference/opt/shaders/frag/ground.frag000066400000000000000000000023621400026215700236440ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 4, std140) uniform GlobalPSData { vec4 g_CamPos; vec4 g_SunDir; vec4 g_SunColor; vec4 g_ResolutionParams; vec4 g_TimeParams; vec4 g_FogColor_Distance; } _101; layout(binding = 2) uniform mediump sampler2D TexNormalmap; layout(location = 3) out vec4 LightingOut; layout(location = 2) out vec4 NormalOut; layout(location = 1) out vec4 SpecularOut; layout(location = 0) out vec4 AlbedoOut; layout(location = 0) in vec2 TexCoord; layout(location = 1) in vec3 EyeVec; void main() { vec3 _68 = normalize((texture(TexNormalmap, TexCoord).xyz * 2.0) - vec3(1.0)); float _113 = smoothstep(0.0, 0.1500000059604644775390625, (_101.g_CamPos.y + EyeVec.y) * 0.004999999888241291046142578125); float _125 = smoothstep(0.699999988079071044921875, 0.75, _68.y); vec3 _130 = mix(vec3(0.100000001490116119384765625), mix(vec3(0.100000001490116119384765625, 0.300000011920928955078125, 0.100000001490116119384765625), vec3(0.800000011920928955078125), vec3(_113)), vec3(_125)); LightingOut = vec4(0.0); NormalOut = vec4((_68 * 0.5) + vec3(0.5), 0.0); SpecularOut = vec4(1.0 - (_125 * _113), 0.0, 0.0, 0.0); AlbedoOut = vec4(_130 * _130, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/frag/helper-invocation.frag000066400000000000000000000005761400026215700260010ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uSampler; layout(location = 0) in vec2 vUV; layout(location = 0) out vec4 FragColor; void main() { vec4 _52; if (!gl_HelperInvocation) { _52 = textureLod(uSampler, vUV, 0.0); } else { _52 = vec4(1.0); } FragColor = _52; } spirv-cross-2021.01.15/reference/opt/shaders/frag/hoisted-temporary-use-continue-block-as-value.frag000066400000000000000000000010771400026215700332460ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int vA; layout(location = 1) flat in mediump int vB; void main() { FragColor = vec4(0.0); mediump int _49; mediump int _58; for (mediump int _57 = 0, _60 = 0; _57 < vA; _60 = _58, _57 += _49) { if ((vA + _57) == 20) { _58 = 50; } else { _58 = ((vB + _57) == 40) ? 60 : _60; } _49 = _58 + 10; FragColor += vec4(1.0); } } spirv-cross-2021.01.15/reference/opt/shaders/frag/image-load-store-uint-coord.asm.frag000066400000000000000000000010541400026215700303340ustar00rootroot00000000000000#version 450 layout(binding = 1, rgba32f) uniform image2D RWIm; layout(binding = 0, rgba32f) uniform writeonly imageBuffer RWBuf; layout(binding = 1) uniform sampler2D ROIm; layout(binding = 0) uniform samplerBuffer ROBuf; layout(location = 0) out vec4 _entryPointOutput; void main() { imageStore(RWIm, ivec2(uvec2(10u)), vec4(10.0, 0.5, 8.0, 2.0)); vec4 _70 = imageLoad(RWIm, ivec2(uvec2(30u))); imageStore(RWBuf, int(80u), _70); _entryPointOutput = (_70 + texelFetch(ROIm, ivec2(uvec2(50u, 60u)), 0)) + texelFetch(ROBuf, int(80u)); } spirv-cross-2021.01.15/reference/opt/shaders/frag/inside-loop-dominated-variable-preservation.frag000066400000000000000000000002251400026215700330300ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/frag/loop-dominator-and-switch-default.frag000066400000000000000000000022121400026215700307640ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 fragColor; vec4 _80; void main() { mediump int _18 = int(_80.x); vec4 _82; _82 = _80; vec4 _89; for (mediump int _81 = 0; _81 < _18; _82 = _89, _81++) { vec4 _83; switch (_18) { case 0: { vec4 _74 = _82; _74.y = 0.0; _83 = _74; break; } case 1: { vec4 _76 = _82; _76.y = 1.0; _83 = _76; break; } default: { vec4 _88; _88 = _82; for (mediump int _84 = 0; _84 < _18; ) { vec4 _72 = _88; _72.y = _88.y + 0.5; _88 = _72; _84++; continue; } _89 = _88; continue; } } vec4 _79 = _83; _79.y = _83.y + 0.5; _89 = _79; } fragColor = _82; } spirv-cross-2021.01.15/reference/opt/shaders/frag/lut-promotion.frag000066400000000000000000000016201400026215700251720ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; const float _16[16] = float[](1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0); const vec4 _60[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); const vec4 _104[4] = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0)); layout(location = 0) out float FragColor; layout(location = 0) flat in mediump int index; void main() { FragColor = _16[index]; if (index < 10) { FragColor += _16[index ^ 1]; } else { FragColor += _16[index & 1]; } bool _63 = index > 30; if (_63) { FragColor += _60[index & 3].y; } else { FragColor += _60[index & 1].x; } vec4 foobar[4] = _60; if (_63) { foobar[1].z = 20.0; } mediump int _91 = index & 3; FragColor += foobar[_91].z; FragColor += _104[_91].z; } spirv-cross-2021.01.15/reference/opt/shaders/frag/mix.frag000066400000000000000000000006211400026215700231370ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vIn0; layout(location = 1) in vec4 vIn1; layout(location = 2) in float vIn2; layout(location = 3) in float vIn3; void main() { FragColor = vec4(vIn0.x, vIn1.y, vIn0.z, vIn0.w); FragColor = vec4(vIn3); FragColor = vIn0.xyzw; FragColor = vec4(vIn2); } spirv-cross-2021.01.15/reference/opt/shaders/frag/partial-write-preserve.frag000066400000000000000000000001201400026215700267510ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; void main() { } spirv-cross-2021.01.15/reference/opt/shaders/frag/pixel-interlock-ordered.frag000066400000000000000000000010521400026215700270740ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 2, std430) coherent buffer Buffer { int foo; uint bar; } _30; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0), vec4(1.0, 0.0, 0.0, 1.0)); uint _27 = imageAtomicAdd(img2, ivec2(0), 1u); _30.foo += 42; uint _41 = atomicAnd(_30.bar, 255u); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/opt/shaders/frag/pixel-interlock-unordered.frag000066400000000000000000000010541400026215700274410ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_unordered) in; layout(binding = 2, std430) coherent buffer Buffer { int foo; uint bar; } _30; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0), vec4(1.0, 0.0, 0.0, 1.0)); uint _27 = imageAtomicAdd(img2, ivec2(0), 1u); _30.foo += 42; uint _41 = atomicAnd(_30.bar, 255u); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/opt/shaders/frag/pls.frag000066400000000000000000000007611400026215700231450ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 PLSOut0; layout(location = 0) in vec4 PLSIn0; layout(location = 1) out vec4 PLSOut1; layout(location = 1) in vec4 PLSIn1; layout(location = 2) out vec4 PLSOut2; layout(location = 2) in vec4 PLSIn2; layout(location = 3) out vec4 PLSOut3; layout(location = 3) in vec4 PLSIn3; void main() { PLSOut0 = PLSIn0 * 2.0; PLSOut1 = PLSIn1 * 6.0; PLSOut2 = PLSIn2 * 7.0; PLSOut3 = PLSIn3 * 4.0; } spirv-cross-2021.01.15/reference/opt/shaders/frag/post-depth-coverage-es.frag000066400000000000000000000004761400026215700266370ustar00rootroot00000000000000#version 310 es #extension GL_EXT_post_depth_coverage : require #extension GL_OES_sample_variables : require precision mediump float; precision highp int; layout(early_fragment_tests, post_depth_coverage) in; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(gl_SampleMaskIn[0])); } spirv-cross-2021.01.15/reference/opt/shaders/frag/post-depth-coverage.frag000066400000000000000000000005041400026215700262220ustar00rootroot00000000000000#version 450 #if defined(GL_ARB_post_depth_coverge) #extension GL_ARB_post_depth_coverage : require #else #extension GL_EXT_post_depth_coverage : require #endif layout(early_fragment_tests, post_depth_coverage) in; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(gl_SampleMaskIn[0])); } spirv-cross-2021.01.15/reference/opt/shaders/frag/round-even.frag000066400000000000000000000003131400026215700244220ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in float vB; void main() { FragColor = roundEven(vA); FragColor *= roundEven(vB); } spirv-cross-2021.01.15/reference/opt/shaders/frag/round.frag000066400000000000000000000003031400026215700234660ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in float vB; void main() { FragColor = round(vA); FragColor *= round(vB); } spirv-cross-2021.01.15/reference/opt/shaders/frag/sample-interlock-ordered.frag000066400000000000000000000010771400026215700272430ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(sample_interlock_ordered) in; layout(binding = 2, std430) coherent buffer Buffer { int foo; uint bar; } _30; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0), vec4(1.0, 0.0, 0.0, 1.0)); uint _27 = imageAtomicAdd(img2, ivec2(0), 1u); _30.foo += 42; uint _47 = atomicAnd(_30.bar, uint(gl_SampleMaskIn[0])); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/opt/shaders/frag/sample-interlock-unordered.frag000066400000000000000000000010551400026215700276020ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(sample_interlock_unordered) in; layout(binding = 2, std430) coherent buffer Buffer { int foo; uint bar; } _30; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0), vec4(1.0, 0.0, 0.0, 1.0)); uint _27 = imageAtomicAdd(img2, ivec2(0), 1u); _30.foo += 42; uint _41 = atomicAnd(_30.bar, 255u); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/opt/shaders/frag/sample-parameter.frag000066400000000000000000000004431400026215700256030ustar00rootroot00000000000000#version 310 es #extension GL_OES_sample_variables : require precision mediump float; precision highp int; layout(location = 0) out vec2 FragColor; void main() { FragColor = (gl_SamplePosition + vec2(float(gl_SampleMaskIn[0]))) + vec2(float(gl_SampleID)); gl_SampleMask[0] = 1; } spirv-cross-2021.01.15/reference/opt/shaders/frag/sampler-ms.frag000066400000000000000000000005541400026215700244270ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2DMS uSampler; layout(location = 0) out vec4 FragColor; void main() { ivec2 _17 = ivec2(gl_FragCoord.xy); FragColor = ((texelFetch(uSampler, _17, 0) + texelFetch(uSampler, _17, 1)) + texelFetch(uSampler, _17, 2)) + texelFetch(uSampler, _17, 3); } spirv-cross-2021.01.15/reference/opt/shaders/frag/sampler-proj.frag000066400000000000000000000004551400026215700247620ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uTex; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vTex; void main() { highp vec4 _19 = vTex; _19.z = vTex.w; FragColor = textureProj(uTex, _19.xyz); } spirv-cross-2021.01.15/reference/opt/shaders/frag/sampler.frag000066400000000000000000000004451400026215700240110ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uTex; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; void main() { FragColor = vColor * texture(uTex, vTex); } spirv-cross-2021.01.15/reference/opt/shaders/frag/scalar-refract-reflect.frag000066400000000000000000000005301400026215700266540ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(location = 0) in vec3 vRefract; void main() { FragColor = refract(vRefract.x, vRefract.y, vRefract.z); FragColor += reflect(vRefract.x, vRefract.y); FragColor += refract(vRefract.xy, vRefract.yz, vRefract.z).y; FragColor += reflect(vRefract.xy, vRefract.zy).y; } spirv-cross-2021.01.15/reference/opt/shaders/frag/selection-block-dominator.frag000066400000000000000000000004451400026215700274150ustar00rootroot00000000000000#version 450 layout(location = 0) flat in int vIndex; layout(location = 0) out vec4 FragColor; void main() { do { if (vIndex != 1) { FragColor = vec4(1.0); break; } FragColor = vec4(10.0); break; } while(false); } spirv-cross-2021.01.15/reference/opt/shaders/frag/struct-type-unrelated-alias.frag000066400000000000000000000001401400026215700277110ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; void main() { FragColor = 30.0; } spirv-cross-2021.01.15/reference/opt/shaders/frag/switch-unsigned-case.frag000066400000000000000000000007701400026215700263730ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0, std140) uniform Buff { mediump uint TestVal; } _15; layout(location = 0) out vec4 fsout_Color; void main() { fsout_Color = vec4(1.0); switch (_15.TestVal) { case 0u: { fsout_Color = vec4(0.100000001490116119384765625); break; } case 1u: { fsout_Color = vec4(0.20000000298023223876953125); break; } } } spirv-cross-2021.01.15/reference/opt/shaders/frag/swizzle.frag000066400000000000000000000012141400026215700240500ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D samp; layout(location = 0) out vec4 FragColor; layout(location = 2) in vec2 vUV; layout(location = 1) in vec3 vNormal; void main() { vec4 _19 = texture(samp, vUV); float _23 = _19.x; FragColor = vec4(_23, _19.yz, 1.0); FragColor = vec4(_23, _19.z, 1.0, 4.0); FragColor = vec4(_23, _23, texture(samp, vUV + vec2(0.100000001490116119384765625)).yy); FragColor = vec4(vNormal, 1.0); FragColor = vec4(vNormal + vec3(1.7999999523162841796875), 1.0); FragColor = vec4(vUV, vUV + vec2(1.7999999523162841796875)); } spirv-cross-2021.01.15/reference/opt/shaders/frag/texel-fetch-offset.frag000066400000000000000000000005441400026215700260420ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uTexture; layout(location = 0) out vec4 FragColor; void main() { mediump ivec2 _22 = ivec2(gl_FragCoord.xy); FragColor = texelFetchOffset(uTexture, _22, 0, ivec2(1)); FragColor += texelFetchOffset(uTexture, _22, 0, ivec2(-1, 1)); } spirv-cross-2021.01.15/reference/opt/shaders/frag/ubo-load-row-major-workaround.frag000066400000000000000000000015761400026215700301620ustar00rootroot00000000000000#version 450 struct RowMajor { mat4 B; }; struct NestedRowMajor { RowMajor rm; }; layout(binding = 2, std140) uniform UBO3 { layout(row_major) NestedRowMajor rm2; } _17; layout(binding = 1, std140) uniform UBO2 { layout(row_major) RowMajor rm; } _35; layout(binding = 0, std140) uniform UBO { layout(row_major) mat4 A; mat4 C; } _42; layout(binding = 3, std140) uniform UBONoWorkaround { mat4 D; } _56; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 Clip; NestedRowMajor spvWorkaroundRowMajor(NestedRowMajor wrap) { return wrap; } mat4 spvWorkaroundRowMajor(mat4 wrap) { return wrap; } void main() { FragColor = (((spvWorkaroundRowMajor(_17.rm2).rm.B * spvWorkaroundRowMajor(_35.rm.B)) * spvWorkaroundRowMajor(_42.A)) * spvWorkaroundRowMajor(_42.C)) * Clip; FragColor += (_56.D * Clip); FragColor += (_42.A[1] * Clip); } spirv-cross-2021.01.15/reference/opt/shaders/frag/ubo_layout.frag000066400000000000000000000005401400026215700245240ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct Str { mat4 foo; }; layout(binding = 0, std140) uniform UBO1 { layout(row_major) Str foo; } ubo1; layout(binding = 1, std140) uniform UBO2 { Str foo; } ubo0; layout(location = 0) out vec4 FragColor; void main() { FragColor = ubo1.foo.foo[0] + ubo0.foo.foo[0]; } spirv-cross-2021.01.15/reference/opt/shaders/frag/unary-enclose.frag000066400000000000000000000002611400026215700251260ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vIn; void main() { FragColor = vIn; } spirv-cross-2021.01.15/reference/opt/shaders/geom/000077500000000000000000000000001400026215700215125ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/geom/basic.geom000066400000000000000000000011751400026215700234500ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(invocations = 4, triangles) in; layout(max_vertices = 3, triangle_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[3]; void main() { gl_Position = gl_in[0].gl_Position; float _37 = float(gl_InvocationID); vNormal = vin[0].normal + vec3(_37); EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal + vec3(4.0 * _37); EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal + vec3(2.0 * _37); EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/opt/shaders/geom/geometry-passthrough.geom000066400000000000000000000006311400026215700265630ustar00rootroot00000000000000#version 450 #extension GL_NV_geometry_shader_passthrough : require layout(triangles) in; layout(passthrough) in gl_PerVertex { vec4 gl_Position; } gl_in[]; layout(passthrough, location = 0) in VertexBlock { int a; int b; } v1[3]; layout(location = 2) in VertexBlock2 { int a; layout(passthrough) int b; } v2[3]; void main() { gl_Layer = (gl_InvocationID + v1[0].a) + v2[1].b; } spirv-cross-2021.01.15/reference/opt/shaders/geom/lines-adjacency.geom000066400000000000000000000010261400026215700254130ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(lines_adjacency) in; layout(max_vertices = 3, line_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[4]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/opt/shaders/geom/lines.geom000066400000000000000000000006651400026215700235040ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(lines) in; layout(max_vertices = 2, line_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[2]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/opt/shaders/geom/multi-stream.geom000066400000000000000000000004371400026215700250120ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(max_vertices = 2, points) out; void main() { gl_Position = gl_in[0].gl_Position; EmitStreamVertex(0); EndStreamPrimitive(0); gl_Position = gl_in[0].gl_Position + vec4(2.0); EmitStreamVertex(1); EndStreamPrimitive(1); } spirv-cross-2021.01.15/reference/opt/shaders/geom/points.geom000066400000000000000000000010111400026215700236700ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(points) in; layout(max_vertices = 3, points) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[1]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/opt/shaders/geom/single-invocation.geom000066400000000000000000000010241400026215700260100ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles) in; layout(max_vertices = 3, triangle_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[3]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/opt/shaders/geom/transform-feedback-streams.geom000066400000000000000000000011101400026215700275650ustar00rootroot00000000000000#version 450 layout(points) in; layout(max_vertices = 2, points) out; layout(xfb_buffer = 1, xfb_stride = 20, stream = 1) out gl_PerVertex { layout(xfb_offset = 4) vec4 gl_Position; float gl_PointSize; }; layout(location = 0, xfb_buffer = 2, xfb_stride = 32, xfb_offset = 16, stream = 1) out vec4 vFoo; layout(xfb_buffer = 3, xfb_stride = 16, stream = 2) out VertOut { layout(location = 1, xfb_offset = 0) vec4 vBar; } _23; void main() { gl_Position = vec4(1.0); vFoo = vec4(3.0); EmitStreamVertex(1); _23.vBar = vec4(5.0); EmitStreamVertex(2); } spirv-cross-2021.01.15/reference/opt/shaders/geom/triangles-adjacency.geom000066400000000000000000000010361400026215700262720ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles_adjacency) in; layout(max_vertices = 3, triangle_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[6]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/opt/shaders/geom/triangles.geom000066400000000000000000000010241400026215700243500ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles) in; layout(max_vertices = 3, triangle_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[3]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/opt/shaders/legacy/000077500000000000000000000000001400026215700220275ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/legacy/fragment/000077500000000000000000000000001400026215700236325ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/legacy/fragment/explicit-lod.legacy.frag000066400000000000000000000004121400026215700303300ustar00rootroot00000000000000#version 100 #extension GL_EXT_shader_texture_lod : require precision mediump float; precision highp int; uniform mediump sampler2D tex; void main() { gl_FragData[0] = texture2DLodEXT(tex, vec2(0.4000000059604644775390625, 0.60000002384185791015625), 0.0); } spirv-cross-2021.01.15/reference/opt/shaders/legacy/fragment/explicit-lod.legacy.vert000066400000000000000000000003061400026215700303730ustar00rootroot00000000000000#version 100 uniform mediump sampler2D tex; varying mediump vec4 FragColor; void main() { FragColor = texture2DLod(tex, vec2(0.4000000059604644775390625, 0.60000002384185791015625), 3.0); } spirv-cross-2021.01.15/reference/opt/shaders/legacy/fragment/fma.legacy.frag000066400000000000000000000002661400026215700265050ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; varying highp vec4 vA; varying highp vec4 vB; varying highp vec4 vC; void main() { gl_FragData[0] = vA * vB + vC; } spirv-cross-2021.01.15/reference/opt/shaders/legacy/fragment/io-blocks.legacy.frag000066400000000000000000000002671400026215700276250ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; varying vec4 vin_color; varying highp vec3 vin_normal; void main() { gl_FragData[0] = vin_color + vin_normal.xyzz; } spirv-cross-2021.01.15/reference/opt/shaders/legacy/fragment/multiple-struct-flattening.legacy.frag000066400000000000000000000010351400026215700332430ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; struct Foo { highp vec4 a; highp vec4 b; }; struct Bar { highp vec4 a; highp vec4 b; }; struct Baz { Foo foo; Bar bar; }; varying highp vec4 baz_foo_a; varying highp vec4 baz_foo_b; varying highp vec4 baz_bar_a; varying highp vec4 baz_bar_b; varying highp vec4 _33_a_a; varying highp vec4 _33_a_b; varying highp vec4 _33_b_a; varying highp vec4 _33_b_b; void main() { gl_FragData[0] = (((_33_a_a + _33_b_b) + baz_foo_b) + baz_foo_a) + baz_bar_b; } spirv-cross-2021.01.15/reference/opt/shaders/legacy/fragment/round.legacy.frag000066400000000000000000000003271400026215700270670ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; varying highp vec4 vA; varying highp float vB; void main() { gl_FragData[0] = floor(vA + vec4(0.5)); gl_FragData[0] *= floor(vB + float(0.5)); } spirv-cross-2021.01.15/reference/opt/shaders/legacy/fragment/struct-varying.legacy.frag000066400000000000000000000005311400026215700307360ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; struct Inputs { highp vec4 a; highp vec2 b; }; varying highp vec4 vin_a; varying highp vec2 vin_b; void main() { gl_FragData[0] = ((((Inputs(vin_a, vin_b).a + Inputs(vin_a, vin_b).b.xxyy) + Inputs(vin_a, vin_b).a) + Inputs(vin_a, vin_b).b.yyxx) + vin_a) + vin_b.xxyy; } spirv-cross-2021.01.15/reference/opt/shaders/legacy/fragment/switch.legacy.frag000066400000000000000000000032161400026215700272410ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; varying highp float vIndexF; void main() { int _13 = int(vIndexF); highp vec4 _65; highp vec4 _66; highp vec4 _68; for (int spvDummy25 = 0; spvDummy25 < 1; spvDummy25++) { if (_13 == 2) { _68 = vec4(0.0, 2.0, 3.0, 4.0); break; } else if ((_13 == 4) || (_13 == 5)) { _68 = vec4(1.0, 2.0, 3.0, 4.0); break; } else if ((_13 == 8) || (_13 == 9)) { _68 = vec4(40.0, 20.0, 30.0, 40.0); break; } else if (_13 == 10) { _65 = vec4(10.0); highp vec4 _45 = _65 + vec4(1.0); _66 = _45; highp vec4 _48 = _66 + vec4(2.0); _68 = _48; break; } else if (_13 == 11) { _65 = vec4(0.0); highp vec4 _45 = _65 + vec4(1.0); _66 = _45; highp vec4 _48 = _66 + vec4(2.0); _68 = _48; break; } else if (_13 == 12) { _66 = vec4(0.0); highp vec4 _48 = _66 + vec4(2.0); _68 = _48; break; } else { _68 = vec4(10.0, 20.0, 30.0, 40.0); break; } } highp vec4 _70; for (int spvDummy146 = 0; spvDummy146 < 1; spvDummy146++) { if ((_13 == 10) || (_13 == 20)) { _70 = vec4(40.0); break; } else { _70 = vec4(20.0); break; } } gl_FragData[0] = _68 + _70; } spirv-cross-2021.01.15/reference/opt/shaders/legacy/vert/000077500000000000000000000000001400026215700230075ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/legacy/vert/implicit-lod.legacy.vert000066400000000000000000000002471400026215700275450ustar00rootroot00000000000000#version 100 uniform mediump sampler2D tex; void main() { gl_Position = texture2DLod(tex, vec2(0.4000000059604644775390625, 0.60000002384185791015625), 0.0); } spirv-cross-2021.01.15/reference/opt/shaders/legacy/vert/io-block.legacy.vert000066400000000000000000000003011400026215700266450ustar00rootroot00000000000000#version 100 attribute vec4 Position; varying vec4 vout_color; varying vec3 vout_normal; void main() { gl_Position = Position; vout_color = vec4(1.0); vout_normal = vec3(0.5); } spirv-cross-2021.01.15/reference/opt/shaders/legacy/vert/struct-flatten-inner-array.legacy.vert000066400000000000000000000003051400026215700323560ustar00rootroot00000000000000#version 100 struct Foo { float a[4]; }; varying float foo_a[4]; void main() { gl_Position = vec4(1.0); for (int _46 = 0; _46 < 4; foo_a[_46] = float(_46 + 2), _46++) { } } struct-flatten-stores-multi-dimension.legacy.vert000066400000000000000000000022511400026215700345040ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/legacy/vert#version 100 struct Foo { vec4 a; vec4 b; }; struct Bar { vec4 a; vec4 b; }; struct Baz { Foo foo; Bar bar; }; varying vec4 _12_a_a; varying vec4 _12_a_b; varying vec4 _12_b_a; varying vec4 _12_b_b; varying vec4 baz_foo_a; varying vec4 baz_foo_b; varying vec4 baz_bar_a; varying vec4 baz_bar_b; void main() { _12_a_a = vec4(10.0); _12_a_b = vec4(20.0); _12_b_a = vec4(30.0); _12_b_b = vec4(40.0); _12_a_a = Foo(vec4(50.0), vec4(60.0)).a; _12_a_b = Foo(vec4(50.0), vec4(60.0)).b; _12_b_a = Bar(vec4(50.0), vec4(60.0)).a; _12_b_b = Bar(vec4(50.0), vec4(60.0)).b; baz_foo_a = Foo(vec4(100.0), vec4(200.0)).a; baz_foo_b = Foo(vec4(100.0), vec4(200.0)).b; baz_bar_a = Bar(vec4(300.0), vec4(400.0)).a; baz_bar_b = Bar(vec4(300.0), vec4(400.0)).b; baz_foo_a = Baz(Foo(vec4(1000.0), vec4(2000.0)), Bar(vec4(3000.0), vec4(4000.0))).foo.a; baz_foo_b = Baz(Foo(vec4(1000.0), vec4(2000.0)), Bar(vec4(3000.0), vec4(4000.0))).foo.b; baz_bar_a = Baz(Foo(vec4(1000.0), vec4(2000.0)), Bar(vec4(3000.0), vec4(4000.0))).bar.a; baz_bar_b = Baz(Foo(vec4(1000.0), vec4(2000.0)), Bar(vec4(3000.0), vec4(4000.0))).bar.b; } spirv-cross-2021.01.15/reference/opt/shaders/legacy/vert/struct-varying.legacy.vert000066400000000000000000000006471400026215700301640ustar00rootroot00000000000000#version 100 struct Output { vec4 a; vec2 b; }; varying vec4 vout_a; varying vec2 vout_b; void main() { vout_a = Output(vec4(0.5), vec2(0.25)).a; vout_b = Output(vec4(0.5), vec2(0.25)).b; vout_a = Output(vec4(0.5), vec2(0.25)).a; vout_b = Output(vec4(0.5), vec2(0.25)).b; Output _22 = Output(vout_a, vout_b); vout_a = _22.a; vout_b = _22.b; vout_a.x = 1.0; vout_b.y = 1.0; } spirv-cross-2021.01.15/reference/opt/shaders/legacy/vert/switch-nested.legacy.vert000066400000000000000000000014151400026215700277360ustar00rootroot00000000000000#version 100 struct UBO { int func_arg; int inner_func_arg; }; uniform UBO _34; void main() { vec4 _102; for (int spvDummy30 = 0; spvDummy30 < 1; spvDummy30++) { if (_34.func_arg != 0) { vec4 _101; for (int spvDummy45 = 0; spvDummy45 < 1; spvDummy45++) { if (_34.inner_func_arg != 0) { _101 = vec4(1.0); break; } else { _101 = vec4(0.0); break; } } _102 = _101; break; } else { _102 = vec4(0.0); break; } } gl_Position = _102; } spirv-cross-2021.01.15/reference/opt/shaders/legacy/vert/transpose.legacy.vert000066400000000000000000000020601400026215700271700ustar00rootroot00000000000000#version 100 struct Buffer { mat4 MVPRowMajor; mat4 MVPColMajor; mat4 M; }; uniform Buffer _13; attribute vec4 Position; mat4 spvWorkaroundRowMajor(mat4 wrap) { return wrap; } mat4 spvTranspose(mat4 m) { return mat4(m[0][0], m[1][0], m[2][0], m[3][0], m[0][1], m[1][1], m[2][1], m[3][1], m[0][2], m[1][2], m[2][2], m[3][2], m[0][3], m[1][3], m[2][3], m[3][3]); } void main() { mat4 _55 = _13.MVPRowMajor; mat4 _61 = spvWorkaroundRowMajor(_13.MVPColMajor); mat4 _80 = spvTranspose(_13.MVPRowMajor) * 2.0; mat4 _87 = spvTranspose(_61) * 2.0; gl_Position = (((((((((((spvWorkaroundRowMajor(_13.M) * (Position * _13.MVPRowMajor)) + (spvWorkaroundRowMajor(_13.M) * (spvWorkaroundRowMajor(_13.MVPColMajor) * Position))) + (spvWorkaroundRowMajor(_13.M) * (_13.MVPRowMajor * Position))) + (spvWorkaroundRowMajor(_13.M) * (Position * spvWorkaroundRowMajor(_13.MVPColMajor)))) + (_55 * Position)) + (Position * _61)) + (Position * _55)) + (_61 * Position)) + (_80 * Position)) + (_87 * Position)) + (Position * _80)) + (Position * _87); } spirv-cross-2021.01.15/reference/opt/shaders/tesc/000077500000000000000000000000001400026215700215215ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/tesc/basic.tesc000066400000000000000000000007411400026215700234640ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(vertices = 1) out; layout(location = 0) patch out vec3 vFoo; void main() { gl_TessLevelInner[0] = 8.8999996185302734375; gl_TessLevelInner[1] = 6.900000095367431640625; gl_TessLevelOuter[0] = 8.8999996185302734375; gl_TessLevelOuter[1] = 6.900000095367431640625; gl_TessLevelOuter[2] = 3.900000095367431640625; gl_TessLevelOuter[3] = 4.900000095367431640625; vFoo = vec3(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/tesc/water_tess.tesc000066400000000000000000000105121400026215700245600ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(vertices = 1) out; layout(binding = 0, std140) uniform UBO { vec4 uScale; vec3 uCamPos; vec2 uPatchSize; vec2 uMaxTessLevel; float uDistanceMod; vec4 uFrustum[6]; } _41; layout(location = 1) patch out vec2 vOutPatchPosBase; layout(location = 2) patch out vec4 vPatchLods; layout(location = 0) in vec2 vPatchPosBase[]; void main() { vec2 _431 = (vPatchPosBase[0] - vec2(10.0)) * _41.uScale.xy; vec2 _441 = ((vPatchPosBase[0] + _41.uPatchSize) + vec2(10.0)) * _41.uScale.xy; vec3 _446 = vec3(_431.x, -10.0, _431.y); vec3 _451 = vec3(_441.x, 10.0, _441.y); vec4 _467 = vec4((_446 + _451) * 0.5, 1.0); vec3 _514 = vec3(length(_451 - _446) * (-0.5)); bool _516 = any(lessThanEqual(vec3(dot(_41.uFrustum[0], _467), dot(_41.uFrustum[1], _467), dot(_41.uFrustum[2], _467)), _514)); bool _526; if (!_516) { _526 = any(lessThanEqual(vec3(dot(_41.uFrustum[3], _467), dot(_41.uFrustum[4], _467), dot(_41.uFrustum[5], _467)), _514)); } else { _526 = _516; } if (!(!_526)) { gl_TessLevelOuter[0] = -1.0; gl_TessLevelOuter[1] = -1.0; gl_TessLevelOuter[2] = -1.0; gl_TessLevelOuter[3] = -1.0; gl_TessLevelInner[0] = -1.0; gl_TessLevelInner[1] = -1.0; } else { vOutPatchPosBase = vPatchPosBase[0]; vec2 _681 = (vPatchPosBase[0] + (vec2(-0.5) * _41.uPatchSize)) * _41.uScale.xy; vec2 _710 = (vPatchPosBase[0] + (vec2(0.5, -0.5) * _41.uPatchSize)) * _41.uScale.xy; float _729 = clamp(log2((length(_41.uCamPos - vec3(_710.x, 0.0, _710.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); vec2 _739 = (vPatchPosBase[0] + (vec2(1.5, -0.5) * _41.uPatchSize)) * _41.uScale.xy; vec2 _768 = (vPatchPosBase[0] + (vec2(-0.5, 0.5) * _41.uPatchSize)) * _41.uScale.xy; float _787 = clamp(log2((length(_41.uCamPos - vec3(_768.x, 0.0, _768.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); vec2 _797 = (vPatchPosBase[0] + (vec2(0.5) * _41.uPatchSize)) * _41.uScale.xy; float _816 = clamp(log2((length(_41.uCamPos - vec3(_797.x, 0.0, _797.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); vec2 _826 = (vPatchPosBase[0] + (vec2(1.5, 0.5) * _41.uPatchSize)) * _41.uScale.xy; float _845 = clamp(log2((length(_41.uCamPos - vec3(_826.x, 0.0, _826.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); vec2 _855 = (vPatchPosBase[0] + (vec2(-0.5, 1.5) * _41.uPatchSize)) * _41.uScale.xy; vec2 _884 = (vPatchPosBase[0] + (vec2(0.5, 1.5) * _41.uPatchSize)) * _41.uScale.xy; float _903 = clamp(log2((length(_41.uCamPos - vec3(_884.x, 0.0, _884.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x); vec2 _913 = (vPatchPosBase[0] + (vec2(1.5) * _41.uPatchSize)) * _41.uScale.xy; float _614 = dot(vec4(_787, _816, clamp(log2((length(_41.uCamPos - vec3(_855.x, 0.0, _855.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _903), vec4(0.25)); float _620 = dot(vec4(clamp(log2((length(_41.uCamPos - vec3(_681.x, 0.0, _681.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _729, _787, _816), vec4(0.25)); float _626 = dot(vec4(_729, clamp(log2((length(_41.uCamPos - vec3(_739.x, 0.0, _739.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _816, _845), vec4(0.25)); float _632 = dot(vec4(_816, _845, _903, clamp(log2((length(_41.uCamPos - vec3(_913.x, 0.0, _913.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x)), vec4(0.25)); vec4 _633 = vec4(_614, _620, _626, _632); vPatchLods = _633; vec4 _940 = exp2(-min(_633, _633.yzwx)) * _41.uMaxTessLevel.y; gl_TessLevelOuter[0] = _940.x; gl_TessLevelOuter[1] = _940.y; gl_TessLevelOuter[2] = _940.z; gl_TessLevelOuter[3] = _940.w; float _948 = _41.uMaxTessLevel.y * exp2(-min(min(min(_614, _620), min(_626, _632)), _816)); gl_TessLevelInner[0] = _948; gl_TessLevelInner[1] = _948; } } spirv-cross-2021.01.15/reference/opt/shaders/tese/000077500000000000000000000000001400026215700215235ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/tese/ccw.tese000066400000000000000000000002431400026215700231600ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, ccw, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/tese/cw.tese000066400000000000000000000002421400026215700230140ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/tese/equal.tese000066400000000000000000000002301400026215700235070ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, equal_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/tese/fractional_even.tese000066400000000000000000000002421400026215700255420ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/tese/fractional_odd.tese000066400000000000000000000002411400026215700253520ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, fractional_odd_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/tese/input-array.tese000066400000000000000000000003561400026215700246640ustar00rootroot00000000000000#version 450 layout(quads, ccw, fractional_odd_spacing) in; layout(location = 0) in vec4 Floats[]; layout(location = 2) in vec4 Floats2[]; void main() { gl_Position = (Floats[0] * gl_TessCoord.x) + (Floats2[1] * gl_TessCoord.y); } spirv-cross-2021.01.15/reference/opt/shaders/tese/line.tese000066400000000000000000000002511400026215700233320ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(isolines, point_mode, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/tese/load-array-of-array.tese000066400000000000000000000002771400026215700261640ustar00rootroot00000000000000#version 450 layout(quads, ccw, equal_spacing) in; layout(location = 0) in vec4 vTexCoord[][1]; void main() { gl_Position = (vTexCoord[0u][0] + vTexCoord[2u][0]) + vTexCoord[3u][0]; } spirv-cross-2021.01.15/reference/opt/shaders/tese/patch-input-array.tese000066400000000000000000000002401400026215700257510ustar00rootroot00000000000000#version 450 layout(quads, ccw, equal_spacing) in; layout(location = 0) patch in float P[4]; void main() { gl_Position = vec4(P[0], P[1], P[2], P[3]); } spirv-cross-2021.01.15/reference/opt/shaders/tese/triangle.tese000066400000000000000000000002421400026215700242100ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/opt/shaders/tese/water_tess.tese000066400000000000000000000024301400026215700245640ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(quads, cw, fractional_even_spacing) in; layout(binding = 1, std140) uniform UBO { mat4 uMVP; vec4 uScale; vec2 uInvScale; vec3 uCamPos; vec2 uPatchSize; vec2 uInvHeightmapSize; } _31; layout(binding = 0) uniform mediump sampler2D uHeightmapDisplacement; layout(location = 0) patch in vec2 vOutPatchPosBase; layout(location = 1) patch in vec4 vPatchLods; layout(location = 1) out vec4 vGradNormalTex; layout(location = 0) out vec3 vWorld; void main() { vec2 _202 = vOutPatchPosBase + (gl_TessCoord.xy * _31.uPatchSize); vec2 _216 = mix(vPatchLods.yx, vPatchLods.zw, vec2(gl_TessCoord.x)); float _223 = mix(_216.x, _216.y, gl_TessCoord.y); mediump float _225 = floor(_223); vec2 _125 = _202 * _31.uInvHeightmapSize; vec2 _141 = _31.uInvHeightmapSize * exp2(_225); vGradNormalTex = vec4(_125 + (_31.uInvHeightmapSize * 0.5), _125 * _31.uScale.zw); mediump vec3 _256 = mix(textureLod(uHeightmapDisplacement, _125 + (_141 * 0.5), _225).xyz, textureLod(uHeightmapDisplacement, _125 + (_141 * 1.0), _225 + 1.0).xyz, vec3(_223 - _225)); vec2 _171 = (_202 * _31.uScale.xy) + _256.yz; vWorld = vec3(_171.x, _256.x, _171.y); gl_Position = _31.uMVP * vec4(vWorld, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/vert/000077500000000000000000000000001400026215700215435ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vert/basic.vert000066400000000000000000000004241400026215700235260ustar00rootroot00000000000000#version 310 es layout(binding = 0, std140) uniform UBO { mat4 uMVP; } _16; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec3 vNormal; layout(location = 1) in vec3 aNormal; void main() { gl_Position = _16.uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/reference/opt/shaders/vert/ground.vert000066400000000000000000000053701400026215700237500ustar00rootroot00000000000000#version 310 es #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif struct PatchData { vec4 Position; vec4 LODs; }; layout(binding = 0, std140) uniform PerPatch { PatchData Patches[256]; } _53; layout(binding = 2, std140) uniform GlobalGround { vec4 GroundScale; vec4 GroundPosition; vec4 InvGroundSize_PatchScale; } _156; layout(binding = 0, std140) uniform GlobalVSData { vec4 g_ViewProj_Row0; vec4 g_ViewProj_Row1; vec4 g_ViewProj_Row2; vec4 g_ViewProj_Row3; vec4 g_CamPos; vec4 g_CamRight; vec4 g_CamUp; vec4 g_CamFront; vec4 g_SunDir; vec4 g_SunColor; vec4 g_TimeParams; vec4 g_ResolutionParams; vec4 g_CamAxisRight; vec4 g_FogColor_Distance; vec4 g_ShadowVP_Row0; vec4 g_ShadowVP_Row1; vec4 g_ShadowVP_Row2; vec4 g_ShadowVP_Row3; } _236; layout(binding = 1) uniform mediump sampler2D TexLOD; layout(binding = 0) uniform mediump sampler2D TexHeightmap; layout(location = 1) in vec4 LODWeights; #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif layout(location = 0) in vec2 Position; layout(location = 1) out vec3 EyeVec; layout(location = 0) out vec2 TexCoord; void main() { float _301 = all(equal(LODWeights, vec4(0.0))) ? _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].Position.w : dot(LODWeights, _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].LODs); float _303 = floor(_301); uint _308 = uint(_303); uvec2 _310 = uvec2(Position); uvec2 _317 = (uvec2(1u) << uvec2(_308, _308 + 1u)) - uvec2(1u); uint _384; if (_310.x < 32u) { _384 = _317.x; } else { _384 = 0u; } uint _385; if (_310.y < 32u) { _385 = _317.y; } else { _385 = 0u; } vec4 _345 = vec4((_310 + uvec2(_384, _385)).xyxy & (~_317).xxyy); vec2 _173 = ((_53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].Position.xz * _156.InvGroundSize_PatchScale.zw) + mix(_345.xy, _345.zw, vec2(_301 - _303))) * _156.InvGroundSize_PatchScale.xy; mediump float _362 = textureLod(TexLOD, _173, 0.0).x * 7.96875; float _364 = floor(_362); vec2 _185 = _156.InvGroundSize_PatchScale.xy * exp2(_364); vec3 _230 = (vec3(_173.x, mix(textureLod(TexHeightmap, _173 + (_185 * 0.5), _364).x, textureLod(TexHeightmap, _173 + (_185 * 1.0), _364 + 1.0).x, _362 - _364), _173.y) * _156.GroundScale.xyz) + _156.GroundPosition.xyz; EyeVec = _230 - _236.g_CamPos.xyz; TexCoord = _173 + (_156.InvGroundSize_PatchScale.xy * 0.5); gl_Position = (((_236.g_ViewProj_Row0 * _230.x) + (_236.g_ViewProj_Row1 * _230.y)) + (_236.g_ViewProj_Row2 * _230.z)) + _236.g_ViewProj_Row3; } spirv-cross-2021.01.15/reference/opt/shaders/vert/invariant.vert000066400000000000000000000006061400026215700244420ustar00rootroot00000000000000#version 310 es invariant gl_Position; layout(location = 0) in vec4 vInput0; layout(location = 1) in vec4 vInput1; layout(location = 2) in vec4 vInput2; layout(location = 0) invariant out vec4 vColor; void main() { vec4 _20 = vInput1 * vInput2; vec4 _21 = vInput0 + _20; gl_Position = _21; vec4 _27 = vInput0 - vInput1; vec4 _29 = _27 * vInput2; vColor = _29; } spirv-cross-2021.01.15/reference/opt/shaders/vert/ocean.vert000066400000000000000000000065541400026215700235440ustar00rootroot00000000000000#version 310 es #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif struct PatchData { vec4 Position; vec4 LODs; }; layout(binding = 0, std140) uniform Offsets { PatchData Patches[256]; } _53; layout(binding = 4, std140) uniform GlobalOcean { vec4 OceanScale; vec4 OceanPosition; vec4 InvOceanSize_PatchScale; vec4 NormalTexCoordScale; } _180; layout(binding = 0, std140) uniform GlobalVSData { vec4 g_ViewProj_Row0; vec4 g_ViewProj_Row1; vec4 g_ViewProj_Row2; vec4 g_ViewProj_Row3; vec4 g_CamPos; vec4 g_CamRight; vec4 g_CamUp; vec4 g_CamFront; vec4 g_SunDir; vec4 g_SunColor; vec4 g_TimeParams; vec4 g_ResolutionParams; vec4 g_CamAxisRight; vec4 g_FogColor_Distance; vec4 g_ShadowVP_Row0; vec4 g_ShadowVP_Row1; vec4 g_ShadowVP_Row2; vec4 g_ShadowVP_Row3; } _273; layout(binding = 1) uniform mediump sampler2D TexLOD; layout(binding = 0) uniform mediump sampler2D TexDisplacement; layout(location = 1) in vec4 LODWeights; #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif layout(location = 0) in vec4 Position; layout(location = 0) out vec3 EyeVec; layout(location = 1) out vec4 TexCoord; uvec4 _476; void main() { float _351 = all(equal(LODWeights, vec4(0.0))) ? _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].Position.w : dot(LODWeights, _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].LODs); float _353 = floor(_351); uint _358 = uint(_353); uvec4 _360 = uvec4(Position); uvec2 _367 = (uvec2(1u) << uvec2(_358, _358 + 1u)) - uvec2(1u); bool _370 = _360.x < 32u; uint _467; if (_370) { _467 = _367.x; } else { _467 = 0u; } uvec4 _445 = _476; _445.x = _467; bool _380 = _360.y < 32u; uint _470; if (_380) { _470 = _367.x; } else { _470 = 0u; } uvec4 _449 = _445; _449.y = _470; uint _472; if (_370) { _472 = _367.y; } else { _472 = 0u; } uvec4 _453 = _449; _453.z = _472; uint _474; if (_380) { _474 = _367.y; } else { _474 = 0u; } uvec4 _457 = _453; _457.w = _474; vec4 _416 = vec4((_360.xyxy + _457) & (~_367).xxyy); vec2 _197 = ((_53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].Position.xz * _180.InvOceanSize_PatchScale.zw) + mix(_416.xy, _416.zw, vec2(_351 - _353))) * _180.InvOceanSize_PatchScale.xy; vec2 _204 = _197 * _180.NormalTexCoordScale.zw; mediump float _433 = textureLod(TexLOD, _197, 0.0).x * 7.96875; float _435 = floor(_433); vec2 _220 = (_180.InvOceanSize_PatchScale.xy * exp2(_435)) * _180.NormalTexCoordScale.zw; vec3 _267 = ((vec3(_197.x, 0.0, _197.y) + mix(textureLod(TexDisplacement, _204 + (_220 * 0.5), _435).yxz, textureLod(TexDisplacement, _204 + (_220 * 1.0), _435 + 1.0).yxz, vec3(_433 - _435))) * _180.OceanScale.xyz) + _180.OceanPosition.xyz; EyeVec = _267 - _273.g_CamPos.xyz; TexCoord = vec4(_204, _204 * _180.NormalTexCoordScale.xy) + ((_180.InvOceanSize_PatchScale.xyxy * 0.5) * _180.NormalTexCoordScale.zwzw); gl_Position = (((_273.g_ViewProj_Row0 * _267.x) + (_273.g_ViewProj_Row1 * _267.y)) + (_273.g_ViewProj_Row2 * _267.z)) + _273.g_ViewProj_Row3; } spirv-cross-2021.01.15/reference/opt/shaders/vert/read-from-row-major-array.vert000066400000000000000000000016151400026215700273530ustar00rootroot00000000000000#version 310 es layout(binding = 0, std140) uniform Block { layout(row_major) mat2x3 var[3][4]; } _104; layout(location = 0) in vec4 a_position; layout(location = 0) out mediump float v_vtxResult; mat2x3 spvWorkaroundRowMajor(mat2x3 wrap) { return wrap; } void main() { gl_Position = a_position; v_vtxResult = ((float(abs(spvWorkaroundRowMajor(_104.var[0][0])[0].x - 2.0) < 0.0500000007450580596923828125) * float(abs(spvWorkaroundRowMajor(_104.var[0][0])[0].y - 6.0) < 0.0500000007450580596923828125)) * float(abs(spvWorkaroundRowMajor(_104.var[0][0])[0].z - (-6.0)) < 0.0500000007450580596923828125)) * ((float(abs(spvWorkaroundRowMajor(_104.var[0][0])[1].x) < 0.0500000007450580596923828125) * float(abs(spvWorkaroundRowMajor(_104.var[0][0])[1].y - 5.0) < 0.0500000007450580596923828125)) * float(abs(spvWorkaroundRowMajor(_104.var[0][0])[1].z - 5.0) < 0.0500000007450580596923828125)); } spirv-cross-2021.01.15/reference/opt/shaders/vert/return-array.vert000066400000000000000000000001611400026215700250760ustar00rootroot00000000000000#version 310 es layout(location = 1) in vec4 vInput1; void main() { gl_Position = vec4(10.0) + vInput1; } spirv-cross-2021.01.15/reference/opt/shaders/vert/texture_buffer.vert000066400000000000000000000004171400026215700255000ustar00rootroot00000000000000#version 310 es #extension GL_OES_texture_buffer : require layout(binding = 4) uniform highp samplerBuffer uSamp; layout(binding = 5, rgba32f) uniform readonly highp imageBuffer uSampo; void main() { gl_Position = texelFetch(uSamp, 10) + imageLoad(uSampo, 100); } spirv-cross-2021.01.15/reference/opt/shaders/vert/transform-feedback-decorations.vert000066400000000000000000000006711400026215700305160ustar00rootroot00000000000000#version 450 layout(xfb_buffer = 1, xfb_stride = 20) out gl_PerVertex { layout(xfb_offset = 4) vec4 gl_Position; float gl_PointSize; }; layout(location = 0, xfb_buffer = 2, xfb_stride = 32, xfb_offset = 16) out vec4 vFoo; layout(xfb_buffer = 3, xfb_stride = 16) out VertOut { layout(location = 1, xfb_offset = 0) vec4 vBar; } _22; void main() { gl_Position = vec4(1.0); vFoo = vec4(3.0); _22.vBar = vec4(5.0); } spirv-cross-2021.01.15/reference/opt/shaders/vert/ubo.vert000066400000000000000000000004221400026215700232300ustar00rootroot00000000000000#version 310 es layout(binding = 0, std140) uniform UBO { mat4 mvp; } _16; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec3 vNormal; layout(location = 1) in vec3 aNormal; void main() { gl_Position = _16.mvp * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/000077500000000000000000000000001400026215700220635ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/comp/000077500000000000000000000000001400026215700230215ustar00rootroot00000000000000array-of-buffer-reference.nocompat.vk.comp.vk000066400000000000000000000007751400026215700334330ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/comp#version 450 #extension GL_EXT_buffer_reference : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer Block; layout(buffer_reference, std430) buffer Block { float v; }; layout(set = 0, binding = 0, std140) uniform UBO { Block blocks[4]; } ubo; void main() { Block blocks[4]; blocks[0] = ubo.blocks[0]; blocks[1] = ubo.blocks[1]; blocks[2] = ubo.blocks[2]; blocks[3] = ubo.blocks[3]; blocks[gl_WorkGroupID.x].v = 20.0; } buffer-reference-bitcast.nocompat.vk.comp.vk000066400000000000000000000007231400026215700333350ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/comp#version 450 #extension GL_EXT_buffer_reference : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer PtrUint; layout(buffer_reference) buffer PtrInt; layout(buffer_reference, std430) buffer PtrUint { uint value; }; layout(buffer_reference, std430) buffer PtrInt { int value; }; layout(set = 0, binding = 0, std430) buffer Buf { PtrUint ptr; } _11; void main() { PtrInt(_11.ptr).value = 10; } buffer-reference-decorations.nocompat.vk.comp.vk000066400000000000000000000013531400026215700342160ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/comp#version 450 #extension GL_EXT_buffer_reference : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer RO; layout(buffer_reference) buffer RW; layout(buffer_reference) buffer WO; layout(buffer_reference, std430) readonly buffer RO { vec4 v[]; }; layout(buffer_reference, std430) restrict buffer RW { vec4 v[]; }; layout(buffer_reference, std430) coherent writeonly buffer WO { vec4 v[]; }; layout(push_constant, std430) uniform Registers { RO ro; RW rw; WO wo; } registers; void main() { registers.rw.v[gl_GlobalInvocationID.x] = registers.ro.v[gl_GlobalInvocationID.x]; registers.wo.v[gl_GlobalInvocationID.x] = registers.ro.v[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/comp/buffer-reference.nocompat.vk.comp.vk000066400000000000000000000013471400026215700317700ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require #extension GL_EXT_buffer_reference : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer Node; layout(buffer_reference, std430) buffer Node { layout(offset = 0) int value; layout(offset = 16) Node next; layout(offset = 32) Node prev; }; layout(set = 0, binding = 0, std430) restrict buffer LinkedList { Node head1; Node head2; } _50; void main() { Node _114; if (gl_WorkGroupID.x < 4u) { _114 = _50.head1; } else { _114 = _50.head2; } _114.next.value = _50.head1.value + _50.head2.value; _50.head1.value = 20; _50.head1.value = _50.head2.value * 10; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/comp/spec-constant-op-member-array.vk.comp000066400000000000000000000016021400026215700320750ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 100 #endif const int a = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 200 #endif const int b = SPIRV_CROSS_CONSTANT_ID_1; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 300 #endif const int c = SPIRV_CROSS_CONSTANT_ID_2; const int d = (c + 50); #ifndef SPIRV_CROSS_CONSTANT_ID_3 #define SPIRV_CROSS_CONSTANT_ID_3 400 #endif const int e = SPIRV_CROSS_CONSTANT_ID_3; layout(binding = 0, std430) buffer SSBO { A member_a; B member_b; int v[a]; int w[d]; } _22; void main() { _22.w[gl_GlobalInvocationID.x] += (_22.v[gl_GlobalInvocationID.x] + e); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/comp/spec-constant-op-member-array.vk.comp.vk000066400000000000000000000011271400026215700325160ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(constant_id = 0) const int a = 100; layout(constant_id = 1) const int b = 200; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; layout(constant_id = 2) const int c = 300; const int d = (c + 50); layout(constant_id = 3) const int e = 400; layout(set = 1, binding = 0, std430) buffer SSBO { A member_a; B member_b; int v[a]; int w[d]; } _22; void main() { _22.w[gl_GlobalInvocationID.x] += (_22.v[gl_GlobalInvocationID.x] + e); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/comp/spec-constant-work-group-size.vk.comp000066400000000000000000000014661400026215700321720ustar00rootroot00000000000000#version 450 #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 2 #endif const int b = SPIRV_CROSS_CONSTANT_ID_1; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 1 #endif const int a = SPIRV_CROSS_CONSTANT_ID_0; const uint _21 = (uint(a) + 0u); #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 1u #endif const uint _27 = gl_WorkGroupSize.x; const uint _28 = (_21 + _27); const uint _29 = gl_WorkGroupSize.y; const uint _30 = (_28 + _29); const int _32 = (1 - a); layout(local_size_x = SPIRV_CROSS_CONSTANT_ID_10, local_size_y = 20, local_size_z = 1) in; layout(binding = 0, std430) writeonly buffer SSBO { int v[]; } _17; void main() { int spec_const_array_size[b]; spec_const_array_size[a] = a; _17.v[_30] = b + spec_const_array_size[_32]; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/comp/spec-constant-work-group-size.vk.comp.vk000066400000000000000000000010771400026215700326070ustar00rootroot00000000000000#version 450 layout(local_size_x_id = 10, local_size_y = 20, local_size_z = 1) in; layout(constant_id = 1) const int b = 2; layout(constant_id = 0) const int a = 1; const uint _21 = (uint(a) + 0u); const uint _27 = gl_WorkGroupSize.x; const uint _28 = (_21 + _27); const uint _29 = gl_WorkGroupSize.y; const uint _30 = (_28 + _29); const int _32 = (1 - a); layout(set = 1, binding = 0, std430) writeonly buffer SSBO { int v[]; } _17; void main() { int spec_const_array_size[b]; spec_const_array_size[a] = a; _17.v[_30] = b + spec_const_array_size[_32]; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/000077500000000000000000000000001400026215700230025ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/combined-texture-sampler-shadow.vk.frag000066400000000000000000000006211400026215700324630ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump sampler2DShadow SPIRV_Cross_CombineduDepthuSampler; uniform mediump sampler2D SPIRV_Cross_CombineduDepthuSampler1; layout(location = 0) out float FragColor; void main() { FragColor = texture(SPIRV_Cross_CombineduDepthuSampler, vec3(vec3(1.0).xy, 1.0)) + texture(SPIRV_Cross_CombineduDepthuSampler1, vec2(1.0)).x; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/combined-texture-sampler-shadow.vk.frag.vk000066400000000000000000000007121400026215700331030ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(set = 0, binding = 2) uniform mediump texture2D uDepth; layout(set = 0, binding = 0) uniform mediump samplerShadow uSampler; layout(set = 0, binding = 1) uniform mediump sampler uSampler1; layout(location = 0) out float FragColor; void main() { FragColor = texture(sampler2DShadow(uDepth, uSampler), vec3(vec3(1.0).xy, 1.0)) + texture(sampler2D(uDepth, uSampler1), vec2(1.0)).x; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/combined-texture-sampler.vk.frag000066400000000000000000000017651400026215700312120ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump sampler2D SPIRV_Cross_CombineduTexture0uSampler0; uniform mediump sampler2D SPIRV_Cross_CombineduTexture1uSampler1; uniform mediump sampler2D SPIRV_Cross_CombineduTexture1uSampler0; uniform mediump sampler2D SPIRV_Cross_CombineduTexture0uSampler1; layout(location = 0) in vec2 vTex; layout(location = 0) out vec4 FragColor; void main() { FragColor = ((((texture(SPIRV_Cross_CombineduTexture0uSampler0, vTex) + texture(SPIRV_Cross_CombineduTexture1uSampler1, vTex)) + (texture(SPIRV_Cross_CombineduTexture0uSampler0, vTex) + texture(SPIRV_Cross_CombineduTexture1uSampler0, vTex))) + (texture(SPIRV_Cross_CombineduTexture0uSampler1, vTex) + texture(SPIRV_Cross_CombineduTexture1uSampler1, vTex))) + (texture(SPIRV_Cross_CombineduTexture0uSampler0, vTex) + texture(SPIRV_Cross_CombineduTexture0uSampler1, vTex))) + (texture(SPIRV_Cross_CombineduTexture1uSampler0, vTex) + texture(SPIRV_Cross_CombineduTexture1uSampler1, vTex)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/combined-texture-sampler.vk.frag.vk000066400000000000000000000016531400026215700316250ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(set = 0, binding = 2) uniform mediump texture2D uTexture0; layout(set = 0, binding = 3) uniform mediump texture2D uTexture1; layout(set = 0, binding = 0) uniform mediump sampler uSampler0; layout(set = 0, binding = 1) uniform mediump sampler uSampler1; layout(location = 0) in vec2 vTex; layout(location = 0) out vec4 FragColor; void main() { FragColor = ((((texture(sampler2D(uTexture0, uSampler0), vTex) + texture(sampler2D(uTexture1, uSampler1), vTex)) + (texture(sampler2D(uTexture0, uSampler0), vTex) + texture(sampler2D(uTexture1, uSampler0), vTex))) + (texture(sampler2D(uTexture0, uSampler1), vTex) + texture(sampler2D(uTexture1, uSampler1), vTex))) + (texture(sampler2D(uTexture0, uSampler0), vTex) + texture(sampler2D(uTexture0, uSampler1), vTex))) + (texture(sampler2D(uTexture1, uSampler0), vTex) + texture(sampler2D(uTexture1, uSampler1), vTex)); } demote-to-helper-forwarding.asm.vk.nocompat.frag.vk000066400000000000000000000003731400026215700345350ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag#version 450 #extension GL_EXT_demote_to_helper_invocation : require layout(location = 0) out vec4 FragColor; void main() { bool _15 = helperInvocationEXT(); demote; if (!_15) { FragColor = vec4(1.0, 0.0, 0.0, 1.0); } } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/demote-to-helper.vk.nocompat.frag.vk000066400000000000000000000002101400026215700316630ustar00rootroot00000000000000#version 450 #extension GL_EXT_demote_to_helper_invocation : require void main() { demote; bool _9 = helperInvocationEXT(); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/desktop-mediump.vk.frag000066400000000000000000000003361400026215700273730ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 F; layout(location = 1) flat in ivec4 I; layout(location = 2) flat in uvec4 U; void main() { FragColor = (F + vec4(I)) + vec4(U); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/desktop-mediump.vk.frag.vk000066400000000000000000000003761400026215700300160ustar00rootroot00000000000000#version 450 layout(location = 0) out mediump vec4 FragColor; layout(location = 0) in mediump vec4 F; layout(location = 1) flat in mediump ivec4 I; layout(location = 2) flat in mediump uvec4 U; void main() { FragColor = (F + vec4(I)) + vec4(U); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/input-attachment-ms.vk.frag000066400000000000000000000005441400026215700301670ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2DMS uSubpass0; layout(binding = 1) uniform sampler2DMS uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = (texelFetch(uSubpass0, ivec2(gl_FragCoord.xy), 1) + texelFetch(uSubpass1, ivec2(gl_FragCoord.xy), 2)) + texelFetch(uSubpass0, ivec2(gl_FragCoord.xy), gl_SampleID); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/input-attachment-ms.vk.frag.vk000066400000000000000000000005571400026215700306120ustar00rootroot00000000000000#version 450 layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInputMS uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform subpassInputMS uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = (subpassLoad(uSubpass0, 1) + subpassLoad(uSubpass1, 2)) + subpassLoad(uSubpass0, gl_SampleID); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/input-attachment.vk.frag000066400000000000000000000005421400026215700275500ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uSubpass0; layout(binding = 1) uniform mediump sampler2D uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = texelFetch(uSubpass0, ivec2(gl_FragCoord.xy), 0) + texelFetch(uSubpass1, ivec2(gl_FragCoord.xy), 0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/input-attachment.vk.frag.vk000066400000000000000000000005761400026215700301760ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = subpassLoad(uSubpass0) + subpassLoad(uSubpass1); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/nonuniform-qualifier.vk.nocompat.frag.vk000066400000000000000000000016661400026215700327020ustar00rootroot00000000000000#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(set = 0, binding = 2, std140) uniform UBO { vec4 v[64]; } ubos[]; layout(set = 0, binding = 3, std430) readonly buffer SSBO { vec4 v[]; } ssbos[]; layout(set = 0, binding = 0) uniform texture2D uSamplers[]; layout(set = 0, binding = 1) uniform sampler uSamps[]; layout(set = 0, binding = 4) uniform sampler2D uCombinedSamplers[]; layout(location = 0) flat in int vIndex; layout(location = 0) out vec4 FragColor; layout(location = 1) in vec2 vUV; void main() { int _23 = vIndex + 10; int _34 = vIndex + 40; FragColor = texture(sampler2D(uSamplers[nonuniformEXT(_23)], uSamps[nonuniformEXT(_34)]), vUV); FragColor = texture(uCombinedSamplers[nonuniformEXT(_23)], vUV); int _66 = vIndex + 20; FragColor += ubos[nonuniformEXT(_66)].v[_34]; int _84 = vIndex + 50; int _88 = vIndex + 60; FragColor += ssbos[nonuniformEXT(_84)].v[_88]; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/push-constant-as-ubo.push-ubo.vk.frag000066400000000000000000000002351400026215700320150ustar00rootroot00000000000000#version 450 layout(std140) uniform UBO { float ubo[4]; } _14; layout(location = 0) out float FragColor; void main() { FragColor = _14.ubo[1]; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/push-constant-as-ubo.push-ubo.vk.frag.vk000066400000000000000000000002541400026215700324350ustar00rootroot00000000000000#version 450 layout(push_constant, std140) uniform UBO { float ubo[4]; } _14; layout(location = 0) out float FragColor; void main() { FragColor = _14.ubo[1]; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/push-constant.vk.frag000066400000000000000000000004571400026215700270760ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct PushConstants { vec4 value0; vec4 value1; }; uniform PushConstants push; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; void main() { FragColor = (vColor + push.value0) + push.value1; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/push-constant.vk.frag.vk000066400000000000000000000004661400026215700275150ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(push_constant, std430) uniform PushConstants { vec4 value0; vec4 value1; } push; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; void main() { FragColor = (vColor + push.value0) + push.value1; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/separate-combined-fake-overload.vk.frag000066400000000000000000000003751400026215700323660ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSamp; uniform sampler2D SPIRV_Cross_CombineduTuS; layout(location = 0) out vec4 FragColor; void main() { FragColor = texture(uSamp, vec2(0.5)) + texture(SPIRV_Cross_CombineduTuS, vec2(0.5)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/separate-combined-fake-overload.vk.frag.vk000066400000000000000000000004671400026215700330070ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform sampler2D uSamp; layout(set = 0, binding = 1) uniform texture2D uT; layout(set = 0, binding = 2) uniform sampler uS; layout(location = 0) out vec4 FragColor; void main() { FragColor = texture(uSamp, vec2(0.5)) + texture(sampler2D(uT, uS), vec2(0.5)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/separate-sampler-texture-array.vk.frag000066400000000000000000000020131400026215700323350ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump sampler2D SPIRV_Cross_CombineduTextureuSampler[4]; uniform mediump sampler2DArray SPIRV_Cross_CombineduTextureArrayuSampler[4]; uniform mediump samplerCube SPIRV_Cross_CombineduTextureCubeuSampler[4]; uniform mediump sampler3D SPIRV_Cross_CombineduTexture3DuSampler[4]; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; layout(location = 0) out vec4 FragColor; void main() { vec2 _95 = (vTex + (vec2(1.0) / vec2(textureSize(SPIRV_Cross_CombineduTextureuSampler[1], 0)))) + (vec2(1.0) / vec2(textureSize(SPIRV_Cross_CombineduTextureuSampler[2], 1))); FragColor = ((((texture(SPIRV_Cross_CombineduTextureuSampler[2], _95) + texture(SPIRV_Cross_CombineduTextureuSampler[1], _95)) + texture(SPIRV_Cross_CombineduTextureuSampler[1], _95)) + texture(SPIRV_Cross_CombineduTextureArrayuSampler[3], vTex3)) + texture(SPIRV_Cross_CombineduTextureCubeuSampler[1], vTex3)) + texture(SPIRV_Cross_CombineduTexture3DuSampler[2], vTex3); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/separate-sampler-texture-array.vk.frag.vk000066400000000000000000000020351400026215700327600ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(set = 0, binding = 1) uniform mediump texture2D uTexture[4]; layout(set = 0, binding = 0) uniform mediump sampler uSampler; layout(set = 0, binding = 4) uniform mediump texture2DArray uTextureArray[4]; layout(set = 0, binding = 3) uniform mediump textureCube uTextureCube[4]; layout(set = 0, binding = 2) uniform mediump texture3D uTexture3D[4]; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; layout(location = 0) out vec4 FragColor; void main() { vec2 _95 = (vTex + (vec2(1.0) / vec2(textureSize(sampler2D(uTexture[1], uSampler), 0)))) + (vec2(1.0) / vec2(textureSize(sampler2D(uTexture[2], uSampler), 1))); FragColor = ((((texture(sampler2D(uTexture[2], uSampler), _95) + texture(sampler2D(uTexture[1], uSampler), _95)) + texture(sampler2D(uTexture[1], uSampler), _95)) + texture(sampler2DArray(uTextureArray[3], uSampler), vTex3)) + texture(samplerCube(uTextureCube[1], uSampler), vTex3)) + texture(sampler3D(uTexture3D[2], uSampler), vTex3); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/separate-sampler-texture.vk.frag000066400000000000000000000016601400026215700312300ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump sampler2D SPIRV_Cross_CombineduTextureuSampler; uniform mediump sampler2DArray SPIRV_Cross_CombineduTextureArrayuSampler; uniform mediump samplerCube SPIRV_Cross_CombineduTextureCubeuSampler; uniform mediump sampler3D SPIRV_Cross_CombineduTexture3DuSampler; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; layout(location = 0) out vec4 FragColor; void main() { vec2 _73 = (vTex + (vec2(1.0) / vec2(textureSize(SPIRV_Cross_CombineduTextureuSampler, 0)))) + (vec2(1.0) / vec2(textureSize(SPIRV_Cross_CombineduTextureuSampler, 1))); FragColor = (((texture(SPIRV_Cross_CombineduTextureuSampler, _73) + texture(SPIRV_Cross_CombineduTextureuSampler, _73)) + texture(SPIRV_Cross_CombineduTextureArrayuSampler, vTex3)) + texture(SPIRV_Cross_CombineduTextureCubeuSampler, vTex3)) + texture(SPIRV_Cross_CombineduTexture3DuSampler, vTex3); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/separate-sampler-texture.vk.frag.vk000066400000000000000000000017111400026215700316440ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(set = 0, binding = 1) uniform mediump texture2D uTexture; layout(set = 0, binding = 0) uniform mediump sampler uSampler; layout(set = 0, binding = 4) uniform mediump texture2DArray uTextureArray; layout(set = 0, binding = 3) uniform mediump textureCube uTextureCube; layout(set = 0, binding = 2) uniform mediump texture3D uTexture3D; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; layout(location = 0) out vec4 FragColor; void main() { vec2 _73 = (vTex + (vec2(1.0) / vec2(textureSize(sampler2D(uTexture, uSampler), 0)))) + (vec2(1.0) / vec2(textureSize(sampler2D(uTexture, uSampler), 1))); FragColor = (((texture(sampler2D(uTexture, uSampler), _73) + texture(sampler2D(uTexture, uSampler), _73)) + texture(sampler2DArray(uTextureArray, uSampler), vTex3)) + texture(samplerCube(uTextureCube, uSampler), vTex3)) + texture(sampler3D(uTexture3D, uSampler), vTex3); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/shader-arithmetic-8bit.nocompat.vk.frag.vk000066400000000000000000000023351400026215700327640ustar00rootroot00000000000000#version 450 #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require #extension GL_EXT_shader_8bit_storage : require layout(set = 0, binding = 1, std430) buffer SSBO { int8_t i8[16]; uint8_t u8[16]; } ssbo; layout(set = 0, binding = 0, std140) uniform UBO { int8_t i8; uint8_t u8; } ubo; layout(push_constant, std430) uniform Push { int8_t i8; uint8_t u8; } registers; layout(location = 0) flat in ivec4 vColor; layout(location = 0) out ivec4 FragColorInt; layout(location = 1) out uvec4 FragColorUint; void main() { i8vec4 _199 = unpack8(20); ssbo.i8[0] = _199.x; ssbo.i8[1] = _199.y; ssbo.i8[2] = _199.z; ssbo.i8[3] = _199.w; u8vec4 _224 = unpack8(20u); ssbo.u8[0] = _224.x; ssbo.u8[1] = _224.y; ssbo.u8[2] = _224.z; ssbo.u8[3] = _224.w; i8vec4 _249 = i8vec4(vColor); FragColorInt = ivec4((((((_249 + i8vec4(registers.i8)) + i8vec4(-40)) + i8vec4(-50)) + i8vec4(int8_t(10), int8_t(20), int8_t(30), int8_t(40))) + i8vec4(ssbo.i8[4])) + i8vec4(ubo.i8)); FragColorUint = uvec4((((((u8vec4(_249) + u8vec4(registers.u8)) + u8vec4(216)) + u8vec4(206)) + u8vec4(uint8_t(10), uint8_t(20), uint8_t(30), uint8_t(40))) + u8vec4(ssbo.u8[4])) + u8vec4(ubo.u8)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/spec-constant-block-size.vk.frag000066400000000000000000000006421400026215700311050ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 2 #endif const int Value = SPIRV_CROSS_CONSTANT_ID_10; layout(binding = 0, std140) uniform SpecConstArray { vec4 samples[Value]; } _15; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int Index; void main() { FragColor = _15.samples[Index]; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/spec-constant-block-size.vk.frag.vk000066400000000000000000000005341400026215700315240ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(constant_id = 10) const int Value = 2; layout(set = 0, binding = 0, std140) uniform SpecConstArray { vec4 samples[Value]; } _15; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int Index; void main() { FragColor = _15.samples[Index]; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/spec-constant-ternary.vk.frag000066400000000000000000000004321400026215700305240ustar00rootroot00000000000000#version 450 #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 10u #endif const uint s = SPIRV_CROSS_CONSTANT_ID_0; const bool _13 = (s > 20u); const uint f = _13 ? 30u : 50u; layout(location = 0) out float FragColor; void main() { FragColor = float(f); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/frag/spec-constant-ternary.vk.frag.vk000066400000000000000000000003151400026215700311430ustar00rootroot00000000000000#version 450 layout(constant_id = 0) const uint s = 10u; const bool _13 = (s > 20u); const uint f = _13 ? 30u : 50u; layout(location = 0) out float FragColor; void main() { FragColor = float(f); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rahit/000077500000000000000000000000001400026215700231725ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rahit/terminators.khr.spv14.nocompat.vk.rahit.vk000066400000000000000000000003271400026215700332100ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require rayPayloadInEXT float payload; void main() { if (payload > 0.0) { ignoreIntersectionEXT; } else { terminateRayEXT; } } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rahit/terminators.nocompat.vk.rahit.vk000066400000000000000000000003271400026215700314510ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require rayPayloadInNV float payload; void main() { if (payload > 0.0) { ignoreIntersectionNV(); } else { terminateRayNV(); } } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/000077500000000000000000000000001400026215700231745ustar00rootroot00000000000000hit_attribute_block.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000004311400026215700346030ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require struct Foo { float a; float b; }; struct Foo2 { float a; float b; }; layout(location = 0) rayPayloadInEXT Foo payload; hitAttributeEXT Foo2 hit; void main() { payload.a = hit.a; payload.b = hit.b; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/hit_attribute_block.nocompat.vk.rchit.vk000066400000000000000000000004261400026215700331270ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Foo { float a; float b; }; struct Foo2 { float a; float b; }; layout(location = 0) rayPayloadInNV Foo payload; hitAttributeNV Foo2 hit; void main() { payload.a = hit.a; payload.b = hit.b; } hit_attribute_block_in_function.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000004311400026215700371760ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require struct Foo { float a; float b; }; struct Foo2 { float a; float b; }; layout(location = 0) rayPayloadInEXT Foo payload; hitAttributeEXT Foo2 hit; void main() { payload.a = hit.a; payload.b = hit.b; } hit_attribute_block_in_function.nocompat.vk.rchit.vk000066400000000000000000000004261400026215700354430ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_NV_ray_tracing : require struct Foo { float a; float b; }; struct Foo2 { float a; float b; }; layout(location = 0) rayPayloadInNV Foo payload; hitAttributeNV Foo2 hit; void main() { payload.a = hit.a; payload.b = hit.b; } hit_attribute_plain.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002501400026215700346130ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec2 payload; hitAttributeEXT vec2 hit; void main() { payload = hit; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/hit_attribute_plain.nocompat.vk.rchit.vk000066400000000000000000000002451400026215700331370ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec2 payload; hitAttributeNV vec2 hit; void main() { payload = hit; } hit_attribute_struct.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000003211400026215700350330ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require struct Foo { float a; float b; }; layout(location = 0) rayPayloadInEXT Foo payload; hitAttributeEXT Foo hit; void main() { payload = hit; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/hit_attribute_struct.nocompat.vk.rchit.vk000066400000000000000000000003161400026215700333570ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Foo { float a; float b; }; layout(location = 0) rayPayloadInNV Foo payload; hitAttributeNV Foo hit; void main() { payload = hit; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/hit_kind.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002301400026215700324270ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = gl_HitKindEXT; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/hit_kind.nocompat.vk.rchit.vk000066400000000000000000000002251400026215700306740ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = gl_HitKindNV; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/hit_t.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002311400026215700317460ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = gl_RayTmaxEXT; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/hit_t.nocompat.vk.rchit.vk000066400000000000000000000002231400026215700302100ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = gl_HitTNV; } incoming_ray_flags.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002411400026215700344130ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = gl_IncomingRayFlagsEXT; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/incoming_ray_flags.nocompat.vk.rchit.vk000066400000000000000000000002361400026215700327370ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = gl_IncomingRayFlagsNV; } instance_custom_id.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002521400026215700344350ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = uint(gl_InstanceCustomIndexEXT); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/instance_custom_id.nocompat.vk.rchit.vk000066400000000000000000000002471400026215700327610ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = uint(gl_InstanceCustomIndexNV); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/instance_id.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002361400026215700331240ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = uint(gl_InstanceID); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/instance_id.nocompat.vk.rchit.vk000066400000000000000000000002341400026215700313630ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = uint(gl_InstanceID); } object_ray_direction.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002431400026215700347440ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_ObjectRayDirectionEXT; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/object_ray_direction.nocompat.vk.rchit.vk000066400000000000000000000002401400026215700332610ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_ObjectRayDirectionNV; } object_ray_origin.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002401400026215700342500ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_ObjectRayOriginEXT; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/object_ray_origin.nocompat.vk.rchit.vk000066400000000000000000000002351400026215700325740ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_ObjectRayOriginNV; } object_to_world.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002631400026215700337440ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_ObjectToWorldEXT * vec4(payload, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/object_to_world.nocompat.vk.rchit.vk000066400000000000000000000002601400026215700322610ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_ObjectToWorldNV * vec4(payload, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/payloads.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002731400026215700324610ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require struct Payload { vec4 a; }; layout(location = 0) rayPayloadInEXT Payload payload; void main() { payload.a = vec4(10.0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/payloads.nocompat.vk.rchit.vk000066400000000000000000000002711400026215700307200ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Payload { vec4 a; }; layout(location = 0) rayPayloadInNV Payload payload; void main() { payload.a = vec4(10.0); } primitive_id.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002371400026215700332520ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = uint(gl_PrimitiveID); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/primitive_id.nocompat.vk.rchit.vk000066400000000000000000000002351400026215700315700ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = uint(gl_PrimitiveID); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/ray_tmax.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002311400026215700324630ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = gl_RayTmaxEXT; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/ray_tmax.nocompat.vk.rchit.vk000066400000000000000000000002261400026215700307300ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = gl_RayTmaxNV; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/ray_tmin.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002311400026215700324610ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = gl_RayTminEXT; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/ray_tmin.nocompat.vk.rchit.vk000066400000000000000000000002261400026215700307260ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = gl_RayTminNV; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/ray_tracing.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002461400026215700331470ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = 1.0 + float(gl_InstanceID); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/ray_tracing.nocompat.vk.rchit.vk000066400000000000000000000002441400026215700314060ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = 1.0 + float(gl_InstanceID); } world_ray_direction.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002421400026215700346240ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_WorldRayDirectionEXT; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/world_ray_direction.nocompat.vk.rchit.vk000066400000000000000000000002371400026215700331500ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_WorldRayDirectionNV; } world_ray_origin.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002371400026215700341370ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_WorldRayOriginEXT; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/world_ray_origin.nocompat.vk.rchit.vk000066400000000000000000000002341400026215700324540ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_WorldRayOriginNV; } world_to_object.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002631400026215700337440ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_WorldToObjectEXT * vec4(payload, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rchit/world_to_object.nocompat.vk.rchit.vk000066400000000000000000000002601400026215700322610ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_WorldToObjectNV * vec4(payload, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/000077500000000000000000000000001400026215700230165ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/convert-u-to-as.spv14.vk.nocompat.rgen.vk000066400000000000000000000004741400026215700324740ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(push_constant, std430) uniform Registers { uvec2 ptr; } _19; layout(location = 0) rayPayloadEXT vec4 payload; void main() { traceRayEXT(accelerationStructureEXT(_19.ptr), 1u, 255u, 0u, 0u, 0u, vec3(0.0), 0.0, vec3(0.0, 0.0, -1.0), 100.0, 0); } execute_callable.nocompat.khr.spv14.vk.rgen.vk000066400000000000000000000007661400026215700335220ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT vec4 payload; layout(location = 1) callableDataEXT float blend; layout(set = 0, binding = 1, rgba32f) uniform writeonly image2D image; void main() { traceRayEXT(as, 1u, 255u, 0u, 0u, 0u, vec3(0.0), 0.0, vec3(0.0, 0.0, -1.0), 100.0, 0); executeCallableEXT(0u, 1); imageStore(image, ivec2(gl_LaunchIDEXT.xy), payload + vec4(blend)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/execute_callable.nocompat.vk.rgen.vk000066400000000000000000000007541400026215700320370ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0) uniform accelerationStructureNV as; layout(set = 0, binding = 1, rgba32f) uniform writeonly image2D image; layout(location = 0) rayPayloadNV vec4 payload; layout(location = 0) callableDataNV float blend; void main() { traceNV(as, 1u, 255u, 0u, 0u, 0u, vec3(0.0), 0.0, vec3(0.0, 0.0, -1.0), 100.0, 0); executeCallableNV(0u, 0); imageStore(image, ivec2(gl_LaunchIDNV.xy), payload + vec4(blend)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/launch_id.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000003041400026215700322320ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchIDEXT.xy), vec4(1.0)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/launch_id.nocompat.vk.rgen.vk000066400000000000000000000003021400026215700304710ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchIDNV.xy), vec4(1.0)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/launch_size.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000003211400026215700326070ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchSizeEXT.xy) - ivec2(1), vec4(1.0)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/launch_size.nocompat.vk.rgen.vk000066400000000000000000000003171400026215700310550ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchSizeNV.xy) - ivec2(1), vec4(1.0)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/payloads.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000016771400026215700321360ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require struct Payload { float a; float b; }; struct Block { float a; float b; Payload c; Payload d; }; layout(set = 0, binding = 1) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT Payload payload2; layout(location = 1) rayPayloadEXT float payload1; layout(location = 2) rayPayloadEXT Block _71; layout(set = 0, binding = 0, rgba8) uniform writeonly image2D image; void main() { traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, vec3(1.0, 0.0, 0.0), 0.0, vec3(0.0, 1.0, 0.0), 1000.0, 1); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, vec3(1.0, 0.0, 0.0), 0.0, vec3(0.0, 1.0, 0.0), 1000.0, 0); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, vec3(1.0, 0.0, 0.0), 0.0, vec3(0.0, 1.0, 0.0), 1000.0, 2); imageStore(image, ivec2(gl_LaunchIDEXT.xy), (vec4(payload1) + (vec4(payload2.a) + vec4(payload2.b))) + vec4(((((_71.a + _71.b) + _71.c.a) + _71.c.b) + _71.d.a) + _71.d.b)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/payloads.nocompat.vk.rgen.vk000066400000000000000000000016551400026215700303730ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Payload { float a; float b; }; struct Block { float a; float b; Payload c; Payload d; }; layout(set = 0, binding = 1) uniform accelerationStructureNV as; layout(location = 1) rayPayloadNV Payload payload2; layout(location = 0) rayPayloadNV float payload1; layout(location = 2) rayPayloadNV Block _71; layout(set = 0, binding = 0, rgba8) uniform writeonly image2D image; void main() { traceNV(as, 0u, 255u, 0u, 1u, 0u, vec3(1.0, 0.0, 0.0), 0.0, vec3(0.0, 1.0, 0.0), 1000.0, 0); traceNV(as, 0u, 255u, 0u, 1u, 0u, vec3(1.0, 0.0, 0.0), 0.0, vec3(0.0, 1.0, 0.0), 1000.0, 1); traceNV(as, 0u, 255u, 0u, 1u, 0u, vec3(1.0, 0.0, 0.0), 0.0, vec3(0.0, 1.0, 0.0), 1000.0, 2); imageStore(image, ivec2(gl_LaunchIDNV.xy), (vec4(payload1) + (vec4(payload2.a) + vec4(payload2.b))) + vec4(((((_71.a + _71.b) + _71.c.a) + _71.c.b) + _71.d.a) + _71.d.b)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/pure_call.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000006101400026215700322520ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT float payload; void main() { vec2 _57 = vec2(gl_LaunchIDEXT.xy); vec2 _61 = vec2(gl_LaunchSizeEXT.xy); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, vec3(_57.x / _61.x, _57.y / _61.y, 1.0), 0.0, vec3(0.0, 0.0, -1.0), 1000.0, 0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/pure_call.nocompat.vk.rgen.vk000066400000000000000000000005161400026215700305200ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureNV as; void main() { vec2 _55 = vec2(gl_LaunchIDNV.xy); vec2 _59 = vec2(gl_LaunchSizeNV.xy); traceNV(as, 0u, 255u, 0u, 1u, 0u, vec3(_55.x / _59.x, _55.y / _59.y, 1.0), 0.0, vec3(0.0, 0.0, -1.0), 1000.0, 0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/ray_tracing.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000010731400026215700326120ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT float payload; layout(set = 0, binding = 0, rgba8) uniform writeonly image2D image; void main() { traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, vec3(float(gl_LaunchIDEXT.x) / float(gl_LaunchSizeEXT.x), float(gl_LaunchIDEXT.y) / float(gl_LaunchSizeEXT.y), 1.0), 0.0, vec3(0.0, 0.0, -1.0), 1000.0, 0); vec4 _68 = vec4(0.0, 0.0, 0.0, 1.0); _68.y = payload; imageStore(image, ivec2(gl_LaunchIDEXT.xy), _68); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/ray_tracing.nocompat.vk.rgen.vk000066400000000000000000000010571400026215700310550ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureNV as; layout(location = 0) rayPayloadNV float payload; layout(set = 0, binding = 0, rgba8) uniform writeonly image2D image; void main() { traceNV(as, 0u, 255u, 0u, 1u, 0u, vec3(float(gl_LaunchIDNV.x) / float(gl_LaunchSizeNV.x), float(gl_LaunchIDNV.y) / float(gl_LaunchSizeNV.y), 1.0), 0.0, vec3(0.0, 0.0, -1.0), 1000.0, 0); vec4 _68 = vec4(0.0, 0.0, 0.0, 1.0); _68.y = payload; imageStore(image, ivec2(gl_LaunchIDNV.xy), _68); } shader_record_buffer.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000005541400026215700343710ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen#version 460 #extension GL_EXT_ray_tracing : require layout(shaderRecordEXT, std430) buffer sbt { vec3 direction; float tmax; } _20; layout(set = 0, binding = 0) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT float payload; void main() { traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, vec3(0.0), 0.0, _20.direction, _20.tmax, 0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rgen/shader_record_buffer.nocompat.vk.rgen.vk000066400000000000000000000004631400026215700327100ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(shaderRecordNV, std430) buffer sbt { vec3 direction; float tmax; } _20; layout(set = 0, binding = 0) uniform accelerationStructureNV as; void main() { traceNV(as, 0u, 255u, 0u, 1u, 0u, vec3(0.0), 0.0, _20.direction, _20.tmax, 0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rint/000077500000000000000000000000001400026215700230375ustar00rootroot00000000000000report-intersection.khr.spv14.nocompat.vk.rint.vk000066400000000000000000000001671400026215700343150ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rint#version 460 #extension GL_EXT_ray_tracing : require void main() { bool _16 = reportIntersectionEXT(0.5, 10u); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rint/report-intersection.nocompat.vk.rint.vk000066400000000000000000000001651400026215700326330ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require void main() { bool _16 = reportIntersectionNV(0.5, 10u); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rmiss/000077500000000000000000000000001400026215700232205ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rmiss/ray_tracing.khr.spv14.nocompat.vk.rmiss.vk000066400000000000000000000002171400026215700332150ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = 0.0; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/rmiss/ray_tracing.nocompat.vk.rmiss.vk000066400000000000000000000002151400026215700314540ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = 0.0; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/vert/000077500000000000000000000000001400026215700230435ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/opt/shaders/vulkan/vert/device-group.nocompat.vk.vert.vk000066400000000000000000000001671400026215700312170ustar00rootroot00000000000000#version 450 #extension GL_EXT_device_group : require void main() { gl_Position = vec4(float(gl_DeviceIndex)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/vert/multiview.nocompat.vk.vert.vk000066400000000000000000000003611400026215700306470ustar00rootroot00000000000000#version 310 es #extension GL_EXT_multiview : require layout(set = 0, binding = 0, std140) uniform MVPs { mat4 MVP[2]; } _19; layout(location = 0) in vec4 Position; void main() { gl_Position = _19.MVP[gl_ViewIndex] * Position; } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/vert/small-storage.vk.vert000066400000000000000000000027711400026215700271450ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_int16) #extension GL_AMD_gpu_shader_int16 : require #else #error No extension available for Int16. #endif #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_NV_gpu_shader5) #extension GL_NV_gpu_shader5 : require #else #error No extension available for FP16. #endif layout(binding = 0, std140) uniform block { i16vec2 a; u16vec2 b; i8vec2 c; u8vec2 d; f16vec2 e; } _26; layout(binding = 1, std430) readonly buffer storage { i16vec3 f; u16vec3 g; i8vec3 h; u8vec3 i; f16vec3 j; } _53; struct pushconst { i16vec4 k; u16vec4 l; i8vec4 m; u8vec4 n; f16vec4 o; }; uniform pushconst _76; layout(location = 0) out i16vec4 p; layout(location = 0, component = 0) in int16_t foo; layout(location = 1) out u16vec4 q; layout(location = 0, component = 1) in uint16_t bar; layout(location = 2) out f16vec4 r; layout(location = 1) in float16_t baz; void main() { p = i16vec4((((ivec4(int(foo)) + ivec4(ivec2(_26.a), ivec2(_26.c))) - ivec4(ivec3(_53.f) / ivec3(_53.h), 1)) + ivec4(_76.k)) + ivec4(_76.m)); q = u16vec4((((uvec4(uint(bar)) + uvec4(uvec2(_26.b), uvec2(_26.d))) - uvec4(uvec3(_53.g) / uvec3(_53.i), 1u)) + uvec4(_76.l)) + uvec4(_76.n)); r = f16vec4(((vec4(float(baz)) + vec4(vec2(_26.e), 0.0, 1.0)) - vec4(vec3(_53.j), 1.0)) + vec4(_76.o)); gl_Position = vec4(0.0, 0.0, 0.0, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/vert/small-storage.vk.vert.vk000066400000000000000000000031561400026215700275620ustar00rootroot00000000000000#version 450 #extension GL_EXT_shader_explicit_arithmetic_types_int16 : require #extension GL_EXT_shader_16bit_storage : require #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require #extension GL_EXT_shader_8bit_storage : require #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_EXT_shader_explicit_arithmetic_types_float16) #extension GL_EXT_shader_explicit_arithmetic_types_float16 : require #else #error No extension available for FP16. #endif layout(set = 0, binding = 0, std140) uniform block { i16vec2 a; u16vec2 b; i8vec2 c; u8vec2 d; f16vec2 e; } _26; layout(set = 0, binding = 1, std430) readonly buffer storage { i16vec3 f; u16vec3 g; i8vec3 h; u8vec3 i; f16vec3 j; } _53; layout(push_constant, std430) uniform pushconst { i16vec4 k; u16vec4 l; i8vec4 m; u8vec4 n; f16vec4 o; } _76; layout(location = 0) out i16vec4 p; layout(location = 0, component = 0) in int16_t foo; layout(location = 1) out u16vec4 q; layout(location = 0, component = 1) in uint16_t bar; layout(location = 2) out f16vec4 r; layout(location = 1) in float16_t baz; void main() { p = i16vec4((((ivec4(int(foo)) + ivec4(ivec2(_26.a), ivec2(_26.c))) - ivec4(ivec3(_53.f) / ivec3(_53.h), 1)) + ivec4(_76.k)) + ivec4(_76.m)); q = u16vec4((((uvec4(uint(bar)) + uvec4(uvec2(_26.b), uvec2(_26.d))) - uvec4(uvec3(_53.g) / uvec3(_53.i), 1u)) + uvec4(_76.l)) + uvec4(_76.n)); r = f16vec4(((vec4(float(baz)) + vec4(vec2(_26.e), 0.0, 1.0)) - vec4(vec3(_53.j), 1.0)) + vec4(_76.o)); gl_Position = vec4(0.0, 0.0, 0.0, 1.0); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/vert/vulkan-vertex.vk.vert000066400000000000000000000005731400026215700272040ustar00rootroot00000000000000#version 310 es #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif void main() { gl_Position = vec4(1.0, 2.0, 3.0, 4.0) * float(gl_VertexID + (gl_InstanceID + SPIRV_Cross_BaseInstance)); } spirv-cross-2021.01.15/reference/opt/shaders/vulkan/vert/vulkan-vertex.vk.vert.vk000066400000000000000000000001711400026215700276150ustar00rootroot00000000000000#version 310 es void main() { gl_Position = vec4(1.0, 2.0, 3.0, 4.0) * float(gl_VertexIndex + gl_InstanceIndex); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/000077500000000000000000000000001400026215700221335ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/000077500000000000000000000000001400026215700227135ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/comp/000077500000000000000000000000001400026215700236515ustar00rootroot00000000000000access-chain-load-store-composite.asm.comp000066400000000000000000000034341400026215700336250ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/compstruct Baz { float c; }; struct Bar { float d[2][4]; Baz baz[2]; }; struct Foo { column_major float2x2 a; float2 b; Bar c[5]; }; static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _10 : register(u0); void comp_main() { Foo _64; _64.a = asfloat(uint2x2(_10.Load(0), _10.Load(8), _10.Load(4), _10.Load(12))); _64.b = asfloat(_10.Load2(16)); [unroll] for (int _0ident = 0; _0ident < 5; _0ident++) { [unroll] for (int _1ident = 0; _1ident < 2; _1ident++) { [unroll] for (int _2ident = 0; _2ident < 4; _2ident++) { _64.c[_0ident].d[_1ident][_2ident] = asfloat(_10.Load(_2ident * 4 + _1ident * 16 + _0ident * 40 + 24)); } } [unroll] for (int _3ident = 0; _3ident < 2; _3ident++) { _64.c[_0ident].baz[_3ident].c = asfloat(_10.Load(_3ident * 4 + _0ident * 40 + 56)); } } _10.Store(224, asuint(_64.a[0].x)); _10.Store(228, asuint(_64.a[1].x)); _10.Store(232, asuint(_64.a[0].y)); _10.Store(236, asuint(_64.a[1].y)); _10.Store2(240, asuint(_64.b)); [unroll] for (int _4ident = 0; _4ident < 5; _4ident++) { [unroll] for (int _5ident = 0; _5ident < 2; _5ident++) { [unroll] for (int _6ident = 0; _6ident < 4; _6ident++) { _10.Store(_6ident * 4 + _5ident * 16 + _4ident * 40 + 248, asuint(_64.c[_4ident].d[_5ident][_6ident])); } } [unroll] for (int _7ident = 0; _7ident < 2; _7ident++) { _10.Store(_7ident * 4 + _4ident * 40 + 280, asuint(_64.c[_4ident].baz[_7ident].c)); } } } [numthreads(1, 1, 1)] void main() { comp_main(); } aliased-struct-divergent-member-name.asm.comp000066400000000000000000000004511400026215700343250ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/compstruct T { float c; }; static const T _18 = { 40.0f }; RWByteAddressBuffer _7 : register(u0); RWByteAddressBuffer _10 : register(u1); void comp_main() { T v = _18; _7.Store(40, asuint(v.c)); _10.Store(480, asuint(v.c)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/comp/atomic-load-store.asm.comp000066400000000000000000000004461400026215700306370ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _5 : register(u0); void comp_main() { uint _20; _5.InterlockedAdd(4, 0, _20); uint c = _20; uint _23; _5.InterlockedExchange(0, c, _23); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/comp/atomic-result-temporary.asm.comp000066400000000000000000000007251400026215700321240ustar00rootroot00000000000000RWByteAddressBuffer _5 : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { uint _24; _5.InterlockedAdd(0, 1u, _24); if (_24 < 1024u) { _5.Store(_24 * 4 + 4, gl_GlobalInvocationID.x); } } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/comp/bitfield-signed-operations.asm.comp000066400000000000000000000064101400026215700325230ustar00rootroot00000000000000RWByteAddressBuffer _3 : register(u0); uint spvBitfieldInsert(uint Base, uint Insert, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : (((1u << Count) - 1) << (Offset & 31)); return (Base & ~Mask) | ((Insert << Offset) & Mask); } uint2 spvBitfieldInsert(uint2 Base, uint2 Insert, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : (((1u << Count) - 1) << (Offset & 31)); return (Base & ~Mask) | ((Insert << Offset) & Mask); } uint3 spvBitfieldInsert(uint3 Base, uint3 Insert, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : (((1u << Count) - 1) << (Offset & 31)); return (Base & ~Mask) | ((Insert << Offset) & Mask); } uint4 spvBitfieldInsert(uint4 Base, uint4 Insert, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : (((1u << Count) - 1) << (Offset & 31)); return (Base & ~Mask) | ((Insert << Offset) & Mask); } uint spvBitfieldUExtract(uint Base, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : ((1 << Count) - 1); return (Base >> Offset) & Mask; } uint2 spvBitfieldUExtract(uint2 Base, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : ((1 << Count) - 1); return (Base >> Offset) & Mask; } uint3 spvBitfieldUExtract(uint3 Base, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : ((1 << Count) - 1); return (Base >> Offset) & Mask; } uint4 spvBitfieldUExtract(uint4 Base, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : ((1 << Count) - 1); return (Base >> Offset) & Mask; } int spvBitfieldSExtract(int Base, int Offset, int Count) { int Mask = Count == 32 ? -1 : ((1 << Count) - 1); int Masked = (Base >> Offset) & Mask; int ExtendShift = (32 - Count) & 31; return (Masked << ExtendShift) >> ExtendShift; } int2 spvBitfieldSExtract(int2 Base, int Offset, int Count) { int Mask = Count == 32 ? -1 : ((1 << Count) - 1); int2 Masked = (Base >> Offset) & Mask; int ExtendShift = (32 - Count) & 31; return (Masked << ExtendShift) >> ExtendShift; } int3 spvBitfieldSExtract(int3 Base, int Offset, int Count) { int Mask = Count == 32 ? -1 : ((1 << Count) - 1); int3 Masked = (Base >> Offset) & Mask; int ExtendShift = (32 - Count) & 31; return (Masked << ExtendShift) >> ExtendShift; } int4 spvBitfieldSExtract(int4 Base, int Offset, int Count) { int Mask = Count == 32 ? -1 : ((1 << Count) - 1); int4 Masked = (Base >> Offset) & Mask; int ExtendShift = (32 - Count) & 31; return (Masked << ExtendShift) >> ExtendShift; } void comp_main() { int4 _19 = int4(_3.Load4(0)); uint4 _20 = _3.Load4(16); _3.Store4(0, uint4(countbits(_19))); _3.Store4(16, uint4(countbits(_19))); _3.Store4(0, uint4(int4(countbits(_20)))); _3.Store4(16, countbits(_20)); _3.Store4(0, uint4(reversebits(_19))); _3.Store4(16, reversebits(_20)); _3.Store4(0, uint4(spvBitfieldSExtract(_19, 1, 11u))); _3.Store4(16, spvBitfieldSExtract(_20, 11u, 1)); _3.Store4(0, uint4(spvBitfieldUExtract(_19, 1, 11u))); _3.Store4(16, spvBitfieldUExtract(_20, 11u, 1)); _3.Store4(0, uint4(int4(spvBitfieldInsert(_19, _19.wzyx, 1, 11u)))); _3.Store4(16, spvBitfieldInsert(_20, _20.wzyx, 11u, 1)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/comp/bitscan.asm.comp000066400000000000000000000013361400026215700267360ustar00rootroot00000000000000RWByteAddressBuffer _4 : register(u0); void comp_main() { uint4 _19 = _4.Load4(0); int4 _20 = int4(_4.Load4(16)); _4.Store4(0, firstbitlow(_19)); _4.Store4(16, uint4(int4(firstbitlow(_19)))); _4.Store4(0, uint4(firstbitlow(_20))); _4.Store4(16, uint4(firstbitlow(_20))); _4.Store4(0, firstbithigh(_19)); _4.Store4(16, uint4(int4(firstbithigh(_19)))); _4.Store4(0, firstbithigh(uint4(_20))); _4.Store4(16, uint4(int4(firstbithigh(uint4(_20))))); _4.Store4(0, uint4(firstbithigh(int4(_19)))); _4.Store4(16, uint4(firstbithigh(int4(_19)))); _4.Store4(0, uint4(firstbithigh(_20))); _4.Store4(16, uint4(firstbithigh(_20))); } [numthreads(1, 1, 1)] void main() { comp_main(); } buffer-atomic-nonuniform.asm.sm51.nonuniformresource.comp000066400000000000000000000007221400026215700366720ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/compRWByteAddressBuffer ssbos[] : register(u0, space0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { uint _24 = gl_GlobalInvocationID.z; uint _25; ssbos[NonUniformResourceIndex(_24)].InterlockedAdd(0, 1u, _25); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/comp/constant-composite-undef.asm.comp000066400000000000000000000004221400026215700322360ustar00rootroot00000000000000RWByteAddressBuffer block : register(u0); static float _15; void comp_main() { block.Store4(0, asuint(float4(0.100000001490116119384765625f, 0.20000000298023223876953125f, 0.300000011920928955078125f, 0.0f))); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/comp/glsl-signed-operations.asm.comp000066400000000000000000000032521400026215700317030ustar00rootroot00000000000000RWByteAddressBuffer _4 : register(u0); void comp_main() { int4 _19 = int4(_4.Load4(0)); uint4 _20 = _4.Load4(16); _4.Store4(0, uint4(abs(_19))); _4.Store4(16, uint4(abs(_19))); _4.Store4(0, uint4(abs(int4(_20)))); _4.Store4(16, uint4(abs(int4(_20)))); _4.Store4(0, uint4(sign(_19))); _4.Store4(16, uint4(sign(_19))); _4.Store4(0, uint4(sign(int4(_20)))); _4.Store4(16, uint4(sign(int4(_20)))); _4.Store4(0, uint4(firstbithigh(int4(_20)))); _4.Store4(16, uint4(firstbithigh(int4(_20)))); _4.Store4(0, uint4(int4(firstbithigh(uint4(_19))))); _4.Store4(16, firstbithigh(uint4(_19))); _4.Store4(0, uint4(min(_19, _19))); _4.Store4(16, uint4(min(_19, int4(_20)))); _4.Store4(0, uint4(min(int4(_20), int4(_20)))); _4.Store4(16, uint4(min(int4(_20), _19))); _4.Store4(0, uint4(int4(min(uint4(_19), _20)))); _4.Store4(16, min(uint4(_19), _20)); _4.Store4(0, uint4(int4(min(_20, uint4(_19))))); _4.Store4(16, min(_20, uint4(_19))); _4.Store4(0, uint4(max(_19, _19))); _4.Store4(16, uint4(max(_19, _19))); _4.Store4(0, uint4(max(int4(_20), _19))); _4.Store4(16, uint4(max(int4(_20), _19))); _4.Store4(0, uint4(int4(max(uint4(_19), _20)))); _4.Store4(16, max(uint4(_19), uint4(_19))); _4.Store4(0, uint4(int4(max(_20, uint4(_19))))); _4.Store4(16, max(_20, uint4(_19))); _4.Store4(0, uint4(clamp(int4(_20), int4(_20), int4(_20)))); _4.Store4(16, uint4(clamp(int4(_20), int4(_20), int4(_20)))); _4.Store4(0, uint4(int4(clamp(uint4(_19), uint4(_19), uint4(_19))))); _4.Store4(16, clamp(uint4(_19), uint4(_19), uint4(_19))); } [numthreads(1, 1, 1)] void main() { comp_main(); } glsl.std450.frexp-modf-struct.fxconly.asm.comp000066400000000000000000000006701400026215700342700ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/compstruct _8 { float _m0; float _m1; }; struct _15 { float _m0; int _m1; }; RWByteAddressBuffer _4 : register(u0); void comp_main() { _8 _23; _23._m0 = modf(20.0f, _23._m1); _15 _24; _24._m0 = frexp(40.0f, _24._m1); _4.Store(0, asuint(_23._m0)); _4.Store(0, asuint(_23._m1)); _4.Store(0, asuint(_24._m0)); _4.Store(4, uint(_24._m1)); } [numthreads(1, 1, 1)] void main() { comp_main(); } image-atomic-nonuniform.asm.sm51.nonuniformresource.comp000066400000000000000000000007601400026215700365050ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/compRWTexture2D uImage[] : register(u0, space0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { uint _26 = gl_GlobalInvocationID.z; uint _31; InterlockedAdd(uImage[NonUniformResourceIndex(_26)][int2(gl_GlobalInvocationID.xy)], 1u, _31); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } specialization-constant-workgroup.nofxc.asm.comp000066400000000000000000000010361400026215700352470ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/comp#ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 9u #endif static const uint _5 = SPIRV_CROSS_CONSTANT_ID_10; #ifndef SPIRV_CROSS_CONSTANT_ID_12 #define SPIRV_CROSS_CONSTANT_ID_12 4u #endif static const uint _6 = SPIRV_CROSS_CONSTANT_ID_12; static const uint3 gl_WorkGroupSize = uint3(_5, 20u, _6); RWByteAddressBuffer _4 : register(u0); void comp_main() { _4.Store(0, asuint(asfloat(_4.Load(0)) + 1.0f)); } [numthreads(SPIRV_CROSS_CONSTANT_ID_10, 20, SPIRV_CROSS_CONSTANT_ID_12)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/comp/storage-buffer-basic.nofxc.asm.comp000066400000000000000000000015461400026215700324240ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 1u #endif static const uint _3 = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 3u #endif static const uint _4 = SPIRV_CROSS_CONSTANT_ID_2; static const uint3 gl_WorkGroupSize = uint3(_3, 2u, _4); RWByteAddressBuffer _8 : register(u0); RWByteAddressBuffer _9 : register(u1); static uint3 gl_WorkGroupID; struct SPIRV_Cross_Input { uint3 gl_WorkGroupID : SV_GroupID; }; static uint3 _22 = gl_WorkGroupSize; void comp_main() { _8.Store(gl_WorkGroupID.x * 4 + 0, asuint(asfloat(_9.Load(gl_WorkGroupID.x * 4 + 0)) + asfloat(_8.Load(gl_WorkGroupID.x * 4 + 0)))); } [numthreads(SPIRV_CROSS_CONSTANT_ID_0, 2, SPIRV_CROSS_CONSTANT_ID_2)] void main(SPIRV_Cross_Input stage_input) { gl_WorkGroupID = stage_input.gl_WorkGroupID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/frag/000077500000000000000000000000001400026215700236325ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/frag/empty-struct-in-struct.asm.frag000066400000000000000000000011061400026215700316560ustar00rootroot00000000000000struct EmptyStructTest { int empty_struct_member; }; struct EmptyStruct2Test { EmptyStructTest _m0; }; static const EmptyStructTest _30 = { 0 }; static const EmptyStruct2Test _20 = { { 0 } }; float GetValue(EmptyStruct2Test self) { return 0.0f; } float GetValue_1(EmptyStruct2Test self) { return 0.0f; } void frag_main() { EmptyStructTest _25 = { 0 }; EmptyStruct2Test _26 = { _25 }; EmptyStruct2Test emptyStruct; float value = GetValue(emptyStruct); value = GetValue_1(_26); value = GetValue_1(_20); } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/frag/image-fetch-uint-coord.asm.frag000066400000000000000000000011551400026215700315060ustar00rootroot00000000000000Texture2D Tex : register(t0); static uint3 in_var_TEXCOORD0; static float4 out_var_SV_Target0; struct SPIRV_Cross_Input { nointerpolation uint3 in_var_TEXCOORD0 : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 out_var_SV_Target0 : SV_Target0; }; void frag_main() { out_var_SV_Target0 = Tex.Load(int3(in_var_TEXCOORD0.xy, in_var_TEXCOORD0.z)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { in_var_TEXCOORD0 = stage_input.in_var_TEXCOORD0; frag_main(); SPIRV_Cross_Output stage_output; stage_output.out_var_SV_Target0 = out_var_SV_Target0; return stage_output; } nonuniform-bracket-handling-2.nonuniformresource.sm51.asm.frag000066400000000000000000000020571400026215700374500ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/fragByteAddressBuffer _8 : register(t0, space2); Texture2D uSamplers[] : register(t0, space0); SamplerState _uSamplers_sampler[] : register(s0, space0); Texture2D uSampler : register(t1, space1); SamplerState _uSampler_sampler : register(s1, space1); static float4 gl_FragCoord; static float4 FragColor; static float2 vUV; struct SPIRV_Cross_Input { float2 vUV : TEXCOORD0; float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = uSamplers[NonUniformResourceIndex(_8.Load(40))].SampleLevel(_uSamplers_sampler[NonUniformResourceIndex(_8.Load(40))], vUV, 0.0f); FragColor += uSampler.SampleLevel(_uSampler_sampler, vUV, float(_8.Load(int(gl_FragCoord.y) * 4 + 0))); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } nonuniform-qualifier-propagation.nonuniformresource.sm51.asm.frag000066400000000000000000000026221400026215700404140ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/fragstruct UBO_1_1 { float4 v[64]; }; ConstantBuffer ubos[] : register(b0, space2); ByteAddressBuffer ssbos[] : register(t0, space3); Texture2D uSamplers[] : register(t0, space0); SamplerState uSamps[] : register(s0, space1); Texture2D uCombinedSamplers[] : register(t4, space0); SamplerState _uCombinedSamplers_sampler[] : register(s4, space0); static int vIndex; static float4 FragColor; static float2 vUV; struct SPIRV_Cross_Input { nointerpolation int vIndex : TEXCOORD0; float2 vUV : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int i = vIndex; int _59 = i + 10; int _64 = i + 40; FragColor = uSamplers[NonUniformResourceIndex(_59)].Sample(uSamps[NonUniformResourceIndex(_64)], vUV); int _71 = i + 10; FragColor = uCombinedSamplers[NonUniformResourceIndex(_71)].Sample(_uCombinedSamplers_sampler[NonUniformResourceIndex(_71)], vUV); int _77 = i + 20; int _80 = i + 40; FragColor += ubos[NonUniformResourceIndex(_77)].v[_80]; int _87 = i + 50; int _90 = i + 60; FragColor += asfloat(ssbos[NonUniformResourceIndex(_87)].Load4(_90 * 16 + 0)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vIndex = stage_input.vIndex; vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/frag/only-initializer-frag-depth.asm.frag000066400000000000000000000004261400026215700325750ustar00rootroot00000000000000static float gl_FragDepth = 0.5f; struct SPIRV_Cross_Output { float gl_FragDepth : SV_Depth; }; void frag_main() { } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_FragDepth = gl_FragDepth; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/frag/phi.zero-initialize.asm.frag000066400000000000000000000013751400026215700311550ustar00rootroot00000000000000struct Foo { int a; }; static float4 vColor; static float4 FragColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; static int uninit_int = 0; static int4 uninit_vector = int4(0, 0, 0, 0); static float4x4 uninit_matrix = float4x4(0.0f.xxxx, 0.0f.xxxx, 0.0f.xxxx, 0.0f.xxxx); static Foo uninit_foo = { 0 }; void frag_main() { int _39 = 0; if (vColor.x > 10.0f) { _39 = 10; } else { _39 = 20; } FragColor = vColor; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } pixel-interlock-callstack.sm51.fxconly.asm.frag000066400000000000000000000011621400026215700345100ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/fragRasterizerOrderedByteAddressBuffer _7 : register(u1, space0); RWByteAddressBuffer _9 : register(u0, space0); static float4 gl_FragCoord; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; void callee2() { int _31 = int(gl_FragCoord.x); _7.Store(_31 * 4 + 0, _7.Load(_31 * 4 + 0) + 1u); } void callee() { int _39 = int(gl_FragCoord.x); _9.Store(_39 * 4 + 0, _9.Load(_39 * 4 + 0) + 1u); callee2(); } void frag_main() { callee(); } void main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); } pixel-interlock-control-flow.sm51.fxconly.asm.frag000066400000000000000000000014261400026215700351770ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/fragRasterizerOrderedByteAddressBuffer _7 : register(u1, space0); RWByteAddressBuffer _13 : register(u2, space0); RasterizerOrderedByteAddressBuffer _9 : register(u0, space0); static float4 gl_FragCoord; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; void callee2() { int _44 = int(gl_FragCoord.x); _7.Store(_44 * 4 + 0, _7.Load(_44 * 4 + 0) + 1u); } void callee() { int _52 = int(gl_FragCoord.x); _9.Store(_52 * 4 + 0, _9.Load(_52 * 4 + 0) + 1u); callee2(); if (true) { } } void _35() { _13.Store(int(gl_FragCoord.x) * 4 + 0, 4u); } void frag_main() { callee(); _35(); } void main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); } pixel-interlock-split-functions.sm51.fxconly.asm.frag000066400000000000000000000012671400026215700357160ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/fragRasterizerOrderedByteAddressBuffer _7 : register(u1, space0); RasterizerOrderedByteAddressBuffer _9 : register(u0, space0); static float4 gl_FragCoord; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; void callee2() { int _37 = int(gl_FragCoord.x); _7.Store(_37 * 4 + 0, _7.Load(_37 * 4 + 0) + 1u); } void callee() { int _45 = int(gl_FragCoord.x); _9.Store(_45 * 4 + 0, _9.Load(_45 * 4 + 0) + 1u); callee2(); } void _29() { } void _31() { } void frag_main() { callee(); _29(); _31(); } void main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/frag/reserved-function-identifier.asm.frag000066400000000000000000000007751400026215700330450ustar00rootroot00000000000000static float FragColor; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; float _mat3(float a) { return a + 1.0f; } float _RESERVED_IDENTIFIER_FIXUP_gl_Foo(int a) { return float(a) + 1.0f; } void frag_main() { float param = 2.0f; int param_1 = 4; FragColor = _mat3(param) + _RESERVED_IDENTIFIER_FIXUP_gl_Foo(param_1); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } struct-packing-last-element-array-matrix-rule.invalid.asm.frag000066400000000000000000000010621400026215700375300ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/fragstruct Foo { row_major float3x3 m[2]; float v; }; struct Bar { row_major float3x3 m; float v; }; cbuffer FooUBO : register(b0) { Foo _6_foo : packoffset(c0); }; cbuffer BarUBO : register(b1) { Bar _9_bar : packoffset(c0); }; static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = (_6_foo.v + _9_bar.v).xxxx; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } subgroup-arithmetic-cast.invalid.nofxc.sm60.asm.frag000066400000000000000000000011431400026215700354440ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/fragstatic int index; static uint FragColor; struct SPIRV_Cross_Input { nointerpolation int index : TEXCOORD0; }; struct SPIRV_Cross_Output { uint FragColor : SV_Target0; }; void frag_main() { uint _17 = uint(index); FragColor = uint(WaveActiveMin(index)); FragColor = uint(WaveActiveMax(int(_17))); FragColor = WaveActiveMin(uint(index)); FragColor = WaveActiveMax(_17); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { index = stage_input.index; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } switch-block-case-fallthrough.asm.invalid.frag000066400000000000000000000024711400026215700344430ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/fragstatic int vIndex; static float4 FragColor; struct SPIRV_Cross_Input { nointerpolation int vIndex : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int i = 0; int j; int _30; int _31; switch (vIndex) { case 0: { _30 = 3; j = _30; _31 = 0; j = _31; break; } default: { _30 = 2; j = _30; _31 = 0; j = _31; break; } case 1: case 11: { _31 = 1; j = _31; break; } case 2: { break; } case 3: { if (vIndex > 3) { i = 0; break; } else { break; } } case 4: { i = 0; break; } case 5: { i = 0; break; } } FragColor = float(i).xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vIndex = stage_input.vIndex; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/frag/unordered-compare.asm.frag000066400000000000000000000042101400026215700306620ustar00rootroot00000000000000static float4 A; static float4 B; static float4 FragColor; struct SPIRV_Cross_Input { float4 A : TEXCOORD0; float4 B : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; float4 test_vector() { bool4 le = bool4(!(A.x >= B.x), !(A.y >= B.y), !(A.z >= B.z), !(A.w >= B.w)); bool4 leq = bool4(!(A.x > B.x), !(A.y > B.y), !(A.z > B.z), !(A.w > B.w)); bool4 ge = bool4(!(A.x <= B.x), !(A.y <= B.y), !(A.z <= B.z), !(A.w <= B.w)); bool4 geq = bool4(!(A.x < B.x), !(A.y < B.y), !(A.z < B.z), !(A.w < B.w)); bool4 eq = bool4(A.x == B.x, A.y == B.y, A.z == B.z, A.w == B.w); bool4 neq = bool4(A.x != B.x, A.y != B.y, A.z != B.z, A.w != B.w); return ((((float4(le.x ? 1.0f.xxxx.x : 0.0f.xxxx.x, le.y ? 1.0f.xxxx.y : 0.0f.xxxx.y, le.z ? 1.0f.xxxx.z : 0.0f.xxxx.z, le.w ? 1.0f.xxxx.w : 0.0f.xxxx.w) + float4(leq.x ? 1.0f.xxxx.x : 0.0f.xxxx.x, leq.y ? 1.0f.xxxx.y : 0.0f.xxxx.y, leq.z ? 1.0f.xxxx.z : 0.0f.xxxx.z, leq.w ? 1.0f.xxxx.w : 0.0f.xxxx.w)) + float4(ge.x ? 1.0f.xxxx.x : 0.0f.xxxx.x, ge.y ? 1.0f.xxxx.y : 0.0f.xxxx.y, ge.z ? 1.0f.xxxx.z : 0.0f.xxxx.z, ge.w ? 1.0f.xxxx.w : 0.0f.xxxx.w)) + float4(geq.x ? 1.0f.xxxx.x : 0.0f.xxxx.x, geq.y ? 1.0f.xxxx.y : 0.0f.xxxx.y, geq.z ? 1.0f.xxxx.z : 0.0f.xxxx.z, geq.w ? 1.0f.xxxx.w : 0.0f.xxxx.w)) + float4(eq.x ? 1.0f.xxxx.x : 0.0f.xxxx.x, eq.y ? 1.0f.xxxx.y : 0.0f.xxxx.y, eq.z ? 1.0f.xxxx.z : 0.0f.xxxx.z, eq.w ? 1.0f.xxxx.w : 0.0f.xxxx.w)) + float4(neq.x ? 1.0f.xxxx.x : 0.0f.xxxx.x, neq.y ? 1.0f.xxxx.y : 0.0f.xxxx.y, neq.z ? 1.0f.xxxx.z : 0.0f.xxxx.z, neq.w ? 1.0f.xxxx.w : 0.0f.xxxx.w); } float test_scalar() { bool le = !(A.x >= B.x); bool leq = !(A.x > B.x); bool ge = !(A.x <= B.x); bool geq = !(A.x < B.x); bool eq = A.x == B.x; bool neq = A.x != B.x; return ((((float(le) + float(leq)) + float(ge)) + float(geq)) + float(eq)) + float(neq); } void frag_main() { FragColor = test_vector() + test_scalar().xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { A = stage_input.A; B = stage_input.B; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/frag/vector-shuffle-undef-index.asm.frag000066400000000000000000000010301400026215700324040ustar00rootroot00000000000000static float4 FragColor; static float4 vFloat; struct SPIRV_Cross_Input { float4 vFloat : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; static float4 undef; void frag_main() { FragColor = float4(undef.x, vFloat.y, 0.0f, vFloat.w) + float4(vFloat.z, vFloat.y, 0.0f, vFloat.w); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vFloat = stage_input.vFloat; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/temporary.zero-initialize.asm.frag000066400000000000000000000014771400026215700315030ustar00rootroot00000000000000static float4 FragColor; static int vA; static int vB; struct SPIRV_Cross_Input { nointerpolation int vA : TEXCOORD0; nointerpolation int vB : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = 0.0f.xxxx; int _10 = 0; int _15 = 0; for (int _16 = 0, _17 = 0; _16 < vA; _17 = _15, _16 += _10) { if ((vA + _16) == 20) { _15 = 50; } else { _15 = ((vB + _16) == 40) ? 60 : _17; } _10 = _15 + 10; FragColor += 1.0f.xxxx; } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vA = stage_input.vA; vB = stage_input.vB; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/vert/000077500000000000000000000000001400026215700236735ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/vert/block-struct-initializer.asm.vert000066400000000000000000000007301400026215700323110ustar00rootroot00000000000000struct Foo { float c; float d; }; static const Foo _13 = { 0.0f, 0.0f }; static Foo foo = _13; struct Vert { float a : TEXCOORD0; float b : TEXCOORD1; }; static Vert _3 = { 0.0f, 0.0f }; struct SPIRV_Cross_Output { Foo foo : TEXCOORD2; }; void vert_main() { } SPIRV_Cross_Output main(out Vert stage_output_3) { vert_main(); stage_output_3 = _3; SPIRV_Cross_Output stage_output; stage_output.foo = foo; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/vert/builtin-output-initializer.asm.vert000066400000000000000000000013101400026215700326740ustar00rootroot00000000000000static const float _23[1] = { 0.0f }; static const float _24[1] = { 0.0f }; static float4 gl_Position = 0.0f.xxxx; static float gl_PointSize = 0.0f; static float gl_ClipDistance[1] = _23; static float gl_CullDistance[1] = _24; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; float gl_ClipDistance0 : SV_ClipDistance0; float gl_CullDistance0 : SV_CullDistance0; }; void vert_main() { gl_Position = 1.0f.xxxx; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.gl_ClipDistance0.x = gl_ClipDistance[0]; stage_output.gl_CullDistance0.x = gl_CullDistance[0]; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/vert/complex-link-by-name.asm.vert000066400000000000000000000022601400026215700313040ustar00rootroot00000000000000struct Struct_vec4 { float4 m0; }; cbuffer UBO : register(b0) { Struct_vec4 ubo_binding_0_m0 : packoffset(c0); Struct_vec4 ubo_binding_0_m1 : packoffset(c1); }; static float4 gl_Position; static Struct_vec4 output_location_2; static Struct_vec4 output_location_3; struct VertexOut { Struct_vec4 m0 : TEXCOORD0; Struct_vec4 m1 : TEXCOORD1; }; static VertexOut output_location_0; struct SPIRV_Cross_Output { Struct_vec4 output_location_2 : TEXCOORD2; Struct_vec4 output_location_3 : TEXCOORD3; float4 gl_Position : SV_Position; }; void vert_main() { Struct_vec4 c; c.m0 = ubo_binding_0_m0.m0; Struct_vec4 b; b.m0 = ubo_binding_0_m1.m0; gl_Position = c.m0 + b.m0; output_location_0.m0 = c; output_location_0.m1 = b; output_location_2 = c; output_location_3 = b; } SPIRV_Cross_Output main(out VertexOut stage_outputoutput_location_0) { vert_main(); stage_outputoutput_location_0 = output_location_0; SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.output_location_2 = output_location_2; stage_output.output_location_3 = output_location_3; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/asm/vert/empty-struct-composite.asm.vert000066400000000000000000000002161400026215700320330ustar00rootroot00000000000000struct Test { int empty_struct_member; }; void vert_main() { Test _14 = { 0 }; Test t = _14; } void main() { vert_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/comp/000077500000000000000000000000001400026215700230715ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/comp/bitfield.comp000066400000000000000000000070021400026215700255320ustar00rootroot00000000000000uint spvBitfieldInsert(uint Base, uint Insert, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : (((1u << Count) - 1) << (Offset & 31)); return (Base & ~Mask) | ((Insert << Offset) & Mask); } uint2 spvBitfieldInsert(uint2 Base, uint2 Insert, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : (((1u << Count) - 1) << (Offset & 31)); return (Base & ~Mask) | ((Insert << Offset) & Mask); } uint3 spvBitfieldInsert(uint3 Base, uint3 Insert, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : (((1u << Count) - 1) << (Offset & 31)); return (Base & ~Mask) | ((Insert << Offset) & Mask); } uint4 spvBitfieldInsert(uint4 Base, uint4 Insert, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : (((1u << Count) - 1) << (Offset & 31)); return (Base & ~Mask) | ((Insert << Offset) & Mask); } uint spvBitfieldUExtract(uint Base, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : ((1 << Count) - 1); return (Base >> Offset) & Mask; } uint2 spvBitfieldUExtract(uint2 Base, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : ((1 << Count) - 1); return (Base >> Offset) & Mask; } uint3 spvBitfieldUExtract(uint3 Base, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : ((1 << Count) - 1); return (Base >> Offset) & Mask; } uint4 spvBitfieldUExtract(uint4 Base, uint Offset, uint Count) { uint Mask = Count == 32 ? 0xffffffff : ((1 << Count) - 1); return (Base >> Offset) & Mask; } int spvBitfieldSExtract(int Base, int Offset, int Count) { int Mask = Count == 32 ? -1 : ((1 << Count) - 1); int Masked = (Base >> Offset) & Mask; int ExtendShift = (32 - Count) & 31; return (Masked << ExtendShift) >> ExtendShift; } int2 spvBitfieldSExtract(int2 Base, int Offset, int Count) { int Mask = Count == 32 ? -1 : ((1 << Count) - 1); int2 Masked = (Base >> Offset) & Mask; int ExtendShift = (32 - Count) & 31; return (Masked << ExtendShift) >> ExtendShift; } int3 spvBitfieldSExtract(int3 Base, int Offset, int Count) { int Mask = Count == 32 ? -1 : ((1 << Count) - 1); int3 Masked = (Base >> Offset) & Mask; int ExtendShift = (32 - Count) & 31; return (Masked << ExtendShift) >> ExtendShift; } int4 spvBitfieldSExtract(int4 Base, int Offset, int Count) { int Mask = Count == 32 ? -1 : ((1 << Count) - 1); int4 Masked = (Base >> Offset) & Mask; int ExtendShift = (32 - Count) & 31; return (Masked << ExtendShift) >> ExtendShift; } void comp_main() { int signed_value = 0; uint unsigned_value = 0u; int3 signed_values = int3(0, 0, 0); uint3 unsigned_values = uint3(0u, 0u, 0u); int s = spvBitfieldSExtract(signed_value, 5, 20); uint u = spvBitfieldUExtract(unsigned_value, 6, 21); s = int(spvBitfieldInsert(s, 40, 5, 4)); u = spvBitfieldInsert(u, 60u, 5, 4); u = reversebits(u); s = reversebits(s); int v0 = int(countbits(u)); int v1 = countbits(s); int v2 = int(firstbithigh(u)); int v3 = firstbitlow(s); int3 s_1 = spvBitfieldSExtract(signed_values, 5, 20); uint3 u_1 = spvBitfieldUExtract(unsigned_values, 6, 21); s_1 = int3(spvBitfieldInsert(s_1, int3(40, 40, 40), 5, 4)); u_1 = spvBitfieldInsert(u_1, uint3(60u, 60u, 60u), 5, 4); u_1 = reversebits(u_1); s_1 = reversebits(s_1); int3 v0_1 = int3(countbits(u_1)); int3 v1_1 = countbits(s_1); int3 v2_1 = int3(firstbithigh(u_1)); int3 v3_1 = firstbitlow(s_1); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/comp/glsl.std450.fxconly.comp000066400000000000000000000315571400026215700274300ustar00rootroot00000000000000struct ResType { float _m0; int _m1; }; static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _19 : register(u0); uint spvPackHalf2x16(float2 value) { uint2 Packed = f32tof16(value); return Packed.x | (Packed.y << 16); } float2 spvUnpackHalf2x16(uint value) { return f16tof32(uint2(value & 0xffff, value >> 16)); } uint spvPackUnorm4x8(float4 value) { uint4 Packed = uint4(round(saturate(value) * 255.0)); return Packed.x | (Packed.y << 8) | (Packed.z << 16) | (Packed.w << 24); } float4 spvUnpackUnorm4x8(uint value) { uint4 Packed = uint4(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, value >> 24); return float4(Packed) / 255.0; } uint spvPackSnorm4x8(float4 value) { int4 Packed = int4(round(clamp(value, -1.0, 1.0) * 127.0)) & 0xff; return uint(Packed.x | (Packed.y << 8) | (Packed.z << 16) | (Packed.w << 24)); } float4 spvUnpackSnorm4x8(uint value) { int SignedValue = int(value); int4 Packed = int4(SignedValue << 24, SignedValue << 16, SignedValue << 8, SignedValue) >> 24; return clamp(float4(Packed) / 127.0, -1.0, 1.0); } uint spvPackUnorm2x16(float2 value) { uint2 Packed = uint2(round(saturate(value) * 65535.0)); return Packed.x | (Packed.y << 16); } float2 spvUnpackUnorm2x16(uint value) { uint2 Packed = uint2(value & 0xffff, value >> 16); return float2(Packed) / 65535.0; } uint spvPackSnorm2x16(float2 value) { int2 Packed = int2(round(clamp(value, -1.0, 1.0) * 32767.0)) & 0xffff; return uint(Packed.x | (Packed.y << 16)); } float2 spvUnpackSnorm2x16(uint value) { int SignedValue = int(value); int2 Packed = int2(SignedValue << 16, SignedValue) >> 16; return clamp(float2(Packed) / 32767.0, -1.0, 1.0); } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. float2x2 spvInverse(float2x2 m) { float2x2 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = m[1][1]; adj[0][1] = -m[0][1]; adj[1][0] = -m[1][0]; adj[1][1] = m[0][0]; // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the determinant of a 2x2 matrix. float spvDet2x2(float a1, float a2, float b1, float b2) { return a1 * b2 - b1 * a2; } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. float3x3 spvInverse(float3x3 m) { float3x3 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]); adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]); adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]); adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]); adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]); adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]); adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]); adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]); adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the determinant of a 3x3 matrix. float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) { return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3); } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. float4x4 spvInverse(float4x4 m) { float4x4 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]); adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]); adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]); adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]); adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]); adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]); adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]); adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] * m[3][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } float spvReflect(float i, float n) { return i - 2.0 * dot(n, i) * n; } float spvRefract(float i, float n, float eta) { float NoI = n * i; float NoI2 = NoI * NoI; float k = 1.0 - eta * eta * (1.0 - NoI2); if (k < 0.0) { return 0.0; } else { return eta * i - (eta * NoI + sqrt(k)) * n; } } float spvFaceForward(float n, float i, float nref) { return i * nref < 0.0 ? n : -n; } void comp_main() { _19.Store(0, asuint(round(asfloat(_19.Load(16))))); _19.Store(0, asuint(trunc(asfloat(_19.Load(16))))); _19.Store(0, asuint(abs(asfloat(_19.Load(16))))); _19.Store(4, uint(abs(int(_19.Load(32))))); _19.Store(0, asuint(sign(asfloat(_19.Load(16))))); _19.Store(4, uint(sign(int(_19.Load(32))))); _19.Store(0, asuint(floor(asfloat(_19.Load(16))))); _19.Store(0, asuint(ceil(asfloat(_19.Load(16))))); _19.Store(0, asuint(frac(asfloat(_19.Load(16))))); _19.Store(0, asuint(radians(asfloat(_19.Load(16))))); _19.Store(0, asuint(degrees(asfloat(_19.Load(16))))); _19.Store(0, asuint(sin(asfloat(_19.Load(16))))); _19.Store(0, asuint(cos(asfloat(_19.Load(16))))); _19.Store(0, asuint(tan(asfloat(_19.Load(16))))); _19.Store(0, asuint(asin(asfloat(_19.Load(16))))); _19.Store(0, asuint(acos(asfloat(_19.Load(16))))); _19.Store(0, asuint(atan(asfloat(_19.Load(16))))); _19.Store(0, asuint(sinh(asfloat(_19.Load(16))))); _19.Store(0, asuint(cosh(asfloat(_19.Load(16))))); _19.Store(0, asuint(tanh(asfloat(_19.Load(16))))); _19.Store(0, asuint(atan2(asfloat(_19.Load(16)), asfloat(_19.Load(20))))); _19.Store(0, asuint(pow(asfloat(_19.Load(16)), asfloat(_19.Load(20))))); _19.Store(0, asuint(exp(asfloat(_19.Load(16))))); _19.Store(0, asuint(log(asfloat(_19.Load(16))))); _19.Store(0, asuint(exp2(asfloat(_19.Load(16))))); _19.Store(0, asuint(log2(asfloat(_19.Load(16))))); _19.Store(0, asuint(sqrt(asfloat(_19.Load(16))))); _19.Store(0, asuint(rsqrt(asfloat(_19.Load(16))))); _19.Store(0, asuint(length(asfloat(_19.Load(16))))); _19.Store(0, asuint(distance(asfloat(_19.Load(16)), asfloat(_19.Load(20))))); _19.Store(0, asuint(sign(asfloat(_19.Load(16))))); _19.Store(0, asuint(spvFaceForward(asfloat(_19.Load(16)), asfloat(_19.Load(20)), asfloat(_19.Load(24))))); _19.Store(0, asuint(spvReflect(asfloat(_19.Load(16)), asfloat(_19.Load(20))))); _19.Store(0, asuint(spvRefract(asfloat(_19.Load(16)), asfloat(_19.Load(20)), asfloat(_19.Load(24))))); _19.Store(0, asuint(length(asfloat(_19.Load4(16)).xy))); _19.Store(0, asuint(distance(asfloat(_19.Load4(16)).xy, asfloat(_19.Load4(16)).zw))); float2 v2 = normalize(asfloat(_19.Load4(16)).xy); v2 = faceforward(asfloat(_19.Load4(16)).xy, asfloat(_19.Load4(16)).yz, asfloat(_19.Load4(16)).zw); v2 = reflect(asfloat(_19.Load4(16)).xy, asfloat(_19.Load4(16)).zw); v2 = refract(asfloat(_19.Load4(16)).xy, asfloat(_19.Load4(16)).yz, asfloat(_19.Load(28))); float3 v3 = cross(asfloat(_19.Load4(16)).xyz, asfloat(_19.Load4(16)).yzw); float2x2 _240 = asfloat(uint2x2(_19.Load2(64), _19.Load2(72))); _19.Store(0, asuint(determinant(_240))); float3x3 _246 = asfloat(uint3x3(_19.Load3(80), _19.Load3(96), _19.Load3(112))); _19.Store(0, asuint(determinant(_246))); float4x4 _252 = asfloat(uint4x4(_19.Load4(128), _19.Load4(144), _19.Load4(160), _19.Load4(176))); _19.Store(0, asuint(determinant(_252))); float2x2 _256 = asfloat(uint2x2(_19.Load2(64), _19.Load2(72))); float2x2 _257 = spvInverse(_256); _19.Store2(64, asuint(_257[0])); _19.Store2(72, asuint(_257[1])); float3x3 _260 = asfloat(uint3x3(_19.Load3(80), _19.Load3(96), _19.Load3(112))); float3x3 _261 = spvInverse(_260); _19.Store3(80, asuint(_261[0])); _19.Store3(96, asuint(_261[1])); _19.Store3(112, asuint(_261[2])); float4x4 _264 = asfloat(uint4x4(_19.Load4(128), _19.Load4(144), _19.Load4(160), _19.Load4(176))); float4x4 _265 = spvInverse(_264); _19.Store4(128, asuint(_265[0])); _19.Store4(144, asuint(_265[1])); _19.Store4(160, asuint(_265[2])); _19.Store4(176, asuint(_265[3])); float tmp; float _271 = modf(asfloat(_19.Load(16)), tmp); _19.Store(0, asuint(_271)); _19.Store(0, asuint(min(asfloat(_19.Load(16)), asfloat(_19.Load(20))))); _19.Store(8, min(_19.Load(48), _19.Load(52))); _19.Store(4, uint(min(int(_19.Load(32)), int(_19.Load(36))))); _19.Store(0, asuint(max(asfloat(_19.Load(16)), asfloat(_19.Load(20))))); _19.Store(8, max(_19.Load(48), _19.Load(52))); _19.Store(4, uint(max(int(_19.Load(32)), int(_19.Load(36))))); _19.Store(0, asuint(clamp(asfloat(_19.Load(16)), asfloat(_19.Load(20)), asfloat(_19.Load(24))))); _19.Store(8, clamp(_19.Load(48), _19.Load(52), _19.Load(56))); _19.Store(4, uint(clamp(int(_19.Load(32)), int(_19.Load(36)), int(_19.Load(40))))); _19.Store(0, asuint(lerp(asfloat(_19.Load(16)), asfloat(_19.Load(20)), asfloat(_19.Load(24))))); _19.Store(0, asuint(step(asfloat(_19.Load(16)), asfloat(_19.Load(20))))); _19.Store(0, asuint(smoothstep(asfloat(_19.Load(16)), asfloat(_19.Load(20)), asfloat(_19.Load(24))))); _19.Store(0, asuint(mad(asfloat(_19.Load(16)), asfloat(_19.Load(20)), asfloat(_19.Load(24))))); ResType _371; _371._m0 = frexp(asfloat(_19.Load(16)), _371._m1); int itmp = _371._m1; _19.Store(0, asuint(_371._m0)); _19.Store(0, asuint(ldexp(asfloat(_19.Load(16)), itmp))); _19.Store(8, spvPackSnorm4x8(asfloat(_19.Load4(16)))); _19.Store(8, spvPackUnorm4x8(asfloat(_19.Load4(16)))); _19.Store(8, spvPackSnorm2x16(asfloat(_19.Load4(16)).xy)); _19.Store(8, spvPackUnorm2x16(asfloat(_19.Load4(16)).xy)); _19.Store(8, spvPackHalf2x16(asfloat(_19.Load4(16)).xy)); v2 = spvUnpackSnorm2x16(_19.Load(48)); v2 = spvUnpackUnorm2x16(_19.Load(48)); v2 = spvUnpackHalf2x16(_19.Load(48)); float4 v4 = spvUnpackSnorm4x8(_19.Load(48)); v4 = spvUnpackUnorm4x8(_19.Load(48)); _19.Store4(32, uint4(firstbitlow(int4(_19.Load4(32))))); _19.Store4(32, uint4(int4(firstbitlow(_19.Load4(48))))); _19.Store4(32, uint4(firstbithigh(int4(_19.Load4(32))))); _19.Store4(32, uint4(int4(firstbithigh(_19.Load4(48))))); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/comp/illegal-struct-name.asm.comp000066400000000000000000000004351400026215700304030ustar00rootroot00000000000000struct Foo { float _abs; }; RWByteAddressBuffer _7 : register(u0); void comp_main() { Foo _24; _24._abs = asfloat(_7.Load(0)); Foo f; f._abs = _24._abs; int _abs = 10; _7.Store(4, asuint(f._abs)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/comp/subgroups.invalid.nofxc.sm60.comp000066400000000000000000000112241400026215700313270ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _9 : register(u0, space0); static uint4 gl_SubgroupEqMask; static uint4 gl_SubgroupGeMask; static uint4 gl_SubgroupGtMask; static uint4 gl_SubgroupLeMask; static uint4 gl_SubgroupLtMask; void comp_main() { _9.Store(0, asuint(float(WaveGetLaneCount()))); _9.Store(0, asuint(float(WaveGetLaneIndex()))); bool elected = WaveIsFirstLane(); _9.Store(0, asuint(float4(gl_SubgroupEqMask).x)); _9.Store(0, asuint(float4(gl_SubgroupGeMask).x)); _9.Store(0, asuint(float4(gl_SubgroupGtMask).x)); _9.Store(0, asuint(float4(gl_SubgroupLeMask).x)); _9.Store(0, asuint(float4(gl_SubgroupLtMask).x)); float4 broadcasted = WaveReadLaneAt(10.0f.xxxx, 8u); float3 first = WaveReadLaneFirst(20.0f.xxx); uint4 ballot_value = WaveActiveBallot(true); uint bit_count = countbits(ballot_value.x) + countbits(ballot_value.y) + countbits(ballot_value.z) + countbits(ballot_value.w); bool has_all = WaveActiveAllTrue(true); bool has_any = WaveActiveAnyTrue(true); bool has_equal = WaveActiveAllEqualBool(true); float4 added = WaveActiveSum(20.0f.xxxx); int4 iadded = WaveActiveSum(int4(20, 20, 20, 20)); float4 multiplied = WaveActiveProduct(20.0f.xxxx); int4 imultiplied = WaveActiveProduct(int4(20, 20, 20, 20)); float4 lo = WaveActiveMin(20.0f.xxxx); float4 hi = WaveActiveMax(20.0f.xxxx); int4 slo = WaveActiveMin(int4(20, 20, 20, 20)); int4 shi = WaveActiveMax(int4(20, 20, 20, 20)); uint4 ulo = WaveActiveMin(uint4(20u, 20u, 20u, 20u)); uint4 uhi = WaveActiveMax(uint4(20u, 20u, 20u, 20u)); uint4 anded = WaveActiveBitAnd(ballot_value); uint4 ored = WaveActiveBitOr(ballot_value); uint4 xored = WaveActiveBitXor(ballot_value); added = WavePrefixSum(added) + added; iadded = WavePrefixSum(iadded) + iadded; multiplied = WavePrefixProduct(multiplied) * multiplied; imultiplied = WavePrefixProduct(imultiplied) * imultiplied; added = WavePrefixSum(multiplied); multiplied = WavePrefixProduct(multiplied); iadded = WavePrefixSum(imultiplied); imultiplied = WavePrefixProduct(imultiplied); float4 swap_horiz = QuadReadAcrossX(20.0f.xxxx); float4 swap_vertical = QuadReadAcrossY(20.0f.xxxx); float4 swap_diagonal = QuadReadAcrossDiagonal(20.0f.xxxx); float4 quad_broadcast = QuadReadLaneAt(20.0f.xxxx, 3u); } [numthreads(1, 1, 1)] void main() { gl_SubgroupEqMask = 1u << (WaveGetLaneIndex() - uint4(0, 32, 64, 96)); if (WaveGetLaneIndex() >= 32) gl_SubgroupEqMask.x = 0; if (WaveGetLaneIndex() >= 64 || WaveGetLaneIndex() < 32) gl_SubgroupEqMask.y = 0; if (WaveGetLaneIndex() >= 96 || WaveGetLaneIndex() < 64) gl_SubgroupEqMask.z = 0; if (WaveGetLaneIndex() < 96) gl_SubgroupEqMask.w = 0; gl_SubgroupGeMask = ~((1u << (WaveGetLaneIndex() - uint4(0, 32, 64, 96))) - 1u); if (WaveGetLaneIndex() >= 32) gl_SubgroupGeMask.x = 0u; if (WaveGetLaneIndex() >= 64) gl_SubgroupGeMask.y = 0u; if (WaveGetLaneIndex() >= 96) gl_SubgroupGeMask.z = 0u; if (WaveGetLaneIndex() < 32) gl_SubgroupGeMask.y = ~0u; if (WaveGetLaneIndex() < 64) gl_SubgroupGeMask.z = ~0u; if (WaveGetLaneIndex() < 96) gl_SubgroupGeMask.w = ~0u; uint gt_lane_index = WaveGetLaneIndex() + 1; gl_SubgroupGtMask = ~((1u << (gt_lane_index - uint4(0, 32, 64, 96))) - 1u); if (gt_lane_index >= 32) gl_SubgroupGtMask.x = 0u; if (gt_lane_index >= 64) gl_SubgroupGtMask.y = 0u; if (gt_lane_index >= 96) gl_SubgroupGtMask.z = 0u; if (gt_lane_index >= 128) gl_SubgroupGtMask.w = 0u; if (gt_lane_index < 32) gl_SubgroupGtMask.y = ~0u; if (gt_lane_index < 64) gl_SubgroupGtMask.z = ~0u; if (gt_lane_index < 96) gl_SubgroupGtMask.w = ~0u; uint le_lane_index = WaveGetLaneIndex() + 1; gl_SubgroupLeMask = (1u << (le_lane_index - uint4(0, 32, 64, 96))) - 1u; if (le_lane_index >= 32) gl_SubgroupLeMask.x = ~0u; if (le_lane_index >= 64) gl_SubgroupLeMask.y = ~0u; if (le_lane_index >= 96) gl_SubgroupLeMask.z = ~0u; if (le_lane_index >= 128) gl_SubgroupLeMask.w = ~0u; if (le_lane_index < 32) gl_SubgroupLeMask.y = 0u; if (le_lane_index < 64) gl_SubgroupLeMask.z = 0u; if (le_lane_index < 96) gl_SubgroupLeMask.w = 0u; gl_SubgroupLtMask = (1u << (WaveGetLaneIndex() - uint4(0, 32, 64, 96))) - 1u; if (WaveGetLaneIndex() >= 32) gl_SubgroupLtMask.x = ~0u; if (WaveGetLaneIndex() >= 64) gl_SubgroupLtMask.y = ~0u; if (WaveGetLaneIndex() >= 96) gl_SubgroupLtMask.z = ~0u; if (WaveGetLaneIndex() < 32) gl_SubgroupLtMask.y = 0u; if (WaveGetLaneIndex() < 64) gl_SubgroupLtMask.z = 0u; if (WaveGetLaneIndex() < 96) gl_SubgroupLtMask.w = 0u; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/frag/000077500000000000000000000000001400026215700230525ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/frag/cbuffer-packing-straddle.frag000066400000000000000000000027321400026215700305450ustar00rootroot00000000000000cbuffer UBO : register(b0) { float4 _18_a[2] : packoffset(c0); float4 _18_b : packoffset(c2); float4 _18_c : packoffset(c3); row_major float4x4 _18_d : packoffset(c4); float _18_e : packoffset(c8); float2 _18_f : packoffset(c8.z); float _18_g : packoffset(c9); float2 _18_h : packoffset(c9.z); float _18_i : packoffset(c10); float2 _18_j : packoffset(c10.z); float _18_k : packoffset(c11); float2 _18_l : packoffset(c11.z); float _18_m : packoffset(c12); float _18_n : packoffset(c12.y); float _18_o : packoffset(c12.z); float4 _18_p : packoffset(c13); float4 _18_q : packoffset(c14); float3 _18_r : packoffset(c15); float4 _18_s : packoffset(c16); float4 _18_t : packoffset(c17); float4 _18_u : packoffset(c18); float _18_v : packoffset(c19); float _18_w : packoffset(c19.y); float _18_x : packoffset(c19.z); float _18_y : packoffset(c19.w); float _18_z : packoffset(c20); float _18_aa : packoffset(c20.y); float _18_ab : packoffset(c20.z); float _18_ac : packoffset(c20.w); float _18_ad : packoffset(c21); float _18_ae : packoffset(c21.y); float4 _18_ef : packoffset(c22); }; static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = _18_a[1]; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/frag/constant-buffer-array.invalid.sm51.frag000066400000000000000000000014141400026215700323400ustar00rootroot00000000000000struct CBO_1 { float4 a; float4 b; float4 c; float4 d; }; ConstantBuffer cbo[2][4] : register(b4, space0); cbuffer PushMe { float4 push_a : packoffset(c0); float4 push_b : packoffset(c1); float4 push_c : packoffset(c2); float4 push_d : packoffset(c3); }; static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = cbo[1][2].a; FragColor += cbo[1][2].b; FragColor += cbo[1][2].c; FragColor += cbo[1][2].d; FragColor += push_a; FragColor += push_b; FragColor += push_c; FragColor += push_d; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/frag/fp16.invalid.desktop.frag000066400000000000000000000103311400026215700275620ustar00rootroot00000000000000static min16float4 v4; static min16float3 v3; static min16float v1; static min16float2 v2; static float o1; static float2 o2; static float3 o3; static float4 o4; struct SPIRV_Cross_Input { min16float v1 : TEXCOORD0; min16float2 v2 : TEXCOORD1; min16float3 v3 : TEXCOORD2; min16float4 v4 : TEXCOORD3; }; struct SPIRV_Cross_Output { float o1 : SV_Target0; float2 o2 : SV_Target1; float3 o3 : SV_Target2; float4 o4 : SV_Target3; }; float mod(float x, float y) { return x - y * floor(x / y); } float2 mod(float2 x, float2 y) { return x - y * floor(x / y); } float3 mod(float3 x, float3 y) { return x - y * floor(x / y); } float4 mod(float4 x, float4 y) { return x - y * floor(x / y); } uint spvPackFloat2x16(min16float2 value) { uint2 Packed = f32tof16(value); return Packed.x | (Packed.y << 16); } min16float2 spvUnpackFloat2x16(uint value) { return min16float2(f16tof32(uint2(value & 0xffff, value >> 16))); } void test_constants() { min16float a = min16float(1.0); min16float b = min16float(1.5); min16float c = min16float(-1.5); min16float d = min16float(0.0 / 0.0); min16float e = min16float(1.0 / 0.0); min16float f = min16float(-1.0 / 0.0); min16float g = min16float(1014.0); min16float h = min16float(9.5367431640625e-07); } min16float test_result() { return min16float(1.0); } void test_conversions() { min16float one = test_result(); int a = int(one); uint b = uint(one); bool c = one != min16float(0.0); float d = float(one); double e = double(one); min16float a2 = min16float(a); min16float b2 = min16float(b); min16float c2 = min16float(c); min16float d2 = min16float(d); min16float e2 = min16float(e); } void test_builtins() { min16float4 res = radians(v4); res = degrees(v4); res = sin(v4); res = cos(v4); res = tan(v4); res = asin(v4); res = atan2(v4, v3.xyzz); res = atan(v4); res = sinh(v4); res = cosh(v4); res = tanh(v4); res = pow(v4, v4); res = exp(v4); res = log(v4); res = exp2(v4); res = log2(v4); res = sqrt(v4); res = rsqrt(v4); res = abs(v4); res = sign(v4); res = floor(v4); res = trunc(v4); res = round(v4); res = ceil(v4); res = frac(v4); res = mod(v4, v4); min16float4 tmp; min16float4 _144 = modf(v4, tmp); res = _144; res = min(v4, v4); res = max(v4, v4); res = clamp(v4, v4, v4); res = lerp(v4, v4, v4); bool4 _164 = bool4(v4.x < v4.x, v4.y < v4.y, v4.z < v4.z, v4.w < v4.w); res = min16float4(_164.x ? v4.x : v4.x, _164.y ? v4.y : v4.y, _164.z ? v4.z : v4.z, _164.w ? v4.w : v4.w); res = step(v4, v4); res = smoothstep(v4, v4, v4); bool4 btmp = isnan(v4); btmp = isinf(v4); res = mad(v4, v4, v4); uint pack0 = spvPackFloat2x16(v4.xy); uint pack1 = spvPackFloat2x16(v4.zw); res = min16float4(spvUnpackFloat2x16(pack0), spvUnpackFloat2x16(pack1)); min16float t0 = length(v4); t0 = distance(v4, v4); t0 = dot(v4, v4); min16float3 res3 = cross(v3, v3); res = normalize(v4); res = faceforward(v4, v4, v4); res = reflect(v4, v4); res = refract(v4, v4, v1); btmp = bool4(v4.x < v4.x, v4.y < v4.y, v4.z < v4.z, v4.w < v4.w); btmp = bool4(v4.x <= v4.x, v4.y <= v4.y, v4.z <= v4.z, v4.w <= v4.w); btmp = bool4(v4.x > v4.x, v4.y > v4.y, v4.z > v4.z, v4.w > v4.w); btmp = bool4(v4.x >= v4.x, v4.y >= v4.y, v4.z >= v4.z, v4.w >= v4.w); btmp = bool4(v4.x == v4.x, v4.y == v4.y, v4.z == v4.z, v4.w == v4.w); btmp = bool4(v4.x != v4.x, v4.y != v4.y, v4.z != v4.z, v4.w != v4.w); res = ddx(v4); res = ddy(v4); res = ddx_fine(v4); res = ddy_fine(v4); res = ddx_coarse(v4); res = ddy_coarse(v4); res = fwidth(v4); res = fwidth(v4); res = fwidth(v4); } void frag_main() { test_constants(); test_conversions(); test_builtins(); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { v4 = stage_input.v4; v3 = stage_input.v3; v1 = stage_input.v1; v2 = stage_input.v2; frag_main(); SPIRV_Cross_Output stage_output; stage_output.o1 = o1; stage_output.o2 = o2; stage_output.o3 = o3; stage_output.o4 = o4; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/frag/frag-coord.frag000066400000000000000000000010261400026215700257350ustar00rootroot00000000000000static float4 gl_FragCoord; static float3 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float3 FragColor : SV_Target0; }; void frag_main() { FragColor = gl_FragCoord.xyz / gl_FragCoord.w.xxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } native-16bit-types.fxconly.nofxc.sm62.native-16bit.frag000066400000000000000000000060601400026215700350040ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/fragRWByteAddressBuffer _62 : register(u0, space0); static float4 gl_FragCoord; static half4 Output; static half4 Input; static int16_t4 OutputI; static int16_t4 InputI; static uint16_t4 OutputU; static uint16_t4 InputU; struct SPIRV_Cross_Input { half4 Input : TEXCOORD0; nointerpolation int16_t4 InputI : TEXCOORD1; nointerpolation uint16_t4 InputU : TEXCOORD2; float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { half4 Output : SV_Target0; int16_t4 OutputI : SV_Target1; uint16_t4 OutputU : SV_Target2; }; void frag_main() { int index = int(gl_FragCoord.x); Output = Input + half(20.0).xxxx; OutputI = InputI + int16_t4(int16_t(-40), int16_t(-40), int16_t(-40), int16_t(-40)); OutputU = InputU + uint16_t4(20u, 20u, 20u, 20u); Output += _62.Load(index * 2 + 0).xxxx; OutputI += _62.Load(index * 2 + 8).xxxx; OutputU += _62.Load(index * 2 + 16).xxxx; Output += _62.Load(index * 8 + 24); OutputI += _62.Load(index * 8 + 56); OutputU += _62.Load(index * 8 + 88); Output += _62.Load(index * 16 + 128).xyzz; Output += half3(_62.Load(index * 12 + 186), _62.Load(index * 12 + 190), _62.Load(index * 12 + 194)).xyzz; half2x3 _128 = half2x3(_62.Load(index * 16 + 120), _62.Load(index * 16 + 128)); half2x3 m0 = _128; half2x3 _132 = half2x3(_62.Load(index * 12 + 184), _62.Load(index * 12 + 188), _62.Load(index * 12 + 192), _62.Load(index * 12 + 186), _62.Load(index * 12 + 190), _62.Load(index * 12 + 194)); half2x3 m1 = _132; _62.Store(index * 2 + 0, Output.x); _62.Store(index * 2 + 8, OutputI.y); _62.Store(index * 2 + 16, OutputU.z); _62.Store(index * 8 + 24, Output); _62.Store(index * 8 + 56, OutputI); _62.Store(index * 8 + 88, OutputU); _62.Store(index * 16 + 128, Output.xyz); _62.Store(index * 12 + 186, Output.x); _62.Store(index * 12 + 190, Output.xyz.y); _62.Store(index * 12 + 194, Output.xyz.z); half2x3 _182 = half2x3(half3(Output.xyz), half3(Output.wzy)); _62.Store(index * 16 + 120, _182[0]); _62.Store(index * 16 + 128, _182[1]); half2x3 _197 = half2x3(half3(Output.xyz), half3(Output.wzy)); _62.Store(index * 12 + 184, _197[0].x); _62.Store(index * 12 + 186, _197[1].x); _62.Store(index * 12 + 188, _197[0].y); _62.Store(index * 12 + 190, _197[1].y); _62.Store(index * 12 + 192, _197[0].z); _62.Store(index * 12 + 194, _197[1].z); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; Input = stage_input.Input; InputI = stage_input.InputI; InputU = stage_input.InputU; frag_main(); SPIRV_Cross_Output stage_output; stage_output.Output = Output; stage_output.OutputI = OutputI; stage_output.OutputU = OutputU; return stage_output; } nonuniform-constructor.sm51.nonuniformresource.frag000066400000000000000000000012251400026215700351360ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/fragTexture2D uTex[] : register(t0, space0); SamplerState Immut : register(s0, space1); static float4 FragColor; static int vIndex; static float2 vUV; struct SPIRV_Cross_Input { float2 vUV : TEXCOORD0; nointerpolation int vIndex : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = uTex[NonUniformResourceIndex(vIndex)].Sample(Immut, vUV); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vIndex = stage_input.vIndex; vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } pixel-interlock-simple-callstack.sm51.fxconly.frag000066400000000000000000000012071400026215700344400ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/fragRasterizerOrderedByteAddressBuffer _14 : register(u1, space0); RasterizerOrderedByteAddressBuffer _35 : register(u0, space0); static float4 gl_FragCoord; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; void callee2() { int _25 = int(gl_FragCoord.x); _14.Store(_25 * 4 + 0, _14.Load(_25 * 4 + 0) + 1u); } void callee() { int _38 = int(gl_FragCoord.x); _35.Store(_38 * 4 + 0, _35.Load(_38 * 4 + 0) + 1u); callee2(); } void frag_main() { callee(); } void main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/frag/spec-constant.frag000066400000000000000000000070551400026215700265030ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 1.0f #endif static const float a = SPIRV_CROSS_CONSTANT_ID_1; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 2.0f #endif static const float b = SPIRV_CROSS_CONSTANT_ID_2; #ifndef SPIRV_CROSS_CONSTANT_ID_3 #define SPIRV_CROSS_CONSTANT_ID_3 3 #endif static const int c = SPIRV_CROSS_CONSTANT_ID_3; static const uint _18 = (uint(c) + 0u); static const int _21 = (-c); static const int _23 = (~c); #ifndef SPIRV_CROSS_CONSTANT_ID_4 #define SPIRV_CROSS_CONSTANT_ID_4 4 #endif static const int d = SPIRV_CROSS_CONSTANT_ID_4; static const int _26 = (c + d); static const int _28 = (c - d); static const int _30 = (c * d); static const int _32 = (c / d); #ifndef SPIRV_CROSS_CONSTANT_ID_5 #define SPIRV_CROSS_CONSTANT_ID_5 5u #endif static const uint e = SPIRV_CROSS_CONSTANT_ID_5; #ifndef SPIRV_CROSS_CONSTANT_ID_6 #define SPIRV_CROSS_CONSTANT_ID_6 6u #endif static const uint f = SPIRV_CROSS_CONSTANT_ID_6; static const uint _36 = (e / f); static const int _38 = (c % d); static const uint _40 = (e % f); static const int _42 = (c >> d); static const uint _44 = (e >> f); static const int _46 = (c << d); static const int _48 = (c | d); static const int _50 = (c ^ d); static const int _52 = (c & d); #ifndef SPIRV_CROSS_CONSTANT_ID_7 #define SPIRV_CROSS_CONSTANT_ID_7 false #endif static const bool g = SPIRV_CROSS_CONSTANT_ID_7; #ifndef SPIRV_CROSS_CONSTANT_ID_8 #define SPIRV_CROSS_CONSTANT_ID_8 true #endif static const bool h = SPIRV_CROSS_CONSTANT_ID_8; static const bool _58 = (g || h); static const bool _60 = (g && h); static const bool _62 = (!g); static const bool _64 = (g == h); static const bool _66 = (g != h); static const bool _68 = (c == d); static const bool _70 = (c != d); static const bool _72 = (c < d); static const bool _74 = (e < f); static const bool _76 = (c > d); static const bool _78 = (e > f); static const bool _80 = (c <= d); static const bool _82 = (e <= f); static const bool _84 = (c >= d); static const bool _86 = (e >= f); static const int _92 = int(e + 0u); static const bool _94 = (c != int(0u)); static const bool _96 = (e != 0u); static const int _100 = int(g); static const uint _103 = uint(g); static const int _111 = (c + 3); static const int _118 = (c + 2); static const int _124 = (d + 2); struct Foo { float elems[_124]; }; static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { float t0 = a; float t1 = b; uint c0 = _18; int c1 = _21; int c2 = _23; int c3 = _26; int c4 = _28; int c5 = _30; int c6 = _32; uint c7 = _36; int c8 = _38; uint c9 = _40; int c10 = _42; uint c11 = _44; int c12 = _46; int c13 = _48; int c14 = _50; int c15 = _52; bool c16 = _58; bool c17 = _60; bool c18 = _62; bool c19 = _64; bool c20 = _66; bool c21 = _68; bool c22 = _70; bool c23 = _72; bool c24 = _74; bool c25 = _76; bool c26 = _78; bool c27 = _80; bool c28 = _82; bool c29 = _84; bool c30 = _86; int c31 = c8 + c3; int c32 = _92; bool c33 = _94; bool c34 = _96; int c35 = _100; uint c36 = _103; float c37 = float(g); float vec0[_111][8]; vec0[0][0] = 10.0f; float vec1[_118]; vec1[0] = 20.0f; Foo foo; foo.elems[c] = 10.0f; FragColor = (((t0 + t1).xxxx + vec0[0][0].xxxx) + vec1[0].xxxx) + foo.elems[c].xxxx; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/frag/ubo-offset-out-of-order.frag000066400000000000000000000010721400026215700303040ustar00rootroot00000000000000cbuffer UBO : register(b0) { row_major float4x4 _13_m : packoffset(c1); float4 _13_v : packoffset(c0); }; static float4 FragColor; static float4 vColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = mul(vColor, _13_m) + _13_v; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/frag/variables.zero-initialize.frag000066400000000000000000000014551400026215700310050ustar00rootroot00000000000000struct Foo { int a; }; static float4 vColor; static float4 FragColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; static int uninit_int = 0; static int4 uninit_vector = int4(0, 0, 0, 0); static float4x4 uninit_matrix = float4x4(0.0f.xxxx, 0.0f.xxxx, 0.0f.xxxx, 0.0f.xxxx); static Foo uninit_foo = { 0 }; void frag_main() { int uninit_function_int = 0; if (vColor.x > 10.0f) { uninit_function_int = 10; } else { uninit_function_int = 20; } FragColor = vColor; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/vert/000077500000000000000000000000001400026215700231135ustar00rootroot00000000000000flatten-matrix-input.flatten-matrix-vertex-input.vert000066400000000000000000000023441400026215700354430ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/vertstatic float4 gl_Position; static float4x4 m4; static float4 v; static float3x3 m3; static float2x2 m2; struct SPIRV_Cross_Input { float4 m4_0 : TEXCOORD0; float4 m4_1 : TEXCOORD1; float4 m4_2 : TEXCOORD2; float4 m4_3 : TEXCOORD3; float3 m3_0 : TEXCOORD4; float3 m3_1 : TEXCOORD5; float3 m3_2 : TEXCOORD6; float2 m2_0 : TEXCOORD7; float2 m2_1 : TEXCOORD8; float4 v : TEXCOORD9; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = mul(v, m4); float3 _37 = gl_Position.xyz + mul(v.xyz, m3); gl_Position = float4(_37.x, _37.y, _37.z, gl_Position.w); float2 _52 = gl_Position.xy + mul(v.xy, m2); gl_Position = float4(_52.x, _52.y, gl_Position.z, gl_Position.w); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { m4[0] = stage_input.m4_0; m4[1] = stage_input.m4_1; m4[2] = stage_input.m4_2; m4[3] = stage_input.m4_3; v = stage_input.v; m3[0] = stage_input.m3_0; m3[1] = stage_input.m3_1; m3[2] = stage_input.m3_2; m2[0] = stage_input.m2_0; m2[1] = stage_input.m2_1; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl-no-opt/vert/pass-array-by-value.vert000066400000000000000000000021111400026215700276140ustar00rootroot00000000000000static const float4 _68[4] = { 0.0f.xxxx, 1.0f.xxxx, 2.0f.xxxx, 3.0f.xxxx }; static float4 gl_Position; static int Index1; static int Index2; struct SPIRV_Cross_Input { int Index1 : TEXCOORD0; int Index2 : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; float4 consume_constant_arrays2(float4 positions[4], float4 positions2[4]) { float4 indexable[4] = positions; float4 indexable_1[4] = positions2; return indexable[Index1] + indexable_1[Index2]; } float4 consume_constant_arrays(float4 positions[4], float4 positions2[4]) { return consume_constant_arrays2(positions, positions2); } void vert_main() { float4 LUT2[4]; LUT2[0] = 10.0f.xxxx; LUT2[1] = 11.0f.xxxx; LUT2[2] = 12.0f.xxxx; LUT2[3] = 13.0f.xxxx; gl_Position = consume_constant_arrays(_68, LUT2); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { Index1 = stage_input.Index1; Index2 = stage_input.Index2; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/000077500000000000000000000000001400026215700207215ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl/asm/000077500000000000000000000000001400026215700215015ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl/asm/comp/000077500000000000000000000000001400026215700224375ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl/asm/comp/access-chain-invalidate.asm.comp000066400000000000000000000004751400026215700305430ustar00rootroot00000000000000RWByteAddressBuffer _4 : register(u0); void comp_main() { uint _21 = _4.Load(_4.Load(0) * 4 + 4); for (uint _23 = 0u; _23 < 64u; ) { _4.Store(_23 * 4 + 4, 0u); _23++; continue; } _4.Store(_4.Load(0) * 4 + 4, _21); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/comp/atomic-decrement.asm.comp000066400000000000000000000010611400026215700273140ustar00rootroot00000000000000RWByteAddressBuffer u0_counter : register(u1); RWBuffer u0 : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { uint _29; u0_counter.InterlockedAdd(0, -1, _29); float4 r0; r0.x = asfloat(_29); u0[(uint(asint(r0.x)) * 1u) + (uint(0) >> 2u)] = uint(int(gl_GlobalInvocationID.x)).x; } [numthreads(4, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/comp/atomic-increment.asm.comp000066400000000000000000000010601400026215700273310ustar00rootroot00000000000000RWByteAddressBuffer u0_counter : register(u1); RWBuffer u0 : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { uint _29; u0_counter.InterlockedAdd(0, 1, _29); float4 r0; r0.x = asfloat(_29); u0[(uint(asint(r0.x)) * 1u) + (uint(0) >> 2u)] = uint(int(gl_GlobalInvocationID.x)).x; } [numthreads(4, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/comp/bitcast_icmp.asm.comp000066400000000000000000000073741400026215700265520ustar00rootroot00000000000000RWByteAddressBuffer _5 : register(u0); RWByteAddressBuffer _6 : register(u1); void comp_main() { bool4 _31 = bool4(int(_5.Load4(16).x) < int4(_5.Load4(0)).x, int(_5.Load4(16).y) < int4(_5.Load4(0)).y, int(_5.Load4(16).z) < int4(_5.Load4(0)).z, int(_5.Load4(16).w) < int4(_5.Load4(0)).w); bool4 _32 = bool4(int(_5.Load4(16).x) <= int4(_5.Load4(0)).x, int(_5.Load4(16).y) <= int4(_5.Load4(0)).y, int(_5.Load4(16).z) <= int4(_5.Load4(0)).z, int(_5.Load4(16).w) <= int4(_5.Load4(0)).w); bool4 _33 = bool4(_5.Load4(16).x < uint(int4(_5.Load4(0)).x), _5.Load4(16).y < uint(int4(_5.Load4(0)).y), _5.Load4(16).z < uint(int4(_5.Load4(0)).z), _5.Load4(16).w < uint(int4(_5.Load4(0)).w)); bool4 _34 = bool4(_5.Load4(16).x <= uint(int4(_5.Load4(0)).x), _5.Load4(16).y <= uint(int4(_5.Load4(0)).y), _5.Load4(16).z <= uint(int4(_5.Load4(0)).z), _5.Load4(16).w <= uint(int4(_5.Load4(0)).w)); bool4 _35 = bool4(int(_5.Load4(16).x) > int4(_5.Load4(0)).x, int(_5.Load4(16).y) > int4(_5.Load4(0)).y, int(_5.Load4(16).z) > int4(_5.Load4(0)).z, int(_5.Load4(16).w) > int4(_5.Load4(0)).w); bool4 _36 = bool4(int(_5.Load4(16).x) >= int4(_5.Load4(0)).x, int(_5.Load4(16).y) >= int4(_5.Load4(0)).y, int(_5.Load4(16).z) >= int4(_5.Load4(0)).z, int(_5.Load4(16).w) >= int4(_5.Load4(0)).w); bool4 _37 = bool4(_5.Load4(16).x > uint(int4(_5.Load4(0)).x), _5.Load4(16).y > uint(int4(_5.Load4(0)).y), _5.Load4(16).z > uint(int4(_5.Load4(0)).z), _5.Load4(16).w > uint(int4(_5.Load4(0)).w)); bool4 _38 = bool4(_5.Load4(16).x >= uint(int4(_5.Load4(0)).x), _5.Load4(16).y >= uint(int4(_5.Load4(0)).y), _5.Load4(16).z >= uint(int4(_5.Load4(0)).z), _5.Load4(16).w >= uint(int4(_5.Load4(0)).w)); _6.Store4(0, uint4(_31.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _31.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _31.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _31.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_32.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _32.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _32.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _32.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_33.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _33.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _33.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _33.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_34.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _34.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _34.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _34.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_35.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _35.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _35.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _35.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_36.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _36.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _36.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _36.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_37.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _37.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _37.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _37.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); _6.Store4(0, uint4(_38.x ? uint4(1u, 1u, 1u, 1u).x : uint4(0u, 0u, 0u, 0u).x, _38.y ? uint4(1u, 1u, 1u, 1u).y : uint4(0u, 0u, 0u, 0u).y, _38.z ? uint4(1u, 1u, 1u, 1u).z : uint4(0u, 0u, 0u, 0u).z, _38.w ? uint4(1u, 1u, 1u, 1u).w : uint4(0u, 0u, 0u, 0u).w)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/comp/block-name-alias-global.asm.comp000066400000000000000000000016141400026215700304350ustar00rootroot00000000000000struct A { int a; int b; }; RWByteAddressBuffer C1 : register(u1); cbuffer C2 : register(b2) { A C2_1_Data[1024] : packoffset(c0); }; RWByteAddressBuffer C3 : register(u0); cbuffer B : register(b3) { A C4_Data[1024] : packoffset(c0); }; static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { C1.Store(gl_GlobalInvocationID.x * 8 + 0, uint(C2_1_Data[gl_GlobalInvocationID.x].a)); C1.Store(gl_GlobalInvocationID.x * 8 + 4, uint(C2_1_Data[gl_GlobalInvocationID.x].b)); C3.Store(gl_GlobalInvocationID.x * 8 + 0, uint(C4_Data[gl_GlobalInvocationID.x].a)); C3.Store(gl_GlobalInvocationID.x * 8 + 4, uint(C4_Data[gl_GlobalInvocationID.x].b)); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/comp/control-flow-hints.asm.comp000066400000000000000000000013721400026215700276510ustar00rootroot00000000000000RWByteAddressBuffer bar : register(u0); RWByteAddressBuffer foo : register(u1); void _main() { [unroll] for (int i = 0; i < 16; i++) { bar.Store4(i * 16 + 0, asuint(asfloat(foo.Load4(i * 16 + 0)))); } [loop] for (int i_1 = 0; i_1 < 16; i_1++) { bar.Store4((15 - i_1) * 16 + 0, asuint(asfloat(foo.Load4(i_1 * 16 + 0)))); } float v = asfloat(bar.Load(160)); float w = asfloat(foo.Load(160)); [branch] if (v > 10.0f) { foo.Store4(320, asuint(5.0f.xxxx)); } float value = 20.0f; [flatten] if (w > 40.0f) { value = 20.0f; } foo.Store4(320, asuint(value.xxxx)); } void comp_main() { _main(); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/comp/global-parameter-name-alias.asm.comp000066400000000000000000000013161400026215700313220ustar00rootroot00000000000000ByteAddressBuffer ssbo : register(t1); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void Load(uint size) { int byteAddrTemp = int(size >> uint(2)); uint4 data = uint4(ssbo.Load(byteAddrTemp * 4 + 0), ssbo.Load((byteAddrTemp + 1) * 4 + 0), ssbo.Load((byteAddrTemp + 2) * 4 + 0), ssbo.Load((byteAddrTemp + 3) * 4 + 0)); } void _main(uint3 id) { uint param = 4u; Load(param); } void comp_main() { uint3 id = gl_GlobalInvocationID; uint3 param = id; _main(param); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/comp/nmin-max-clamp.asm.comp000066400000000000000000000156701400026215700267250ustar00rootroot00000000000000RWByteAddressBuffer _4 : register(u0); void comp_main() { _4.Store(0, asuint(isnan(asfloat(_4.Load(96))) ? asfloat(_4.Load(48)) : (isnan(asfloat(_4.Load(48))) ? asfloat(_4.Load(96)) : min(asfloat(_4.Load(48)), asfloat(_4.Load(96)))))); bool2 _145 = isnan(asfloat(_4.Load2(56))); bool2 _146 = isnan(asfloat(_4.Load2(104))); float2 _147 = min(asfloat(_4.Load2(56)), asfloat(_4.Load2(104))); float2 _148 = float2(_145.x ? asfloat(_4.Load2(104)).x : _147.x, _145.y ? asfloat(_4.Load2(104)).y : _147.y); _4.Store2(8, asuint(float2(_146.x ? asfloat(_4.Load2(56)).x : _148.x, _146.y ? asfloat(_4.Load2(56)).y : _148.y))); bool3 _150 = isnan(asfloat(_4.Load3(64))); bool3 _151 = isnan(asfloat(_4.Load3(112))); float3 _152 = min(asfloat(_4.Load3(64)), asfloat(_4.Load3(112))); float3 _153 = float3(_150.x ? asfloat(_4.Load3(112)).x : _152.x, _150.y ? asfloat(_4.Load3(112)).y : _152.y, _150.z ? asfloat(_4.Load3(112)).z : _152.z); _4.Store3(16, asuint(float3(_151.x ? asfloat(_4.Load3(64)).x : _153.x, _151.y ? asfloat(_4.Load3(64)).y : _153.y, _151.z ? asfloat(_4.Load3(64)).z : _153.z))); bool4 _155 = isnan(asfloat(_4.Load4(80))); bool4 _156 = isnan(asfloat(_4.Load4(128))); float4 _157 = min(asfloat(_4.Load4(80)), asfloat(_4.Load4(128))); float4 _158 = float4(_155.x ? asfloat(_4.Load4(128)).x : _157.x, _155.y ? asfloat(_4.Load4(128)).y : _157.y, _155.z ? asfloat(_4.Load4(128)).z : _157.z, _155.w ? asfloat(_4.Load4(128)).w : _157.w); _4.Store4(32, asuint(float4(_156.x ? asfloat(_4.Load4(80)).x : _158.x, _156.y ? asfloat(_4.Load4(80)).y : _158.y, _156.z ? asfloat(_4.Load4(80)).z : _158.z, _156.w ? asfloat(_4.Load4(80)).w : _158.w))); _4.Store(0, asuint(isnan(asfloat(_4.Load(96))) ? asfloat(_4.Load(48)) : (isnan(asfloat(_4.Load(48))) ? asfloat(_4.Load(96)) : max(asfloat(_4.Load(48)), asfloat(_4.Load(96)))))); bool2 _165 = isnan(asfloat(_4.Load2(56))); bool2 _166 = isnan(asfloat(_4.Load2(104))); float2 _167 = max(asfloat(_4.Load2(56)), asfloat(_4.Load2(104))); float2 _168 = float2(_165.x ? asfloat(_4.Load2(104)).x : _167.x, _165.y ? asfloat(_4.Load2(104)).y : _167.y); _4.Store2(8, asuint(float2(_166.x ? asfloat(_4.Load2(56)).x : _168.x, _166.y ? asfloat(_4.Load2(56)).y : _168.y))); bool3 _170 = isnan(asfloat(_4.Load3(64))); bool3 _171 = isnan(asfloat(_4.Load3(112))); float3 _172 = max(asfloat(_4.Load3(64)), asfloat(_4.Load3(112))); float3 _173 = float3(_170.x ? asfloat(_4.Load3(112)).x : _172.x, _170.y ? asfloat(_4.Load3(112)).y : _172.y, _170.z ? asfloat(_4.Load3(112)).z : _172.z); _4.Store3(16, asuint(float3(_171.x ? asfloat(_4.Load3(64)).x : _173.x, _171.y ? asfloat(_4.Load3(64)).y : _173.y, _171.z ? asfloat(_4.Load3(64)).z : _173.z))); bool4 _175 = isnan(asfloat(_4.Load4(80))); bool4 _176 = isnan(asfloat(_4.Load4(128))); float4 _177 = max(asfloat(_4.Load4(80)), asfloat(_4.Load4(128))); float4 _178 = float4(_175.x ? asfloat(_4.Load4(128)).x : _177.x, _175.y ? asfloat(_4.Load4(128)).y : _177.y, _175.z ? asfloat(_4.Load4(128)).z : _177.z, _175.w ? asfloat(_4.Load4(128)).w : _177.w); _4.Store4(32, asuint(float4(_176.x ? asfloat(_4.Load4(80)).x : _178.x, _176.y ? asfloat(_4.Load4(80)).y : _178.y, _176.z ? asfloat(_4.Load4(80)).z : _178.z, _176.w ? asfloat(_4.Load4(80)).w : _178.w))); float _179 = isnan(asfloat(_4.Load(48))) ? asfloat(_4.Load(0)) : (isnan(asfloat(_4.Load(0))) ? asfloat(_4.Load(48)) : max(asfloat(_4.Load(0)), asfloat(_4.Load(48)))); _4.Store(0, asuint(isnan(asfloat(_4.Load(96))) ? _179 : (isnan(_179) ? asfloat(_4.Load(96)) : min(_179, asfloat(_4.Load(96)))))); bool2 _192 = isnan(asfloat(_4.Load2(8))); bool2 _193 = isnan(asfloat(_4.Load2(56))); float2 _194 = max(asfloat(_4.Load2(8)), asfloat(_4.Load2(56))); float2 _195 = float2(_192.x ? asfloat(_4.Load2(56)).x : _194.x, _192.y ? asfloat(_4.Load2(56)).y : _194.y); float2 _190 = float2(_193.x ? asfloat(_4.Load2(8)).x : _195.x, _193.y ? asfloat(_4.Load2(8)).y : _195.y); bool2 _197 = isnan(_190); bool2 _198 = isnan(asfloat(_4.Load2(104))); float2 _199 = min(_190, asfloat(_4.Load2(104))); float2 _200 = float2(_197.x ? asfloat(_4.Load2(104)).x : _199.x, _197.y ? asfloat(_4.Load2(104)).y : _199.y); _4.Store2(8, asuint(float2(_198.x ? _190.x : _200.x, _198.y ? _190.y : _200.y))); bool3 _203 = isnan(asfloat(_4.Load3(16))); bool3 _204 = isnan(asfloat(_4.Load3(64))); float3 _205 = max(asfloat(_4.Load3(16)), asfloat(_4.Load3(64))); float3 _206 = float3(_203.x ? asfloat(_4.Load3(64)).x : _205.x, _203.y ? asfloat(_4.Load3(64)).y : _205.y, _203.z ? asfloat(_4.Load3(64)).z : _205.z); float3 _201 = float3(_204.x ? asfloat(_4.Load3(16)).x : _206.x, _204.y ? asfloat(_4.Load3(16)).y : _206.y, _204.z ? asfloat(_4.Load3(16)).z : _206.z); bool3 _208 = isnan(_201); bool3 _209 = isnan(asfloat(_4.Load3(112))); float3 _210 = min(_201, asfloat(_4.Load3(112))); float3 _211 = float3(_208.x ? asfloat(_4.Load3(112)).x : _210.x, _208.y ? asfloat(_4.Load3(112)).y : _210.y, _208.z ? asfloat(_4.Load3(112)).z : _210.z); _4.Store3(16, asuint(float3(_209.x ? _201.x : _211.x, _209.y ? _201.y : _211.y, _209.z ? _201.z : _211.z))); bool4 _214 = isnan(asfloat(_4.Load4(32))); bool4 _215 = isnan(asfloat(_4.Load4(80))); float4 _216 = max(asfloat(_4.Load4(32)), asfloat(_4.Load4(80))); float4 _217 = float4(_214.x ? asfloat(_4.Load4(80)).x : _216.x, _214.y ? asfloat(_4.Load4(80)).y : _216.y, _214.z ? asfloat(_4.Load4(80)).z : _216.z, _214.w ? asfloat(_4.Load4(80)).w : _216.w); float4 _212 = float4(_215.x ? asfloat(_4.Load4(32)).x : _217.x, _215.y ? asfloat(_4.Load4(32)).y : _217.y, _215.z ? asfloat(_4.Load4(32)).z : _217.z, _215.w ? asfloat(_4.Load4(32)).w : _217.w); bool4 _219 = isnan(_212); bool4 _220 = isnan(asfloat(_4.Load4(128))); float4 _221 = min(_212, asfloat(_4.Load4(128))); float4 _222 = float4(_219.x ? asfloat(_4.Load4(128)).x : _221.x, _219.y ? asfloat(_4.Load4(128)).y : _221.y, _219.z ? asfloat(_4.Load4(128)).z : _221.z, _219.w ? asfloat(_4.Load4(128)).w : _221.w); _4.Store4(32, asuint(float4(_220.x ? _212.x : _222.x, _220.y ? _212.y : _222.y, _220.z ? _212.z : _222.z, _220.w ? _212.w : _222.w))); float _223; for (int i = 0; i < 2; i++, _223 = isnan(asfloat(_4.Load(56))) ? asfloat(_4.Load(0)) : (isnan(asfloat(_4.Load(0))) ? asfloat(_4.Load(56)) : max(asfloat(_4.Load(0)), asfloat(_4.Load(56)))), _4.Store(0, asuint(isnan(asfloat(_4.Load(60))) ? _223 : (isnan(_223) ? asfloat(_4.Load(60)) : min(_223, asfloat(_4.Load(60))))))) { bool2 _235 = isnan(asfloat(_4.Load2(56))); bool2 _236 = isnan(asfloat(_4.Load2(104))); float2 _237 = min(asfloat(_4.Load2(56)), asfloat(_4.Load2(104))); float2 _238 = float2(_235.x ? asfloat(_4.Load2(104)).x : _237.x, _235.y ? asfloat(_4.Load2(104)).y : _237.y); _4.Store2(8, asuint(float2(_236.x ? asfloat(_4.Load2(56)).x : _238.x, _236.y ? asfloat(_4.Load2(56)).y : _238.y))); } } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/000077500000000000000000000000001400026215700224205ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/cbuffer-stripped.asm.frag000066400000000000000000000006721400026215700273110ustar00rootroot00000000000000cbuffer _4_5 : register(b0) { column_major float2x4 _5_m0 : packoffset(c0); float4 _5_m1 : packoffset(c4); }; static float2 _3; struct SPIRV_Cross_Output { float2 _3 : SV_Target0; }; float2 _23() { float2 _25 = mul(_5_m0, _5_m1); return _25; } void frag_main() { _3 = _23(); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output._3 = _3; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/combined-sampler-reuse.asm.frag000066400000000000000000000011011400026215700303730ustar00rootroot00000000000000Texture2D uTex : register(t1); SamplerState uSampler : register(s0); static float4 FragColor; static float2 vUV; struct SPIRV_Cross_Input { float2 vUV : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = uTex.Sample(uSampler, vUV); FragColor += uTex.Sample(uSampler, vUV, int2(1, 1)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/empty-struct.asm.frag000066400000000000000000000005611400026215700265220ustar00rootroot00000000000000struct EmptyStructTest { int empty_struct_member; }; float GetValue(EmptyStructTest self) { return 0.0f; } float GetValue_1(EmptyStructTest self) { return 0.0f; } void frag_main() { EmptyStructTest _23 = { 0 }; EmptyStructTest emptyStruct; float value = GetValue(emptyStruct); value = GetValue_1(_23); } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/frem.asm.frag000066400000000000000000000007561400026215700250010ustar00rootroot00000000000000static float4 FragColor; static float4 vA; static float4 vB; struct SPIRV_Cross_Input { float4 vA : TEXCOORD0; float4 vB : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = fmod(vA, vB); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vA = stage_input.vA; vB = stage_input.vB; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/function-overload-alias.asm.frag000066400000000000000000000014521400026215700305670ustar00rootroot00000000000000static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; float4 foo(float4 foo_1) { return foo_1 + 1.0f.xxxx; } float4 foo(float3 foo_1) { return foo_1.xyzz + 1.0f.xxxx; } float4 foo_1(float4 foo_2) { return foo_2 + 2.0f.xxxx; } float4 foo(float2 foo_2) { return foo_2.xyxy + 2.0f.xxxx; } void frag_main() { float4 foo_3 = 1.0f.xxxx; float4 foo_2 = foo(foo_3); float3 foo_5 = 1.0f.xxx; float4 foo_4 = foo(foo_5); float4 foo_7 = 1.0f.xxxx; float4 foo_6 = foo_1(foo_7); float2 foo_9 = 1.0f.xx; float4 foo_8 = foo(foo_9); FragColor = ((foo_2 + foo_4) + foo_6) + foo_8; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/image-extract-reuse.asm.frag000066400000000000000000000012561400026215700277170ustar00rootroot00000000000000Texture2D uTexture : register(t0); SamplerState _uTexture_sampler : register(s0); static int2 Size; struct SPIRV_Cross_Output { int2 Size : SV_Target0; }; uint2 spvTextureSize(Texture2D Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(Level, ret.x, ret.y, Param); return ret; } void frag_main() { uint _19_dummy_parameter; uint _20_dummy_parameter; Size = int2(spvTextureSize(uTexture, uint(0), _19_dummy_parameter)) + int2(spvTextureSize(uTexture, uint(1), _20_dummy_parameter)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.Size = Size; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/implicit-read-dep-phi.asm.frag000066400000000000000000000020131400026215700301030ustar00rootroot00000000000000Texture2D uImage : register(t0); SamplerState _uImage_sampler : register(s0); static float4 v0; static float4 FragColor; struct SPIRV_Cross_Input { float4 v0 : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int i = 0; float phi; float4 _36; phi = 1.0f; _36 = float4(1.0f, 2.0f, 1.0f, 2.0f); for (;;) { FragColor = _36; if (i < 4) { if (v0[i] > 0.0f) { float2 _48 = phi.xx; i++; phi += 2.0f; _36 = uImage.SampleLevel(_uImage_sampler, _48, 0.0f); continue; } else { break; } } else { break; } } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { v0 = stage_input.v0; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/inf-nan-constant.asm.frag000066400000000000000000000005421400026215700272160ustar00rootroot00000000000000static float3 FragColor; struct SPIRV_Cross_Output { float3 FragColor : SV_Target0; }; void frag_main() { FragColor = float3(asfloat(0x7f800000u), asfloat(0xff800000u), asfloat(0x7fc00000u)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/line-directive.line.asm.frag000066400000000000000000000031301400026215700276660ustar00rootroot00000000000000static float FragColor; static float vColor; struct SPIRV_Cross_Input { float vColor : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; #line 6 "test.frag" void func() { #line 8 "test.frag" FragColor = 1.0f; #line 9 "test.frag" FragColor = 2.0f; #line 10 "test.frag" if (vColor < 0.0f) { #line 12 "test.frag" FragColor = 3.0f; } else { #line 16 "test.frag" FragColor = 4.0f; } #line 19 "test.frag" for (int i = 0; float(i) < (40.0f + vColor); i += (int(vColor) + 5)) { #line 21 "test.frag" FragColor += 0.20000000298023223876953125f; #line 22 "test.frag" FragColor += 0.300000011920928955078125f; } #line 25 "test.frag" switch (int(vColor)) { case 0: { #line 28 "test.frag" FragColor += 0.20000000298023223876953125f; #line 29 "test.frag" break; } case 1: { #line 32 "test.frag" FragColor += 0.4000000059604644775390625f; #line 33 "test.frag" break; } default: { #line 36 "test.frag" FragColor += 0.800000011920928955078125f; #line 37 "test.frag" break; } } do { #line 42 "test.frag" FragColor += (10.0f + vColor); } while (FragColor < 100.0f); } #line 46 "test.frag" void frag_main() { #line 48 "test.frag" func(); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/lut-promotion-initializer.asm.frag000066400000000000000000000022461400026215700312150ustar00rootroot00000000000000static const float _46[16] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f }; static const float4 _76[4] = { 0.0f.xxxx, 1.0f.xxxx, 8.0f.xxxx, 5.0f.xxxx }; static const float4 _90[4] = { 20.0f.xxxx, 30.0f.xxxx, 50.0f.xxxx, 60.0f.xxxx }; static float FragColor; static int index; struct SPIRV_Cross_Input { nointerpolation int index : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { float4 foobar[4] = _76; float4 baz[4] = _76; FragColor = _46[index]; if (index < 10) { FragColor += _46[index ^ 1]; } else { FragColor += _46[index & 1]; } if (index > 30) { FragColor += _76[index & 3].y; } else { FragColor += _76[index & 1].x; } if (index > 30) { foobar[1].z = 20.0f; } FragColor += foobar[index & 3].z; baz = _90; FragColor += baz[index & 3].z; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { index = stage_input.index; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } pack-and-unpack-uint2.fxconly.nofxc.sm60.asm.frag000066400000000000000000000013061400026215700333360ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl/asm/fragstatic float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; uint64_t spvPackUint2x32(uint2 value) { return (uint64_t(value.y) << 32) | uint64_t(value.x); } uint2 spvUnpackUint2x32(uint64_t value) { uint2 Unpacked; Unpacked.x = uint(value & 0xffffffff); Unpacked.y = uint(value >> 32); return Unpacked; } void frag_main() { uint64_t _packed = spvPackUint2x32(uint2(18u, 52u)); uint2 unpacked = spvUnpackUint2x32(_packed); FragColor = float4(float(unpacked.x), float(unpacked.y), 1.0f, 1.0f); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/pass-by-value.asm.frag000066400000000000000000000006631400026215700265350ustar00rootroot00000000000000cbuffer Registers { float registers_foo : packoffset(c0); }; static float FragColor; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; float add_value(float v, float w) { return v + w; } void frag_main() { FragColor = add_value(10.0f, registers_foo); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/sample-and-compare.asm.frag000066400000000000000000000013761400026215700275140ustar00rootroot00000000000000Texture2D g_Texture : register(t0); SamplerState g_Sampler : register(s0); SamplerComparisonState g_CompareSampler : register(s1); static float2 in_var_TEXCOORD0; static float out_var_SV_Target; struct SPIRV_Cross_Input { float2 in_var_TEXCOORD0 : TEXCOORD0; }; struct SPIRV_Cross_Output { float out_var_SV_Target : SV_Target0; }; void frag_main() { out_var_SV_Target = g_Texture.Sample(g_Sampler, in_var_TEXCOORD0).x + g_Texture.SampleCmpLevelZero(g_CompareSampler, in_var_TEXCOORD0, 0.5f); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { in_var_TEXCOORD0 = stage_input.in_var_TEXCOORD0; frag_main(); SPIRV_Cross_Output stage_output; stage_output.out_var_SV_Target = out_var_SV_Target; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/single-function-private-lut.asm.frag000066400000000000000000000022521400026215700314170ustar00rootroot00000000000000struct myType { float data; }; static const myType _18 = { 0.0f }; static const myType _20 = { 1.0f }; static const myType _21[5] = { { 0.0f }, { 1.0f }, { 0.0f }, { 1.0f }, { 0.0f } }; static float4 gl_FragCoord; static float4 o_color; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 o_color : SV_Target0; }; float mod(float x, float y) { return x - y * floor(x / y); } float2 mod(float2 x, float2 y) { return x - y * floor(x / y); } float3 mod(float3 x, float3 y) { return x - y * floor(x / y); } float4 mod(float4 x, float4 y) { return x - y * floor(x / y); } void frag_main() { float2 uv = gl_FragCoord.xy; int index = int(mod(uv.x, 4.0f)); myType elt = _21[index]; if (elt.data > 0.0f) { o_color = float4(0.0f, 1.0f, 0.0f, 1.0f); } else { o_color = float4(1.0f, 0.0f, 0.0f, 1.0f); } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.o_color = o_color; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/srem.asm.frag000066400000000000000000000010251400026215700250040ustar00rootroot00000000000000static float4 FragColor; static int4 vA; static int4 vB; struct SPIRV_Cross_Input { nointerpolation int4 vA : TEXCOORD0; nointerpolation int4 vB : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = float4(vA - vB * (vA / vB)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vA = stage_input.vA; vB = stage_input.vB; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/storage-class-output-initializer.asm.frag000066400000000000000000000007261400026215700324730ustar00rootroot00000000000000static const float4 _20[2] = { float4(1.0f, 2.0f, 3.0f, 4.0f), 10.0f.xxxx }; static float4 FragColors[2] = _20; static float4 FragColor = 5.0f.xxxx; struct SPIRV_Cross_Output { float4 FragColors[2] : SV_Target0; float4 FragColor : SV_Target2; }; void frag_main() { } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColors = FragColors; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/texel-fetch-no-lod.asm.frag000066400000000000000000000011711400026215700274360ustar00rootroot00000000000000Texture2D uTexture : register(t0); SamplerState _uTexture_sampler : register(s0); static float4 gl_FragCoord; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = uTexture.Load(int3(int2(gl_FragCoord.xy), 0)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/texture-sampling-fp16.asm.frag000066400000000000000000000010761400026215700301260ustar00rootroot00000000000000Texture2D uTexture : register(t0); SamplerState _uTexture_sampler : register(s0); static min16float4 FragColor; static min16float2 UV; struct SPIRV_Cross_Input { min16float2 UV : TEXCOORD0; }; struct SPIRV_Cross_Output { min16float4 FragColor : SV_Target0; }; void frag_main() { FragColor = min16float4(uTexture.Sample(_uTexture_sampler, UV)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { UV = stage_input.UV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/unknown-depth-state.asm.frag000066400000000000000000000014621400026215700277620ustar00rootroot00000000000000Texture2D uShadow : register(t0); SamplerComparisonState _uShadow_sampler : register(s0); Texture2D uTexture : register(t1); SamplerComparisonState uSampler : register(s2); static float3 vUV; static float FragColor; struct SPIRV_Cross_Input { float3 vUV : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; float sample_combined() { return uShadow.SampleCmp(_uShadow_sampler, vUV.xy, vUV.z); } float sample_separate() { return uTexture.SampleCmp(uSampler, vUV.xy, vUV.z); } void frag_main() { FragColor = sample_combined() + sample_separate(); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/frag/unreachable.asm.frag000066400000000000000000000013131400026215700263070ustar00rootroot00000000000000static int counter; static float4 FragColor; struct SPIRV_Cross_Input { nointerpolation int counter : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; static float4 _21; void frag_main() { float4 _24; _24 = _21; float4 _33; for (;;) { if (counter == 10) { _33 = 10.0f.xxxx; break; } else { _33 = 30.0f.xxxx; break; } } FragColor = _33; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { counter = stage_input.counter; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/vert/000077500000000000000000000000001400026215700224615ustar00rootroot00000000000000extract-transposed-matrix-from-struct.asm.vert000066400000000000000000000027741400026215700335140ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl/asm/vertstruct V2F { float4 Position; float4 Color; }; struct InstanceData { column_major float4x4 MATRIX_MVP; float4 Color; }; cbuffer gInstanceData : register(b0) { InstanceData gInstanceData_1_data[32] : packoffset(c0); }; static float4 gl_Position; static int gl_InstanceIndex; static float3 PosL; static float4 _entryPointOutput_Color; struct SPIRV_Cross_Input { float3 PosL : TEXCOORD0; uint gl_InstanceIndex : SV_InstanceID; }; struct SPIRV_Cross_Output { float4 _entryPointOutput_Color : TEXCOORD0; float4 gl_Position : SV_Position; }; V2F _VS(float3 PosL_1, uint instanceID) { InstanceData instData; instData.MATRIX_MVP = gInstanceData_1_data[instanceID].MATRIX_MVP; instData.Color = gInstanceData_1_data[instanceID].Color; V2F v2f; v2f.Position = mul(float4(PosL_1, 1.0f), instData.MATRIX_MVP); v2f.Color = instData.Color; return v2f; } void vert_main() { float3 PosL_1 = PosL; uint instanceID = uint(gl_InstanceIndex); float3 param = PosL_1; uint param_1 = instanceID; V2F flattenTemp = _VS(param, param_1); gl_Position = flattenTemp.Position; _entryPointOutput_Color = flattenTemp.Color; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_InstanceIndex = int(stage_input.gl_InstanceIndex); PosL = stage_input.PosL; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output._entryPointOutput_Color = _entryPointOutput_Color; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/vert/spec-constant-op-composite.asm.vert000066400000000000000000000024161400026215700313420ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_201 #define SPIRV_CROSS_CONSTANT_ID_201 -10 #endif static const int _7 = SPIRV_CROSS_CONSTANT_ID_201; static const int _20 = (_7 + 2); #ifndef SPIRV_CROSS_CONSTANT_ID_202 #define SPIRV_CROSS_CONSTANT_ID_202 100u #endif static const uint _8 = SPIRV_CROSS_CONSTANT_ID_202; static const uint _25 = (_8 % 5u); #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 int4(20, 30, _20, _20) #endif static const int4 _30 = SPIRV_CROSS_CONSTANT_ID_0; static const int2 _32 = int2(_30.y, _30.x); static const int _33 = _30.y; #ifndef SPIRV_CROSS_CONSTANT_ID_200 #define SPIRV_CROSS_CONSTANT_ID_200 3.141590118408203125f #endif static const float _9 = SPIRV_CROSS_CONSTANT_ID_200; static float4 gl_Position; static int _4; struct SPIRV_Cross_Output { nointerpolation int _4 : TEXCOORD0; float4 gl_Position : SV_Position; }; void vert_main() { float4 pos = 0.0f.xxxx; pos.y += float(_20); pos.z += float(_25); pos += float4(_30); float2 _56 = pos.xy + float2(_32); pos = float4(_56.x, _56.y, pos.z, pos.w); gl_Position = pos; _4 = _33; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output._4 = _4; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/vert/uint-vertex-id-instance-id.asm.vert000066400000000000000000000014611400026215700312240ustar00rootroot00000000000000static float4 gl_Position; static int gl_VertexIndex; static int gl_InstanceIndex; struct SPIRV_Cross_Input { uint gl_VertexIndex : SV_VertexID; uint gl_InstanceIndex : SV_InstanceID; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; float4 _main(uint vid, uint iid) { return float(vid + iid).xxxx; } void vert_main() { uint vid = uint(gl_VertexIndex); uint iid = uint(gl_InstanceIndex); uint param = vid; uint param_1 = iid; gl_Position = _main(param, param_1); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_VertexIndex = int(stage_input.gl_VertexIndex); gl_InstanceIndex = int(stage_input.gl_InstanceIndex); vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/asm/vert/vertex-id-instance-id.asm.vert000066400000000000000000000012071400026215700302450ustar00rootroot00000000000000static float4 gl_Position; static int gl_VertexIndex; static int gl_InstanceIndex; struct SPIRV_Cross_Input { uint gl_VertexIndex : SV_VertexID; uint gl_InstanceIndex : SV_InstanceID; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = float(gl_VertexIndex + gl_InstanceIndex).xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_VertexIndex = int(stage_input.gl_VertexIndex); gl_InstanceIndex = int(stage_input.gl_InstanceIndex); vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/000077500000000000000000000000001400026215700216575ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl/comp/access-chain-load-composite.comp000066400000000000000000000127141400026215700300020ustar00rootroot00000000000000struct Baz { float c; }; struct Bar { float d[2][4]; Baz baz[2]; }; struct Foo { column_major float2x2 a; float2 b; Bar c[5]; }; static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _31 : register(u0); void comp_main() { Foo _36; _36.a = asfloat(uint2x2(_31.Load(0), _31.Load(8), _31.Load(4), _31.Load(12))); _36.b = asfloat(_31.Load2(16)); [unroll] for (int _4ident = 0; _4ident < 5; _4ident++) { [unroll] for (int _5ident = 0; _5ident < 2; _5ident++) { [unroll] for (int _6ident = 0; _6ident < 4; _6ident++) { _36.c[_4ident].d[_5ident][_6ident] = asfloat(_31.Load(_6ident * 4 + _5ident * 16 + _4ident * 40 + 24)); } } [unroll] for (int _7ident = 0; _7ident < 2; _7ident++) { _36.c[_4ident].baz[_7ident].c = asfloat(_31.Load(_7ident * 4 + _4ident * 40 + 56)); } } Foo f; f.a = _36.a; f.b = _36.b; f.c[0].d[0][0] = _36.c[0].d[0][0]; f.c[0].d[0][1] = _36.c[0].d[0][1]; f.c[0].d[0][2] = _36.c[0].d[0][2]; f.c[0].d[0][3] = _36.c[0].d[0][3]; f.c[0].d[1][0] = _36.c[0].d[1][0]; f.c[0].d[1][1] = _36.c[0].d[1][1]; f.c[0].d[1][2] = _36.c[0].d[1][2]; f.c[0].d[1][3] = _36.c[0].d[1][3]; f.c[0].baz[0].c = _36.c[0].baz[0].c; f.c[0].baz[1].c = _36.c[0].baz[1].c; f.c[1].d[0][0] = _36.c[1].d[0][0]; f.c[1].d[0][1] = _36.c[1].d[0][1]; f.c[1].d[0][2] = _36.c[1].d[0][2]; f.c[1].d[0][3] = _36.c[1].d[0][3]; f.c[1].d[1][0] = _36.c[1].d[1][0]; f.c[1].d[1][1] = _36.c[1].d[1][1]; f.c[1].d[1][2] = _36.c[1].d[1][2]; f.c[1].d[1][3] = _36.c[1].d[1][3]; f.c[1].baz[0].c = _36.c[1].baz[0].c; f.c[1].baz[1].c = _36.c[1].baz[1].c; f.c[2].d[0][0] = _36.c[2].d[0][0]; f.c[2].d[0][1] = _36.c[2].d[0][1]; f.c[2].d[0][2] = _36.c[2].d[0][2]; f.c[2].d[0][3] = _36.c[2].d[0][3]; f.c[2].d[1][0] = _36.c[2].d[1][0]; f.c[2].d[1][1] = _36.c[2].d[1][1]; f.c[2].d[1][2] = _36.c[2].d[1][2]; f.c[2].d[1][3] = _36.c[2].d[1][3]; f.c[2].baz[0].c = _36.c[2].baz[0].c; f.c[2].baz[1].c = _36.c[2].baz[1].c; f.c[3].d[0][0] = _36.c[3].d[0][0]; f.c[3].d[0][1] = _36.c[3].d[0][1]; f.c[3].d[0][2] = _36.c[3].d[0][2]; f.c[3].d[0][3] = _36.c[3].d[0][3]; f.c[3].d[1][0] = _36.c[3].d[1][0]; f.c[3].d[1][1] = _36.c[3].d[1][1]; f.c[3].d[1][2] = _36.c[3].d[1][2]; f.c[3].d[1][3] = _36.c[3].d[1][3]; f.c[3].baz[0].c = _36.c[3].baz[0].c; f.c[3].baz[1].c = _36.c[3].baz[1].c; f.c[4].d[0][0] = _36.c[4].d[0][0]; f.c[4].d[0][1] = _36.c[4].d[0][1]; f.c[4].d[0][2] = _36.c[4].d[0][2]; f.c[4].d[0][3] = _36.c[4].d[0][3]; f.c[4].d[1][0] = _36.c[4].d[1][0]; f.c[4].d[1][1] = _36.c[4].d[1][1]; f.c[4].d[1][2] = _36.c[4].d[1][2]; f.c[4].d[1][3] = _36.c[4].d[1][3]; f.c[4].baz[0].c = _36.c[4].baz[0].c; f.c[4].baz[1].c = _36.c[4].baz[1].c; float2 _229 = 1.0f.xx; f.a = float2x2(f.a[0] + _229, f.a[1] + _229); f.b += 2.0f.xx; f.c[3].d[1][1] += 5.0f; _31.Store(224, asuint(f.a[0].x)); _31.Store(228, asuint(f.a[1].x)); _31.Store(232, asuint(f.a[0].y)); _31.Store(236, asuint(f.a[1].y)); _31.Store2(240, asuint(f.b)); _31.Store(248, asuint(f.c[0].d[0][0])); _31.Store(252, asuint(f.c[0].d[0][1])); _31.Store(256, asuint(f.c[0].d[0][2])); _31.Store(260, asuint(f.c[0].d[0][3])); _31.Store(264, asuint(f.c[0].d[1][0])); _31.Store(268, asuint(f.c[0].d[1][1])); _31.Store(272, asuint(f.c[0].d[1][2])); _31.Store(276, asuint(f.c[0].d[1][3])); _31.Store(280, asuint(f.c[0].baz[0].c)); _31.Store(284, asuint(f.c[0].baz[1].c)); _31.Store(288, asuint(f.c[1].d[0][0])); _31.Store(292, asuint(f.c[1].d[0][1])); _31.Store(296, asuint(f.c[1].d[0][2])); _31.Store(300, asuint(f.c[1].d[0][3])); _31.Store(304, asuint(f.c[1].d[1][0])); _31.Store(308, asuint(f.c[1].d[1][1])); _31.Store(312, asuint(f.c[1].d[1][2])); _31.Store(316, asuint(f.c[1].d[1][3])); _31.Store(320, asuint(f.c[1].baz[0].c)); _31.Store(324, asuint(f.c[1].baz[1].c)); _31.Store(328, asuint(f.c[2].d[0][0])); _31.Store(332, asuint(f.c[2].d[0][1])); _31.Store(336, asuint(f.c[2].d[0][2])); _31.Store(340, asuint(f.c[2].d[0][3])); _31.Store(344, asuint(f.c[2].d[1][0])); _31.Store(348, asuint(f.c[2].d[1][1])); _31.Store(352, asuint(f.c[2].d[1][2])); _31.Store(356, asuint(f.c[2].d[1][3])); _31.Store(360, asuint(f.c[2].baz[0].c)); _31.Store(364, asuint(f.c[2].baz[1].c)); _31.Store(368, asuint(f.c[3].d[0][0])); _31.Store(372, asuint(f.c[3].d[0][1])); _31.Store(376, asuint(f.c[3].d[0][2])); _31.Store(380, asuint(f.c[3].d[0][3])); _31.Store(384, asuint(f.c[3].d[1][0])); _31.Store(388, asuint(f.c[3].d[1][1])); _31.Store(392, asuint(f.c[3].d[1][2])); _31.Store(396, asuint(f.c[3].d[1][3])); _31.Store(400, asuint(f.c[3].baz[0].c)); _31.Store(404, asuint(f.c[3].baz[1].c)); _31.Store(408, asuint(f.c[4].d[0][0])); _31.Store(412, asuint(f.c[4].d[0][1])); _31.Store(416, asuint(f.c[4].d[0][2])); _31.Store(420, asuint(f.c[4].d[0][3])); _31.Store(424, asuint(f.c[4].d[1][0])); _31.Store(428, asuint(f.c[4].d[1][1])); _31.Store(432, asuint(f.c[4].d[1][2])); _31.Store(436, asuint(f.c[4].d[1][3])); _31.Store(440, asuint(f.c[4].baz[0].c)); _31.Store(444, asuint(f.c[4].baz[1].c)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/access-chains.comp000066400000000000000000000012161400026215700252430ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer wo : register(u1); ByteAddressBuffer ro : register(t0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { wo.Store4(gl_GlobalInvocationID.x * 64 + 272, asuint(asfloat(ro.Load4(gl_GlobalInvocationID.x * 64 + 160)))); wo.Store4(gl_GlobalInvocationID.x * 16 + 480, asuint(asfloat(ro.Load4(gl_GlobalInvocationID.x * 16 + 480)))); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/access-chains.force-uav.comp000066400000000000000000000012201400026215700271240ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer wo : register(u1); RWByteAddressBuffer ro : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { wo.Store4(gl_GlobalInvocationID.x * 64 + 272, asuint(asfloat(ro.Load4(gl_GlobalInvocationID.x * 64 + 160)))); wo.Store4(gl_GlobalInvocationID.x * 16 + 480, asuint(asfloat(ro.Load4(gl_GlobalInvocationID.x * 16 + 480)))); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/address-buffers.comp000066400000000000000000000006271400026215700256230ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer WriteOnly : register(u2); ByteAddressBuffer ReadOnly : register(t0); RWByteAddressBuffer ReadWrite : register(u1); void comp_main() { WriteOnly.Store4(0, asuint(asfloat(ReadOnly.Load4(0)))); ReadWrite.Store4(0, asuint(asfloat(ReadWrite.Load4(0)) + 10.0f.xxxx)); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/atomic.comp000066400000000000000000000046611400026215700240220ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer ssbo : register(u2); RWTexture2D uImage : register(u0); RWTexture2D iImage : register(u1); groupshared int int_atomic; groupshared uint uint_atomic; groupshared int int_atomic_array[1]; groupshared uint uint_atomic_array[1]; void comp_main() { uint _19; InterlockedAdd(uImage[int2(1, 5)], 1u, _19); uint _27; InterlockedAdd(uImage[int2(1, 5)], 1u, _27); iImage[int2(1, 6)] = int(_27).x; uint _32; InterlockedOr(uImage[int2(1, 5)], 1u, _32); uint _34; InterlockedXor(uImage[int2(1, 5)], 1u, _34); uint _36; InterlockedAnd(uImage[int2(1, 5)], 1u, _36); uint _38; InterlockedMin(uImage[int2(1, 5)], 1u, _38); uint _40; InterlockedMax(uImage[int2(1, 5)], 1u, _40); uint _44; InterlockedCompareExchange(uImage[int2(1, 5)], 10u, 2u, _44); int _47; InterlockedAdd(iImage[int2(1, 6)], 1, _47); int _49; InterlockedOr(iImage[int2(1, 6)], 1, _49); int _51; InterlockedXor(iImage[int2(1, 6)], 1, _51); int _53; InterlockedAnd(iImage[int2(1, 6)], 1, _53); int _55; InterlockedMin(iImage[int2(1, 6)], 1, _55); int _57; InterlockedMax(iImage[int2(1, 6)], 1, _57); int _61; InterlockedCompareExchange(iImage[int2(1, 5)], 10, 2, _61); uint _68; ssbo.InterlockedAdd(0, 1u, _68); uint _70; ssbo.InterlockedOr(0, 1u, _70); uint _72; ssbo.InterlockedXor(0, 1u, _72); uint _74; ssbo.InterlockedAnd(0, 1u, _74); uint _76; ssbo.InterlockedMin(0, 1u, _76); uint _78; ssbo.InterlockedMax(0, 1u, _78); uint _80; ssbo.InterlockedExchange(0, 1u, _80); uint _82; ssbo.InterlockedCompareExchange(0, 10u, 2u, _82); int _85; ssbo.InterlockedAdd(4, 1, _85); int _87; ssbo.InterlockedOr(4, 1, _87); int _89; ssbo.InterlockedXor(4, 1, _89); int _91; ssbo.InterlockedAnd(4, 1, _91); int _93; ssbo.InterlockedMin(4, 1, _93); int _95; ssbo.InterlockedMax(4, 1, _95); int _97; ssbo.InterlockedExchange(4, 1, _97); int _99; ssbo.InterlockedCompareExchange(4, 10, 2, _99); int _102; InterlockedAdd(int_atomic, 10, _102); uint _105; InterlockedAdd(uint_atomic, 10u, _105); int _110; InterlockedAdd(int_atomic_array[0], 10, _110); uint _115; InterlockedAdd(uint_atomic_array[0], 10u, _115); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/barriers.comp000066400000000000000000000022201400026215700243440ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(4u, 1u, 1u); void barrier_shared() { GroupMemoryBarrier(); } void full_barrier() { AllMemoryBarrier(); } void image_barrier() { DeviceMemoryBarrier(); } void buffer_barrier() { DeviceMemoryBarrier(); } void group_barrier() { AllMemoryBarrier(); } void barrier_shared_exec() { GroupMemoryBarrierWithGroupSync(); } void full_barrier_exec() { AllMemoryBarrier(); GroupMemoryBarrierWithGroupSync(); } void image_barrier_exec() { DeviceMemoryBarrier(); GroupMemoryBarrierWithGroupSync(); } void buffer_barrier_exec() { DeviceMemoryBarrier(); GroupMemoryBarrierWithGroupSync(); } void group_barrier_exec() { AllMemoryBarrier(); GroupMemoryBarrierWithGroupSync(); } void exec_barrier() { GroupMemoryBarrierWithGroupSync(); } void comp_main() { barrier_shared(); full_barrier(); image_barrier(); buffer_barrier(); group_barrier(); barrier_shared_exec(); full_barrier_exec(); image_barrier_exec(); buffer_barrier_exec(); group_barrier_exec(); exec_barrier(); } [numthreads(4, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/builtins.comp000066400000000000000000000017371400026215700244000ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(8u, 4u, 2u); static uint3 gl_WorkGroupID; static uint3 gl_LocalInvocationID; static uint3 gl_GlobalInvocationID; static uint gl_LocalInvocationIndex; struct SPIRV_Cross_Input { uint3 gl_WorkGroupID : SV_GroupID; uint3 gl_LocalInvocationID : SV_GroupThreadID; uint3 gl_GlobalInvocationID : SV_DispatchThreadID; uint gl_LocalInvocationIndex : SV_GroupIndex; }; void comp_main() { uint3 local_id = gl_LocalInvocationID; uint3 global_id = gl_GlobalInvocationID; uint local_index = gl_LocalInvocationIndex; uint3 work_group_size = gl_WorkGroupSize; uint3 work_group_id = gl_WorkGroupID; } [numthreads(8, 4, 2)] void main(SPIRV_Cross_Input stage_input) { gl_WorkGroupID = stage_input.gl_WorkGroupID; gl_LocalInvocationID = stage_input.gl_LocalInvocationID; gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; gl_LocalInvocationIndex = stage_input.gl_LocalInvocationIndex; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/composite-array-initialization.comp000066400000000000000000000030311400026215700306770ustar00rootroot00000000000000struct Data { float a; float b; }; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 4.0f #endif static const float X = SPIRV_CROSS_CONSTANT_ID_0; static const uint3 gl_WorkGroupSize = uint3(2u, 1u, 1u); static const Data _21 = { 1.0f, 2.0f }; static const Data _24 = { 3.0f, 4.0f }; static const Data _25[2] = { { 1.0f, 2.0f }, { 3.0f, 4.0f } }; static const Data _30 = { 3.0f, 5.0f }; RWByteAddressBuffer _61 : register(u0); static uint3 gl_WorkGroupID; static uint3 gl_LocalInvocationID; static uint gl_LocalInvocationIndex; struct SPIRV_Cross_Input { uint3 gl_WorkGroupID : SV_GroupID; uint3 gl_LocalInvocationID : SV_GroupThreadID; uint gl_LocalInvocationIndex : SV_GroupIndex; }; static Data data[2]; static Data data2[2]; Data combine(Data a, Data b) { Data _46 = { a.a + b.a, a.b + b.b }; return _46; } void comp_main() { data = _25; Data _28 = { X, 2.0f }; Data _31[2] = { _28, _30 }; data2 = _31; if (gl_LocalInvocationIndex == 0u) { Data param = data[gl_LocalInvocationID.x]; Data param_1 = data2[gl_LocalInvocationID.x]; Data _79 = combine(param, param_1); _61.Store(gl_WorkGroupID.x * 8 + 0, asuint(_79.a)); _61.Store(gl_WorkGroupID.x * 8 + 4, asuint(_79.b)); } } [numthreads(2, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_WorkGroupID = stage_input.gl_WorkGroupID; gl_LocalInvocationID = stage_input.gl_LocalInvocationID; gl_LocalInvocationIndex = stage_input.gl_LocalInvocationIndex; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/globallycoherent.comp000066400000000000000000000007511400026215700260770ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); globallycoherent RWByteAddressBuffer _29 : register(u3); ByteAddressBuffer _33 : register(t2); RWTexture2D uImageIn : register(u0); globallycoherent RWTexture2D uImageOut : register(u1); void comp_main() { int2 coord = int2(9, 7); float4 indata = uImageIn[coord].xxxx; uImageOut[coord] = indata.x; _29.Store(0, asuint(asfloat(_33.Load(0)))); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/image.comp000066400000000000000000000062171400026215700236270ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWTexture2D uImageInF : register(u0); RWTexture2D uImageOutF : register(u1); RWTexture2D uImageInI : register(u2); RWTexture2D uImageOutI : register(u3); RWTexture2D uImageInU : register(u4); RWTexture2D uImageOutU : register(u5); RWBuffer uImageInBuffer : register(u6); RWBuffer uImageOutBuffer : register(u7); RWTexture2D uImageInF2 : register(u8); RWTexture2D uImageOutF2 : register(u9); RWTexture2D uImageInI2 : register(u10); RWTexture2D uImageOutI2 : register(u11); RWTexture2D uImageInU2 : register(u12); RWTexture2D uImageOutU2 : register(u13); RWBuffer uImageInBuffer2 : register(u14); RWBuffer uImageOutBuffer2 : register(u15); RWTexture2D uImageInF4 : register(u16); RWTexture2D uImageOutF4 : register(u17); RWTexture2D uImageInI4 : register(u18); RWTexture2D uImageOutI4 : register(u19); RWTexture2D uImageInU4 : register(u20); RWTexture2D uImageOutU4 : register(u21); RWBuffer uImageInBuffer4 : register(u22); RWBuffer uImageOutBuffer4 : register(u23); RWTexture2D uImageNoFmtF : register(u24); RWTexture2D uImageNoFmtU : register(u25); RWTexture2D uImageNoFmtI : register(u26); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { float4 f = uImageInF[int2(gl_GlobalInvocationID.xy)].xxxx; uImageOutF[int2(gl_GlobalInvocationID.xy)] = f.x; int4 i = uImageInI[int2(gl_GlobalInvocationID.xy)].xxxx; uImageOutI[int2(gl_GlobalInvocationID.xy)] = i.x; uint4 u = uImageInU[int2(gl_GlobalInvocationID.xy)].xxxx; uImageOutU[int2(gl_GlobalInvocationID.xy)] = u.x; float4 b = uImageInBuffer[int(gl_GlobalInvocationID.x)].xxxx; uImageOutBuffer[int(gl_GlobalInvocationID.x)] = b.x; float4 f2 = uImageInF2[int2(gl_GlobalInvocationID.xy)].xyyy; uImageOutF2[int2(gl_GlobalInvocationID.xy)] = f2.xy; int4 i2 = uImageInI2[int2(gl_GlobalInvocationID.xy)].xyyy; uImageOutI2[int2(gl_GlobalInvocationID.xy)] = i2.xy; uint4 u2 = uImageInU2[int2(gl_GlobalInvocationID.xy)].xyyy; uImageOutU2[int2(gl_GlobalInvocationID.xy)] = u2.xy; float4 b2 = uImageInBuffer2[int(gl_GlobalInvocationID.x)].xyyy; uImageOutBuffer2[int(gl_GlobalInvocationID.x)] = b2.xy; float4 f4 = uImageInF4[int2(gl_GlobalInvocationID.xy)]; uImageOutF4[int2(gl_GlobalInvocationID.xy)] = f4; int4 i4 = uImageInI4[int2(gl_GlobalInvocationID.xy)]; uImageOutI4[int2(gl_GlobalInvocationID.xy)] = i4; uint4 u4 = uImageInU4[int2(gl_GlobalInvocationID.xy)]; uImageOutU4[int2(gl_GlobalInvocationID.xy)] = u4; float4 b4 = uImageInBuffer4[int(gl_GlobalInvocationID.x)]; uImageOutBuffer4[int(gl_GlobalInvocationID.x)] = b4; uImageNoFmtF[int2(gl_GlobalInvocationID.xy)] = b2; uImageNoFmtU[int2(gl_GlobalInvocationID.xy)] = u4; uImageNoFmtI[int2(gl_GlobalInvocationID.xy)] = i4; } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/image.nonwritable-uav-texture.comp000066400000000000000000000061231400026215700304350ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); Texture2D uImageInF : register(t0); RWTexture2D uImageOutF : register(u1); Texture2D uImageInI : register(t2); RWTexture2D uImageOutI : register(u3); Texture2D uImageInU : register(t4); RWTexture2D uImageOutU : register(u5); Buffer uImageInBuffer : register(t6); RWBuffer uImageOutBuffer : register(u7); Texture2D uImageInF2 : register(t8); RWTexture2D uImageOutF2 : register(u9); Texture2D uImageInI2 : register(t10); RWTexture2D uImageOutI2 : register(u11); Texture2D uImageInU2 : register(t12); RWTexture2D uImageOutU2 : register(u13); Buffer uImageInBuffer2 : register(t14); RWBuffer uImageOutBuffer2 : register(u15); Texture2D uImageInF4 : register(t16); RWTexture2D uImageOutF4 : register(u17); Texture2D uImageInI4 : register(t18); RWTexture2D uImageOutI4 : register(u19); Texture2D uImageInU4 : register(t20); RWTexture2D uImageOutU4 : register(u21); Buffer uImageInBuffer4 : register(t22); RWBuffer uImageOutBuffer4 : register(u23); RWTexture2D uImageNoFmtF : register(u24); RWTexture2D uImageNoFmtU : register(u25); RWTexture2D uImageNoFmtI : register(u26); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { float4 f = uImageInF[int2(gl_GlobalInvocationID.xy)]; uImageOutF[int2(gl_GlobalInvocationID.xy)] = f.x; int4 i = uImageInI[int2(gl_GlobalInvocationID.xy)]; uImageOutI[int2(gl_GlobalInvocationID.xy)] = i.x; uint4 u = uImageInU[int2(gl_GlobalInvocationID.xy)]; uImageOutU[int2(gl_GlobalInvocationID.xy)] = u.x; float4 b = uImageInBuffer[int(gl_GlobalInvocationID.x)]; uImageOutBuffer[int(gl_GlobalInvocationID.x)] = b.x; float4 f2 = uImageInF2[int2(gl_GlobalInvocationID.xy)]; uImageOutF2[int2(gl_GlobalInvocationID.xy)] = f2.xy; int4 i2 = uImageInI2[int2(gl_GlobalInvocationID.xy)]; uImageOutI2[int2(gl_GlobalInvocationID.xy)] = i2.xy; uint4 u2 = uImageInU2[int2(gl_GlobalInvocationID.xy)]; uImageOutU2[int2(gl_GlobalInvocationID.xy)] = u2.xy; float4 b2 = uImageInBuffer2[int(gl_GlobalInvocationID.x)]; uImageOutBuffer2[int(gl_GlobalInvocationID.x)] = b2.xy; float4 f4 = uImageInF4[int2(gl_GlobalInvocationID.xy)]; uImageOutF4[int2(gl_GlobalInvocationID.xy)] = f4; int4 i4 = uImageInI4[int2(gl_GlobalInvocationID.xy)]; uImageOutI4[int2(gl_GlobalInvocationID.xy)] = i4; uint4 u4 = uImageInU4[int2(gl_GlobalInvocationID.xy)]; uImageOutU4[int2(gl_GlobalInvocationID.xy)] = u4; float4 b4 = uImageInBuffer4[int(gl_GlobalInvocationID.x)]; uImageOutBuffer4[int(gl_GlobalInvocationID.x)] = b4; uImageNoFmtF[int2(gl_GlobalInvocationID.xy)] = b2; uImageNoFmtU[int2(gl_GlobalInvocationID.xy)] = u4; uImageNoFmtI[int2(gl_GlobalInvocationID.xy)] = i4; } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/inverse.comp000066400000000000000000000135051400026215700242160ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _15 : register(u0); ByteAddressBuffer _20 : register(t1); // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. float2x2 spvInverse(float2x2 m) { float2x2 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = m[1][1]; adj[0][1] = -m[0][1]; adj[1][0] = -m[1][0]; adj[1][1] = m[0][0]; // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the determinant of a 2x2 matrix. float spvDet2x2(float a1, float a2, float b1, float b2) { return a1 * b2 - b1 * a2; } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. float3x3 spvInverse(float3x3 m) { float3x3 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]); adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]); adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]); adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]); adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]); adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]); adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]); adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]); adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the determinant of a 3x3 matrix. float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) { return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3); } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. float4x4 spvInverse(float4x4 m) { float4x4 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]); adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]); adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]); adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]); adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]); adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]); adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]); adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] * m[3][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } void comp_main() { float2x2 _23 = asfloat(uint2x2(_20.Load2(0), _20.Load2(8))); float2x2 _24 = spvInverse(_23); _15.Store2(0, asuint(_24[0])); _15.Store2(8, asuint(_24[1])); float3x3 _29 = asfloat(uint3x3(_20.Load3(16), _20.Load3(32), _20.Load3(48))); float3x3 _30 = spvInverse(_29); _15.Store3(16, asuint(_30[0])); _15.Store3(32, asuint(_30[1])); _15.Store3(48, asuint(_30[2])); float4x4 _35 = asfloat(uint4x4(_20.Load4(64), _20.Load4(80), _20.Load4(96), _20.Load4(112))); float4x4 _36 = spvInverse(_35); _15.Store4(64, asuint(_36[0])); _15.Store4(80, asuint(_36[1])); _15.Store4(96, asuint(_36[2])); _15.Store4(112, asuint(_36[3])); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/num-workgroups-alone.comp000066400000000000000000000005331400026215700266530ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _10 : register(u0); cbuffer SPIRV_Cross_NumWorkgroups : register(b0) { uint3 SPIRV_Cross_NumWorkgroups_1_count : packoffset(c0); }; void comp_main() { _10.Store3(0, SPIRV_Cross_NumWorkgroups_1_count); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/num-workgroups-with-builtins.comp000066400000000000000000000010351400026215700303550ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _10 : register(u0); cbuffer SPIRV_Cross_NumWorkgroups : register(b0) { uint3 SPIRV_Cross_NumWorkgroups_1_count : packoffset(c0); }; static uint3 gl_WorkGroupID; struct SPIRV_Cross_Input { uint3 gl_WorkGroupID : SV_GroupID; }; void comp_main() { _10.Store3(0, SPIRV_Cross_NumWorkgroups_1_count + gl_WorkGroupID); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_WorkGroupID = stage_input.gl_WorkGroupID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/outer-product.comp000066400000000000000000000054111400026215700253540ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _21 : register(u0); ByteAddressBuffer _26 : register(t1); void comp_main() { float2x2 _32 = float2x2(asfloat(_26.Load2(0)) * asfloat(_26.Load2(0)).x, asfloat(_26.Load2(0)) * asfloat(_26.Load2(0)).y); _21.Store2(0, asuint(_32[0])); _21.Store2(8, asuint(_32[1])); float2x3 _41 = float2x3(asfloat(_26.Load3(16)) * asfloat(_26.Load2(0)).x, asfloat(_26.Load3(16)) * asfloat(_26.Load2(0)).y); _21.Store3(16, asuint(_41[0])); _21.Store3(32, asuint(_41[1])); float2x4 _50 = float2x4(asfloat(_26.Load4(32)) * asfloat(_26.Load2(0)).x, asfloat(_26.Load4(32)) * asfloat(_26.Load2(0)).y); _21.Store4(48, asuint(_50[0])); _21.Store4(64, asuint(_50[1])); float3x2 _58 = float3x2(asfloat(_26.Load2(0)) * asfloat(_26.Load3(16)).x, asfloat(_26.Load2(0)) * asfloat(_26.Load3(16)).y, asfloat(_26.Load2(0)) * asfloat(_26.Load3(16)).z); _21.Store2(80, asuint(_58[0])); _21.Store2(88, asuint(_58[1])); _21.Store2(96, asuint(_58[2])); float3x3 _66 = float3x3(asfloat(_26.Load3(16)) * asfloat(_26.Load3(16)).x, asfloat(_26.Load3(16)) * asfloat(_26.Load3(16)).y, asfloat(_26.Load3(16)) * asfloat(_26.Load3(16)).z); _21.Store3(112, asuint(_66[0])); _21.Store3(128, asuint(_66[1])); _21.Store3(144, asuint(_66[2])); float3x4 _74 = float3x4(asfloat(_26.Load4(32)) * asfloat(_26.Load3(16)).x, asfloat(_26.Load4(32)) * asfloat(_26.Load3(16)).y, asfloat(_26.Load4(32)) * asfloat(_26.Load3(16)).z); _21.Store4(160, asuint(_74[0])); _21.Store4(176, asuint(_74[1])); _21.Store4(192, asuint(_74[2])); float4x2 _82 = float4x2(asfloat(_26.Load2(0)) * asfloat(_26.Load4(32)).x, asfloat(_26.Load2(0)) * asfloat(_26.Load4(32)).y, asfloat(_26.Load2(0)) * asfloat(_26.Load4(32)).z, asfloat(_26.Load2(0)) * asfloat(_26.Load4(32)).w); _21.Store2(208, asuint(_82[0])); _21.Store2(216, asuint(_82[1])); _21.Store2(224, asuint(_82[2])); _21.Store2(232, asuint(_82[3])); float4x3 _90 = float4x3(asfloat(_26.Load3(16)) * asfloat(_26.Load4(32)).x, asfloat(_26.Load3(16)) * asfloat(_26.Load4(32)).y, asfloat(_26.Load3(16)) * asfloat(_26.Load4(32)).z, asfloat(_26.Load3(16)) * asfloat(_26.Load4(32)).w); _21.Store3(240, asuint(_90[0])); _21.Store3(256, asuint(_90[1])); _21.Store3(272, asuint(_90[2])); _21.Store3(288, asuint(_90[3])); float4x4 _98 = float4x4(asfloat(_26.Load4(32)) * asfloat(_26.Load4(32)).x, asfloat(_26.Load4(32)) * asfloat(_26.Load4(32)).y, asfloat(_26.Load4(32)) * asfloat(_26.Load4(32)).z, asfloat(_26.Load4(32)) * asfloat(_26.Load4(32)).w); _21.Store4(304, asuint(_98[0])); _21.Store4(320, asuint(_98[1])); _21.Store4(336, asuint(_98[2])); _21.Store4(352, asuint(_98[3])); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/rmw-matrix.comp000066400000000000000000000012761400026215700246540ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _11 : register(u0); void comp_main() { _11.Store(0, asuint(asfloat(_11.Load(0)) * asfloat(_11.Load(96)))); _11.Store4(16, asuint(asfloat(_11.Load4(16)) * asfloat(_11.Load4(112)))); float4x4 _35 = asfloat(uint4x4(_11.Load4(128), _11.Load4(144), _11.Load4(160), _11.Load4(176))); float4x4 _37 = asfloat(uint4x4(_11.Load4(32), _11.Load4(48), _11.Load4(64), _11.Load4(80))); float4x4 _38 = mul(_35, _37); _11.Store4(32, asuint(_38[0])); _11.Store4(48, asuint(_38[1])); _11.Store4(64, asuint(_38[2])); _11.Store4(80, asuint(_38[3])); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/rwbuffer-matrix.comp000066400000000000000000000133311400026215700256640ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _28 : register(u0); cbuffer UBO : register(b1) { int _68_index0 : packoffset(c0); int _68_index1 : packoffset(c0.y); }; void row_to_col() { float4x4 _55 = asfloat(uint4x4(_28.Load(64), _28.Load(80), _28.Load(96), _28.Load(112), _28.Load(68), _28.Load(84), _28.Load(100), _28.Load(116), _28.Load(72), _28.Load(88), _28.Load(104), _28.Load(120), _28.Load(76), _28.Load(92), _28.Load(108), _28.Load(124))); _28.Store4(0, asuint(_55[0])); _28.Store4(16, asuint(_55[1])); _28.Store4(32, asuint(_55[2])); _28.Store4(48, asuint(_55[3])); float2x2 _58 = asfloat(uint2x2(_28.Load(144), _28.Load(152), _28.Load(148), _28.Load(156))); _28.Store2(128, asuint(_58[0])); _28.Store2(136, asuint(_58[1])); float2x3 _61 = asfloat(uint2x3(_28.Load(192), _28.Load(200), _28.Load(208), _28.Load(196), _28.Load(204), _28.Load(212))); _28.Store3(160, asuint(_61[0])); _28.Store3(176, asuint(_61[1])); float3x2 _64 = asfloat(uint3x2(_28.Load(240), _28.Load(256), _28.Load(244), _28.Load(260), _28.Load(248), _28.Load(264))); _28.Store2(216, asuint(_64[0])); _28.Store2(224, asuint(_64[1])); _28.Store2(232, asuint(_64[2])); } void col_to_row() { float4x4 _34 = asfloat(uint4x4(_28.Load4(0), _28.Load4(16), _28.Load4(32), _28.Load4(48))); _28.Store(64, asuint(_34[0].x)); _28.Store(68, asuint(_34[1].x)); _28.Store(72, asuint(_34[2].x)); _28.Store(76, asuint(_34[3].x)); _28.Store(80, asuint(_34[0].y)); _28.Store(84, asuint(_34[1].y)); _28.Store(88, asuint(_34[2].y)); _28.Store(92, asuint(_34[3].y)); _28.Store(96, asuint(_34[0].z)); _28.Store(100, asuint(_34[1].z)); _28.Store(104, asuint(_34[2].z)); _28.Store(108, asuint(_34[3].z)); _28.Store(112, asuint(_34[0].w)); _28.Store(116, asuint(_34[1].w)); _28.Store(120, asuint(_34[2].w)); _28.Store(124, asuint(_34[3].w)); float2x2 _40 = asfloat(uint2x2(_28.Load2(128), _28.Load2(136))); _28.Store(144, asuint(_40[0].x)); _28.Store(148, asuint(_40[1].x)); _28.Store(152, asuint(_40[0].y)); _28.Store(156, asuint(_40[1].y)); float2x3 _46 = asfloat(uint2x3(_28.Load3(160), _28.Load3(176))); _28.Store(192, asuint(_46[0].x)); _28.Store(196, asuint(_46[1].x)); _28.Store(200, asuint(_46[0].y)); _28.Store(204, asuint(_46[1].y)); _28.Store(208, asuint(_46[0].z)); _28.Store(212, asuint(_46[1].z)); float3x2 _52 = asfloat(uint3x2(_28.Load2(216), _28.Load2(224), _28.Load2(232))); _28.Store(240, asuint(_52[0].x)); _28.Store(244, asuint(_52[1].x)); _28.Store(248, asuint(_52[2].x)); _28.Store(256, asuint(_52[0].y)); _28.Store(260, asuint(_52[1].y)); _28.Store(264, asuint(_52[2].y)); } void write_dynamic_index_row() { _28.Store(_68_index0 * 4 + _68_index1 * 16 + 64, asuint(1.0f)); _28.Store(_68_index0 * 4 + _68_index1 * 8 + 144, asuint(2.0f)); _28.Store(_68_index0 * 4 + _68_index1 * 8 + 192, asuint(3.0f)); _28.Store(_68_index0 * 4 + _68_index1 * 16 + 240, asuint(4.0f)); _28.Store(_68_index0 * 4 + 64, asuint(1.0f.x)); _28.Store(_68_index0 * 4 + 80, asuint(1.0f.xxxx.y)); _28.Store(_68_index0 * 4 + 96, asuint(1.0f.xxxx.z)); _28.Store(_68_index0 * 4 + 112, asuint(1.0f.xxxx.w)); _28.Store(_68_index0 * 4 + 144, asuint(2.0f.x)); _28.Store(_68_index0 * 4 + 152, asuint(2.0f.xx.y)); _28.Store(_68_index0 * 4 + 192, asuint(3.0f.x)); _28.Store(_68_index0 * 4 + 200, asuint(3.0f.xxx.y)); _28.Store(_68_index0 * 4 + 208, asuint(3.0f.xxx.z)); _28.Store(_68_index0 * 4 + 240, asuint(4.0f.x)); _28.Store(_68_index0 * 4 + 256, asuint(4.0f.xx.y)); } void write_dynamic_index_col() { _28.Store(_68_index0 * 16 + _68_index1 * 4 + 0, asuint(1.0f)); _28.Store(_68_index0 * 8 + _68_index1 * 4 + 128, asuint(2.0f)); _28.Store(_68_index0 * 16 + _68_index1 * 4 + 160, asuint(3.0f)); _28.Store(_68_index0 * 8 + _68_index1 * 4 + 216, asuint(4.0f)); _28.Store4(_68_index0 * 16 + 0, asuint(1.0f.xxxx)); _28.Store2(_68_index0 * 8 + 128, asuint(2.0f.xx)); _28.Store3(_68_index0 * 16 + 160, asuint(3.0f.xxx)); _28.Store2(_68_index0 * 8 + 216, asuint(4.0f.xx)); } void read_dynamic_index_row() { float a0 = asfloat(_28.Load(_68_index0 * 4 + _68_index1 * 16 + 64)); float a1 = asfloat(_28.Load(_68_index0 * 4 + _68_index1 * 8 + 144)); float a2 = asfloat(_28.Load(_68_index0 * 4 + _68_index1 * 8 + 192)); float a3 = asfloat(_28.Load(_68_index0 * 4 + _68_index1 * 16 + 240)); float4 v0 = asfloat(uint4(_28.Load(_68_index0 * 4 + 64), _28.Load(_68_index0 * 4 + 80), _28.Load(_68_index0 * 4 + 96), _28.Load(_68_index0 * 4 + 112))); float2 v1 = asfloat(uint2(_28.Load(_68_index0 * 4 + 144), _28.Load(_68_index0 * 4 + 152))); float3 v2 = asfloat(uint3(_28.Load(_68_index0 * 4 + 192), _28.Load(_68_index0 * 4 + 200), _28.Load(_68_index0 * 4 + 208))); float2 v3 = asfloat(uint2(_28.Load(_68_index0 * 4 + 240), _28.Load(_68_index0 * 4 + 256))); } void read_dynamic_index_col() { float a0 = asfloat(_28.Load(_68_index0 * 16 + _68_index1 * 4 + 0)); float a1 = asfloat(_28.Load(_68_index0 * 8 + _68_index1 * 4 + 128)); float a2 = asfloat(_28.Load(_68_index0 * 16 + _68_index1 * 4 + 160)); float a3 = asfloat(_28.Load(_68_index0 * 8 + _68_index1 * 4 + 216)); float4 v0 = asfloat(_28.Load4(_68_index0 * 16 + 0)); float2 v1 = asfloat(_28.Load2(_68_index0 * 8 + 128)); float3 v2 = asfloat(_28.Load3(_68_index0 * 16 + 160)); float2 v3 = asfloat(_28.Load2(_68_index0 * 8 + 216)); } void comp_main() { row_to_col(); col_to_row(); write_dynamic_index_row(); write_dynamic_index_col(); read_dynamic_index_row(); read_dynamic_index_col(); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/scalar-std450-distance-length-normalize.comp000066400000000000000000000005501400026215700320720ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _9 : register(u0); void comp_main() { _9.Store(8, asuint(distance(asfloat(_9.Load(0)), asfloat(_9.Load(4))))); _9.Store(12, asuint(length(asfloat(_9.Load(0))))); _9.Store(16, asuint(sign(asfloat(_9.Load(0))))); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/shared.comp000066400000000000000000000015541400026215700240120ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(4u, 1u, 1u); ByteAddressBuffer _22 : register(t0); RWByteAddressBuffer _44 : register(u1); static uint3 gl_GlobalInvocationID; static uint gl_LocalInvocationIndex; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; uint gl_LocalInvocationIndex : SV_GroupIndex; }; groupshared float sShared[4]; void comp_main() { uint ident = gl_GlobalInvocationID.x; float idata = asfloat(_22.Load(ident * 4 + 0)); sShared[gl_LocalInvocationIndex] = idata; GroupMemoryBarrierWithGroupSync(); _44.Store(ident * 4 + 0, asuint(sShared[(4u - gl_LocalInvocationIndex) - 1u])); } [numthreads(4, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; gl_LocalInvocationIndex = stage_input.gl_LocalInvocationIndex; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/spec-constant-op-member-array.comp000066400000000000000000000022661400026215700303230ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 100 #endif static const int a = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 200 #endif static const int b = SPIRV_CROSS_CONSTANT_ID_1; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 300 #endif static const int c = SPIRV_CROSS_CONSTANT_ID_2; static const int d = (c + 50); #ifndef SPIRV_CROSS_CONSTANT_ID_3 #define SPIRV_CROSS_CONSTANT_ID_3 400 #endif static const int e = SPIRV_CROSS_CONSTANT_ID_3; static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _22 : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { _22.Store(gl_GlobalInvocationID.x * 4 + 2800, uint(int(_22.Load(gl_GlobalInvocationID.x * 4 + 2800)) + (int(_22.Load(gl_GlobalInvocationID.x * 4 + 2400)) + e))); } [numthreads(1, 1, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/spec-constant-work-group-size.comp000066400000000000000000000023621400026215700304050ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 2 #endif static const int b = SPIRV_CROSS_CONSTANT_ID_1; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 1 #endif static const int a = SPIRV_CROSS_CONSTANT_ID_0; static const uint _26 = (uint(a) + 0u); #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 1u #endif static const uint _27 = SPIRV_CROSS_CONSTANT_ID_10; static const uint3 gl_WorkGroupSize = uint3(_27, 20u, 1u); static const uint _32 = gl_WorkGroupSize.x; static const uint _33 = (_26 + _32); static const uint _34 = gl_WorkGroupSize.y; static const uint _35 = (_33 + _34); static const int _42 = (1 - a); RWByteAddressBuffer _23 : register(u0); static uint3 gl_GlobalInvocationID; struct SPIRV_Cross_Input { uint3 gl_GlobalInvocationID : SV_DispatchThreadID; }; void comp_main() { int spec_const_array_size[b]; spec_const_array_size[0] = 10; spec_const_array_size[1] = 40; spec_const_array_size[a] = a; _23.Store((_35 + gl_GlobalInvocationID.x) * 4 + 0, uint(b + spec_const_array_size[_42])); } [numthreads(SPIRV_CROSS_CONSTANT_ID_10, 20, 1)] void main(SPIRV_Cross_Input stage_input) { gl_GlobalInvocationID = stage_input.gl_GlobalInvocationID; comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/ssbo-array-length.comp000066400000000000000000000004271400026215700261030ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer _11 : register(u1); void comp_main() { uint _14; _11.GetDimensions(_14); _14 = (_14 - 16) / 16; _11.Store(0, uint(int(_14))); } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/comp/ssbo-array.comp000066400000000000000000000002621400026215700246210ustar00rootroot00000000000000static const uint3 gl_WorkGroupSize = uint3(1u, 1u, 1u); RWByteAddressBuffer ssbo0 : register(u0); void comp_main() { } [numthreads(1, 1, 1)] void main() { comp_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/000077500000000000000000000000001400026215700216405ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl/frag/array-lut-no-loop-variable.frag000066400000000000000000000010171400026215700275640ustar00rootroot00000000000000static const float _17[5] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; static float4 FragColor; static float4 v0; struct SPIRV_Cross_Input { float4 v0 : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { for (int i = 0; i < 4; i++, FragColor += _17[i].xxxx) { } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { v0 = stage_input.v0; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/basic-color-3comp.sm30.frag000066400000000000000000000006771400026215700265100ustar00rootroot00000000000000static float3 FragColor; static float4 vColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : COLOR0; }; void frag_main() { FragColor = vColor.xyz; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = float4(FragColor, 0.0); return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/basic-color-3comp.sm50.frag000066400000000000000000000006661400026215700265100ustar00rootroot00000000000000static float3 FragColor; static float4 vColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; }; struct SPIRV_Cross_Output { float3 FragColor : SV_Target0; }; void frag_main() { FragColor = vColor.xyz; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/basic.frag000066400000000000000000000011661400026215700235660ustar00rootroot00000000000000Texture2D uTex : register(t0); SamplerState _uTex_sampler : register(s0); static float4 FragColor; static float4 vColor; static float2 vTex; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; float2 vTex : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = vColor * uTex.Sample(_uTex_sampler, vTex); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; vTex = stage_input.vTex; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/bit-conversions.frag000066400000000000000000000007501400026215700256270ustar00rootroot00000000000000static float2 value; static float4 FragColor; struct SPIRV_Cross_Input { float2 value : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int i = asint(value.x); FragColor = float4(1.0f, 0.0f, asfloat(i), 1.0f); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { value = stage_input.value; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/boolean-mix.frag000066400000000000000000000010561400026215700247150ustar00rootroot00000000000000static float2 FragColor; static float2 x0; struct SPIRV_Cross_Input { float2 x0 : TEXCOORD0; }; struct SPIRV_Cross_Output { float2 FragColor : SV_Target0; }; void frag_main() { bool2 _27 = (x0.x > x0.y).xx; FragColor = float2(_27.x ? float2(1.0f, 0.0f).x : float2(0.0f, 1.0f).x, _27.y ? float2(1.0f, 0.0f).y : float2(0.0f, 1.0f).y); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { x0 = stage_input.x0; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/builtins.frag000066400000000000000000000013411400026215700243310ustar00rootroot00000000000000static float4 gl_FragCoord; static float gl_FragDepth; static float4 FragColor; static float4 vColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; float gl_FragDepth : SV_Depth; }; void frag_main() { FragColor = gl_FragCoord + vColor; gl_FragDepth = 0.5f; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; vColor = stage_input.vColor; frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_FragDepth = gl_FragDepth; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/bvec-operations.frag000066400000000000000000000012331400026215700256000ustar00rootroot00000000000000static float2 value; static float4 FragColor; struct SPIRV_Cross_Input { float2 value : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { bool2 _25 = bool2(value.x == 0.0f, value.y == 0.0f); bool2 bools1 = bool2(!_25.x, !_25.y); bool2 bools2 = bool2(value.x <= float2(1.5f, 0.5f).x, value.y <= float2(1.5f, 0.5f).y); FragColor = float4(1.0f, 0.0f, float(bools1.x), float(bools2.x)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { value = stage_input.value; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/clip-cull-distance.frag000066400000000000000000000013361400026215700261600ustar00rootroot00000000000000static float gl_ClipDistance[2]; static float gl_CullDistance[1]; static float FragColor; struct SPIRV_Cross_Input { float2 gl_ClipDistance0 : SV_ClipDistance0; float gl_CullDistance0 : SV_CullDistance0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = (gl_ClipDistance[0] + gl_CullDistance[0]) + gl_ClipDistance[1]; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_ClipDistance[0] = stage_input.gl_ClipDistance0.x; gl_ClipDistance[1] = stage_input.gl_ClipDistance0.y; gl_CullDistance[0] = stage_input.gl_CullDistance0.x; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/combined-texture-sampler-parameter.frag000066400000000000000000000021261400026215700313770ustar00rootroot00000000000000Texture2D uSampler : register(t0); SamplerState _uSampler_sampler : register(s0); Texture2D uSamplerShadow : register(t1); SamplerComparisonState _uSamplerShadow_sampler : register(s1); static float FragColor; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; float4 samp2(Texture2D s, SamplerState _s_sampler) { return s.Sample(_s_sampler, 1.0f.xx) + s.Load(int3(int2(10, 10), 0)); } float4 samp3(Texture2D s, SamplerState _s_sampler) { return samp2(s, _s_sampler); } float samp4(Texture2D s, SamplerComparisonState _s_sampler) { return s.SampleCmp(_s_sampler, 1.0f.xxx.xy, 1.0f.xxx.z); } float samp(Texture2D s0, SamplerState _s0_sampler, Texture2D s1, SamplerComparisonState _s1_sampler) { return samp3(s0, _s0_sampler).x + samp4(s1, _s1_sampler); } void frag_main() { FragColor = samp(uSampler, _uSampler_sampler, uSamplerShadow, _uSamplerShadow_sampler); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/combined-texture-sampler-shadow.frag000066400000000000000000000014441400026215700307060ustar00rootroot00000000000000Texture2D uDepth : register(t2); SamplerComparisonState uSampler : register(s0); SamplerState uSampler1 : register(s1); static float FragColor; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; float samp2(Texture2D t, SamplerComparisonState s) { return t.SampleCmp(s, 1.0f.xxx.xy, 1.0f.xxx.z); } float samp3(Texture2D t, SamplerState s) { return t.Sample(s, 1.0f.xx).x; } float samp(Texture2D t, SamplerComparisonState s, SamplerState s1) { float r0 = samp2(t, s); float r1 = samp3(t, s1); return r0 + r1; } void frag_main() { FragColor = samp(uDepth, uSampler, uSampler1); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/complex-expression-in-access-chain.frag000066400000000000000000000017611400026215700312750ustar00rootroot00000000000000RWByteAddressBuffer _34 : register(u0); Texture2D Buf : register(t1); SamplerState _Buf_sampler : register(s1); static float4 gl_FragCoord; static int vIn; static int vIn2; static float4 FragColor; struct SPIRV_Cross_Input { nointerpolation int vIn : TEXCOORD0; nointerpolation int vIn2 : TEXCOORD1; float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int4 coords = Buf.Load(int3(int2(gl_FragCoord.xy), 0)); float4 foo = asfloat(_34.Load4((coords.x % 16) * 16 + 0)); int c = vIn * vIn; int d = vIn2 * vIn2; FragColor = (foo + foo) + asfloat(_34.Load4((c + d) * 16 + 0)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; vIn = stage_input.vIn; vIn2 = stage_input.vIn2; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/constant-composites.frag000066400000000000000000000013621400026215700265170ustar00rootroot00000000000000struct Foo { float a; float b; }; static const float _16[4] = { 1.0f, 4.0f, 3.0f, 2.0f }; static const Foo _24 = { 10.0f, 20.0f }; static const Foo _27 = { 30.0f, 40.0f }; static const Foo _28[2] = { { 10.0f, 20.0f }, { 30.0f, 40.0f } }; static float4 FragColor; static int _line; struct SPIRV_Cross_Input { nointerpolation int _line : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = _16[_line].xxxx; FragColor += (_28[_line].a * _28[1 - _line].a).xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { _line = stage_input._line; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/control-dependent-in-branch.desktop.frag000066400000000000000000000024651400026215700314430ustar00rootroot00000000000000Texture2D uSampler : register(t0); SamplerState _uSampler_sampler : register(s0); static float4 FragColor; static float4 vInput; struct SPIRV_Cross_Input { float4 vInput : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = vInput; float4 t = uSampler.Sample(_uSampler_sampler, vInput.xy); float4 d0 = ddx(vInput); float4 d1 = ddy(vInput); float4 d2 = fwidth(vInput); float4 d3 = ddx_coarse(vInput); float4 d4 = ddy_coarse(vInput); float4 d5 = fwidth(vInput); float4 d6 = ddx_fine(vInput); float4 d7 = ddy_fine(vInput); float4 d8 = fwidth(vInput); float _56_tmp = uSampler.CalculateLevelOfDetail(_uSampler_sampler, vInput.zw); float2 _56 = _56_tmp.xx; float2 lod = _56; if (vInput.y > 10.0f) { FragColor += t; FragColor += d0; FragColor += d1; FragColor += d2; FragColor += d3; FragColor += d4; FragColor += d5; FragColor += d6; FragColor += d7; FragColor += d8; FragColor += lod.xyxy; } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vInput = stage_input.vInput; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/demote-to-helper.frag000066400000000000000000000001041400026215700256460ustar00rootroot00000000000000void frag_main() { discard; } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/depth-greater-than.frag000066400000000000000000000005101400026215700261600ustar00rootroot00000000000000static float gl_FragDepth; struct SPIRV_Cross_Output { float gl_FragDepth : SV_DepthGreaterEqual; }; void frag_main() { gl_FragDepth = 0.5f; } [earlydepthstencil] SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_FragDepth = gl_FragDepth; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/depth-less-than.frag000066400000000000000000000005051400026215700255010ustar00rootroot00000000000000static float gl_FragDepth; struct SPIRV_Cross_Output { float gl_FragDepth : SV_DepthLessEqual; }; void frag_main() { gl_FragDepth = 0.5f; } [earlydepthstencil] SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_FragDepth = gl_FragDepth; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/dual-source-blending.frag000066400000000000000000000006541400026215700265110ustar00rootroot00000000000000static float4 FragColor0; static float4 FragColor1; struct SPIRV_Cross_Output { float4 FragColor0 : SV_Target0; float4 FragColor1 : SV_Target1; }; void frag_main() { FragColor0 = 1.0f.xxxx; FragColor1 = 2.0f.xxxx; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor0 = FragColor0; stage_output.FragColor1 = FragColor1; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/early-fragment-test.frag000066400000000000000000000001131400026215700263660ustar00rootroot00000000000000void frag_main() { } [earlydepthstencil] void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/for-loop-continue-control-flow.frag000066400000000000000000000013241400026215700305030ustar00rootroot00000000000000static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = 0.0f.xxxx; int i = 0; int _36; for (;;) { if (i < 3) { int a = i; FragColor[a] += float(i); if (false) { _36 = 1; } else { int _41 = i; i = _41 + 1; _36 = _41; } continue; } else { break; } } } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/fp16-packing.frag000066400000000000000000000015571400026215700246770ustar00rootroot00000000000000static float2 FP32Out; static uint FP16; static uint FP16Out; static float2 FP32; struct SPIRV_Cross_Input { nointerpolation uint FP16 : TEXCOORD0; nointerpolation float2 FP32 : TEXCOORD1; }; struct SPIRV_Cross_Output { float2 FP32Out : SV_Target0; uint FP16Out : SV_Target1; }; uint spvPackHalf2x16(float2 value) { uint2 Packed = f32tof16(value); return Packed.x | (Packed.y << 16); } float2 spvUnpackHalf2x16(uint value) { return f16tof32(uint2(value & 0xffff, value >> 16)); } void frag_main() { FP32Out = spvUnpackHalf2x16(FP16); FP16Out = spvPackHalf2x16(FP32); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { FP16 = stage_input.FP16; FP32 = stage_input.FP32; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FP32Out = FP32Out; stage_output.FP16Out = FP16Out; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/front-facing.frag000066400000000000000000000012601400026215700250550ustar00rootroot00000000000000static bool gl_FrontFacing; static float4 FragColor; static float4 vA; static float4 vB; struct SPIRV_Cross_Input { float4 vA : TEXCOORD0; float4 vB : TEXCOORD1; bool gl_FrontFacing : SV_IsFrontFace; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { if (gl_FrontFacing) { FragColor = vA; } else { FragColor = vB; } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FrontFacing = stage_input.gl_FrontFacing; vA = stage_input.vA; vB = stage_input.vB; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/image-query-selective.frag000066400000000000000000000105121400026215700267060ustar00rootroot00000000000000Texture1D uSampler1DUint : register(t0); SamplerState _uSampler1DUint_sampler : register(s0); Texture1D uSampler1DInt : register(t0); SamplerState _uSampler1DInt_sampler : register(s0); Texture1D uSampler1DFloat : register(t0); SamplerState _uSampler1DFloat_sampler : register(s0); Texture2DArray uSampler2DArray : register(t2); SamplerState _uSampler2DArray_sampler : register(s2); Texture3D uSampler3D : register(t3); SamplerState _uSampler3D_sampler : register(s3); TextureCube uSamplerCube : register(t4); SamplerState _uSamplerCube_sampler : register(s4); TextureCubeArray uSamplerCubeArray : register(t5); SamplerState _uSamplerCubeArray_sampler : register(s5); Buffer uSamplerBuffer : register(t6); Texture2DMS uSamplerMS : register(t7); SamplerState _uSamplerMS_sampler : register(s7); Texture2DMSArray uSamplerMSArray : register(t8); SamplerState _uSamplerMSArray_sampler : register(s8); Texture2D uSampler2D : register(t1); SamplerState _uSampler2D_sampler : register(s1); uint spvTextureSize(Texture1D Tex, uint Level, out uint Param) { uint ret; Tex.GetDimensions(Level, ret.x, Param); return ret; } uint spvTextureSize(Texture1D Tex, uint Level, out uint Param) { uint ret; Tex.GetDimensions(Level, ret.x, Param); return ret; } uint spvTextureSize(Texture1D Tex, uint Level, out uint Param) { uint ret; Tex.GetDimensions(Level, ret.x, Param); return ret; } uint2 spvTextureSize(Texture2D Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(Level, ret.x, ret.y, Param); return ret; } uint3 spvTextureSize(Texture2DArray Tex, uint Level, out uint Param) { uint3 ret; Tex.GetDimensions(Level, ret.x, ret.y, ret.z, Param); return ret; } uint3 spvTextureSize(Texture3D Tex, uint Level, out uint Param) { uint3 ret; Tex.GetDimensions(Level, ret.x, ret.y, ret.z, Param); return ret; } uint spvTextureSize(Buffer Tex, uint Level, out uint Param) { uint ret; Tex.GetDimensions(ret.x); Param = 0u; return ret; } uint2 spvTextureSize(TextureCube Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(Level, ret.x, ret.y, Param); return ret; } uint3 spvTextureSize(TextureCubeArray Tex, uint Level, out uint Param) { uint3 ret; Tex.GetDimensions(Level, ret.x, ret.y, ret.z, Param); return ret; } uint2 spvTextureSize(Texture2DMS Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(ret.x, ret.y, Param); return ret; } uint3 spvTextureSize(Texture2DMSArray Tex, uint Level, out uint Param) { uint3 ret; Tex.GetDimensions(ret.x, ret.y, ret.z, Param); return ret; } void frag_main() { uint _17_dummy_parameter; int a = int(spvTextureSize(uSampler1DUint, uint(0), _17_dummy_parameter)); uint _24_dummy_parameter; a = int(spvTextureSize(uSampler1DInt, uint(0), _24_dummy_parameter)); uint _32_dummy_parameter; a = int(spvTextureSize(uSampler1DFloat, uint(0), _32_dummy_parameter)); uint _42_dummy_parameter; int3 c = int3(spvTextureSize(uSampler2DArray, uint(0), _42_dummy_parameter)); uint _50_dummy_parameter; int3 d = int3(spvTextureSize(uSampler3D, uint(0), _50_dummy_parameter)); uint _60_dummy_parameter; int2 e = int2(spvTextureSize(uSamplerCube, uint(0), _60_dummy_parameter)); uint _68_dummy_parameter; int3 f = int3(spvTextureSize(uSamplerCubeArray, uint(0), _68_dummy_parameter)); uint _76_dummy_parameter; int g = int(spvTextureSize(uSamplerBuffer, 0u, _76_dummy_parameter)); uint _84_dummy_parameter; int2 h = int2(spvTextureSize(uSamplerMS, 0u, _84_dummy_parameter)); uint _92_dummy_parameter; int3 i = int3(spvTextureSize(uSamplerMSArray, 0u, _92_dummy_parameter)); int _100; spvTextureSize(uSampler2D, 0u, _100); int l1 = int(_100); int _104; spvTextureSize(uSampler2DArray, 0u, _104); int l2 = int(_104); int _108; spvTextureSize(uSampler3D, 0u, _108); int l3 = int(_108); int _112; spvTextureSize(uSamplerCube, 0u, _112); int l4 = int(_112); int _116; spvTextureSize(uSamplerMS, 0u, _116); int s0 = int(_116); int _120; spvTextureSize(uSamplerMSArray, 0u, _120); int s1 = int(_120); } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/image-query-uav.frag000066400000000000000000000027741400026215700255310ustar00rootroot00000000000000RWTexture1D uImage1D : register(u0); RWTexture2D uImage2D : register(u1); RWTexture2DArray uImage2DArray : register(u2); RWTexture3D uImage3D : register(u3); RWBuffer uImageBuffer : register(u6); uint3 spvImageSize(RWTexture2DArray Tex, out uint Param) { uint3 ret; Tex.GetDimensions(ret.x, ret.y, ret.z); Param = 0u; return ret; } uint2 spvImageSize(RWTexture2D Tex, out uint Param) { uint2 ret; Tex.GetDimensions(ret.x, ret.y); Param = 0u; return ret; } uint spvImageSize(RWTexture1D Tex, out uint Param) { uint ret; Tex.GetDimensions(ret.x); Param = 0u; return ret; } uint3 spvImageSize(RWTexture3D Tex, out uint Param) { uint3 ret; Tex.GetDimensions(ret.x, ret.y, ret.z); Param = 0u; return ret; } uint spvImageSize(RWBuffer Tex, out uint Param) { uint ret; Tex.GetDimensions(ret.x); Param = 0u; return ret; } void frag_main() { uint _14_dummy_parameter; int a = int(spvImageSize(uImage1D, _14_dummy_parameter)); uint _22_dummy_parameter; int2 b = int2(spvImageSize(uImage2D, _22_dummy_parameter)); uint _30_dummy_parameter; int3 c = int3(spvImageSize(uImage2DArray, _30_dummy_parameter)); uint _36_dummy_parameter; int3 d = int3(spvImageSize(uImage3D, _36_dummy_parameter)); uint _42_dummy_parameter; int e = int(spvImageSize(uImageBuffer, _42_dummy_parameter)); } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/image-query-uav.nonwritable-uav-texture.frag000066400000000000000000000030141400026215700323270ustar00rootroot00000000000000RWTexture1D uImage1D : register(u0); RWTexture2D uImage2D : register(u1); Texture2DArray uImage2DArray : register(t2); RWTexture3D uImage3D : register(u3); RWBuffer uImageBuffer : register(u6); uint3 spvTextureSize(Texture2DArray Tex, uint Level, out uint Param) { uint3 ret; Tex.GetDimensions(Level, ret.x, ret.y, ret.z, Param); return ret; } uint2 spvImageSize(RWTexture2D Tex, out uint Param) { uint2 ret; Tex.GetDimensions(ret.x, ret.y); Param = 0u; return ret; } uint spvImageSize(RWTexture1D Tex, out uint Param) { uint ret; Tex.GetDimensions(ret.x); Param = 0u; return ret; } uint3 spvImageSize(RWTexture3D Tex, out uint Param) { uint3 ret; Tex.GetDimensions(ret.x, ret.y, ret.z); Param = 0u; return ret; } uint spvImageSize(RWBuffer Tex, out uint Param) { uint ret; Tex.GetDimensions(ret.x); Param = 0u; return ret; } void frag_main() { uint _14_dummy_parameter; int a = int(spvImageSize(uImage1D, _14_dummy_parameter)); uint _22_dummy_parameter; int2 b = int2(spvImageSize(uImage2D, _22_dummy_parameter)); uint _30_dummy_parameter; int3 c = int3(spvTextureSize(uImage2DArray, 0u, _30_dummy_parameter)); uint _36_dummy_parameter; int3 d = int3(spvImageSize(uImage3D, _36_dummy_parameter)); uint _42_dummy_parameter; int e = int(spvImageSize(uImageBuffer, _42_dummy_parameter)); } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/image-query.frag000066400000000000000000000076151400026215700247370ustar00rootroot00000000000000Texture1D uSampler1D : register(t0); SamplerState _uSampler1D_sampler : register(s0); Texture2D uSampler2D : register(t1); SamplerState _uSampler2D_sampler : register(s1); Texture2DArray uSampler2DArray : register(t2); SamplerState _uSampler2DArray_sampler : register(s2); Texture3D uSampler3D : register(t3); SamplerState _uSampler3D_sampler : register(s3); TextureCube uSamplerCube : register(t4); SamplerState _uSamplerCube_sampler : register(s4); TextureCubeArray uSamplerCubeArray : register(t5); SamplerState _uSamplerCubeArray_sampler : register(s5); Buffer uSamplerBuffer : register(t6); Texture2DMS uSamplerMS : register(t7); SamplerState _uSamplerMS_sampler : register(s7); Texture2DMSArray uSamplerMSArray : register(t8); SamplerState _uSamplerMSArray_sampler : register(s8); uint spvTextureSize(Texture1D Tex, uint Level, out uint Param) { uint ret; Tex.GetDimensions(Level, ret.x, Param); return ret; } uint2 spvTextureSize(Texture2D Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(Level, ret.x, ret.y, Param); return ret; } uint3 spvTextureSize(Texture2DArray Tex, uint Level, out uint Param) { uint3 ret; Tex.GetDimensions(Level, ret.x, ret.y, ret.z, Param); return ret; } uint3 spvTextureSize(Texture3D Tex, uint Level, out uint Param) { uint3 ret; Tex.GetDimensions(Level, ret.x, ret.y, ret.z, Param); return ret; } uint spvTextureSize(Buffer Tex, uint Level, out uint Param) { uint ret; Tex.GetDimensions(ret.x); Param = 0u; return ret; } uint2 spvTextureSize(TextureCube Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(Level, ret.x, ret.y, Param); return ret; } uint3 spvTextureSize(TextureCubeArray Tex, uint Level, out uint Param) { uint3 ret; Tex.GetDimensions(Level, ret.x, ret.y, ret.z, Param); return ret; } uint2 spvTextureSize(Texture2DMS Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(ret.x, ret.y, Param); return ret; } uint3 spvTextureSize(Texture2DMSArray Tex, uint Level, out uint Param) { uint3 ret; Tex.GetDimensions(ret.x, ret.y, ret.z, Param); return ret; } void frag_main() { uint _17_dummy_parameter; int a = int(spvTextureSize(uSampler1D, uint(0), _17_dummy_parameter)); uint _27_dummy_parameter; int2 b = int2(spvTextureSize(uSampler2D, uint(0), _27_dummy_parameter)); uint _37_dummy_parameter; int3 c = int3(spvTextureSize(uSampler2DArray, uint(0), _37_dummy_parameter)); uint _45_dummy_parameter; int3 d = int3(spvTextureSize(uSampler3D, uint(0), _45_dummy_parameter)); uint _53_dummy_parameter; int2 e = int2(spvTextureSize(uSamplerCube, uint(0), _53_dummy_parameter)); uint _61_dummy_parameter; int3 f = int3(spvTextureSize(uSamplerCubeArray, uint(0), _61_dummy_parameter)); uint _69_dummy_parameter; int g = int(spvTextureSize(uSamplerBuffer, 0u, _69_dummy_parameter)); uint _77_dummy_parameter; int2 h = int2(spvTextureSize(uSamplerMS, 0u, _77_dummy_parameter)); uint _85_dummy_parameter; int3 i = int3(spvTextureSize(uSamplerMSArray, 0u, _85_dummy_parameter)); int _89; spvTextureSize(uSampler1D, 0u, _89); int l0 = int(_89); int _93; spvTextureSize(uSampler2D, 0u, _93); int l1 = int(_93); int _97; spvTextureSize(uSampler2DArray, 0u, _97); int l2 = int(_97); int _101; spvTextureSize(uSampler3D, 0u, _101); int l3 = int(_101); int _105; spvTextureSize(uSamplerCube, 0u, _105); int l4 = int(_105); int _109; spvTextureSize(uSamplerCubeArray, 0u, _109); int l5 = int(_109); int _113; spvTextureSize(uSamplerMS, 0u, _113); int s0 = int(_113); int _117; spvTextureSize(uSamplerMSArray, 0u, _117); int s1 = int(_117); } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/input-attachment-ms.frag000066400000000000000000000016621400026215700264100ustar00rootroot00000000000000Texture2DMS uSubpass0 : register(t0); Texture2DMS uSubpass1 : register(t1); static float4 gl_FragCoord; static int gl_SampleID; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; uint gl_SampleID : SV_SampleIndex; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; float4 load_subpasses(Texture2DMS uInput) { float4 _24 = uInput.Load(int2(gl_FragCoord.xy), gl_SampleID); return _24; } void frag_main() { FragColor = (uSubpass0.Load(int2(gl_FragCoord.xy), 1) + uSubpass1.Load(int2(gl_FragCoord.xy), 2)) + load_subpasses(uSubpass0); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; gl_SampleID = stage_input.gl_SampleID; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/input-attachment.frag000066400000000000000000000014011400026215700257620ustar00rootroot00000000000000Texture2D uSubpass0 : register(t0); Texture2D uSubpass1 : register(t1); static float4 gl_FragCoord; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; float4 load_subpasses(Texture2D uInput) { return uInput.Load(int3(int2(gl_FragCoord.xy), 0)); } void frag_main() { FragColor = uSubpass0.Load(int3(int2(gl_FragCoord.xy), 0)) + load_subpasses(uSubpass1); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/io-block.frag000066400000000000000000000006761400026215700242110ustar00rootroot00000000000000static float4 FragColor; struct VertexOut { float4 a : TEXCOORD1; float4 b : TEXCOORD2; }; static VertexOut _12; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = _12.a + _12.b; } SPIRV_Cross_Output main(in VertexOut stage_input_12) { _12 = stage_input_12; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/legacy-tex-modifiers.sm30.frag000066400000000000000000000013141400026215700273020ustar00rootroot00000000000000uniform sampler2D uSampler; static float4 FragColor; static float2 vUV; struct SPIRV_Cross_Input { float2 vUV : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : COLOR0; }; void frag_main() { float3 _23 = float3(vUV, 5.0f); FragColor = tex2Dproj(uSampler, float4(_23.xy, 0.0, _23.z)); FragColor += tex2Dbias(uSampler, float4(vUV, 0.0, 3.0f)); FragColor += tex2Dlod(uSampler, float4(vUV, 0.0, 2.0f)); FragColor += tex2Dgrad(uSampler, vUV, 4.0f.xx, 5.0f.xx); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = float4(FragColor); return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/lut-promotion.frag000066400000000000000000000022501400026215700253300ustar00rootroot00000000000000static const float _16[16] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f }; static const float4 _60[4] = { 0.0f.xxxx, 1.0f.xxxx, 8.0f.xxxx, 5.0f.xxxx }; static const float4 _104[4] = { 20.0f.xxxx, 30.0f.xxxx, 50.0f.xxxx, 60.0f.xxxx }; static float FragColor; static int index; struct SPIRV_Cross_Input { nointerpolation int index : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = _16[index]; if (index < 10) { FragColor += _16[index ^ 1]; } else { FragColor += _16[index & 1]; } if (index > 30) { FragColor += _60[index & 3].y; } else { FragColor += _60[index & 1].x; } float4 foobar[4] = _60; if (index > 30) { foobar[1].z = 20.0f; } FragColor += foobar[index & 3].z; float4 baz[4] = _60; baz = _104; FragColor += baz[index & 3].z; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { index = stage_input.index; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/matrix-input.frag000066400000000000000000000006711400026215700251460ustar00rootroot00000000000000static float4 FragColor; static float4x4 m; struct SPIRV_Cross_Input { float4x4 m : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = ((m[0] + m[1]) + m[2]) + m[3]; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { m = stage_input.m; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/mod.frag000066400000000000000000000024521400026215700232630ustar00rootroot00000000000000static float4 a4; static float4 b4; static float3 a3; static float3 b3; static float2 a2; static float2 b2; static float a1; static float b1; static float4 FragColor; struct SPIRV_Cross_Input { float4 a4 : TEXCOORD0; float3 a3 : TEXCOORD1; float2 a2 : TEXCOORD2; float a1 : TEXCOORD3; float4 b4 : TEXCOORD4; float3 b3 : TEXCOORD5; float2 b2 : TEXCOORD6; float b1 : TEXCOORD7; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; float mod(float x, float y) { return x - y * floor(x / y); } float2 mod(float2 x, float2 y) { return x - y * floor(x / y); } float3 mod(float3 x, float3 y) { return x - y * floor(x / y); } float4 mod(float4 x, float4 y) { return x - y * floor(x / y); } void frag_main() { float4 m0 = mod(a4, b4); float3 m1 = mod(a3, b3); float2 m2 = mod(a2, b2); float m3 = mod(a1, b1); FragColor = ((m0 + m1.xyzx) + m2.xyxy) + m3.xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { a4 = stage_input.a4; b4 = stage_input.b4; a3 = stage_input.a3; b3 = stage_input.b3; a2 = stage_input.a2; b2 = stage_input.b2; a1 = stage_input.a1; b1 = stage_input.b1; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/mrt.frag000066400000000000000000000010501400026215700232770ustar00rootroot00000000000000static float4 RT0; static float4 RT1; static float4 RT2; static float4 RT3; struct SPIRV_Cross_Output { float4 RT0 : SV_Target0; float4 RT1 : SV_Target1; float4 RT2 : SV_Target2; float4 RT3 : SV_Target3; }; void frag_main() { RT0 = 1.0f.xxxx; RT1 = 2.0f.xxxx; RT2 = 3.0f.xxxx; RT3 = 4.0f.xxxx; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.RT0 = RT0; stage_output.RT1 = RT1; stage_output.RT2 = RT2; stage_output.RT3 = RT3; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/no-return.frag000066400000000000000000000000671400026215700244350ustar00rootroot00000000000000void frag_main() { } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/no-return2.frag000066400000000000000000000003411400026215700245120ustar00rootroot00000000000000static float4 vColor; struct SPIRV_Cross_Input { float4 vColor : TEXCOORD0; }; void frag_main() { float4 v = vColor; } void main(SPIRV_Cross_Input stage_input) { vColor = stage_input.vColor; frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/nonuniform-qualifier.nonuniformresource.sm51.frag000066400000000000000000000026221400026215700334010ustar00rootroot00000000000000struct UBO_1_1 { float4 v[64]; }; ConstantBuffer ubos[] : register(b0, space3); ByteAddressBuffer ssbos[] : register(t0, space4); Texture2D uSamplers[] : register(t0, space0); SamplerState uSamps[] : register(s0, space2); Texture2D uCombinedSamplers[] : register(t0, space1); SamplerState _uCombinedSamplers_sampler[] : register(s0, space1); static int vIndex; static float4 FragColor; static float2 vUV; struct SPIRV_Cross_Input { nointerpolation int vIndex : TEXCOORD0; float2 vUV : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { int i = vIndex; int _23 = i + 10; int _34 = i + 40; FragColor = uSamplers[NonUniformResourceIndex(_23)].Sample(uSamps[NonUniformResourceIndex(_34)], vUV); int _50 = i + 10; FragColor = uCombinedSamplers[NonUniformResourceIndex(_50)].Sample(_uCombinedSamplers_sampler[NonUniformResourceIndex(_50)], vUV); int _66 = i + 20; int _70 = i + 40; FragColor += ubos[NonUniformResourceIndex(_66)].v[_70]; int _84 = i + 50; int _88 = i + 60; FragColor += asfloat(ssbos[NonUniformResourceIndex(_84)].Load4(_88 * 16 + 0)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vIndex = stage_input.vIndex; vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/partial-write-preserve.frag000066400000000000000000000020211400026215700271110ustar00rootroot00000000000000struct B { float a; float b; }; static const B _80 = { 10.0f, 20.0f }; cbuffer UBO : register(b0) { int _42_some_value : packoffset(c0); }; void partial_inout(inout float4 x) { x.x = 10.0f; } void complete_inout(out float4 x) { x = 50.0f.xxxx; } void branchy_inout(inout float4 v) { v.y = 20.0f; if (_42_some_value == 20) { v = 50.0f.xxxx; } } void branchy_inout_2(out float4 v) { if (_42_some_value == 20) { v = 50.0f.xxxx; } else { v = 70.0f.xxxx; } v.y = 20.0f; } void partial_inout(inout B b) { b.b = 40.0f; } void frag_main() { float4 a = 10.0f.xxxx; float4 param = a; partial_inout(param); a = param; float4 param_1; complete_inout(param_1); a = param_1; float4 param_2 = a; branchy_inout(param_2); a = param_2; float4 param_3; branchy_inout_2(param_3); a = param_3; B b = _80; B param_4 = b; partial_inout(param_4); b = param_4; } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/pixel-interlock-ordered.sm51.fxconly.frag000066400000000000000000000014261400026215700315040ustar00rootroot00000000000000RWByteAddressBuffer _9 : register(u6, space0); globallycoherent RasterizerOrderedByteAddressBuffer _42 : register(u3, space0); RasterizerOrderedByteAddressBuffer _52 : register(u4, space0); RWTexture2D img4 : register(u5, space0); RasterizerOrderedTexture2D img : register(u0, space0); RasterizerOrderedTexture2D img3 : register(u2, space0); RasterizerOrderedTexture2D img2 : register(u1, space0); void frag_main() { _9.Store(0, uint(0)); img4[int2(1, 1)] = float4(1.0f, 0.0f, 0.0f, 1.0f); img[int2(0, 0)] = img3[int2(0, 0)]; uint _39; InterlockedAdd(img2[int2(0, 0)], 1u, _39); _42.Store(0, uint(int(_42.Load(0)) + 42)); uint _55; _42.InterlockedAnd(4, _52.Load(0), _55); } void main() { frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/point-coord-compat.frag000066400000000000000000000004541400026215700262220ustar00rootroot00000000000000static float2 FragColor; struct SPIRV_Cross_Output { float2 FragColor : SV_Target0; }; void frag_main() { FragColor = float2(0.5f, 0.5f); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/query-lod.desktop.frag000066400000000000000000000012131400026215700260670ustar00rootroot00000000000000Texture2D uSampler : register(t0); SamplerState _uSampler_sampler : register(s0); static float4 FragColor; static float2 vTexCoord; struct SPIRV_Cross_Input { float2 vTexCoord : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { float _19_tmp = uSampler.CalculateLevelOfDetail(_uSampler_sampler, vTexCoord); float2 _19 = _19_tmp.xx; FragColor = _19.xyxy; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vTexCoord = stage_input.vTexCoord; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/readonly-coherent-ssbo.force-uav.frag000066400000000000000000000005511400026215700307560ustar00rootroot00000000000000globallycoherent RWByteAddressBuffer _12 : register(u0); static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = asfloat(_12.Load4(0)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/readonly-coherent-ssbo.frag000066400000000000000000000005261400026215700270720ustar00rootroot00000000000000ByteAddressBuffer _12 : register(t0); static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = asfloat(_12.Load4(0)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/resources.frag000066400000000000000000000016121400026215700245130ustar00rootroot00000000000000cbuffer CBuffer : register(b3) { float4 cbuf_a : packoffset(c0); }; cbuffer PushMe { float4 registers_d : packoffset(c0); }; Texture2D uSampledImage : register(t4); SamplerState _uSampledImage_sampler : register(s4); Texture2D uTexture : register(t5); SamplerState uSampler : register(s6); static float2 vTex; static float4 FragColor; struct SPIRV_Cross_Input { float2 vTex : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { float4 c0 = uSampledImage.Sample(_uSampledImage_sampler, vTex); float4 c1 = uTexture.Sample(uSampler, vTex); float4 c2 = cbuf_a + registers_d; FragColor = (c0 + c1) + c2; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vTex = stage_input.vTex; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/row-major-layout-in-struct.frag000066400000000000000000000012541400026215700276610ustar00rootroot00000000000000struct NonFoo { float4x4 v; float4x4 w; }; struct Foo { row_major float4x4 v; row_major float4x4 w; }; cbuffer UBO : register(b0) { Foo _17_foo : packoffset(c0); }; static float4 FragColor; static float4 vUV; struct SPIRV_Cross_Input { float4 vUV : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { NonFoo f; f.v = _17_foo.v; f.w = _17_foo.w; FragColor = mul(mul(vUV, f.w), f.v); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUV = stage_input.vUV; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/sample-cmp-level-zero.frag000066400000000000000000000037601400026215700266270ustar00rootroot00000000000000Texture2D uSampler2D : register(t0); SamplerComparisonState _uSampler2D_sampler : register(s0); Texture2DArray uSampler2DArray : register(t1); SamplerComparisonState _uSampler2DArray_sampler : register(s1); TextureCube uSamplerCube : register(t2); SamplerComparisonState _uSamplerCube_sampler : register(s2); TextureCubeArray uSamplerCubeArray : register(t3); SamplerComparisonState _uSamplerCubeArray_sampler : register(s3); static float3 vUVRef; static float4 vDirRef; static float FragColor; struct SPIRV_Cross_Input { float3 vUVRef : TEXCOORD0; float4 vDirRef : TEXCOORD1; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { float s0 = uSampler2D.SampleCmp(_uSampler2D_sampler, vUVRef.xy, vUVRef.z, int2(-1, -1)); float s1 = uSampler2DArray.SampleCmp(_uSampler2DArray_sampler, vDirRef.xyz, vDirRef.w, int2(-1, -1)); float s2 = uSamplerCube.SampleCmp(_uSamplerCube_sampler, vDirRef.xyz, vDirRef.w); float s3 = uSamplerCubeArray.SampleCmp(_uSamplerCubeArray_sampler, vDirRef, 0.5f); float l0 = uSampler2D.SampleCmpLevelZero(_uSampler2D_sampler, vUVRef.xy, vUVRef.z, int2(-1, -1)); float l1 = uSampler2DArray.SampleCmpLevelZero(_uSampler2DArray_sampler, vDirRef.xyz, vDirRef.w, int2(-1, -1)); float l2 = uSamplerCube.SampleCmpLevelZero(_uSamplerCube_sampler, vDirRef.xyz, vDirRef.w); float4 _80 = vDirRef; _80.z = vDirRef.w; float p0 = uSampler2D.SampleCmp(_uSampler2D_sampler, _80.xy / _80.z, vDirRef.z / _80.z, int2(1, 1)); float4 _87 = vDirRef; _87.z = vDirRef.w; float p1 = uSampler2D.SampleCmpLevelZero(_uSampler2D_sampler, _87.xy / _87.z, vDirRef.z / _87.z, int2(1, 1)); FragColor = (((((((s0 + s1) + s2) + s3) + l0) + l1) + l2) + p0) + p1; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vUVRef = stage_input.vUVRef; vDirRef = stage_input.vDirRef; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/sample-mask-in-and-out.frag000066400000000000000000000011531400026215700266640ustar00rootroot00000000000000static int gl_SampleMaskIn; static int gl_SampleMask; static float4 FragColor; struct SPIRV_Cross_Input { uint gl_SampleMaskIn : SV_Coverage; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; uint gl_SampleMask : SV_Coverage; }; void frag_main() { FragColor = 1.0f.xxxx; gl_SampleMask = gl_SampleMaskIn; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_SampleMaskIn = stage_input.gl_SampleMaskIn; frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_SampleMask = gl_SampleMask; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/sample-mask-in.frag000066400000000000000000000012051400026215700253150ustar00rootroot00000000000000static int gl_SampleID; static int gl_SampleMaskIn; static float4 FragColor; struct SPIRV_Cross_Input { uint gl_SampleID : SV_SampleIndex; uint gl_SampleMaskIn : SV_Coverage; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { if ((gl_SampleMaskIn & (1 << gl_SampleID)) != 0) { FragColor = 1.0f.xxxx; } } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_SampleID = stage_input.gl_SampleID; gl_SampleMaskIn = stage_input.gl_SampleMaskIn; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/sample-mask-out.frag000066400000000000000000000006521400026215700255230ustar00rootroot00000000000000static int gl_SampleMask; static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; uint gl_SampleMask : SV_Coverage; }; void frag_main() { FragColor = 1.0f.xxxx; gl_SampleMask = 0; } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.gl_SampleMask = gl_SampleMask; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/sampler-array.frag000066400000000000000000000023711400026215700252630ustar00rootroot00000000000000Texture2D uCombined[4] : register(t0); SamplerState _uCombined_sampler[4] : register(s0); Texture2D uTex[4] : register(t4); SamplerState uSampler[4] : register(s8); RWTexture2D uImage[8] : register(u12); static float4 gl_FragCoord; static float2 vTex; static int vIndex; struct SPIRV_Cross_Input { float2 vTex : TEXCOORD0; nointerpolation int vIndex : TEXCOORD1; float4 gl_FragCoord : SV_Position; }; float4 sample_in_function(Texture2D samp, SamplerState _samp_sampler) { return samp.Sample(_samp_sampler, vTex); } float4 sample_in_function2(Texture2D tex, SamplerState samp) { return tex.Sample(samp, vTex); } void frag_main() { float4 color = uCombined[vIndex].Sample(_uCombined_sampler[vIndex], vTex); color += uTex[vIndex].Sample(uSampler[vIndex], vTex); int _72 = vIndex + 1; color += sample_in_function(uCombined[_72], _uCombined_sampler[_72]); color += sample_in_function2(uTex[vIndex + 1], uSampler[vIndex + 1]); uImage[vIndex][int2(gl_FragCoord.xy)] = color; } void main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; vTex = stage_input.vTex; vIndex = stage_input.vIndex; frag_main(); } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/sampler-image-arrays.frag000066400000000000000000000030271400026215700265250ustar00rootroot00000000000000Texture2D uSampler[4] : register(t0); SamplerState _uSampler_sampler[4] : register(s0); Texture2D uTextures[4] : register(t8); SamplerState uSamplers[4] : register(s4); static int vIndex; static float2 vTex; static float4 FragColor; struct SPIRV_Cross_Input { nointerpolation float2 vTex : TEXCOORD0; nointerpolation int vIndex : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; float4 sample_from_global() { return uSampler[vIndex].Sample(_uSampler_sampler[vIndex], vTex + 0.100000001490116119384765625f.xx); } float4 sample_from_argument(Texture2D samplers[4], SamplerState _samplers_sampler[4]) { return samplers[vIndex].Sample(_samplers_sampler[vIndex], vTex + 0.20000000298023223876953125f.xx); } float4 sample_single_from_argument(Texture2D samp, SamplerState _samp_sampler) { return samp.Sample(_samp_sampler, vTex + 0.300000011920928955078125f.xx); } void frag_main() { FragColor = 0.0f.xxxx; FragColor += uTextures[2].Sample(uSamplers[1], vTex); FragColor += uSampler[vIndex].Sample(_uSampler_sampler[vIndex], vTex); FragColor += sample_from_global(); FragColor += sample_from_argument(uSampler, _uSampler_sampler); FragColor += sample_single_from_argument(uSampler[3], _uSampler_sampler[3]); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vIndex = stage_input.vIndex; vTex = stage_input.vTex; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/scalar-refract-reflect.frag000066400000000000000000000017471400026215700270250ustar00rootroot00000000000000static float FragColor; static float3 vRefract; struct SPIRV_Cross_Input { float3 vRefract : TEXCOORD0; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; float spvReflect(float i, float n) { return i - 2.0 * dot(n, i) * n; } float spvRefract(float i, float n, float eta) { float NoI = n * i; float NoI2 = NoI * NoI; float k = 1.0 - eta * eta * (1.0 - NoI2); if (k < 0.0) { return 0.0; } else { return eta * i - (eta * NoI + sqrt(k)) * n; } } void frag_main() { FragColor = spvRefract(vRefract.x, vRefract.y, vRefract.z); FragColor += spvReflect(vRefract.x, vRefract.y); FragColor += refract(vRefract.xy, vRefract.yz, vRefract.z).y; FragColor += reflect(vRefract.xy, vRefract.zy).y; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vRefract = stage_input.vRefract; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/separate-combined-fake-overload.sm30.frag000066400000000000000000000011021400026215700313530ustar00rootroot00000000000000uniform sampler2D uSamp; uniform sampler2D SPIRV_Cross_CombineduTuS; static float4 FragColor; struct SPIRV_Cross_Output { float4 FragColor : COLOR0; }; float4 samp(sampler2D uSamp_1) { return tex2D(uSamp_1, 0.5f.xx); } float4 samp_1(sampler2D SPIRV_Cross_CombinedTS) { return tex2D(SPIRV_Cross_CombinedTS, 0.5f.xx); } void frag_main() { FragColor = samp(uSamp) + samp_1(SPIRV_Cross_CombineduTuS); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = float4(FragColor); return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/spec-constant-block-size.frag000066400000000000000000000012461400026215700273250ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 2 #endif static const int Value = SPIRV_CROSS_CONSTANT_ID_10; cbuffer SpecConstArray : register(b0) { float4 _15_samples[Value] : packoffset(c0); }; static float4 FragColor; static int Index; struct SPIRV_Cross_Input { nointerpolation int Index : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = _15_samples[Index]; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { Index = stage_input.Index; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/spec-constant-ternary.frag000066400000000000000000000007531400026215700267510ustar00rootroot00000000000000#ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 10u #endif static const uint s = SPIRV_CROSS_CONSTANT_ID_0; static const bool _13 = (s > 20u); static const uint f = _13 ? 30u : 50u; static float FragColor; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { FragColor = float(f); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/switch-unsigned-case.frag000066400000000000000000000012111400026215700265200ustar00rootroot00000000000000cbuffer Buff : register(b0) { uint _15_TestVal : packoffset(c0); }; static float4 fsout_Color; struct SPIRV_Cross_Output { float4 fsout_Color : SV_Target0; }; void frag_main() { fsout_Color = 1.0f.xxxx; switch (_15_TestVal) { case 0u: { fsout_Color = 0.100000001490116119384765625f.xxxx; break; } case 1u: { fsout_Color = 0.20000000298023223876953125f.xxxx; break; } } } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.fsout_Color = fsout_Color; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/swizzle-scalar.frag000066400000000000000000000015361400026215700254600ustar00rootroot00000000000000static float4 Float; static float vFloat; static int4 Int; static int vInt; static float4 Float2; static int4 Int2; struct SPIRV_Cross_Input { nointerpolation float vFloat : TEXCOORD0; nointerpolation int vInt : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 Float : SV_Target0; int4 Int : SV_Target1; float4 Float2 : SV_Target2; int4 Int2 : SV_Target3; }; void frag_main() { Float = vFloat.xxxx * 2.0f; Int = vInt.xxxx * int4(2, 2, 2, 2); Float2 = 10.0f.xxxx; Int2 = int4(10, 10, 10, 10); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vFloat = stage_input.vFloat; vInt = stage_input.vInt; frag_main(); SPIRV_Cross_Output stage_output; stage_output.Float = Float; stage_output.Int = Int; stage_output.Float2 = Float2; stage_output.Int2 = Int2; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/tex-sampling-ms.frag000066400000000000000000000014131400026215700255250ustar00rootroot00000000000000Texture2DMS uTex : register(t0); SamplerState _uTex_sampler : register(s0); static float4 gl_FragCoord; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = uTex.Load(int2(gl_FragCoord.xy), 0); FragColor += uTex.Load(int2(gl_FragCoord.xy), 1); FragColor += uTex.Load(int2(gl_FragCoord.xy), 2); FragColor += uTex.Load(int2(gl_FragCoord.xy), 3); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/tex-sampling.frag000066400000000000000000000116271400026215700251200ustar00rootroot00000000000000Texture1D tex1d : register(t0); SamplerState _tex1d_sampler : register(s0); Texture2D tex2d : register(t1); SamplerState _tex2d_sampler : register(s1); Texture3D tex3d : register(t2); SamplerState _tex3d_sampler : register(s2); TextureCube texCube : register(t3); SamplerState _texCube_sampler : register(s3); Texture1D tex1dShadow : register(t4); SamplerComparisonState _tex1dShadow_sampler : register(s4); Texture2D tex2dShadow : register(t5); SamplerComparisonState _tex2dShadow_sampler : register(s5); TextureCube texCubeShadow : register(t6); SamplerComparisonState _texCubeShadow_sampler : register(s6); Texture1DArray tex1dArray : register(t7); SamplerState _tex1dArray_sampler : register(s7); Texture2DArray tex2dArray : register(t8); SamplerState _tex2dArray_sampler : register(s8); TextureCubeArray texCubeArray : register(t9); SamplerState _texCubeArray_sampler : register(s9); Texture2D separateTex2d : register(t12); SamplerState samplerNonDepth : register(s11); Texture2D separateTex2dDepth : register(t13); SamplerComparisonState samplerDepth : register(s10); static float texCoord1d; static float2 texCoord2d; static float3 texCoord3d; static float4 texCoord4d; static float4 FragColor; struct SPIRV_Cross_Input { float texCoord1d : TEXCOORD0; float2 texCoord2d : TEXCOORD1; float3 texCoord3d : TEXCOORD2; float4 texCoord4d : TEXCOORD3; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { float4 texcolor = tex1d.Sample(_tex1d_sampler, texCoord1d); texcolor += tex1d.Sample(_tex1d_sampler, texCoord1d, 1); texcolor += tex1d.SampleLevel(_tex1d_sampler, texCoord1d, 2.0f); texcolor += tex1d.SampleGrad(_tex1d_sampler, texCoord1d, 1.0f, 2.0f); float2 _41 = float2(texCoord1d, 2.0f); texcolor += tex1d.Sample(_tex1d_sampler, _41.x / _41.y); texcolor += tex1d.SampleBias(_tex1d_sampler, texCoord1d, 1.0f); texcolor += tex2d.Sample(_tex2d_sampler, texCoord2d); texcolor += tex2d.Sample(_tex2d_sampler, texCoord2d, int2(1, 2)); texcolor += tex2d.SampleLevel(_tex2d_sampler, texCoord2d, 2.0f); texcolor += tex2d.SampleGrad(_tex2d_sampler, texCoord2d, float2(1.0f, 2.0f), float2(3.0f, 4.0f)); float3 _88 = float3(texCoord2d, 2.0f); texcolor += tex2d.Sample(_tex2d_sampler, _88.xy / _88.z); texcolor += tex2d.SampleBias(_tex2d_sampler, texCoord2d, 1.0f); texcolor += tex3d.Sample(_tex3d_sampler, texCoord3d); texcolor += tex3d.Sample(_tex3d_sampler, texCoord3d, int3(1, 2, 3)); texcolor += tex3d.SampleLevel(_tex3d_sampler, texCoord3d, 2.0f); texcolor += tex3d.SampleGrad(_tex3d_sampler, texCoord3d, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f)); float4 _135 = float4(texCoord3d, 2.0f); texcolor += tex3d.Sample(_tex3d_sampler, _135.xyz / _135.w); texcolor += tex3d.SampleBias(_tex3d_sampler, texCoord3d, 1.0f); texcolor += texCube.Sample(_texCube_sampler, texCoord3d); texcolor += texCube.SampleLevel(_texCube_sampler, texCoord3d, 2.0f); texcolor += texCube.SampleBias(_texCube_sampler, texCoord3d, 1.0f); float3 _170 = float3(texCoord1d, 0.0f, 0.0f); texcolor.w += tex1dShadow.SampleCmp(_tex1dShadow_sampler, _170.x, _170.z); float3 _188 = float3(texCoord2d, 0.0f); texcolor.w += tex2dShadow.SampleCmp(_tex2dShadow_sampler, _188.xy, _188.z); float4 _204 = float4(texCoord3d, 0.0f); texcolor.w += texCubeShadow.SampleCmp(_texCubeShadow_sampler, _204.xyz, _204.w); texcolor += tex1dArray.Sample(_tex1dArray_sampler, texCoord2d); texcolor += tex2dArray.Sample(_tex2dArray_sampler, texCoord3d); texcolor += texCubeArray.Sample(_texCubeArray_sampler, texCoord4d); texcolor += tex2d.GatherRed(_tex2d_sampler, texCoord2d); texcolor += tex2d.GatherRed(_tex2d_sampler, texCoord2d); texcolor += tex2d.GatherGreen(_tex2d_sampler, texCoord2d); texcolor += tex2d.GatherBlue(_tex2d_sampler, texCoord2d); texcolor += tex2d.GatherAlpha(_tex2d_sampler, texCoord2d); texcolor += tex2d.GatherRed(_tex2d_sampler, texCoord2d, int2(1, 1)); texcolor += tex2d.GatherRed(_tex2d_sampler, texCoord2d, int2(1, 1)); texcolor += tex2d.GatherGreen(_tex2d_sampler, texCoord2d, int2(1, 1)); texcolor += tex2d.GatherBlue(_tex2d_sampler, texCoord2d, int2(1, 1)); texcolor += tex2d.GatherAlpha(_tex2d_sampler, texCoord2d, int2(1, 1)); texcolor += tex2d.Load(int3(int2(1, 2), 0)); texcolor += separateTex2d.Sample(samplerNonDepth, texCoord2d); texcolor.w += separateTex2dDepth.SampleCmp(samplerDepth, texCoord3d.xy, texCoord3d.z); FragColor = texcolor; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { texCoord1d = stage_input.texCoord1d; texCoord2d = stage_input.texCoord2d; texCoord3d = stage_input.texCoord3d; texCoord4d = stage_input.texCoord4d; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/tex-sampling.sm30.frag000066400000000000000000000063111400026215700256730ustar00rootroot00000000000000uniform sampler1D tex1d; uniform sampler2D tex2d; uniform sampler3D tex3d; uniform samplerCUBE texCube; uniform sampler1D tex1dShadow; uniform sampler2D tex2dShadow; static float texCoord1d; static float2 texCoord2d; static float3 texCoord3d; static float4 FragColor; static float4 texCoord4d; struct SPIRV_Cross_Input { float texCoord1d : TEXCOORD0; float2 texCoord2d : TEXCOORD1; float3 texCoord3d : TEXCOORD2; float4 texCoord4d : TEXCOORD3; }; struct SPIRV_Cross_Output { float4 FragColor : COLOR0; }; void frag_main() { float4 texcolor = tex1D(tex1d, texCoord1d); texcolor += tex1Dlod(tex1d, float4(texCoord1d, 0.0, 0.0, 2.0f)); texcolor += tex1Dgrad(tex1d, texCoord1d, 1.0f, 2.0f); float2 _34 = float2(texCoord1d, 2.0f); texcolor += tex1Dproj(tex1d, float4(_34.x, 0.0, 0.0, _34.y)); texcolor += tex1Dbias(tex1d, float4(texCoord1d, 0.0, 0.0, 1.0f)); texcolor += tex2D(tex2d, texCoord2d); texcolor += tex2Dlod(tex2d, float4(texCoord2d, 0.0, 2.0f)); texcolor += tex2Dgrad(tex2d, texCoord2d, float2(1.0f, 2.0f), float2(3.0f, 4.0f)); float3 _73 = float3(texCoord2d, 2.0f); texcolor += tex2Dproj(tex2d, float4(_73.xy, 0.0, _73.z)); texcolor += tex2Dbias(tex2d, float4(texCoord2d, 0.0, 1.0f)); texcolor += tex3D(tex3d, texCoord3d); texcolor += tex3Dlod(tex3d, float4(texCoord3d, 2.0f)); texcolor += tex3Dgrad(tex3d, texCoord3d, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f)); float4 _112 = float4(texCoord3d, 2.0f); texcolor += tex3Dproj(tex3d, float4(_112.xyz, _112.w)); texcolor += tex3Dbias(tex3d, float4(texCoord3d, 1.0f)); texcolor += texCUBE(texCube, texCoord3d); texcolor += texCUBElod(texCube, float4(texCoord3d, 2.0f)); texcolor += texCUBEbias(texCube, float4(texCoord3d, 1.0f)); float3 _147 = float3(texCoord1d, 0.0f, 0.0f); texcolor.w += tex1Dproj(tex1dShadow, float4(_147.x, 0.0, _147.z, 1.0)).x; float3 _159 = float3(texCoord1d, 0.0f, 0.0f); texcolor.w += tex1Dlod(tex1dShadow, float4(_159.x, 0.0, _159.z, 2.0f)).x; float4 _168 = float4(texCoord1d, 0.0f, 0.0f, 2.0f); float4 _171 = _168; _171.y = _168.w; texcolor.w += tex1Dproj(tex1dShadow, float4(_171.x, 0.0, _168.z, _171.y)).x; float3 _179 = float3(texCoord1d, 0.0f, 0.0f); texcolor.w += tex1Dbias(tex1dShadow, float4(_179.x, 0.0, _179.z, 1.0f)).x; float3 _194 = float3(texCoord2d, 0.0f); texcolor.w += tex2Dproj(tex2dShadow, float4(_194.xy, _194.z, 1.0)).x; float3 _205 = float3(texCoord2d, 0.0f); texcolor.w += tex2Dlod(tex2dShadow, float4(_205.xy, _205.z, 2.0f)).x; float4 _216 = float4(texCoord2d, 0.0f, 2.0f); float4 _219 = _216; _219.z = _216.w; texcolor.w += tex2Dproj(tex2dShadow, float4(_219.xy, _216.z, _219.z)).x; float3 _229 = float3(texCoord2d, 0.0f); texcolor.w += tex2Dbias(tex2dShadow, float4(_229.xy, _229.z, 1.0f)).x; FragColor = texcolor; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { texCoord1d = stage_input.texCoord1d; texCoord2d = stage_input.texCoord2d; texCoord3d = stage_input.texCoord3d; texCoord4d = stage_input.texCoord4d; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = float4(FragColor); return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/texel-fetch-offset.frag000066400000000000000000000013221400026215700261730ustar00rootroot00000000000000Texture2D uTexture : register(t0); SamplerState _uTexture_sampler : register(s0); static float4 gl_FragCoord; static float4 FragColor; struct SPIRV_Cross_Input { float4 gl_FragCoord : SV_Position; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = uTexture.Load(int3(int2(gl_FragCoord.xy), 0), int2(1, 1)); FragColor += uTexture.Load(int3(int2(gl_FragCoord.xy), 0), int2(-1, 1)); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_FragCoord = stage_input.gl_FragCoord; gl_FragCoord.w = 1.0 / gl_FragCoord.w; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/texture-proj-shadow.frag000066400000000000000000000030561400026215700264400ustar00rootroot00000000000000Texture1D uShadow1D : register(t0); SamplerComparisonState _uShadow1D_sampler : register(s0); Texture2D uShadow2D : register(t1); SamplerComparisonState _uShadow2D_sampler : register(s1); Texture1D uSampler1D : register(t2); SamplerState _uSampler1D_sampler : register(s2); Texture2D uSampler2D : register(t3); SamplerState _uSampler2D_sampler : register(s3); Texture3D uSampler3D : register(t4); SamplerState _uSampler3D_sampler : register(s4); static float FragColor; static float4 vClip4; static float2 vClip2; static float3 vClip3; struct SPIRV_Cross_Input { float3 vClip3 : TEXCOORD0; float4 vClip4 : TEXCOORD1; float2 vClip2 : TEXCOORD2; }; struct SPIRV_Cross_Output { float FragColor : SV_Target0; }; void frag_main() { float4 _20 = vClip4; _20.y = vClip4.w; FragColor = uShadow1D.SampleCmp(_uShadow1D_sampler, _20.x / _20.y, vClip4.z / _20.y); float4 _30 = vClip4; _30.z = vClip4.w; FragColor = uShadow2D.SampleCmp(_uShadow2D_sampler, _30.xy / _30.z, vClip4.z / _30.z); FragColor = uSampler1D.Sample(_uSampler1D_sampler, vClip2.x / vClip2.y).x; FragColor = uSampler2D.Sample(_uSampler2D_sampler, vClip3.xy / vClip3.z).x; FragColor = uSampler3D.Sample(_uSampler3D_sampler, vClip4.xyz / vClip4.w).x; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vClip4 = stage_input.vClip4; vClip2 = stage_input.vClip2; vClip3 = stage_input.vClip3; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/texture-size-combined-image-sampler.frag000066400000000000000000000011121400026215700314430ustar00rootroot00000000000000Texture2D uTex : register(t0); SamplerState uSampler : register(s1); static int2 FooOut; struct SPIRV_Cross_Output { int2 FooOut : SV_Target0; }; uint2 spvTextureSize(Texture2D Tex, uint Level, out uint Param) { uint2 ret; Tex.GetDimensions(Level, ret.x, ret.y, Param); return ret; } void frag_main() { uint _23_dummy_parameter; FooOut = int2(spvTextureSize(uTex, uint(0), _23_dummy_parameter)); } SPIRV_Cross_Output main() { frag_main(); SPIRV_Cross_Output stage_output; stage_output.FooOut = FooOut; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/unary-enclose.frag000066400000000000000000000010731400026215700252660ustar00rootroot00000000000000static float4 FragColor; static float4 vIn; static int4 vIn1; struct SPIRV_Cross_Input { float4 vIn : TEXCOORD0; nointerpolation int4 vIn1 : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { FragColor = -(-vIn); int4 a = ~(~vIn1); bool b = false; b = !(!b); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vIn = stage_input.vIn; vIn1 = stage_input.vIn1; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/unorm-snorm-packing.frag000066400000000000000000000057641400026215700264230ustar00rootroot00000000000000static float4 FP32Out; static uint UNORM8; static uint SNORM8; static uint UNORM16; static uint SNORM16; static uint UNORM8Out; static float4 FP32; static uint SNORM8Out; static uint UNORM16Out; static uint SNORM16Out; struct SPIRV_Cross_Input { nointerpolation uint SNORM8 : TEXCOORD0; nointerpolation uint UNORM8 : TEXCOORD1; nointerpolation uint SNORM16 : TEXCOORD2; nointerpolation uint UNORM16 : TEXCOORD3; nointerpolation float4 FP32 : TEXCOORD4; }; struct SPIRV_Cross_Output { float4 FP32Out : SV_Target0; uint UNORM8Out : SV_Target1; uint SNORM8Out : SV_Target2; uint UNORM16Out : SV_Target3; uint SNORM16Out : SV_Target4; }; uint spvPackUnorm4x8(float4 value) { uint4 Packed = uint4(round(saturate(value) * 255.0)); return Packed.x | (Packed.y << 8) | (Packed.z << 16) | (Packed.w << 24); } float4 spvUnpackUnorm4x8(uint value) { uint4 Packed = uint4(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, value >> 24); return float4(Packed) / 255.0; } uint spvPackSnorm4x8(float4 value) { int4 Packed = int4(round(clamp(value, -1.0, 1.0) * 127.0)) & 0xff; return uint(Packed.x | (Packed.y << 8) | (Packed.z << 16) | (Packed.w << 24)); } float4 spvUnpackSnorm4x8(uint value) { int SignedValue = int(value); int4 Packed = int4(SignedValue << 24, SignedValue << 16, SignedValue << 8, SignedValue) >> 24; return clamp(float4(Packed) / 127.0, -1.0, 1.0); } uint spvPackUnorm2x16(float2 value) { uint2 Packed = uint2(round(saturate(value) * 65535.0)); return Packed.x | (Packed.y << 16); } float2 spvUnpackUnorm2x16(uint value) { uint2 Packed = uint2(value & 0xffff, value >> 16); return float2(Packed) / 65535.0; } uint spvPackSnorm2x16(float2 value) { int2 Packed = int2(round(clamp(value, -1.0, 1.0) * 32767.0)) & 0xffff; return uint(Packed.x | (Packed.y << 16)); } float2 spvUnpackSnorm2x16(uint value) { int SignedValue = int(value); int2 Packed = int2(SignedValue << 16, SignedValue) >> 16; return clamp(float2(Packed) / 32767.0, -1.0, 1.0); } void frag_main() { FP32Out = spvUnpackUnorm4x8(UNORM8); FP32Out = spvUnpackSnorm4x8(SNORM8); float2 _21 = spvUnpackUnorm2x16(UNORM16); FP32Out = float4(_21.x, _21.y, FP32Out.z, FP32Out.w); float2 _26 = spvUnpackSnorm2x16(SNORM16); FP32Out = float4(_26.x, _26.y, FP32Out.z, FP32Out.w); UNORM8Out = spvPackUnorm4x8(FP32); SNORM8Out = spvPackSnorm4x8(FP32); UNORM16Out = spvPackUnorm2x16(FP32.xy); SNORM16Out = spvPackSnorm2x16(FP32.zw); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { UNORM8 = stage_input.UNORM8; SNORM8 = stage_input.SNORM8; UNORM16 = stage_input.UNORM16; SNORM16 = stage_input.SNORM16; FP32 = stage_input.FP32; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FP32Out = FP32Out; stage_output.UNORM8Out = UNORM8Out; stage_output.SNORM8Out = SNORM8Out; stage_output.UNORM16Out = UNORM16Out; stage_output.SNORM16Out = SNORM16Out; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/frag/various-glsl-ops.frag000066400000000000000000000012001400026215700257200ustar00rootroot00000000000000static float2 interpolant; static float4 FragColor; struct SPIRV_Cross_Input { float2 interpolant : TEXCOORD0; }; struct SPIRV_Cross_Output { float4 FragColor : SV_Target0; }; void frag_main() { float4 color = float4(0.0f, 0.0f, 0.0f, EvaluateAttributeSnapped(interpolant, 0.100000001490116119384765625f.xx).x); color += float4(0.0f, 0.0f, 0.0f, ddx_coarse(interpolant.x)); FragColor = color; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { interpolant = stage_input.interpolant; frag_main(); SPIRV_Cross_Output stage_output; stage_output.FragColor = FragColor; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/000077500000000000000000000000001400026215700217015ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-hlsl/vert/basic.vert000066400000000000000000000013611400026215700236650ustar00rootroot00000000000000cbuffer UBO : register(b0) { row_major float4x4 _16_uMVP : packoffset(c0); }; static float4 gl_Position; static float4 aVertex; static float3 vNormal; static float3 aNormal; struct SPIRV_Cross_Input { float4 aVertex : TEXCOORD0; float3 aNormal : TEXCOORD1; }; struct SPIRV_Cross_Output { float3 vNormal : TEXCOORD0; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = mul(aVertex, _16_uMVP); vNormal = aNormal; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { aVertex = stage_input.aVertex; aNormal = stage_input.aNormal; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.vNormal = vNormal; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/clip-cull-distance.vert000066400000000000000000000013311400026215700262550ustar00rootroot00000000000000static float4 gl_Position; static float gl_ClipDistance[2]; static float gl_CullDistance[1]; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; float2 gl_ClipDistance0 : SV_ClipDistance0; float gl_CullDistance0 : SV_CullDistance0; }; void vert_main() { gl_Position = 1.0f.xxxx; gl_ClipDistance[0] = 0.0f; gl_ClipDistance[1] = 0.0f; gl_CullDistance[0] = 4.0f; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.gl_ClipDistance0.x = gl_ClipDistance[0]; stage_output.gl_ClipDistance0.y = gl_ClipDistance[1]; stage_output.gl_CullDistance0.x = gl_CullDistance[0]; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/instancing.vert000066400000000000000000000012071400026215700247400ustar00rootroot00000000000000static float4 gl_Position; static int gl_VertexIndex; static int gl_InstanceIndex; struct SPIRV_Cross_Input { uint gl_VertexIndex : SV_VertexID; uint gl_InstanceIndex : SV_InstanceID; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = float(gl_VertexIndex + gl_InstanceIndex).xxxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { gl_VertexIndex = int(stage_input.gl_VertexIndex); gl_InstanceIndex = int(stage_input.gl_InstanceIndex); vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/locations.vert000066400000000000000000000031711400026215700246000ustar00rootroot00000000000000struct Foo { float3 a; float3 b; float3 c; }; static float4 gl_Position; static float4 Input2; static float4 Input4; static float4 Input0; static float vLocation0; static float vLocation1; static float vLocation2[2]; static Foo vLocation4; static float vLocation9; struct VertexOut { float3 color : TEXCOORD7; float3 foo : TEXCOORD8; }; static VertexOut vout; struct SPIRV_Cross_Input { float4 Input0 : TEXCOORD0; float4 Input2 : TEXCOORD2; float4 Input4 : TEXCOORD4; }; struct SPIRV_Cross_Output { float vLocation0 : TEXCOORD0; float vLocation1 : TEXCOORD1; float vLocation2[2] : TEXCOORD2; Foo vLocation4 : TEXCOORD4; float vLocation9 : TEXCOORD9; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = ((1.0f.xxxx + Input2) + Input4) + Input0; vLocation0 = 0.0f; vLocation1 = 1.0f; vLocation2[0] = 2.0f; vLocation2[1] = 2.0f; Foo foo; foo.a = 1.0f.xxx; foo.b = 1.0f.xxx; foo.c = 1.0f.xxx; vLocation4 = foo; vLocation9 = 9.0f; vout.color = 2.0f.xxx; vout.foo = 4.0f.xxx; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input, out VertexOut stage_outputvout) { Input2 = stage_input.Input2; Input4 = stage_input.Input4; Input0 = stage_input.Input0; vert_main(); stage_outputvout = vout; SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.vLocation0 = vLocation0; stage_output.vLocation1 = vLocation1; stage_output.vLocation2 = vLocation2; stage_output.vLocation4 = vLocation4; stage_output.vLocation9 = vLocation9; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/matrix-attribute.vert000066400000000000000000000012771400026215700261170ustar00rootroot00000000000000static float4 gl_Position; static float4x4 m; static float3 pos; struct SPIRV_Cross_Input { float3 pos : TEXCOORD0; float4 m_0 : TEXCOORD1_0; float4 m_1 : TEXCOORD1_1; float4 m_2 : TEXCOORD1_2; float4 m_3 : TEXCOORD1_3; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = mul(float4(pos, 1.0f), m); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { m[0] = stage_input.m_0; m[1] = stage_input.m_1; m[2] = stage_input.m_2; m[3] = stage_input.m_3; pos = stage_input.pos; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/matrix-output.vert000066400000000000000000000010071400026215700254430ustar00rootroot00000000000000static float4 gl_Position; static float4x4 m; struct SPIRV_Cross_Output { float4x4 m : TEXCOORD0; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = 1.0f.xxxx; m = float4x4(float4(1.0f, 0.0f, 0.0f, 0.0f), float4(0.0f, 1.0f, 0.0f, 0.0f), float4(0.0f, 0.0f, 1.0f, 0.0f), float4(0.0f, 0.0f, 0.0f, 1.0f)); } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.m = m; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/no-input.vert000066400000000000000000000004551400026215700243600ustar00rootroot00000000000000static float4 gl_Position; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = 1.0f.xxxx; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/point-size-compat.vert000066400000000000000000000005411400026215700261650ustar00rootroot00000000000000static float4 gl_Position; static float gl_PointSize; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = 1.0f.xxxx; gl_PointSize = 1.0f; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/qualifiers.vert000066400000000000000000000022551400026215700247530ustar00rootroot00000000000000static float4 gl_Position; static float vFlat; static float vCentroid; static float vSample; static float vNoperspective; struct Block { nointerpolation float vFlat : TEXCOORD4; centroid float vCentroid : TEXCOORD5; sample float vSample : TEXCOORD6; noperspective float vNoperspective : TEXCOORD7; }; static Block vout; struct SPIRV_Cross_Output { nointerpolation float vFlat : TEXCOORD0; centroid float vCentroid : TEXCOORD1; sample float vSample : TEXCOORD2; noperspective float vNoperspective : TEXCOORD3; float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = 1.0f.xxxx; vFlat = 0.0f; vCentroid = 1.0f; vSample = 2.0f; vNoperspective = 3.0f; vout.vFlat = 0.0f; vout.vCentroid = 1.0f; vout.vSample = 2.0f; vout.vNoperspective = 3.0f; } SPIRV_Cross_Output main(out Block stage_outputvout) { vert_main(); stage_outputvout = vout; SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.vFlat = vFlat; stage_output.vCentroid = vCentroid; stage_output.vSample = vSample; stage_output.vNoperspective = vNoperspective; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/read-from-row-major-array.vert000066400000000000000000000027661400026215700275210ustar00rootroot00000000000000cbuffer Block : register(b0) { column_major float2x3 _104_var[3][4] : packoffset(c0); }; static float4 gl_Position; static float4 a_position; static float v_vtxResult; struct SPIRV_Cross_Input { float4 a_position : TEXCOORD0; }; struct SPIRV_Cross_Output { float v_vtxResult : TEXCOORD0; float4 gl_Position : SV_Position; }; float compare_float(float a, float b) { return float(abs(a - b) < 0.0500000007450580596923828125f); } float compare_vec3(float3 a, float3 b) { float param = a.x; float param_1 = b.x; float param_2 = a.y; float param_3 = b.y; float param_4 = a.z; float param_5 = b.z; return (compare_float(param, param_1) * compare_float(param_2, param_3)) * compare_float(param_4, param_5); } float compare_mat2x3(float2x3 a, float2x3 b) { float3 param = a[0]; float3 param_1 = b[0]; float3 param_2 = a[1]; float3 param_3 = b[1]; return compare_vec3(param, param_1) * compare_vec3(param_2, param_3); } void vert_main() { gl_Position = a_position; float result = 1.0f; float2x3 param = _104_var[0][0]; float2x3 param_1 = float2x3(float3(2.0f, 6.0f, -6.0f), float3(0.0f, 5.0f, 5.0f)); result *= compare_mat2x3(param, param_1); v_vtxResult = result; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { a_position = stage_input.a_position; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; stage_output.v_vtxResult = v_vtxResult; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/return-array.vert000066400000000000000000000015751400026215700252460ustar00rootroot00000000000000static const float4 _20[2] = { 10.0f.xxxx, 20.0f.xxxx }; static float4 gl_Position; static float4 vInput0; static float4 vInput1; struct SPIRV_Cross_Input { float4 vInput0 : TEXCOORD0; float4 vInput1 : TEXCOORD1; }; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void test(out float4 spvReturnValue[2]) { spvReturnValue = _20; } void test2(out float4 spvReturnValue[2]) { float4 foobar[2]; foobar[0] = vInput0; foobar[1] = vInput1; spvReturnValue = foobar; } void vert_main() { float4 _42[2]; test(_42); float4 _44[2]; test2(_44); gl_Position = _42[0] + _44[1]; } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { vInput0 = stage_input.vInput0; vInput1 = stage_input.vInput1; vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/sampler-buffers.vert000066400000000000000000000012031400026215700256740ustar00rootroot00000000000000Buffer uFloatSampler : register(t1); Buffer uIntSampler : register(t2); Buffer uUintSampler : register(t3); static float4 gl_Position; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; float4 sample_from_function(Buffer s0, Buffer s1, Buffer s2) { return (s0.Load(20) + asfloat(s1.Load(40))) + asfloat(s2.Load(60)); } void vert_main() { gl_Position = sample_from_function(uFloatSampler, uIntSampler, uUintSampler); } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/struct-composite-decl.vert000066400000000000000000000013661400026215700270420ustar00rootroot00000000000000struct VOut { float4 a; float4 b; float4 c; float4 d; }; static VOut vout; static float4 a; static float4 b; static float4 c; static float4 d; struct SPIRV_Cross_Input { float4 a : TEXCOORD0; float4 b : TEXCOORD1; float4 c : TEXCOORD2; float4 d : TEXCOORD3; }; struct SPIRV_Cross_Output { VOut vout : TEXCOORD0; }; void emit_result(VOut v) { vout = v; } void vert_main() { VOut _26 = { a, b, c, d }; VOut param = _26; emit_result(param); } SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input) { a = stage_input.a; b = stage_input.b; c = stage_input.c; d = stage_input.d; vert_main(); SPIRV_Cross_Output stage_output; stage_output.vout = vout; return stage_output; } spirv-cross-2021.01.15/reference/shaders-hlsl/vert/texture_buffer.vert000066400000000000000000000006161400026215700256370ustar00rootroot00000000000000Buffer uSamp : register(t4); RWBuffer uSampo : register(u5); static float4 gl_Position; struct SPIRV_Cross_Output { float4 gl_Position : SV_Position; }; void vert_main() { gl_Position = uSamp.Load(10) + uSampo[100]; } SPIRV_Cross_Output main() { vert_main(); SPIRV_Cross_Output stage_output; stage_output.gl_Position = gl_Position; return stage_output; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/000077500000000000000000000000001400026215700217645ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/000077500000000000000000000000001400026215700225445ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/000077500000000000000000000000001400026215700235025ustar00rootroot00000000000000aliased-struct-divergent-member-name.asm.comp000066400000000000000000000006441400026215700341620ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp#include #include using namespace metal; struct T { float a; }; struct T_1 { float b; }; struct SSBO1 { T_1 foo[1]; }; struct T_2 { float c; char _m0_final_padding[12]; }; struct SSBO2 { T_2 bar[1]; }; kernel void main0(device SSBO1& _7 [[buffer(0)]], device SSBO2& _10 [[buffer(1)]]) { T v = T{ 40.0 }; _7.foo[10].b = v.a; _10.bar[30].c = v.a; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/arithmetic-conversion-signs.asm.comp000066400000000000000000000015241400026215700326000ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { int s32; uint u32; short s16; ushort u16; float f32; }; kernel void main0(device SSBO& _4 [[buffer(0)]]) { int _29 = _4.s32; uint _30 = _4.u32; short _31 = _4.s16; ushort _32 = _4.u16; float _33 = _4.f32; _4.s32 = int(_31); _4.u32 = uint(_31); _4.s32 = int(short(_32)); _4.u32 = uint(short(_32)); _4.u32 = uint(ushort(_31)); _4.u32 = uint(_32); _4.s16 = short(_29); _4.u16 = ushort(_29); _4.s16 = short(_30); _4.u16 = ushort(_30); _4.u16 = ushort(_29); _4.u16 = ushort(_30); _4.f32 = float(_31); _4.f32 = float(short(_32)); _4.f32 = float(ushort(_31)); _4.f32 = float(_32); _4.s16 = short(_33); _4.u16 = ushort(short(_33)); _4.u16 = ushort(_33); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/atomic-load-store.asm.comp000066400000000000000000000007561400026215700304740ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { uint a; uint b; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _5 [[buffer(0)]]) { uint _20 = atomic_load_explicit((device atomic_uint*)&_5.b, memory_order_relaxed); uint c = _20; atomic_store_explicit((device atomic_uint*)&_5.a, c, memory_order_relaxed); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/atomic-result-temporary.asm.comp000066400000000000000000000007561400026215700317610ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { uint count; uint data[1]; }; kernel void main0(device SSBO& _5 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint _24 = atomic_fetch_add_explicit((device atomic_uint*)&_5.count, 1u, memory_order_relaxed); if (_24 < 1024u) { _5.data[_24] = gl_GlobalInvocationID.x; } } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/bitcast-fp16-fp32.asm.comp000066400000000000000000000005051400026215700301140ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { half2 a; float b; float c; half2 d; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _4 [[buffer(0)]]) { _4.b = as_type(_4.a); _4.d = as_type(_4.c); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/bitfield-signed-operations.asm.comp000066400000000000000000000013611400026215700323540ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { int4 ints; uint4 uints; }; kernel void main0(device SSBO& _3 [[buffer(0)]]) { int4 _19 = _3.ints; uint4 _20 = _3.uints; _3.ints = popcount(_19); _3.uints = uint4(popcount(_19)); _3.ints = int4(popcount(_20)); _3.uints = popcount(_20); _3.ints = reverse_bits(_19); _3.uints = reverse_bits(_20); _3.ints = extract_bits(_19, uint(1), 11u); _3.uints = uint4(extract_bits(int4(_20), 11u, uint(1))); _3.ints = int4(extract_bits(uint4(_19), uint(1), 11u)); _3.uints = extract_bits(_20, 11u, uint(1)); _3.ints = insert_bits(_19, _19.wzyx, uint(1), 11u); _3.uints = insert_bits(_20, _20.wzyx, 11u, uint(1)); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/bitscan.asm.comp000066400000000000000000000022771400026215700265740ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { uint4 u; int4 i; }; // Implementation of the GLSL findLSB() function template inline T spvFindLSB(T x) { return select(ctz(x), T(-1), x == T(0)); } // Implementation of the signed GLSL findMSB() function template inline T spvFindSMSB(T x) { T v = select(x, T(-1) - x, x < T(0)); return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0)); } // Implementation of the unsigned GLSL findMSB() function template inline T spvFindUMSB(T x) { return select(clz(T(0)) - (clz(x) + T(1)), T(-1), x == T(0)); } kernel void main0(device SSBO& _4 [[buffer(0)]]) { uint4 _19 = _4.u; int4 _20 = _4.i; _4.u = spvFindLSB(_19); _4.i = int4(spvFindLSB(_19)); _4.u = uint4(spvFindLSB(_20)); _4.i = spvFindLSB(_20); _4.u = spvFindUMSB(_19); _4.i = int4(spvFindUMSB(_19)); _4.u = spvFindUMSB(uint4(_20)); _4.i = int4(spvFindUMSB(uint4(_20))); _4.u = uint4(spvFindSMSB(int4(_19))); _4.i = spvFindSMSB(int4(_19)); _4.u = uint4(spvFindSMSB(_20)); _4.i = spvFindSMSB(_20); } composite-construct-buffer-struct.asm.comp000066400000000000000000000005611400026215700337010ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp#include #include using namespace metal; struct Block { uint2 _m0[2]; uint2 _m1[2]; }; struct SSBO { Block _m0[3]; }; kernel void main0(device SSBO& ssbo [[buffer(0)]]) { threadgroup uint2 _18[2]; ssbo._m0[0u] = Block{ { ssbo._m0[0u]._m1[0], ssbo._m0[0u]._m1[1] }, { ssbo._m0[0u]._m1[0], ssbo._m0[0u]._m1[1] } }; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/constant-composite-undef.asm.comp000066400000000000000000000004611400026215700320720ustar00rootroot00000000000000#include #include using namespace metal; struct Block { float4 f; }; constant float _15 = {}; kernel void main0(device Block& block [[buffer(0)]]) { block.f = float4(0.100000001490116119384765625, 0.20000000298023223876953125, 0.300000011920928955078125, 0.0); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/copy-logical-2.spv14.asm.comp000066400000000000000000000015541400026215700306430ustar00rootroot00000000000000#include #include using namespace metal; struct _11 { float2x2 _m0; }; struct _12 { float2x4 _m0; }; struct B2 { float4 elem2; }; struct C { float4 c; B2 b2; B2 b2_array[4]; _12 _m3; }; struct B1 { float4 elem1; }; struct A { float4 a; B1 b1; B1 b1_array[4]; _11 _m3; }; struct _8 { A a_block; C c_block; }; kernel void main0(device _8& _3 [[buffer(0)]]) { A _31; _31.a = _3.c_block.c; _31.b1.elem1 = _3.c_block.b2.elem2; _31.b1_array[0].elem1 = _3.c_block.b2_array[0].elem2; _31.b1_array[1].elem1 = _3.c_block.b2_array[1].elem2; _31.b1_array[2].elem1 = _3.c_block.b2_array[2].elem2; _31.b1_array[3].elem1 = _3.c_block.b2_array[3].elem2; _31._m3._m0 = transpose(float2x2(_3.c_block._m3._m0[0].xy, _3.c_block._m3._m0[1].xy)); _3.a_block = _31; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/copy-logical.spv14.asm.comp000066400000000000000000000012611400026215700304770ustar00rootroot00000000000000#include #include using namespace metal; struct B2 { float4 elem2; }; struct C { float4 c; B2 b2; B2 b2_array[4]; }; struct B1 { float4 elem1; }; struct A { float4 a; B1 b1; B1 b1_array[4]; }; struct _8 { A a_block; C c_block; }; kernel void main0(device _8& _3 [[buffer(0)]]) { A _27; _27.a = _3.c_block.c; _27.b1.elem1 = _3.c_block.b2.elem2; _27.b1_array[0].elem1 = _3.c_block.b2_array[0].elem2; _27.b1_array[1].elem1 = _3.c_block.b2_array[1].elem2; _27.b1_array[2].elem1 = _3.c_block.b2_array[2].elem2; _27.b1_array[3].elem1 = _3.c_block.b2_array[3].elem2; _3.a_block = _27; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/device-array-load-temporary.asm.comp000066400000000000000000000073551400026215700324630ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Block { uint2 _m0[2]; uint2 _m1[2]; }; struct SSBO { Block _m0[3]; }; template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } kernel void main0(device SSBO& ssbo [[buffer(0)]]) { threadgroup uint2 _18[2]; spvUnsafeArray _27; spvArrayCopyFromDeviceToStack1(_27.elements, ssbo._m0[0u]._m1); spvArrayCopyFromStackToDevice1(ssbo._m0[0u]._m0, _27.elements); spvArrayCopyFromStackToDevice1(ssbo._m0[0u]._m0, _27.elements); } device-array-load-temporary.force-native-array.asm.comp000066400000000000000000000055061400026215700360750ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Block { uint2 _m0[2]; uint2 _m1[2]; }; struct SSBO { Block _m0[3]; }; template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } kernel void main0(device SSBO& ssbo [[buffer(0)]]) { threadgroup uint2 _18[2]; uint2 _27[2]; spvArrayCopyFromDeviceToStack1(_27, ssbo._m0[0u]._m1); spvArrayCopyFromStackToDevice1(ssbo._m0[0u]._m0, _27); spvArrayCopyFromStackToDevice1(ssbo._m0[0u]._m0, _27); } device-constant-array-load-store.asm.comp000066400000000000000000000101471400026215700333360ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Block { uint2 _m0[2]; uint2 _m1[2]; }; struct SSBO { Block _m0[3]; }; template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } kernel void main0(device SSBO& ssbo [[buffer(0)]], constant SSBO& ubo [[buffer(1)]]) { threadgroup uint2 _18[2]; spvArrayCopyFromDeviceToDevice1(ssbo._m0[0u]._m0, ssbo._m0[0u]._m1); spvArrayCopyFromConstantToDevice1(ssbo._m0[0u]._m0, ubo._m0[0u]._m1); spvUnsafeArray _24; spvArrayCopyFromStackToDevice1(ssbo._m0[0u]._m0, _24.elements); spvArrayCopyFromThreadGroupToDevice1(ssbo._m0[0u]._m0, _18); spvArrayCopyFromDeviceToThreadGroup1(_18, ssbo._m0[0u]._m1); spvArrayCopyFromDeviceToStack1(_24.elements, ssbo._m0[0u]._m1); spvArrayCopyFromConstantToThreadGroup1(_18, ubo._m0[0u]._m1); spvArrayCopyFromConstantToStack1(_24.elements, ubo._m0[0u]._m1); } device-constant-array-load-store.force-native-array.asm.comp000066400000000000000000000063001400026215700370270ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Block { uint2 _m0[2]; uint2 _m1[2]; }; struct SSBO { Block _m0[3]; }; template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } kernel void main0(device SSBO& ssbo [[buffer(0)]], constant SSBO& ubo [[buffer(1)]]) { threadgroup uint2 _18[2]; spvArrayCopyFromDeviceToDevice1(ssbo._m0[0u]._m0, ssbo._m0[0u]._m1); spvArrayCopyFromConstantToDevice1(ssbo._m0[0u]._m0, ubo._m0[0u]._m1); uint2 _24[2]; spvArrayCopyFromStackToDevice1(ssbo._m0[0u]._m0, _24); spvArrayCopyFromThreadGroupToDevice1(ssbo._m0[0u]._m0, _18); spvArrayCopyFromDeviceToThreadGroup1(_18, ssbo._m0[0u]._m1); spvArrayCopyFromDeviceToStack1(_24, ssbo._m0[0u]._m1); spvArrayCopyFromConstantToThreadGroup1(_18, ubo._m0[0u]._m1); spvArrayCopyFromConstantToStack1(_24, ubo._m0[0u]._m1); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/glsl-signed-operations.asm.comp000066400000000000000000000042471400026215700315410ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { int4 ints; uint4 uints; }; // Implementation of the signed GLSL findMSB() function template inline T spvFindSMSB(T x) { T v = select(x, T(-1) - x, x < T(0)); return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0)); } // Implementation of the unsigned GLSL findMSB() function template inline T spvFindUMSB(T x) { return select(clz(T(0)) - (clz(x) + T(1)), T(-1), x == T(0)); } // Implementation of the GLSL sign() function for integer types template::value>::type> inline T sign(T x) { return select(select(select(x, T(0), x == T(0)), T(1), x > T(0)), T(-1), x < T(0)); } kernel void main0(device SSBO& _4 [[buffer(0)]]) { int4 _19 = _4.ints; uint4 _20 = _4.uints; _4.ints = abs(_19); _4.uints = uint4(abs(_19)); _4.ints = abs(int4(_20)); _4.uints = uint4(abs(int4(_20))); _4.ints = sign(_19); _4.uints = uint4(sign(_19)); _4.ints = sign(int4(_20)); _4.uints = uint4(sign(int4(_20))); _4.ints = spvFindSMSB(int4(_20)); _4.uints = uint4(spvFindSMSB(int4(_20))); _4.ints = int4(spvFindUMSB(uint4(_19))); _4.uints = spvFindUMSB(uint4(_19)); _4.ints = min(_19, _19); _4.uints = uint4(min(_19, int4(_20))); _4.ints = min(int4(_20), int4(_20)); _4.uints = uint4(min(int4(_20), _19)); _4.ints = int4(min(uint4(_19), _20)); _4.uints = min(uint4(_19), _20); _4.ints = int4(min(_20, uint4(_19))); _4.uints = min(_20, uint4(_19)); _4.ints = max(_19, _19); _4.uints = uint4(max(_19, _19)); _4.ints = max(int4(_20), _19); _4.uints = uint4(max(int4(_20), _19)); _4.ints = int4(max(uint4(_19), _20)); _4.uints = max(uint4(_19), uint4(_19)); _4.ints = int4(max(_20, uint4(_19))); _4.uints = max(_20, uint4(_19)); _4.ints = clamp(int4(_20), int4(_20), int4(_20)); _4.uints = uint4(clamp(int4(_20), int4(_20), int4(_20))); _4.ints = int4(clamp(uint4(_19), uint4(_19), uint4(_19))); _4.uints = clamp(uint4(_19), uint4(_19), uint4(_19)); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/glsl.std450.frexp-modf-struct.asm.comp000066400000000000000000000006731400026215700325220ustar00rootroot00000000000000#include #include using namespace metal; struct _8 { float _m0; float _m1; }; struct _15 { float _m0; int _m1; }; struct _3 { float _m0; int _m1; }; kernel void main0(device _3& _4 [[buffer(0)]]) { _8 _23; _23._m0 = modf(20.0, _23._m1); _15 _24; _24._m0 = frexp(40.0, _24._m1); _4._m0 = _23._m0; _4._m0 = _23._m1; _4._m0 = _24._m0; _4._m1 = _24._m1; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/storage-buffer-basic.invalid.asm.comp000066400000000000000000000012331400026215700325570ustar00rootroot00000000000000#include #include using namespace metal; struct _6 { float _m0[1]; }; constant uint _3_tmp [[function_constant(0)]]; constant uint _3 = is_function_constant_defined(_3_tmp) ? _3_tmp : 1u; constant uint _4_tmp [[function_constant(2)]]; constant uint _4 = is_function_constant_defined(_4_tmp) ? _4_tmp : 3u; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(_3, 2u, _4); kernel void main0(device _6& _8 [[buffer(0)]], device _6& _9 [[buffer(1)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]]) { uint3 _23 = gl_WorkGroupSize; _8._m0[gl_WorkGroupID.x] = _9._m0[gl_WorkGroupID.x] + _8._m0[gl_WorkGroupID.x]; } storage-buffer-pointer-argument.asm.comp000066400000000000000000000006571400026215700333030ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float a; }; struct SSBORead { float b; }; static inline __attribute__((always_inline)) void copy_out(device float& A, device const float& B) { A = B; } kernel void main0(device SSBO& _7 [[buffer(0)]], const device SSBORead& _9 [[buffer(1)]]) { copy_out(_7.a, _9.b); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/comp/variable-pointers.asm.comp000066400000000000000000000027751400026215700306020ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct foo { int a[128]; uint b; float2 c; }; struct bar { int d; }; struct baz { int e[128]; }; static inline __attribute__((always_inline)) device int* select_buffer(device foo& buf, device baz& buf2, constant bar& cb) { return (cb.d != 0) ? &buf.a[0u] : &buf2.e[0u]; } static inline __attribute__((always_inline)) device int* select_buffer_null(device foo& buf, constant bar& cb) { return (cb.d != 0) ? &buf.a[0u] : nullptr; } static inline __attribute__((always_inline)) threadgroup int* select_tgsm(constant bar& cb, threadgroup int (&tgsm)[128]) { return (cb.d != 0) ? &tgsm[0u] : nullptr; } kernel void main0(device foo& buf [[buffer(0)]], constant bar& cb [[buffer(1)]], device baz& buf2 [[buffer(2)]]) { threadgroup int tgsm[128]; device int* sbuf = select_buffer(buf, buf2, cb); device int* sbuf2 = select_buffer_null(buf, cb); threadgroup int* stgsm = select_tgsm(cb, tgsm); threadgroup int* cur = stgsm; device int* _73; _73 = &buf.a[0u]; threadgroup int* _76; int _77; for (;;) { _76 = cur; _77 = *_73; if (_77 != 0) { int _81 = *_76; int _82 = _77 + _81; *_73 = _82; *_76 = _82; cur = &_76[1u]; _73 = &_73[1u]; continue; } else { break; } } } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/000077500000000000000000000000001400026215700234635ustar00rootroot00000000000000component-insert-packed-expression.asm.frag000066400000000000000000000012321400026215700337500ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag#include #include using namespace metal; struct type_Globals { float4 _BorderWidths[4]; }; struct main0_out { float4 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Globals& _Globals [[buffer(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; float2 _31 = float2(_Globals._BorderWidths[0].x, _Globals._BorderWidths[1].x); float2 _39; if (gl_FragCoord.x > 0.0) { float2 _38 = _31; _38.x = _Globals._BorderWidths[2].x; _39 = _38; } else { _39 = _31; } out.out_var_SV_Target = float4(_39, 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/empty-struct-in-struct.asm.frag000066400000000000000000000012141400026215700315070ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct EmptyStructTest { }; struct EmptyStruct2Test { EmptyStructTest _m0; }; static inline __attribute__((always_inline)) float GetValue(thread const EmptyStruct2Test& self) { return 0.0; } static inline __attribute__((always_inline)) float GetValue_1(EmptyStruct2Test self) { return 0.0; } fragment void main0() { EmptyStruct2Test emptyStruct; float value = GetValue(emptyStruct); value = GetValue_1(EmptyStruct2Test{ EmptyStructTest{ } }); value = GetValue_1(EmptyStruct2Test{ { } }); } fixup-entry-point-identifier.nomain.asm.frag000066400000000000000000000003631400026215700340470ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag#include #include using namespace metal; struct _5ma_in_out { float4 FragColor [[color(0)]]; }; fragment _5ma_in_out _5ma_in() { _5ma_in_out out = {}; out.FragColor = float4(1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/image-fetch-uint-coord.asm.frag000066400000000000000000000006571400026215700313450ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint3 in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d Tex [[texture(0)]]) { main0_out out = {}; out.out_var_SV_Target0 = Tex.read(uint2(in.in_var_TEXCOORD0.xy), in.in_var_TEXCOORD0.z); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/image-gather.asm.frag000066400000000000000000000011121400026215700274300ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d g_texture [[texture(0)]], sampler g_sampler [[sampler(0)]], sampler g_comp [[sampler(1)]]) { main0_out out = {}; out.out_var_SV_Target0 = g_texture.gather(g_sampler, in.in_var_TEXCOORD0, int2(0), component::x) * g_texture.gather(g_sampler, in.in_var_TEXCOORD0, int2(0), component::y); return out; } image-type-normal-comparison-usage.asm.frag000066400000000000000000000013461400026215700336310ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag#include #include using namespace metal; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d ShadowMap [[texture(0)]], sampler SampleNormal [[sampler(0)]], sampler SampleShadow [[sampler(1)]]) { main0_out out = {}; float _41; if (in.in_var_TEXCOORD0.x > 0.5) { _41 = float(float4(ShadowMap.sample(SampleNormal, in.in_var_TEXCOORD0)).x <= 0.5); } else { _41 = ShadowMap.sample_compare(SampleShadow, in.in_var_TEXCOORD0, 0.5, level(0.0)); } out.out_var_SV_Target0 = float4(_41, _41, _41, 1.0); return out; } input-attachment-unused-frag-coord.asm.frag000066400000000000000000000012321400026215700336310ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 load_subpasses(thread const texture2d uInput, thread float4& gl_FragCoord) { return uInput.read(uint2(gl_FragCoord.xy)); } fragment main0_out main0(texture2d uSubpass0 [[texture(0)]], texture2d uSubpass1 [[texture(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = uSubpass0.read(uint2(gl_FragCoord.xy)) + load_subpasses(uSubpass1, gl_FragCoord); return out; } modf-frexp-scalar-access-chain-output.asm.frag000066400000000000000000000004601400026215700342130ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag#include #include using namespace metal; fragment void main0() { float3 col; int2 _18; float _23; float _21 = modf(0.1500000059604644775390625, _23); col.x = _23; int _24; float _22 = frexp(0.1500000059604644775390625, _24); _18.y = _24; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/only-initializer-frag-depth.asm.frag000066400000000000000000000003521400026215700324240ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float gl_FragDepth [[depth(any)]]; }; fragment main0_out main0() { main0_out out = {}; out.gl_FragDepth = 0.5; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/phi.zero-initialize.asm.frag000066400000000000000000000011161400026215700307770ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { int a; }; constant int uninit_int = {}; constant int4 uninit_vector = {}; constant float4x4 uninit_matrix = {}; constant Foo uninit_foo = {}; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; int _39 = {}; if (in.vColor.x > 10.0) { _39 = 10; } else { _39 = 20; } out.FragColor = in.vColor; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/pixel-interlock-callstack.msl2.asm.frag000066400000000000000000000014171400026215700330320ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO1 { uint values1[1]; }; struct SSBO0 { uint values0[1]; }; static inline __attribute__((always_inline)) void callee2(thread float4& gl_FragCoord, device SSBO1& v_7) { int _31 = int(gl_FragCoord.x); v_7.values1[_31]++; } static inline __attribute__((always_inline)) void callee(thread float4& gl_FragCoord, device SSBO1& v_7, device SSBO0& v_9) { int _39 = int(gl_FragCoord.x); v_9.values0[_39]++; callee2(gl_FragCoord, v_7); } fragment void main0(device SSBO1& v_7 [[buffer(0), raster_order_group(0)]], device SSBO0& v_9 [[buffer(1)]], float4 gl_FragCoord [[position]]) { callee(gl_FragCoord, v_7, v_9); } pixel-interlock-control-flow.msl2.asm.frag000066400000000000000000000020611400026215700334330ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO1 { uint values1[1]; }; struct _12 { uint _m0[1]; }; struct SSBO0 { uint values0[1]; }; static inline __attribute__((always_inline)) void callee2(thread float4& gl_FragCoord, device SSBO1& v_7) { int _44 = int(gl_FragCoord.x); v_7.values1[_44]++; } static inline __attribute__((always_inline)) void callee(thread float4& gl_FragCoord, device SSBO1& v_7, device SSBO0& v_9) { int _52 = int(gl_FragCoord.x); v_9.values0[_52]++; callee2(gl_FragCoord, v_7); if (true) { } } static inline __attribute__((always_inline)) void _35(thread float4& gl_FragCoord, device _12& v_13) { v_13._m0[int(gl_FragCoord.x)] = 4u; } fragment void main0(device SSBO1& v_7 [[buffer(0), raster_order_group(0)]], device _12& v_13 [[buffer(1)]], device SSBO0& v_9 [[buffer(2), raster_order_group(0)]], float4 gl_FragCoord [[position]]) { callee(gl_FragCoord, v_7, v_9); _35(gl_FragCoord, v_13); } pixel-interlock-split-functions.msl2.asm.frag000066400000000000000000000016661400026215700341610ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO1 { uint values1[1]; }; struct SSBO0 { uint values0[1]; }; static inline __attribute__((always_inline)) void callee2(thread float4& gl_FragCoord, device SSBO1& v_7) { int _37 = int(gl_FragCoord.x); v_7.values1[_37]++; } static inline __attribute__((always_inline)) void callee(thread float4& gl_FragCoord, device SSBO1& v_7, device SSBO0& v_9) { int _45 = int(gl_FragCoord.x); v_9.values0[_45]++; callee2(gl_FragCoord, v_7); } static inline __attribute__((always_inline)) void _29() { } static inline __attribute__((always_inline)) void _31() { } fragment void main0(device SSBO1& v_7 [[buffer(0), raster_order_group(0)]], device SSBO0& v_9 [[buffer(1), raster_order_group(0)]], float4 gl_FragCoord [[position]]) { callee(gl_FragCoord, v_7, v_9); _29(); _31(); } private-initializer-direct-store.asm.frag000066400000000000000000000004061400026215700334210ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; float b = 10.0; b = 20.0; out.FragColor = b + b; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/reserved-function-identifier.asm.frag000066400000000000000000000011601400026215700326630ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float _mat3(thread const float& a) { return a + 1.0; } static inline __attribute__((always_inline)) float _RESERVED_IDENTIFIER_FIXUP_gl_Foo(thread const int& a) { return float(a) + 1.0; } fragment main0_out main0() { main0_out out = {}; float param = 2.0; int param_1 = 4; out.FragColor = _mat3(param) + _RESERVED_IDENTIFIER_FIXUP_gl_Foo(param_1); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/subgroup-arithmetic-cast.msl21.asm.frag000066400000000000000000000012161400026215700327650ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { uint FragColor [[color(0)]]; }; struct main0_in { int index [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; uint _17 = uint(in.index); out.FragColor = uint(simd_min(in.index)); out.FragColor = uint(simd_max(int(_17))); out.FragColor = simd_min(uint(in.index)); out.FragColor = simd_max(_17); out.FragColor = uint(quad_min(in.index)); out.FragColor = uint(quad_max(int(_17))); out.FragColor = quad_min(uint(in.index)); out.FragColor = quad_max(_17); return out; } switch-block-case-fallthrough.asm.invalid.frag000066400000000000000000000023071400026215700342720ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int vIndex [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { int i = 0; main0_out out = {}; int j; int _30; int _31; if (in.vIndex != 0 && in.vIndex != 1 && in.vIndex != 11 && in.vIndex != 2 && in.vIndex != 3 && in.vIndex != 4 && in.vIndex != 5) { _30 = 2; } if (in.vIndex == 1 || in.vIndex == 11) { _31 = 1; } switch (in.vIndex) { case 0: { _30 = 3; } default: { j = _30; _31 = 0; } case 1: case 11: { j = _31; } case 2: { break; } case 3: { if (in.vIndex > 3) { i = 0; break; } else { break; } } case 4: { } case 5: { i = 0; break; } } out.FragColor = float4(float(i)); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/texture-access.swizzle.asm.frag000066400000000000000000000236231400026215700315560ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } // Wrapper function that swizzles texture gathers. template class Tex, typename... Ts> inline vec spvGatherSwizzle(const thread Tex& t, sampler s, uint sw, component c, Ts... params) METAL_CONST_ARG(c) { if (sw) { switch (spvSwizzle((sw >> (uint(c) * 8)) & 0xFF)) { case spvSwizzle::none: break; case spvSwizzle::zero: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); case spvSwizzle::red: return t.gather(s, spvForward(params)..., component::x); case spvSwizzle::green: return t.gather(s, spvForward(params)..., component::y); case spvSwizzle::blue: return t.gather(s, spvForward(params)..., component::z); case spvSwizzle::alpha: return t.gather(s, spvForward(params)..., component::w); } } switch (c) { case component::x: return t.gather(s, spvForward(params)..., component::x); case component::y: return t.gather(s, spvForward(params)..., component::y); case component::z: return t.gather(s, spvForward(params)..., component::z); case component::w: return t.gather(s, spvForward(params)..., component::w); } } // Wrapper function that swizzles depth texture gathers. template class Tex, typename... Ts> inline vec spvGatherCompareSwizzle(const thread Tex& t, sampler s, uint sw, Ts... params) { if (sw) { switch (spvSwizzle(sw & 0xFF)) { case spvSwizzle::none: case spvSwizzle::red: break; case spvSwizzle::zero: case spvSwizzle::green: case spvSwizzle::blue: case spvSwizzle::alpha: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); } } return t.gather_compare(s, spvForward(params)...); } fragment void main0(constant uint* spvSwizzleConstants [[buffer(30)]], texture1d tex1d [[texture(0)]], texture2d tex2d [[texture(1)]], texture3d tex3d [[texture(2)]], texturecube texCube [[texture(3)]], texture2d_array tex2dArray [[texture(4)]], texturecube_array texCubeArray [[texture(5)]], depth2d depth2d [[texture(6)]], depthcube depthCube [[texture(7)]], depth2d_array depth2dArray [[texture(8)]], depthcube_array depthCubeArray [[texture(9)]], texture2d texBuffer [[texture(10)]], sampler tex1dSamp [[sampler(0)]], sampler tex2dSamp [[sampler(1)]], sampler tex3dSamp [[sampler(2)]], sampler texCubeSamp [[sampler(3)]], sampler tex2dArraySamp [[sampler(4)]], sampler texCubeArraySamp [[sampler(5)]], sampler depth2dSamp [[sampler(6)]], sampler depthCubeSamp [[sampler(7)]], sampler depth2dArraySamp [[sampler(8)]], sampler depthCubeArraySamp [[sampler(9)]]) { constant uint& tex1dSwzl = spvSwizzleConstants[0]; constant uint& tex2dSwzl = spvSwizzleConstants[1]; constant uint& tex3dSwzl = spvSwizzleConstants[2]; constant uint& texCubeSwzl = spvSwizzleConstants[3]; constant uint& tex2dArraySwzl = spvSwizzleConstants[4]; constant uint& texCubeArraySwzl = spvSwizzleConstants[5]; constant uint& depth2dSwzl = spvSwizzleConstants[6]; constant uint& depthCubeSwzl = spvSwizzleConstants[7]; constant uint& depth2dArraySwzl = spvSwizzleConstants[8]; constant uint& depthCubeArraySwzl = spvSwizzleConstants[9]; float4 c = spvTextureSwizzle(tex1d.sample(tex1dSamp, 0.0), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSamp, float2(0.0)), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSamp, float3(0.0)), tex3dSwzl); c = spvTextureSwizzle(texCube.sample(texCubeSamp, float3(0.0)), texCubeSwzl); c = spvTextureSwizzle(tex2dArray.sample(tex2dArraySamp, float3(0.0).xy, uint(round(float3(0.0).z))), tex2dArraySwzl); c = spvTextureSwizzle(texCubeArray.sample(texCubeArraySamp, float4(0.0).xyz, uint(round(float4(0.0).w))), texCubeArraySwzl); c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSamp, float3(0.0, 0.0, 1.0).xy, float3(0.0, 0.0, 1.0).z), depth2dSwzl); c.x = spvTextureSwizzle(depthCube.sample_compare(depthCubeSamp, float4(0.0, 0.0, 0.0, 1.0).xyz, float4(0.0, 0.0, 0.0, 1.0).w), depthCubeSwzl); c.x = spvTextureSwizzle(depth2dArray.sample_compare(depth2dArraySamp, float4(0.0, 0.0, 0.0, 1.0).xy, uint(round(float4(0.0, 0.0, 0.0, 1.0).z)), float4(0.0, 0.0, 0.0, 1.0).w), depth2dArraySwzl); c.x = spvTextureSwizzle(depthCubeArray.sample_compare(depthCubeArraySamp, float4(0.0).xyz, uint(round(float4(0.0).w)), 1.0), depthCubeArraySwzl); c = spvTextureSwizzle(tex1d.sample(tex1dSamp, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSamp, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSamp, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w), tex3dSwzl); float4 _152 = float4(0.0, 0.0, 1.0, 1.0); _152.z = float4(0.0, 0.0, 1.0, 1.0).w; c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSamp, _152.xy / _152.z, float4(0.0, 0.0, 1.0, 1.0).z / _152.z), depth2dSwzl); c = spvTextureSwizzle(tex1d.sample(tex1dSamp, 0.0), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSamp, float2(0.0), level(0.0)), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSamp, float3(0.0), level(0.0)), tex3dSwzl); c = spvTextureSwizzle(texCube.sample(texCubeSamp, float3(0.0), level(0.0)), texCubeSwzl); c = spvTextureSwizzle(tex2dArray.sample(tex2dArraySamp, float3(0.0).xy, uint(round(float3(0.0).z)), level(0.0)), tex2dArraySwzl); c = spvTextureSwizzle(texCubeArray.sample(texCubeArraySamp, float4(0.0).xyz, uint(round(float4(0.0).w)), level(0.0)), texCubeArraySwzl); c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSamp, float3(0.0, 0.0, 1.0).xy, float3(0.0, 0.0, 1.0).z, level(0.0)), depth2dSwzl); c = spvTextureSwizzle(tex1d.sample(tex1dSamp, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSamp, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z, level(0.0)), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSamp, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w, level(0.0)), tex3dSwzl); float4 _202 = float4(0.0, 0.0, 1.0, 1.0); _202.z = float4(0.0, 0.0, 1.0, 1.0).w; c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSamp, _202.xy / _202.z, float4(0.0, 0.0, 1.0, 1.0).z / _202.z, level(0.0)), depth2dSwzl); c = spvTextureSwizzle(tex1d.read(uint(0)), tex1dSwzl); c = spvTextureSwizzle(tex2d.read(uint2(int2(0)), 0), tex2dSwzl); c = spvTextureSwizzle(tex3d.read(uint3(int3(0)), 0), tex3dSwzl); c = spvTextureSwizzle(tex2dArray.read(uint2(int3(0).xy), uint(int3(0).z), 0), tex2dArraySwzl); c = texBuffer.read(spvTexelBufferCoord(0)); c = spvGatherSwizzle(tex2d, tex2dSamp, tex2dSwzl, component::x, float2(0.0), int2(0)); c = spvGatherSwizzle(texCube, texCubeSamp, texCubeSwzl, component::y, float3(0.0)); c = spvGatherSwizzle(tex2dArray, tex2dArraySamp, tex2dArraySwzl, component::z, float3(0.0).xy, uint(round(float3(0.0).z)), int2(0)); c = spvGatherSwizzle(texCubeArray, texCubeArraySamp, texCubeArraySwzl, component::w, float4(0.0).xyz, uint(round(float4(0.0).w))); c = spvGatherCompareSwizzle(depth2d, depth2dSamp, depth2dSwzl, float2(0.0), 1.0); c = spvGatherCompareSwizzle(depthCube, depthCubeSamp, depthCubeSwzl, float3(0.0), 1.0); c = spvGatherCompareSwizzle(depth2dArray, depth2dArraySamp, depth2dArraySwzl, float3(0.0).xy, uint(round(float3(0.0).z)), 1.0); c = spvGatherCompareSwizzle(depthCubeArray, depthCubeArraySamp, depthCubeArraySwzl, float4(0.0).xyz, uint(round(float4(0.0).w)), 1.0); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/frag/vector-shuffle-undef-index.asm.frag000066400000000000000000000006611400026215700322460ustar00rootroot00000000000000#include #include using namespace metal; constant float4 undef = {}; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vFloat [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = float4(undef.x, in.vFloat.y, 0.0, in.vFloat.w) + float4(in.vFloat.z, in.vFloat.y, 0.0, in.vFloat.w); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/000077500000000000000000000000001400026215700241605ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/composite-extract-row-major.asm.comp000066400000000000000000000003341400026215700332040ustar00rootroot00000000000000#include #include using namespace metal; struct SSBORow { float v; float4x4 row_major0; }; kernel void main0(device SSBORow& _4 [[buffer(0)]]) { _4.v = _4.row_major0[2][1]; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding-2.asm.comp000066400000000000000000000004261400026215700326760ustar00rootroot00000000000000#include #include using namespace metal; struct SSBOScalar { float3 a; float3x3 b; float3x3 c; }; kernel void main0(device SSBOScalar& _4 [[buffer(0)]]) { float3x3 _20 = transpose(_4.b); _4.b = _4.c; _4.a = _20 * _4.a; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding-3.asm.comp000066400000000000000000000004771400026215700327050ustar00rootroot00000000000000#include #include using namespace metal; struct SSBOScalar { packed_float3 a; packed_float3 b; packed_float3 c; }; kernel void main0(device SSBOScalar& _4 [[buffer(0)]]) { float3 _17 = float3(_4.b); float3 _19 = float3(_4.c); _4.c = _17; _4.a = _17 * _19; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding-4.asm.comp000066400000000000000000000005511400026215700326770ustar00rootroot00000000000000#include #include using namespace metal; struct SSBOScalar { float4 a[16]; float4 b[16]; float4 c[16]; }; kernel void main0(device SSBOScalar& _4 [[buffer(0)]]) { float2 _27 = _4.b[10].xy; float _29 = _4.c[10].x; (device float2&)_4.b[10] = float2(10.0, 11.0); (device float2&)_4.a[10] = _27 * _29; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding-5.asm.comp000066400000000000000000000005061400026215700327000ustar00rootroot00000000000000#include #include using namespace metal; struct SSBOScalar { float2 a; packed_float3 b; packed_float3 c; }; kernel void main0(device SSBOScalar& _4 [[buffer(0)]]) { float3 _21 = float3(_4.b); float3 _24 = float3(_4.c); _4.b = float3(1.0); _4.a = _21.xy * _24.yz; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding.asm.comp000066400000000000000000000011671400026215700325420ustar00rootroot00000000000000#include #include using namespace metal; typedef packed_float3 packed_rm_float3x3[3]; struct SSBOScalar { packed_float3 a; packed_rm_float3x3 b; packed_rm_float3x3 c; }; kernel void main0(device SSBOScalar& _4 [[buffer(0)]]) { float3x3 _20 = transpose(float3x3(float3(_4.b[0]), float3(_4.b[1]), float3(_4.b[2]))); _4.b[0] = float3x3(float3(_4.c[0]), float3(_4.c[1]), float3(_4.c[2]))[0]; _4.b[1] = float3x3(float3(_4.c[0]), float3(_4.c[1]), float3(_4.c[2]))[1]; _4.b[2] = float3x3(float3(_4.c[0]), float3(_4.c[1]), float3(_4.c[2]))[2]; _4.a = _20 * float3(_4.a); } packed-vector-extract-insert.asm.comp000066400000000000000000000005111400026215700332360ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing#include #include using namespace metal; struct SSBOScalar { float2 a; packed_float3 b; packed_float3 c; float3 d; }; kernel void main0(device SSBOScalar& _4 [[buffer(0)]]) { float3 _24 = _4.b; _24.z = 2.0; _4.a = float2(_4.b[0], _4.b[1]) * _4.b[2]; _4.b = _24; } row-major-split-access-chain.asm.comp000066400000000000000000000003571400026215700331320ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing#include #include using namespace metal; struct SSBORow { float v; float4x4 row_major0; }; kernel void main0(device SSBORow& _4 [[buffer(0)]]) { _4.v = ((device float*)&_4.row_major0[2u])[1]; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/scalar-array-float2.asm.frag000066400000000000000000000006101400026215700313430ustar00rootroot00000000000000#include #include using namespace metal; struct type_Foo { float4 a[1]; char _m1_pad[8]; float b; }; struct main0_out { float2 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (Foo.a[0].xy + Foo.a[1].xy) + float2(Foo.b); return out; } scalar-array-float3-one-element.asm.frag000066400000000000000000000005571400026215700335050ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing#include #include using namespace metal; struct type_Foo { packed_float3 a[1]; float b; }; struct main0_out { float3 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = float3(Foo.a[0]) + float3(Foo.b); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/scalar-array-float3.asm.frag000066400000000000000000000006131400026215700313470ustar00rootroot00000000000000#include #include using namespace metal; struct type_Foo { float4 a[1]; char _m1_pad[12]; float b; }; struct main0_out { float3 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (Foo.a[0].xyz + Foo.a[1].xyz) + float3(Foo.b); return out; } scalar-float2x2-col-major.invalid.asm.frag000066400000000000000000000006121400026215700337320ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing#include #include using namespace metal; struct type_Foo { float4 a[1]; char _m1_pad[8]; float b; }; struct main0_out { float2 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (Foo.a[0u].xy + Foo.a[1u].xy) + float2(Foo.b); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/scalar-float2x2-row-major.asm.frag000066400000000000000000000006661400026215700324270ustar00rootroot00000000000000#include #include using namespace metal; struct type_Foo { float4 a[1]; char _m1_pad[8]; float b; }; struct main0_out { float2 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (float2(Foo.a[0][0u], Foo.a[1][0u]) + float2(Foo.a[0][1u], Foo.a[1][1u])) + float2(Foo.b); return out; } scalar-float2x3-col-major.invalid.asm.frag000066400000000000000000000006151400026215700337360ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing#include #include using namespace metal; struct type_Foo { float4 a[1]; char _m1_pad[12]; float b; }; struct main0_out { float3 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (Foo.a[0u].xyz + Foo.a[1u].xyz) + float3(Foo.b); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/scalar-float2x3-row-major.asm.frag000066400000000000000000000007211400026215700324200ustar00rootroot00000000000000#include #include using namespace metal; struct type_Foo { float2x4 a; char _m1_pad[8]; float b; }; struct main0_out { float3 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (float3(Foo.a[0][0u], Foo.a[1][0u], Foo.a[2][0u]) + float3(Foo.a[0][1u], Foo.a[1][1u], Foo.a[2][1u])) + float3(Foo.b); return out; } scalar-float3x2-col-major.invalid.asm.frag000066400000000000000000000006111400026215700337320ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing#include #include using namespace metal; struct type_Foo { float2x4 a; char _m1_pad[8]; float b; }; struct main0_out { float2 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (Foo.a[0u].xy + Foo.a[1u].xy) + float2(Foo.b); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/scalar-float3x2-row-major.asm.frag000066400000000000000000000006671400026215700324310ustar00rootroot00000000000000#include #include using namespace metal; struct type_Foo { float4 a[1]; char _m1_pad[12]; float b; }; struct main0_out { float2 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (float2(Foo.a[0][0u], Foo.a[1][0u]) + float2(Foo.a[0][1u], Foo.a[1][1u])) + float2(Foo.b); return out; } scalar-float3x3-col-major.invalid.asm.frag000066400000000000000000000006141400026215700337360ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing#include #include using namespace metal; struct type_Foo { float2x4 a; char _m1_pad[12]; float b; }; struct main0_out { float3 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (Foo.a[0u].xyz + Foo.a[1u].xyz) + float3(Foo.b); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/packing/scalar-float3x3-row-major.asm.frag000066400000000000000000000007221400026215700324220ustar00rootroot00000000000000#include #include using namespace metal; struct type_Foo { float2x4 a; char _m1_pad[12]; float b; }; struct main0_out { float3 out_var_SV_Target [[color(0)]]; }; fragment main0_out main0(constant type_Foo& Foo [[buffer(0)]]) { main0_out out = {}; out.out_var_SV_Target = (float3(Foo.a[0][0u], Foo.a[1][0u], Foo.a[2][0u]) + float3(Foo.a[0][1u], Foo.a[1][1u], Foo.a[2][1u])) + float3(Foo.b); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/temporary.zero-initialize.asm.frag000066400000000000000000000012421400026215700313220ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int vA [[user(locn0)]]; int vB [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = float4(0.0); int _10 = {}; int _15 = {}; for (int _16 = 0, _17 = 0; _16 < in.vA; _17 = _15, _16 += _10) { if ((in.vA + _16) == 20) { _15 = 50; } else { _15 = ((in.vB + _16) == 40) ? 60 : _17; } _10 = _15 + 10; out.FragColor += float4(1.0); } return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc/000077500000000000000000000000001400026215700235025ustar00rootroot00000000000000array-control-point-initializer.asm.tesc000066400000000000000000000041231400026215700333260ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _49 = spvUnsafeArray({ 0.0, 0.0, 0.0 }); constant spvUnsafeArray, 4> _27 = spvUnsafeArray, 4>({ spvUnsafeArray({ 0.0, 0.0, 0.0 }), spvUnsafeArray({ 0.0, 0.0, 0.0 }), spvUnsafeArray({ 0.0, 0.0, 0.0 }), spvUnsafeArray({ 0.0, 0.0, 0.0 }) }); struct main0_out { spvUnsafeArray foo; float4 gl_Position; }; kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; gl_out[gl_InvocationID].foo = _27[gl_InvocationID]; gl_out[gl_InvocationID].gl_Position = float4(1.0); gl_out[gl_InvocationID].foo[0] = float(gl_InvocationID); gl_out[gl_InvocationID].foo[1] = float(gl_InvocationID) + 1.0; gl_out[gl_InvocationID].foo[2] = float(gl_InvocationID) + 2.0; } block-control-point-initializer.asm.tesc000066400000000000000000000036011400026215700333020ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Verts { float a; float2 b; }; struct main0_out { float Verts_a; float2 Verts_b; float4 gl_Position; }; kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { spvUnsafeArray _27 = spvUnsafeArray({ Verts{ 0.0, float2(0.0) }, Verts{ 0.0, float2(0.0) }, Verts{ 0.0, float2(0.0) }, Verts{ 0.0, float2(0.0) } }); device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; gl_out[gl_InvocationID].Verts_a = _27[gl_InvocationID].a; gl_out[gl_InvocationID].Verts_b = _27[gl_InvocationID].b; gl_out[gl_InvocationID].gl_Position = float4(1.0); gl_out[gl_InvocationID].Verts_a = float(gl_InvocationID); } builtin-control-point-initializer.asm.tesc000066400000000000000000000051751400026215700336660ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct _RESERVED_IDENTIFIER_FIXUP_gl_PerVertex { float4 _RESERVED_IDENTIFIER_FIXUP_gl_Position; float _RESERVED_IDENTIFIER_FIXUP_gl_PointSize; }; struct Verts { float a; float2 b; }; struct main0_out { float Verts_a; float2 Verts_b; float4 gl_Position; float gl_PointSize; }; kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { spvUnsafeArray<_RESERVED_IDENTIFIER_FIXUP_gl_PerVertex, 4> _17 = spvUnsafeArray<_RESERVED_IDENTIFIER_FIXUP_gl_PerVertex, 4>({ _RESERVED_IDENTIFIER_FIXUP_gl_PerVertex{ float4(0.0), 0.0 }, _RESERVED_IDENTIFIER_FIXUP_gl_PerVertex{ float4(0.0), 0.0 }, _RESERVED_IDENTIFIER_FIXUP_gl_PerVertex{ float4(0.0), 0.0 }, _RESERVED_IDENTIFIER_FIXUP_gl_PerVertex{ float4(0.0), 0.0 } }); spvUnsafeArray _27 = spvUnsafeArray({ Verts{ 0.0, float2(0.0) }, Verts{ 0.0, float2(0.0) }, Verts{ 0.0, float2(0.0) }, Verts{ 0.0, float2(0.0) } }); device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; gl_out[gl_InvocationID].gl_Position = _17[gl_InvocationID]._RESERVED_IDENTIFIER_FIXUP_gl_Position; gl_out[gl_InvocationID].gl_PointSize = _17[gl_InvocationID]._RESERVED_IDENTIFIER_FIXUP_gl_PointSize; gl_out[gl_InvocationID].Verts_a = _27[gl_InvocationID].a; gl_out[gl_InvocationID].Verts_b = _27[gl_InvocationID].b; gl_out[gl_InvocationID].gl_Position = float4(1.0); gl_out[gl_InvocationID].Verts_a = float(gl_InvocationID); } composite-control-point-initializer.asm.tesc000066400000000000000000000035251400026215700342170ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Foo { float a; float2 b; float4 c; }; struct main0_out { Foo foo; float4 gl_Position; }; kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { spvUnsafeArray _27 = spvUnsafeArray({ Foo{ 0.0, float2(0.0), float4(0.0) }, Foo{ 0.0, float2(0.0), float4(0.0) }, Foo{ 0.0, float2(0.0), float4(0.0) }, Foo{ 0.0, float2(0.0), float4(0.0) } }); device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; gl_out[gl_InvocationID].foo = _27[gl_InvocationID]; gl_out[gl_InvocationID].gl_Position = float4(1.0); gl_out[gl_InvocationID].foo.a = float(gl_InvocationID); } plain-control-point-initializer.asm.tesc000066400000000000000000000032261400026215700333160ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _25 = spvUnsafeArray({ 0.0, 0.0, 0.0, 0.0 }); struct main0_out { float v; float4 gl_Position; }; kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; gl_out[gl_InvocationID].v = _25[gl_InvocationID]; gl_out[gl_InvocationID].gl_Position = float4(1.0); gl_out[gl_InvocationID].v = float(gl_InvocationID); } tess-fixed-input-array-builtin-array.invalid.asm.tesc000066400000000000000000000075701400026215700356240ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct VertexOutput { float4 pos; float2 uv; }; struct HSOut { float4 pos; float2 uv; }; struct HSConstantOut { spvUnsafeArray EdgeTess; float InsideTess; }; struct VertexOutput_1 { float2 uv; }; struct HSOut_1 { float2 uv; }; struct main0_out { HSOut_1 _entryPointOutput; float4 gl_Position; }; struct main0_in { float2 VertexOutput_uv [[attribute(0)]]; float4 gl_Position [[attribute(1)]]; }; static inline __attribute__((always_inline)) HSOut _hs_main(thread const spvUnsafeArray (&p), thread const uint& i) { HSOut _output; _output.pos = p[i].pos; _output.uv = p[i].uv; return _output; } static inline __attribute__((always_inline)) HSConstantOut PatchHS(thread const spvUnsafeArray (&_patch)) { HSConstantOut _output; _output.EdgeTess[0] = (float2(1.0) + _patch[0].uv).x; _output.EdgeTess[1] = (float2(1.0) + _patch[0].uv).x; _output.EdgeTess[2] = (float2(1.0) + _patch[0].uv).x; _output.InsideTess = (float2(1.0) + _patch[0].uv).x; return _output; } kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 3) return; spvUnsafeArray p; p[0].pos = gl_in[0].gl_Position; p[0].uv = gl_in[0].VertexOutput_uv; p[1].pos = gl_in[1].gl_Position; p[1].uv = gl_in[1].VertexOutput_uv; p[2].pos = gl_in[2].gl_Position; p[2].uv = gl_in[2].VertexOutput_uv; uint i = gl_InvocationID; spvUnsafeArray param; param = p; uint param_1 = i; HSOut flattenTemp = _hs_main(param, param_1); gl_out[gl_InvocationID].gl_Position = flattenTemp.pos; gl_out[gl_InvocationID]._entryPointOutput.uv = flattenTemp.uv; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (int(gl_InvocationID) == 0) { spvUnsafeArray param_2; param_2 = p; HSConstantOut _patchConstantResult = PatchHS(param_2); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(_patchConstantResult.EdgeTess[0]); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(_patchConstantResult.EdgeTess[1]); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(_patchConstantResult.EdgeTess[2]); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_patchConstantResult.InsideTess); } } tess-fixed-input-array-builtin-array.invalid.multi-patch.asm.tesc000066400000000000000000000076111400026215700400460ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct VertexOutput { float4 pos; float2 uv; }; struct HSOut { float4 pos; float2 uv; }; struct HSConstantOut { spvUnsafeArray EdgeTess; float InsideTess; }; struct VertexOutput_1 { float3 uv; }; struct HSOut_1 { float2 uv; }; struct main0_out { HSOut_1 _entryPointOutput; float4 gl_Position; }; struct main0_in { float3 VertexOutput_uv; ushort2 m_172; float4 gl_Position; }; static inline __attribute__((always_inline)) HSOut _hs_main(thread const spvUnsafeArray (&p), thread const uint& i) { HSOut _output; _output.pos = p[i].pos; _output.uv = p[i].uv; return _output; } static inline __attribute__((always_inline)) HSConstantOut PatchHS(thread const spvUnsafeArray (&_patch)) { HSConstantOut _output; _output.EdgeTess[0] = (float2(1.0) + _patch[0].uv).x; _output.EdgeTess[1] = (float2(1.0) + _patch[0].uv).x; _output.EdgeTess[2] = (float2(1.0) + _patch[0].uv).x; _output.InsideTess = (float2(1.0) + _patch[0].uv).x; return _output; } kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 3]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 3; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1]); spvUnsafeArray p; p[0].pos = gl_in[0].gl_Position; p[0].uv = gl_in[0].VertexOutput_uv.xy; p[1].pos = gl_in[1].gl_Position; p[1].uv = gl_in[1].VertexOutput_uv.xy; p[2].pos = gl_in[2].gl_Position; p[2].uv = gl_in[2].VertexOutput_uv.xy; uint i = gl_InvocationID; spvUnsafeArray param; param = p; uint param_1 = i; HSOut flattenTemp = _hs_main(param, param_1); gl_out[gl_InvocationID].gl_Position = flattenTemp.pos; gl_out[gl_InvocationID]._entryPointOutput.uv = flattenTemp.uv; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (int(gl_InvocationID) == 0) { spvUnsafeArray param_2; param_2 = p; HSConstantOut _patchConstantResult = PatchHS(param_2); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(_patchConstantResult.EdgeTess[0]); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(_patchConstantResult.EdgeTess[1]); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(_patchConstantResult.EdgeTess[2]); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_patchConstantResult.InsideTess); } } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc/tess-level-initializer-quad.asm.tesc000066400000000000000000000056071400026215700325050ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _27 = spvUnsafeArray({ 0.0, 0.0 }); constant spvUnsafeArray _33 = spvUnsafeArray({ 0.0, 0.0, 0.0, 0.0 }); struct main0_out { float4 gl_Position; }; kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(0.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(0.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(0.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(0.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(0.0); gl_out[gl_InvocationID].gl_Position = float4(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(4.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(5.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(6.0); } tess-level-initializer-triangle.asm.tesc000066400000000000000000000047141400026215700332770ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _27 = spvUnsafeArray({ 0.0, 0.0 }); constant spvUnsafeArray _33 = spvUnsafeArray({ 0.0, 0.0, 0.0, 0.0 }); struct main0_out { float4 gl_Position; }; kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(0.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(0.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(0.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(0.0); gl_out[gl_InvocationID].gl_Position = float4(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(4.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(5.0); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/vert/000077500000000000000000000000001400026215700235245ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/vert/block-struct-initializer.asm.vert000066400000000000000000000011451400026215700321430ustar00rootroot00000000000000#include #include using namespace metal; struct Vert { float a; float b; }; struct Foo { float c; float d; }; struct main0_out { float Vert_a [[user(locn0)]]; float Vert_b [[user(locn1)]]; float Foo_c [[user(locn2)]]; float Foo_d [[user(locn3)]]; float4 gl_Position [[position]]; }; vertex main0_out main0() { main0_out out = {}; Vert _3 = Vert{ 0.0, 0.0 }; Foo foo = Foo{ 0.0, 0.0 }; out.gl_Position = float4(0.0); out.Vert_a = _3.a; out.Vert_b = _3.b; out.Foo_c = foo.c; out.Foo_d = foo.d; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/vert/builtin-output-initializer.asm.vert000066400000000000000000000005231400026215700325320ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_PointSize [[point_size]]; }; vertex main0_out main0() { main0_out out = {}; out.gl_Position = float4(0.0); out.gl_PointSize = 0.0; out.gl_Position = float4(1.0); return out; } composite-extract-physical-type-id.asm.vert000066400000000000000000000012711400026215700337640ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/vert#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct type_Float2Array { float4 arr[3]; }; struct main0_out { float4 gl_Position [[position]]; }; static inline __attribute__((always_inline)) float4 src_VSMain(thread const uint& i, constant type_Float2Array& Float2Array) { return float4(Float2Array.arr[i].x, Float2Array.arr[i].y, 0.0, 1.0); } vertex main0_out main0(constant type_Float2Array& Float2Array [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; uint param_var_i = gl_VertexIndex; out.gl_Position = src_VSMain(param_var_i, Float2Array); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/vert/duplicate-view-index.asm.vert000066400000000000000000000006411400026215700312350ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; uint gl_Layer [[render_target_array_index]]; }; vertex main0_out main0(uint gl_InstanceIndex [[instance_id]], uint gl_BaseInstance [[base_instance]]) { main0_out out = {}; const uint gl_ViewIndex = 0; out.gl_Position = float4(float(int(gl_ViewIndex))); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/vert/empty-struct-composite.asm.vert000066400000000000000000000002111400026215700316570ustar00rootroot00000000000000#include #include using namespace metal; struct Test { }; vertex void main0() { Test t = Test{ }; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/asm/vert/op-load-forced-temporary-array.asm.frag000066400000000000000000000027161400026215700331010ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant float _21 = {}; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0() { main0_out out = {}; spvUnsafeArray _23; for (int _25 = 0; _25 < 2; ) { _23[_25] = 0.0; _25++; continue; } float _37; if (as_type(3.0) != 0u) { _37 = _23[0]; } else { _37 = _21; } out.gl_Position = float4(0.0, 0.0, 0.0, _37); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/000077500000000000000000000000001400026215700227225ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/array-copy-threadgroup-memory.comp000066400000000000000000000101271400026215700315210ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(8u, 1u, 1u); template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } kernel void main0(uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { threadgroup float shared_group[8][8]; threadgroup float shared_group_alt[8][8]; spvUnsafeArray blob; for (int i = 0; i < 8; i++) { blob[i] = float(i); } spvArrayCopyFromStackToThreadGroup1(shared_group[gl_LocalInvocationIndex], blob.elements); threadgroup_barrier(mem_flags::mem_threadgroup); spvUnsafeArray copied_blob; spvArrayCopyFromThreadGroupToStack1(copied_blob.elements, shared_group[gl_LocalInvocationIndex ^ 1u]); spvArrayCopyFromThreadGroupToThreadGroup1(shared_group_alt[gl_LocalInvocationIndex], shared_group[gl_LocalInvocationIndex]); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/basic.dynamic-buffer.msl2.invalid.comp000066400000000000000000000062351400026215700320640ustar00rootroot00000000000000#include #include using namespace metal; struct Baz { int e; int f; }; struct Foo { int a; int b; }; struct Bar { int c; int d; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(3u, 3u, 2u); struct spvDescriptorSetBuffer0 { constant Foo* m_34 [[id(0)]]; constant Bar* m_40 [[id(1)]]; }; struct spvDescriptorSetBuffer1 { device Baz* baz [[id(0)]][3][3][2]; }; kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], constant uint* spvDynamicOffsets [[buffer(23)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { constant auto& _34 = *(constant Foo* )((constant char* )spvDescriptorSet0.m_34 + spvDynamicOffsets[0]); device Baz* baz[3][3][2] = { { { (device Baz* )((device char* )spvDescriptorSet1.baz[0][0][0] + spvDynamicOffsets[1]), (device Baz* )((device char* )spvDescriptorSet1.baz[0][0][1] + spvDynamicOffsets[2]), }, { (device Baz* )((device char* )spvDescriptorSet1.baz[0][1][0] + spvDynamicOffsets[3]), (device Baz* )((device char* )spvDescriptorSet1.baz[0][1][1] + spvDynamicOffsets[4]), }, { (device Baz* )((device char* )spvDescriptorSet1.baz[0][2][0] + spvDynamicOffsets[5]), (device Baz* )((device char* )spvDescriptorSet1.baz[0][2][1] + spvDynamicOffsets[6]), }, }, { { (device Baz* )((device char* )spvDescriptorSet1.baz[1][0][0] + spvDynamicOffsets[7]), (device Baz* )((device char* )spvDescriptorSet1.baz[1][0][1] + spvDynamicOffsets[8]), }, { (device Baz* )((device char* )spvDescriptorSet1.baz[1][1][0] + spvDynamicOffsets[9]), (device Baz* )((device char* )spvDescriptorSet1.baz[1][1][1] + spvDynamicOffsets[10]), }, { (device Baz* )((device char* )spvDescriptorSet1.baz[1][2][0] + spvDynamicOffsets[11]), (device Baz* )((device char* )spvDescriptorSet1.baz[1][2][1] + spvDynamicOffsets[12]), }, }, { { (device Baz* )((device char* )spvDescriptorSet1.baz[2][0][0] + spvDynamicOffsets[13]), (device Baz* )((device char* )spvDescriptorSet1.baz[2][0][1] + spvDynamicOffsets[14]), }, { (device Baz* )((device char* )spvDescriptorSet1.baz[2][1][0] + spvDynamicOffsets[15]), (device Baz* )((device char* )spvDescriptorSet1.baz[2][1][1] + spvDynamicOffsets[16]), }, { (device Baz* )((device char* )spvDescriptorSet1.baz[2][2][0] + spvDynamicOffsets[17]), (device Baz* )((device char* )spvDescriptorSet1.baz[2][2][1] + spvDynamicOffsets[18]), }, }, }; uint3 coords = gl_GlobalInvocationID; baz[coords.x][coords.y][coords.z]->e = _34.a + (*spvDescriptorSet0.m_40).c; baz[coords.x][coords.y][coords.z]->f = _34.b * (*spvDescriptorSet0.m_40).d; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/bitcast-16bit-1.invalid.comp000066400000000000000000000013201400026215700277350ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO0 { short4 inputs[1]; }; struct SSBO1 { int4 outputs[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO0& _25 [[buffer(0)]], device SSBO1& _39 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; half2 a = as_type(_25.inputs[ident].xy); ((device int*)&_39.outputs[ident])[0u] = int(as_type(a + half2(half(1.0)))); ((device int*)&_39.outputs[ident])[1u] = as_type(_25.inputs[ident].zw); ((device int*)&_39.outputs[ident])[2u] = int(as_type(ushort2(_25.inputs[ident].xy))); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/bitcast-16bit-2.invalid.comp000066400000000000000000000015621400026215700277460ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO1 { short4 outputs[1]; }; struct SSBO0 { int4 inputs[1]; }; struct UBO { half4 const0; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO1& _21 [[buffer(0)]], device SSBO0& _29 [[buffer(1)]], constant UBO& _40 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; short2 _47 = as_type(((device int*)&_29.inputs[ident])[0u]) + as_type(_40.const0.xy); _21.outputs[ident] = short4(_47.x, _47.y, _21.outputs[ident].z, _21.outputs[ident].w); short2 _66 = short2(as_type(uint(((device int*)&_29.inputs[ident])[1u])) - as_type(_40.const0.zw)); _21.outputs[ident] = short4(_21.outputs[ident].x, _21.outputs[ident].y, _66.x, _66.y); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/bitfield.comp000066400000000000000000000022501400026215700253630ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; // Implementation of the GLSL findLSB() function template inline T spvFindLSB(T x) { return select(ctz(x), T(-1), x == T(0)); } // Implementation of the signed GLSL findMSB() function template inline T spvFindSMSB(T x) { T v = select(x, T(-1) - x, x < T(0)); return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0)); } // Implementation of the unsigned GLSL findMSB() function template inline T spvFindUMSB(T x) { return select(clz(T(0)) - (clz(x) + T(1)), T(-1), x == T(0)); } kernel void main0() { int signed_value = 0; uint unsigned_value = 0u; int s = extract_bits(signed_value, uint(5), uint(20)); uint u = extract_bits(unsigned_value, uint(6), uint(21)); s = insert_bits(s, 40, uint(5), uint(4)); u = insert_bits(u, 60u, uint(5), uint(4)); u = reverse_bits(u); s = reverse_bits(s); int v0 = int(popcount(u)); int v1 = popcount(s); int v2 = int(spvFindUMSB(u)); int v3 = spvFindSMSB(s); int v4 = int(spvFindLSB(u)); int v5 = spvFindLSB(s); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/glsl.std450.comp000066400000000000000000000300401400026215700255620ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float res; int ires; uint ures; float4 f32; int4 s32; uint4 u32; float2x2 m2; float3x3 m3; float4x4 m4; }; struct ResType { float _m0; int _m1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); // Implementation of the GLSL radians() function template inline T radians(T d) { return d * T(0.01745329251); } // Implementation of the GLSL degrees() function template inline T degrees(T r) { return r * T(57.2957795131); } // Implementation of the GLSL findLSB() function template inline T spvFindLSB(T x) { return select(ctz(x), T(-1), x == T(0)); } // Implementation of the signed GLSL findMSB() function template inline T spvFindSMSB(T x) { T v = select(x, T(-1) - x, x < T(0)); return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0)); } // Implementation of the unsigned GLSL findMSB() function template inline T spvFindUMSB(T x) { return select(clz(T(0)) - (clz(x) + T(1)), T(-1), x == T(0)); } // Implementation of the GLSL sign() function for integer types template::value>::type> inline T sign(T x) { return select(select(select(x, T(0), x == T(0)), T(1), x > T(0)), T(-1), x < T(0)); } // Returns the determinant of a 2x2 matrix. static inline __attribute__((always_inline)) float spvDet2x2(float a1, float a2, float b1, float b2) { return a1 * b2 - b1 * a2; } // Returns the determinant of a 3x3 matrix. static inline __attribute__((always_inline)) float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) { return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3); } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float4x4 spvInverse4x4(float4x4 m) { float4x4 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]); adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]); adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]); adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]); adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]); adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]); adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]); adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] * m[3][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float3x3 spvInverse3x3(float3x3 m) { float3x3 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]); adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]); adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]); adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]); adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]); adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]); adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]); adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]); adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float2x2 spvInverse2x2(float2x2 m) { float2x2 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = m[1][1]; adj[0][1] = -m[0][1]; adj[1][0] = -m[1][0]; adj[1][1] = m[0][0]; // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } template inline T spvReflect(T i, T n) { return i - T(2) * i * n * n; } template inline T spvRefract(T i, T n, T eta) { T NoI = n * i; T NoI2 = NoI * NoI; T k = T(1) - eta * eta * (T(1) - NoI2); if (k < T(0)) { return T(0); } else { return eta * i - (eta * NoI + sqrt(k)) * n; } } template inline T spvFaceForward(T n, T i, T nref) { return i * nref < T(0) ? n : -n; } kernel void main0(device SSBO& _19 [[buffer(0)]]) { _19.res = round(((device float*)&_19.f32)[0u]); _19.res = rint(((device float*)&_19.f32)[0u]); _19.res = trunc(((device float*)&_19.f32)[0u]); _19.res = abs(((device float*)&_19.f32)[0u]); _19.ires = abs(((device int*)&_19.s32)[0u]); _19.res = sign(((device float*)&_19.f32)[0u]); _19.ires = sign(((device int*)&_19.s32)[0u]); _19.res = floor(((device float*)&_19.f32)[0u]); _19.res = ceil(((device float*)&_19.f32)[0u]); _19.res = fract(((device float*)&_19.f32)[0u]); _19.res = radians(((device float*)&_19.f32)[0u]); _19.res = degrees(((device float*)&_19.f32)[0u]); _19.res = sin(((device float*)&_19.f32)[0u]); _19.res = cos(((device float*)&_19.f32)[0u]); _19.res = tan(((device float*)&_19.f32)[0u]); _19.res = asin(((device float*)&_19.f32)[0u]); _19.res = acos(((device float*)&_19.f32)[0u]); _19.res = atan(((device float*)&_19.f32)[0u]); _19.res = sinh(((device float*)&_19.f32)[0u]); _19.res = cosh(((device float*)&_19.f32)[0u]); _19.res = tanh(((device float*)&_19.f32)[0u]); _19.res = asinh(((device float*)&_19.f32)[0u]); _19.res = acosh(((device float*)&_19.f32)[0u]); _19.res = atanh(((device float*)&_19.f32)[0u]); _19.res = atan2(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u]); _19.res = pow(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u]); _19.res = exp(((device float*)&_19.f32)[0u]); _19.res = log(((device float*)&_19.f32)[0u]); _19.res = exp2(((device float*)&_19.f32)[0u]); _19.res = log2(((device float*)&_19.f32)[0u]); _19.res = sqrt(((device float*)&_19.f32)[0u]); _19.res = rsqrt(((device float*)&_19.f32)[0u]); _19.res = abs(((device float*)&_19.f32)[0u]); _19.res = abs(((device float*)&_19.f32)[0u] - ((device float*)&_19.f32)[1u]); _19.res = sign(((device float*)&_19.f32)[0u]); _19.res = spvFaceForward(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u], ((device float*)&_19.f32)[2u]); _19.res = spvReflect(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u]); _19.res = spvRefract(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u], ((device float*)&_19.f32)[2u]); _19.res = length(_19.f32.xy); _19.res = distance(_19.f32.xy, _19.f32.zw); float2 v2 = normalize(_19.f32.xy); v2 = faceforward(_19.f32.xy, _19.f32.yz, _19.f32.zw); v2 = reflect(_19.f32.xy, _19.f32.zw); v2 = refract(_19.f32.xy, _19.f32.yz, ((device float*)&_19.f32)[3u]); float3 v3 = cross(_19.f32.xyz, _19.f32.yzw); _19.res = determinant(_19.m2); _19.res = determinant(_19.m3); _19.res = determinant(_19.m4); _19.m2 = spvInverse2x2(_19.m2); _19.m3 = spvInverse3x3(_19.m3); _19.m4 = spvInverse4x4(_19.m4); float tmp; float _287 = modf(((device float*)&_19.f32)[0u], tmp); _19.res = _287; _19.res = fast::min(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u]); _19.ures = min(((device uint*)&_19.u32)[0u], ((device uint*)&_19.u32)[1u]); _19.ires = min(((device int*)&_19.s32)[0u], ((device int*)&_19.s32)[1u]); _19.res = fast::max(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u]); _19.ures = max(((device uint*)&_19.u32)[0u], ((device uint*)&_19.u32)[1u]); _19.ires = max(((device int*)&_19.s32)[0u], ((device int*)&_19.s32)[1u]); _19.res = fast::clamp(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u], ((device float*)&_19.f32)[2u]); _19.ures = clamp(((device uint*)&_19.u32)[0u], ((device uint*)&_19.u32)[1u], ((device uint*)&_19.u32)[2u]); _19.ires = clamp(((device int*)&_19.s32)[0u], ((device int*)&_19.s32)[1u], ((device int*)&_19.s32)[2u]); _19.res = mix(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u], ((device float*)&_19.f32)[2u]); _19.res = step(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u]); _19.res = smoothstep(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u], ((device float*)&_19.f32)[2u]); _19.res = fma(((device float*)&_19.f32)[0u], ((device float*)&_19.f32)[1u], ((device float*)&_19.f32)[2u]); ResType _387; _387._m0 = frexp(((device float*)&_19.f32)[0u], _387._m1); int itmp = _387._m1; _19.res = _387._m0; _19.res = ldexp(((device float*)&_19.f32)[0u], itmp); _19.ures = pack_float_to_snorm4x8(_19.f32); _19.ures = pack_float_to_unorm4x8(_19.f32); _19.ures = pack_float_to_snorm2x16(_19.f32.xy); _19.ures = pack_float_to_unorm2x16(_19.f32.xy); _19.ures = as_type(half2(_19.f32.xy)); v2 = unpack_snorm2x16_to_float(((device uint*)&_19.u32)[0u]); v2 = unpack_unorm2x16_to_float(((device uint*)&_19.u32)[0u]); v2 = float2(as_type(((device uint*)&_19.u32)[0u])); float4 v4 = unpack_snorm4x8_to_float(((device uint*)&_19.u32)[0u]); v4 = unpack_unorm4x8_to_float(((device uint*)&_19.u32)[0u]); _19.s32 = spvFindLSB(_19.s32); _19.s32 = int4(spvFindLSB(_19.u32)); _19.s32 = spvFindSMSB(_19.s32); _19.s32 = int4(spvFindUMSB(_19.u32)); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/illegal-struct-name.asm.comp000066400000000000000000000005061400026215700302330ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { float _abs; }; struct Foo_1 { float _abs; }; struct SSBO { Foo_1 foo; Foo_1 foo2; }; kernel void main0(device SSBO& _7 [[buffer(0)]]) { Foo f; f._abs = _7.foo._abs; int _abs = 10; _7.foo2._abs = f._abs; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/int64.invalid.msl22.comp000066400000000000000000000043111400026215700271300ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct M0 { long v; spvUnsafeArray b; ulong c; spvUnsafeArray d; }; struct SSBO0_Type { long4 a; M0 m0; }; struct SSBO1_Type { ulong4 b; M0 m0; }; struct SSBO2_Type { spvUnsafeArray a; spvUnsafeArray b; }; struct SSBO3_Type { spvUnsafeArray a; spvUnsafeArray b; }; struct SSBO { int s32; uint u32; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _96 [[buffer(0)]]) { SSBO0_Type ssbo_0; ssbo_0.a += long4(10l, 20l, 30l, 40l); SSBO1_Type ssbo_1; ssbo_1.b += ulong4(999999999999999999ul, 8888888888888888ul, 77777777777777777ul, 6666666666666666ul); ssbo_0.a += long4(20l); ssbo_0.a = abs(ssbo_0.a + long4(ssbo_1.b)); ssbo_0.a += long4(1l); ssbo_1.b += ulong4(long4(1l)); ssbo_0.a -= long4(1l); ssbo_1.b -= ulong4(long4(1l)); SSBO2_Type ssbo_2; ssbo_2.a[0] += 1l; SSBO3_Type ssbo_3; ssbo_3.a[0] += 2l; _96.s32 = int(uint(((ulong(ssbo_0.a.x) + ssbo_1.b.y) + ulong(ssbo_2.a[1])) + ulong(ssbo_3.a[2]))); _96.u32 = uint(((ulong(ssbo_0.a.y) + ssbo_1.b.z) + ulong(ssbo_2.a[0])) + ulong(ssbo_3.a[1])); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/loop.comp000066400000000000000000000030131400026215700245500ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4x4 mvp; float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(const device SSBO& _24 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; float4 idat = _24.in_data[ident]; int k = 0; uint i = 0u; if (idat.y == 20.0) { do { k *= 2; i++; } while (i < ident); } switch (k) { case 10: { for (;;) { i++; if (i > 10u) { break; } continue; } break; } default: { for (;;) { i += 2u; if (i > 20u) { break; } continue; } break; } } while (k < 10) { idat *= 2.0; k++; } for (uint i_1 = 0u; i_1 < 16u; i_1++, k++) { for (uint j = 0u; j < 30u; j++) { idat = _24.mvp * idat; } } k = 0; for (;;) { k++; if (k > 10) { k += 2; } else { k += 3; continue; } k += 10; continue; } } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/return.comp000066400000000000000000000013021400026215700251150ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO2& _27 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; if (ident == 2u) { _27.out_data[ident] = float4(20.0); } else { if (ident == 4u) { _27.out_data[ident] = float4(10.0); return; } } int i = 0; while (i < 20) { if (i == 10) { break; } return; } _27.out_data[ident] = float4(10.0); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/std140-array-load-composite-construct.comp000066400000000000000000000005741400026215700327020ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 a[16]; float4 b[16]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _14 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _14.b[gl_GlobalInvocationID.x] = float4(_14.a[gl_GlobalInvocationID.x].x); } struct-packing-scalar.nocompat.invalid.vk.comp000066400000000000000000000063171400026215700336160ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp#include #include using namespace metal; typedef packed_float2 packed_float2x2[2]; typedef packed_float3 packed_float2x3[2]; typedef packed_float3 packed_rm_float3x2[2]; struct S0 { packed_float2 a[1]; float b; }; struct S1 { packed_float3 a; float b; }; struct S2 { packed_float3 a[1]; float b; }; struct S3 { packed_float2 a; float b; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; }; struct SSBO1 { Content content; Content content1[2]; Content content2; float2x2 m0; float2x2 m1; packed_float2x3 m2[4]; float3x2 m3; float2x2 m4; float2x2 m5[9]; float3x2 m6[4][2]; packed_rm_float3x2 m7; float array[1]; }; struct S0_1 { float2 a[1]; char _m1_pad[8]; float b; char _m0_final_padding[12]; }; struct S1_1 { packed_float3 a; float b; }; struct S2_1 { float3 a[1]; float b; char _m0_final_padding[12]; }; struct S3_1 { float2 a; float b; }; struct Content_1 { S0_1 m0s[1]; S1_1 m1s[1]; S2_1 m2s[1]; S0_1 m0; S1_1 m1; S2_1 m2; S3_1 m3; float m4; char _m0_final_padding[12]; }; struct SSBO0 { Content_1 content; Content_1 content1[2]; Content_1 content2; float2x4 m0; float2x4 m1; float2x3 m2[4]; float3x4 m3; float2x4 m4; float2x4 m5[9]; float3x4 m6[4][2]; float2x3 m7; float4 array[1]; }; struct SSBO2 { float m0; packed_float2x2 m1; packed_rm_float3x2 m2; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO1& ssbo_scalar [[buffer(0)]], device SSBO0& ssbo_140 [[buffer(1)]], device SSBO2& ssbo_scalar2 [[buffer(2)]]) { ssbo_scalar.content.m0s[0].a[0] = ssbo_140.content.m0s[0].a[0]; ssbo_scalar.content.m0s[0].b = ssbo_140.content.m0s[0].b; ssbo_scalar.content.m1s[0].a = float3(ssbo_140.content.m1s[0].a); ssbo_scalar.content.m1s[0].b = ssbo_140.content.m1s[0].b; ssbo_scalar.content.m2s[0].a[0] = ssbo_140.content.m2s[0].a[0]; ssbo_scalar.content.m2s[0].b = ssbo_140.content.m2s[0].b; ssbo_scalar.content.m0.a[0] = ssbo_140.content.m0.a[0]; ssbo_scalar.content.m0.b = ssbo_140.content.m0.b; ssbo_scalar.content.m1.a = float3(ssbo_140.content.m1.a); ssbo_scalar.content.m1.b = ssbo_140.content.m1.b; ssbo_scalar.content.m2.a[0] = ssbo_140.content.m2.a[0]; ssbo_scalar.content.m2.b = ssbo_140.content.m2.b; ssbo_scalar.content.m3.a = ssbo_140.content.m3.a; ssbo_scalar.content.m3.b = ssbo_140.content.m3.b; ssbo_scalar.content.m4 = ssbo_140.content.m4; ssbo_scalar.content.m1.a = float2x3(float3(ssbo_scalar.m2[1][0]), float3(ssbo_scalar.m2[1][1])) * float2(ssbo_scalar.content.m0.a[0]); ssbo_scalar.m0 = float2x2(float2(ssbo_scalar2.m1[0]), float2(ssbo_scalar2.m1[1])); ssbo_scalar2.m1[0] = float2(ssbo_scalar.m4[0][0], ssbo_scalar.m4[1][0]); ssbo_scalar2.m1[1] = float2(ssbo_scalar.m4[0][1], ssbo_scalar.m4[1][1]); ssbo_scalar2.m2[0] = float3(ssbo_scalar.m3[0][0], ssbo_scalar.m3[1][0], ssbo_scalar.m3[2][0]); ssbo_scalar2.m2[1] = float3(ssbo_scalar.m3[0][1], ssbo_scalar.m3[1][1], ssbo_scalar.m3[2][1]); } subgroups.nocompat.invalid.vk.msl12.emulate-subgroup.comp000066400000000000000000000021431400026215700356730ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp#include #include using namespace metal; struct SSBO { float FragColor; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _9 [[buffer(0)]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]], unsupported-built-in-type gl_WorkGroupSize [[unsupported-built-in]]) { uint gl_NumSubgroups = gl_WorkGroupSize.x * gl_WorkGroupSize.y * gl_WorkGroupSize.z; uint gl_SubgroupID = gl_LocalInvocationIndex; uint gl_SubgroupSize = 1; uint gl_SubgroupInvocationID = 0; _9.FragColor = float(gl_NumSubgroups); _9.FragColor = float(gl_SubgroupID); _9.FragColor = float(gl_SubgroupSize); _9.FragColor = float(gl_SubgroupInvocationID); threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); threadgroup_barrier(mem_flags::mem_device); threadgroup_barrier(mem_flags::mem_threadgroup); threadgroup_barrier(mem_flags::mem_texture); bool elected = true; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp/subgroups.nocompat.invalid.vk.msl21.comp000066400000000000000000000277121400026215700324640ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float FragColor; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); template inline T spvSubgroupBroadcast(T value, ushort lane) { return simd_broadcast(value, lane); } template<> inline bool spvSubgroupBroadcast(bool value, ushort lane) { return !!simd_broadcast((ushort)value, lane); } template inline vec spvSubgroupBroadcast(vec value, ushort lane) { return (vec)simd_broadcast((vec)value, lane); } template inline T spvSubgroupBroadcastFirst(T value) { return simd_broadcast_first(value); } template<> inline bool spvSubgroupBroadcastFirst(bool value) { return !!simd_broadcast_first((ushort)value); } template inline vec spvSubgroupBroadcastFirst(vec value) { return (vec)simd_broadcast_first((vec)value); } inline uint4 spvSubgroupBallot(bool value) { simd_vote vote = simd_ballot(value); // simd_ballot() returns a 64-bit integer-like object, but // SPIR-V callers expect a uint4. We must convert. // FIXME: This won't include higher bits if Apple ever supports // 128 lanes in an SIMD-group. return uint4((uint)((simd_vote::vote_t)vote & 0xFFFFFFFF), (uint)(((simd_vote::vote_t)vote >> 32) & 0xFFFFFFFF), 0, 0); } inline bool spvSubgroupBallotBitExtract(uint4 ballot, uint bit) { return !!extract_bits(ballot[bit / 32], bit % 32, 1); } inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0); } inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - (clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), ballot.z == 0), ballot.w == 0); } inline uint spvPopCount4(uint4 ballot) { return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w); } inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } template inline bool spvSubgroupAllEqual(T value) { return simd_all(all(value == simd_broadcast_first(value))); } template<> inline bool spvSubgroupAllEqual(bool value) { return simd_all(value) || !simd_any(value); } template inline bool spvSubgroupAllEqual(vec value) { return simd_all(all(value == (vec)simd_broadcast_first((vec)value))); } template inline T spvSubgroupShuffle(T value, ushort lane) { return simd_shuffle(value, lane); } template<> inline bool spvSubgroupShuffle(bool value, ushort lane) { return !!simd_shuffle((ushort)value, lane); } template inline vec spvSubgroupShuffle(vec value, ushort lane) { return (vec)simd_shuffle((vec)value, lane); } template inline T spvSubgroupShuffleXor(T value, ushort mask) { return simd_shuffle_xor(value, mask); } template<> inline bool spvSubgroupShuffleXor(bool value, ushort mask) { return !!simd_shuffle_xor((ushort)value, mask); } template inline vec spvSubgroupShuffleXor(vec value, ushort mask) { return (vec)simd_shuffle_xor((vec)value, mask); } template inline T spvSubgroupShuffleUp(T value, ushort delta) { return simd_shuffle_up(value, delta); } template<> inline bool spvSubgroupShuffleUp(bool value, ushort delta) { return !!simd_shuffle_up((ushort)value, delta); } template inline vec spvSubgroupShuffleUp(vec value, ushort delta) { return (vec)simd_shuffle_up((vec)value, delta); } template inline T spvSubgroupShuffleDown(T value, ushort delta) { return simd_shuffle_down(value, delta); } template<> inline bool spvSubgroupShuffleDown(bool value, ushort delta) { return !!simd_shuffle_down((ushort)value, delta); } template inline vec spvSubgroupShuffleDown(vec value, ushort delta) { return (vec)simd_shuffle_down((vec)value, delta); } template inline T spvQuadBroadcast(T value, uint lane) { return quad_broadcast(value, lane); } template<> inline bool spvQuadBroadcast(bool value, uint lane) { return !!quad_broadcast((ushort)value, lane); } template inline vec spvQuadBroadcast(vec value, uint lane) { return (vec)quad_broadcast((vec)value, lane); } template inline T spvQuadSwap(T value, uint dir) { return quad_shuffle_xor(value, dir + 1); } template<> inline bool spvQuadSwap(bool value, uint dir) { return !!quad_shuffle_xor((ushort)value, dir + 1); } template inline vec spvQuadSwap(vec value, uint dir) { return (vec)quad_shuffle_xor((vec)value, dir + 1); } kernel void main0(device SSBO& _9 [[buffer(0)]], uint gl_NumSubgroups [[simdgroups_per_threadgroup]], uint gl_SubgroupID [[simdgroup_index_in_threadgroup]], uint gl_SubgroupSize [[thread_execution_width]], uint gl_SubgroupInvocationID [[thread_index_in_simdgroup]]) { uint4 gl_SubgroupEqMask = gl_SubgroupInvocationID >= 32 ? uint4(0, (1 << (gl_SubgroupInvocationID - 32)), uint2(0)) : uint4(1 << gl_SubgroupInvocationID, uint3(0)); uint4 gl_SubgroupGeMask = uint4(insert_bits(0u, 0xFFFFFFFF, min(gl_SubgroupInvocationID, 32u), (uint)max(min((int)gl_SubgroupSize, 32) - (int)gl_SubgroupInvocationID, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)gl_SubgroupInvocationID - 32, 0), (uint)max((int)gl_SubgroupSize - (int)max(gl_SubgroupInvocationID, 32u), 0)), uint2(0)); uint4 gl_SubgroupGtMask = uint4(insert_bits(0u, 0xFFFFFFFF, min(gl_SubgroupInvocationID + 1, 32u), (uint)max(min((int)gl_SubgroupSize, 32) - (int)gl_SubgroupInvocationID - 1, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0), (uint)max((int)gl_SubgroupSize - (int)max(gl_SubgroupInvocationID + 1, 32u), 0)), uint2(0)); uint4 gl_SubgroupLeMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0)); uint4 gl_SubgroupLtMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0)); _9.FragColor = float(gl_NumSubgroups); _9.FragColor = float(gl_SubgroupID); _9.FragColor = float(gl_SubgroupSize); _9.FragColor = float(gl_SubgroupInvocationID); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device); simdgroup_barrier(mem_flags::mem_threadgroup); simdgroup_barrier(mem_flags::mem_texture); bool _39 = simd_is_first(); bool elected = _39; _9.FragColor = float4(gl_SubgroupEqMask).x; _9.FragColor = float4(gl_SubgroupGeMask).x; _9.FragColor = float4(gl_SubgroupGtMask).x; _9.FragColor = float4(gl_SubgroupLeMask).x; _9.FragColor = float4(gl_SubgroupLtMask).x; float4 broadcasted = spvSubgroupBroadcast(float4(10.0), 8u); bool2 broadcasted_bool = spvSubgroupBroadcast(bool2(true), 8u); float3 first = spvSubgroupBroadcastFirst(float3(20.0)); bool4 first_bool = spvSubgroupBroadcastFirst(bool4(false)); uint4 ballot_value = spvSubgroupBallot(true); bool inverse_ballot_value = spvSubgroupBallotBitExtract(ballot_value, gl_SubgroupInvocationID); bool bit_extracted = spvSubgroupBallotBitExtract(uint4(10u), 8u); uint bit_count = spvSubgroupBallotBitCount(ballot_value, gl_SubgroupSize); uint inclusive_bit_count = spvSubgroupBallotInclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint exclusive_bit_count = spvSubgroupBallotExclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint lsb = spvSubgroupBallotFindLSB(ballot_value, gl_SubgroupSize); uint msb = spvSubgroupBallotFindMSB(ballot_value, gl_SubgroupSize); uint shuffled = spvSubgroupShuffle(10u, 8u); bool shuffled_bool = spvSubgroupShuffle(true, 9u); uint shuffled_xor = spvSubgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = spvSubgroupShuffleXor(false, 9u); uint shuffled_up = spvSubgroupShuffleUp(20u, 4u); bool shuffled_up_bool = spvSubgroupShuffleUp(true, 4u); uint shuffled_down = spvSubgroupShuffleDown(20u, 4u); bool shuffled_down_bool = spvSubgroupShuffleDown(false, 4u); bool has_all = simd_all(true); bool has_any = simd_any(true); bool has_equal = spvSubgroupAllEqual(0); has_equal = spvSubgroupAllEqual(true); has_equal = spvSubgroupAllEqual(float3(0.0, 1.0, 2.0)); has_equal = spvSubgroupAllEqual(bool4(true, true, false, true)); float4 added = simd_sum(float4(20.0)); int4 iadded = simd_sum(int4(20)); float4 multiplied = simd_product(float4(20.0)); int4 imultiplied = simd_product(int4(20)); float4 lo = simd_min(float4(20.0)); float4 hi = simd_max(float4(20.0)); int4 slo = simd_min(int4(20)); int4 shi = simd_max(int4(20)); uint4 ulo = simd_min(uint4(20u)); uint4 uhi = simd_max(uint4(20u)); uint4 anded = simd_and(ballot_value); uint4 ored = simd_or(ballot_value); uint4 xored = simd_xor(ballot_value); added = simd_prefix_inclusive_sum(added); iadded = simd_prefix_inclusive_sum(iadded); multiplied = simd_prefix_inclusive_product(multiplied); imultiplied = simd_prefix_inclusive_product(imultiplied); added = simd_prefix_exclusive_sum(multiplied); multiplied = simd_prefix_exclusive_product(multiplied); iadded = simd_prefix_exclusive_sum(imultiplied); imultiplied = simd_prefix_exclusive_product(imultiplied); added = quad_sum(added); multiplied = quad_product(multiplied); iadded = quad_sum(iadded); imultiplied = quad_product(imultiplied); lo = quad_min(lo); hi = quad_max(hi); ulo = quad_min(ulo); uhi = quad_max(uhi); slo = quad_min(slo); shi = quad_max(shi); anded = quad_and(anded); ored = quad_or(ored); xored = quad_xor(xored); float4 swap_horiz = spvQuadSwap(float4(20.0), 0u); bool4 swap_horiz_bool = spvQuadSwap(bool4(true), 0u); float4 swap_vertical = spvQuadSwap(float4(20.0), 1u); bool4 swap_vertical_bool = spvQuadSwap(bool4(true), 1u); float4 swap_diagonal = spvQuadSwap(float4(20.0), 2u); bool4 swap_diagonal_bool = spvQuadSwap(bool4(true), 2u); float4 quad_broadcast0 = spvQuadBroadcast(float4(20.0), 3u); bool4 quad_broadcast_bool = spvQuadBroadcast(bool4(true), 3u); } subgroups.nocompat.invalid.vk.msl21.fixed-subgroup.comp000066400000000000000000000270121400026215700353400ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float FragColor; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); template inline T spvSubgroupBroadcast(T value, ushort lane) { return simd_broadcast(value, lane); } template<> inline bool spvSubgroupBroadcast(bool value, ushort lane) { return !!simd_broadcast((ushort)value, lane); } template inline vec spvSubgroupBroadcast(vec value, ushort lane) { return (vec)simd_broadcast((vec)value, lane); } template inline T spvSubgroupBroadcastFirst(T value) { return simd_broadcast_first(value); } template<> inline bool spvSubgroupBroadcastFirst(bool value) { return !!simd_broadcast_first((ushort)value); } template inline vec spvSubgroupBroadcastFirst(vec value) { return (vec)simd_broadcast_first((vec)value); } inline uint4 spvSubgroupBallot(bool value) { simd_vote vote = simd_ballot(value); // simd_ballot() returns a 64-bit integer-like object, but // SPIR-V callers expect a uint4. We must convert. // FIXME: This won't include higher bits if Apple ever supports // 128 lanes in an SIMD-group. return uint4((uint)((simd_vote::vote_t)vote & 0xFFFFFFFF), (uint)(((simd_vote::vote_t)vote >> 32) & 0xFFFFFFFF), 0, 0); } inline bool spvSubgroupBallotBitExtract(uint4 ballot, uint bit) { return !!extract_bits(ballot[bit / 32], bit % 32, 1); } inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0); } inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - (clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), ballot.z == 0), ballot.w == 0); } inline uint spvPopCount4(uint4 ballot) { return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w); } inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } template inline bool spvSubgroupAllEqual(T value) { return simd_all(all(value == simd_broadcast_first(value))); } template<> inline bool spvSubgroupAllEqual(bool value) { return simd_all(value) || !simd_any(value); } template inline bool spvSubgroupAllEqual(vec value) { return simd_all(all(value == (vec)simd_broadcast_first((vec)value))); } template inline T spvSubgroupShuffle(T value, ushort lane) { return simd_shuffle(value, lane); } template<> inline bool spvSubgroupShuffle(bool value, ushort lane) { return !!simd_shuffle((ushort)value, lane); } template inline vec spvSubgroupShuffle(vec value, ushort lane) { return (vec)simd_shuffle((vec)value, lane); } template inline T spvSubgroupShuffleXor(T value, ushort mask) { return simd_shuffle_xor(value, mask); } template<> inline bool spvSubgroupShuffleXor(bool value, ushort mask) { return !!simd_shuffle_xor((ushort)value, mask); } template inline vec spvSubgroupShuffleXor(vec value, ushort mask) { return (vec)simd_shuffle_xor((vec)value, mask); } template inline T spvSubgroupShuffleUp(T value, ushort delta) { return simd_shuffle_up(value, delta); } template<> inline bool spvSubgroupShuffleUp(bool value, ushort delta) { return !!simd_shuffle_up((ushort)value, delta); } template inline vec spvSubgroupShuffleUp(vec value, ushort delta) { return (vec)simd_shuffle_up((vec)value, delta); } template inline T spvSubgroupShuffleDown(T value, ushort delta) { return simd_shuffle_down(value, delta); } template<> inline bool spvSubgroupShuffleDown(bool value, ushort delta) { return !!simd_shuffle_down((ushort)value, delta); } template inline vec spvSubgroupShuffleDown(vec value, ushort delta) { return (vec)simd_shuffle_down((vec)value, delta); } template inline T spvQuadBroadcast(T value, uint lane) { return quad_broadcast(value, lane); } template<> inline bool spvQuadBroadcast(bool value, uint lane) { return !!quad_broadcast((ushort)value, lane); } template inline vec spvQuadBroadcast(vec value, uint lane) { return (vec)quad_broadcast((vec)value, lane); } template inline T spvQuadSwap(T value, uint dir) { return quad_shuffle_xor(value, dir + 1); } template<> inline bool spvQuadSwap(bool value, uint dir) { return !!quad_shuffle_xor((ushort)value, dir + 1); } template inline vec spvQuadSwap(vec value, uint dir) { return (vec)quad_shuffle_xor((vec)value, dir + 1); } kernel void main0(device SSBO& _9 [[buffer(0)]], uint gl_NumSubgroups [[simdgroups_per_threadgroup]], uint gl_SubgroupID [[simdgroup_index_in_threadgroup]], uint gl_SubgroupInvocationID [[thread_index_in_simdgroup]]) { uint gl_SubgroupSize = 32; uint4 gl_SubgroupEqMask = gl_SubgroupInvocationID >= 32 ? uint4(0, (1 << (gl_SubgroupInvocationID - 32)), uint2(0)) : uint4(1 << gl_SubgroupInvocationID, uint3(0)); uint4 gl_SubgroupGeMask = uint4(insert_bits(0u, 0xFFFFFFFF, gl_SubgroupInvocationID, 32 - gl_SubgroupInvocationID), uint3(0)); uint4 gl_SubgroupGtMask = uint4(insert_bits(0u, 0xFFFFFFFF, gl_SubgroupInvocationID + 1, 32 - gl_SubgroupInvocationID - 1), uint3(0)); uint4 gl_SubgroupLeMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0)); uint4 gl_SubgroupLtMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0)); _9.FragColor = float(gl_NumSubgroups); _9.FragColor = float(gl_SubgroupID); _9.FragColor = float(gl_SubgroupSize); _9.FragColor = float(gl_SubgroupInvocationID); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device); simdgroup_barrier(mem_flags::mem_threadgroup); simdgroup_barrier(mem_flags::mem_texture); bool _39 = simd_is_first(); bool elected = _39; _9.FragColor = float4(gl_SubgroupEqMask).x; _9.FragColor = float4(gl_SubgroupGeMask).x; _9.FragColor = float4(gl_SubgroupGtMask).x; _9.FragColor = float4(gl_SubgroupLeMask).x; _9.FragColor = float4(gl_SubgroupLtMask).x; float4 broadcasted = spvSubgroupBroadcast(float4(10.0), 8u); bool2 broadcasted_bool = spvSubgroupBroadcast(bool2(true), 8u); float3 first = spvSubgroupBroadcastFirst(float3(20.0)); bool4 first_bool = spvSubgroupBroadcastFirst(bool4(false)); uint4 ballot_value = spvSubgroupBallot(true); bool inverse_ballot_value = spvSubgroupBallotBitExtract(ballot_value, gl_SubgroupInvocationID); bool bit_extracted = spvSubgroupBallotBitExtract(uint4(10u), 8u); uint bit_count = spvSubgroupBallotBitCount(ballot_value, gl_SubgroupSize); uint inclusive_bit_count = spvSubgroupBallotInclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint exclusive_bit_count = spvSubgroupBallotExclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint lsb = spvSubgroupBallotFindLSB(ballot_value, gl_SubgroupSize); uint msb = spvSubgroupBallotFindMSB(ballot_value, gl_SubgroupSize); uint shuffled = spvSubgroupShuffle(10u, 8u); bool shuffled_bool = spvSubgroupShuffle(true, 9u); uint shuffled_xor = spvSubgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = spvSubgroupShuffleXor(false, 9u); uint shuffled_up = spvSubgroupShuffleUp(20u, 4u); bool shuffled_up_bool = spvSubgroupShuffleUp(true, 4u); uint shuffled_down = spvSubgroupShuffleDown(20u, 4u); bool shuffled_down_bool = spvSubgroupShuffleDown(false, 4u); bool has_all = simd_all(true); bool has_any = simd_any(true); bool has_equal = spvSubgroupAllEqual(0); has_equal = spvSubgroupAllEqual(true); has_equal = spvSubgroupAllEqual(float3(0.0, 1.0, 2.0)); has_equal = spvSubgroupAllEqual(bool4(true, true, false, true)); float4 added = simd_sum(float4(20.0)); int4 iadded = simd_sum(int4(20)); float4 multiplied = simd_product(float4(20.0)); int4 imultiplied = simd_product(int4(20)); float4 lo = simd_min(float4(20.0)); float4 hi = simd_max(float4(20.0)); int4 slo = simd_min(int4(20)); int4 shi = simd_max(int4(20)); uint4 ulo = simd_min(uint4(20u)); uint4 uhi = simd_max(uint4(20u)); uint4 anded = simd_and(ballot_value); uint4 ored = simd_or(ballot_value); uint4 xored = simd_xor(ballot_value); added = simd_prefix_inclusive_sum(added); iadded = simd_prefix_inclusive_sum(iadded); multiplied = simd_prefix_inclusive_product(multiplied); imultiplied = simd_prefix_inclusive_product(imultiplied); added = simd_prefix_exclusive_sum(multiplied); multiplied = simd_prefix_exclusive_product(multiplied); iadded = simd_prefix_exclusive_sum(imultiplied); imultiplied = simd_prefix_exclusive_product(imultiplied); added = quad_sum(added); multiplied = quad_product(multiplied); iadded = quad_sum(iadded); imultiplied = quad_product(imultiplied); lo = quad_min(lo); hi = quad_max(hi); ulo = quad_min(ulo); uhi = quad_max(uhi); slo = quad_min(slo); shi = quad_max(shi); anded = quad_and(anded); ored = quad_or(ored); xored = quad_xor(xored); float4 swap_horiz = spvQuadSwap(float4(20.0), 0u); bool4 swap_horiz_bool = spvQuadSwap(bool4(true), 0u); float4 swap_vertical = spvQuadSwap(float4(20.0), 1u); bool4 swap_vertical_bool = spvQuadSwap(bool4(true), 1u); float4 swap_diagonal = spvQuadSwap(float4(20.0), 2u); bool4 swap_diagonal_bool = spvQuadSwap(bool4(true), 2u); float4 quad_broadcast0 = spvQuadBroadcast(float4(20.0), 3u); bool4 quad_broadcast_bool = spvQuadBroadcast(bool4(true), 3u); } subgroups.nocompat.invalid.vk.msl21.ios.comp000066400000000000000000000104631400026215700331710ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float FragColor; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); template inline T spvSubgroupShuffle(T value, ushort lane) { return quad_shuffle(value, lane); } template<> inline bool spvSubgroupShuffle(bool value, ushort lane) { return !!quad_shuffle((ushort)value, lane); } template inline vec spvSubgroupShuffle(vec value, ushort lane) { return (vec)quad_shuffle((vec)value, lane); } template inline T spvSubgroupShuffleXor(T value, ushort mask) { return quad_shuffle_xor(value, mask); } template<> inline bool spvSubgroupShuffleXor(bool value, ushort mask) { return !!quad_shuffle_xor((ushort)value, mask); } template inline vec spvSubgroupShuffleXor(vec value, ushort mask) { return (vec)quad_shuffle_xor((vec)value, mask); } template inline T spvSubgroupShuffleUp(T value, ushort delta) { return quad_shuffle_up(value, delta); } template<> inline bool spvSubgroupShuffleUp(bool value, ushort delta) { return !!quad_shuffle_up((ushort)value, delta); } template inline vec spvSubgroupShuffleUp(vec value, ushort delta) { return (vec)quad_shuffle_up((vec)value, delta); } template inline T spvSubgroupShuffleDown(T value, ushort delta) { return quad_shuffle_down(value, delta); } template<> inline bool spvSubgroupShuffleDown(bool value, ushort delta) { return !!quad_shuffle_down((ushort)value, delta); } template inline vec spvSubgroupShuffleDown(vec value, ushort delta) { return (vec)quad_shuffle_down((vec)value, delta); } template inline T spvQuadBroadcast(T value, uint lane) { return quad_broadcast(value, lane); } template<> inline bool spvQuadBroadcast(bool value, uint lane) { return !!quad_broadcast((ushort)value, lane); } template inline vec spvQuadBroadcast(vec value, uint lane) { return (vec)quad_broadcast((vec)value, lane); } template inline T spvQuadSwap(T value, uint dir) { return quad_shuffle_xor(value, dir + 1); } template<> inline bool spvQuadSwap(bool value, uint dir) { return !!quad_shuffle_xor((ushort)value, dir + 1); } template inline vec spvQuadSwap(vec value, uint dir) { return (vec)quad_shuffle_xor((vec)value, dir + 1); } kernel void main0(device SSBO& _9 [[buffer(0)]], uint gl_NumSubgroups [[quadgroups_per_threadgroup]], uint gl_SubgroupID [[quadgroup_index_in_threadgroup]], uint gl_SubgroupSize [[thread_execution_width]], uint gl_SubgroupInvocationID [[thread_index_in_quadgroup]]) { _9.FragColor = float(gl_NumSubgroups); _9.FragColor = float(gl_SubgroupID); _9.FragColor = float(gl_SubgroupSize); _9.FragColor = float(gl_SubgroupInvocationID); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device); simdgroup_barrier(mem_flags::mem_threadgroup); simdgroup_barrier(mem_flags::mem_texture); uint shuffled = spvSubgroupShuffle(10u, 8u); bool shuffled_bool = spvSubgroupShuffle(true, 9u); uint shuffled_xor = spvSubgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = spvSubgroupShuffleXor(false, 9u); uint shuffled_up = spvSubgroupShuffleUp(20u, 4u); bool shuffled_up_bool = spvSubgroupShuffleUp(true, 4u); uint shuffled_down = spvSubgroupShuffleDown(20u, 4u); bool shuffled_down_bool = spvSubgroupShuffleDown(false, 4u); float4 swap_horiz = spvQuadSwap(float4(20.0), 0u); bool4 swap_horiz_bool = spvQuadSwap(bool4(true), 0u); float4 swap_vertical = spvQuadSwap(float4(20.0), 1u); bool4 swap_vertical_bool = spvQuadSwap(bool4(true), 1u); float4 swap_diagonal = spvQuadSwap(float4(20.0), 2u); bool4 swap_diagonal_bool = spvQuadSwap(bool4(true), 2u); float4 quad_broadcast0 = spvQuadBroadcast(float4(20.0), 3u); bool4 quad_broadcast_bool = spvQuadBroadcast(bool4(true), 3u); } subgroups.nocompat.invalid.vk.msl22.ios.comp000066400000000000000000000223741400026215700331760ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float FragColor; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); template inline T spvSubgroupBroadcast(T value, ushort lane) { return quad_broadcast(value, lane); } template<> inline bool spvSubgroupBroadcast(bool value, ushort lane) { return !!quad_broadcast((ushort)value, lane); } template inline vec spvSubgroupBroadcast(vec value, ushort lane) { return (vec)quad_broadcast((vec)value, lane); } template inline T spvSubgroupBroadcastFirst(T value) { return quad_broadcast_first(value); } template<> inline bool spvSubgroupBroadcastFirst(bool value) { return !!quad_broadcast_first((ushort)value); } template inline vec spvSubgroupBroadcastFirst(vec value) { return (vec)quad_broadcast_first((vec)value); } inline uint4 spvSubgroupBallot(bool value) { return uint4((quad_vote::vote_t)quad_ballot(value), 0, 0, 0); } inline bool spvSubgroupBallotBitExtract(uint4 ballot, uint bit) { return !!extract_bits(ballot[bit / 32], bit % 32, 1); } inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupSize), uint3(0)); ballot &= mask; return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0); } inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupSize), uint3(0)); ballot &= mask; return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - (clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), ballot.z == 0), ballot.w == 0); } inline uint spvPopCount4(uint4 ballot) { return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w); } inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupSize), uint3(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID + 1), uint3(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID), uint2(0)); return spvPopCount4(ballot & mask); } template inline bool spvSubgroupAllEqual(T value) { return quad_all(all(value == quad_broadcast_first(value))); } template<> inline bool spvSubgroupAllEqual(bool value) { return quad_all(value) || !quad_any(value); } template inline bool spvSubgroupAllEqual(vec value) { return quad_all(all(value == (vec)quad_broadcast_first((vec)value))); } template inline T spvSubgroupShuffle(T value, ushort lane) { return quad_shuffle(value, lane); } template<> inline bool spvSubgroupShuffle(bool value, ushort lane) { return !!quad_shuffle((ushort)value, lane); } template inline vec spvSubgroupShuffle(vec value, ushort lane) { return (vec)quad_shuffle((vec)value, lane); } template inline T spvSubgroupShuffleXor(T value, ushort mask) { return quad_shuffle_xor(value, mask); } template<> inline bool spvSubgroupShuffleXor(bool value, ushort mask) { return !!quad_shuffle_xor((ushort)value, mask); } template inline vec spvSubgroupShuffleXor(vec value, ushort mask) { return (vec)quad_shuffle_xor((vec)value, mask); } template inline T spvSubgroupShuffleUp(T value, ushort delta) { return quad_shuffle_up(value, delta); } template<> inline bool spvSubgroupShuffleUp(bool value, ushort delta) { return !!quad_shuffle_up((ushort)value, delta); } template inline vec spvSubgroupShuffleUp(vec value, ushort delta) { return (vec)quad_shuffle_up((vec)value, delta); } template inline T spvSubgroupShuffleDown(T value, ushort delta) { return quad_shuffle_down(value, delta); } template<> inline bool spvSubgroupShuffleDown(bool value, ushort delta) { return !!quad_shuffle_down((ushort)value, delta); } template inline vec spvSubgroupShuffleDown(vec value, ushort delta) { return (vec)quad_shuffle_down((vec)value, delta); } template inline T spvQuadBroadcast(T value, uint lane) { return quad_broadcast(value, lane); } template<> inline bool spvQuadBroadcast(bool value, uint lane) { return !!quad_broadcast((ushort)value, lane); } template inline vec spvQuadBroadcast(vec value, uint lane) { return (vec)quad_broadcast((vec)value, lane); } template inline T spvQuadSwap(T value, uint dir) { return quad_shuffle_xor(value, dir + 1); } template<> inline bool spvQuadSwap(bool value, uint dir) { return !!quad_shuffle_xor((ushort)value, dir + 1); } template inline vec spvQuadSwap(vec value, uint dir) { return (vec)quad_shuffle_xor((vec)value, dir + 1); } kernel void main0(device SSBO& _9 [[buffer(0)]], uint gl_NumSubgroups [[quadgroups_per_threadgroup]], uint gl_SubgroupID [[quadgroup_index_in_threadgroup]], uint gl_SubgroupSize [[thread_execution_width]], uint gl_SubgroupInvocationID [[thread_index_in_quadgroup]]) { uint4 gl_SubgroupEqMask = uint4(1 << gl_SubgroupInvocationID, uint3(0)); uint4 gl_SubgroupGeMask = uint4(insert_bits(0u, 0xFFFFFFFF, gl_SubgroupInvocationID, gl_SubgroupSize - gl_SubgroupInvocationID), uint3(0)); uint4 gl_SubgroupGtMask = uint4(insert_bits(0u, 0xFFFFFFFF, gl_SubgroupInvocationID + 1, gl_SubgroupSize - gl_SubgroupInvocationID - 1), uint3(0)); uint4 gl_SubgroupLeMask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID + 1), uint3(0)); uint4 gl_SubgroupLtMask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID), uint3(0)); _9.FragColor = float(gl_NumSubgroups); _9.FragColor = float(gl_SubgroupID); _9.FragColor = float(gl_SubgroupSize); _9.FragColor = float(gl_SubgroupInvocationID); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device); simdgroup_barrier(mem_flags::mem_threadgroup); simdgroup_barrier(mem_flags::mem_texture); bool _39 = quad_is_first(); bool elected = _39; _9.FragColor = float4(gl_SubgroupEqMask).x; _9.FragColor = float4(gl_SubgroupGeMask).x; _9.FragColor = float4(gl_SubgroupGtMask).x; _9.FragColor = float4(gl_SubgroupLeMask).x; _9.FragColor = float4(gl_SubgroupLtMask).x; float4 broadcasted = spvSubgroupBroadcast(float4(10.0), 8u); bool2 broadcasted_bool = spvSubgroupBroadcast(bool2(true), 8u); float3 first = spvSubgroupBroadcastFirst(float3(20.0)); bool4 first_bool = spvSubgroupBroadcastFirst(bool4(false)); uint4 ballot_value = spvSubgroupBallot(true); bool inverse_ballot_value = spvSubgroupBallotBitExtract(ballot_value, gl_SubgroupInvocationID); bool bit_extracted = spvSubgroupBallotBitExtract(uint4(10u), 8u); uint bit_count = spvSubgroupBallotBitCount(ballot_value, gl_SubgroupSize); uint inclusive_bit_count = spvSubgroupBallotInclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint exclusive_bit_count = spvSubgroupBallotExclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint lsb = spvSubgroupBallotFindLSB(ballot_value, gl_SubgroupSize); uint msb = spvSubgroupBallotFindMSB(ballot_value, gl_SubgroupSize); uint shuffled = spvSubgroupShuffle(10u, 8u); bool shuffled_bool = spvSubgroupShuffle(true, 9u); uint shuffled_xor = spvSubgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = spvSubgroupShuffleXor(false, 9u); uint shuffled_up = spvSubgroupShuffleUp(20u, 4u); bool shuffled_up_bool = spvSubgroupShuffleUp(true, 4u); uint shuffled_down = spvSubgroupShuffleDown(20u, 4u); bool shuffled_down_bool = spvSubgroupShuffleDown(false, 4u); bool has_all = quad_all(true); bool has_any = quad_any(true); bool has_equal = spvSubgroupAllEqual(0); has_equal = spvSubgroupAllEqual(true); has_equal = spvSubgroupAllEqual(float3(0.0, 1.0, 2.0)); has_equal = spvSubgroupAllEqual(bool4(true, true, false, true)); float4 swap_horiz = spvQuadSwap(float4(20.0), 0u); bool4 swap_horiz_bool = spvQuadSwap(bool4(true), 0u); float4 swap_vertical = spvQuadSwap(float4(20.0), 1u); bool4 swap_vertical_bool = spvQuadSwap(bool4(true), 1u); float4 swap_diagonal = spvQuadSwap(float4(20.0), 2u); bool4 swap_diagonal_bool = spvQuadSwap(bool4(true), 2u); float4 quad_broadcast0 = spvQuadBroadcast(float4(20.0), 3u); bool4 quad_broadcast_bool = spvQuadBroadcast(bool4(true), 3u); } subgroups.nocompat.invalid.vk.msl23.ios.simd.comp000066400000000000000000000251021400026215700341220ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float FragColor; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); template inline T spvSubgroupBroadcast(T value, ushort lane) { return simd_broadcast(value, lane); } template<> inline bool spvSubgroupBroadcast(bool value, ushort lane) { return !!simd_broadcast((ushort)value, lane); } template inline vec spvSubgroupBroadcast(vec value, ushort lane) { return (vec)simd_broadcast((vec)value, lane); } template inline T spvSubgroupBroadcastFirst(T value) { return simd_broadcast_first(value); } template<> inline bool spvSubgroupBroadcastFirst(bool value) { return !!simd_broadcast_first((ushort)value); } template inline vec spvSubgroupBroadcastFirst(vec value) { return (vec)simd_broadcast_first((vec)value); } inline uint4 spvSubgroupBallot(bool value) { return uint4((simd_vote::vote_t)simd_ballot(value), 0, 0, 0); } inline bool spvSubgroupBallotBitExtract(uint4 ballot, uint bit) { return !!extract_bits(ballot[bit / 32], bit % 32, 1); } inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupSize), uint3(0)); ballot &= mask; return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0); } inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupSize), uint3(0)); ballot &= mask; return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - (clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), ballot.z == 0), ballot.w == 0); } inline uint spvPopCount4(uint4 ballot) { return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w); } inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupSize), uint3(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID + 1), uint3(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID), uint2(0)); return spvPopCount4(ballot & mask); } template inline bool spvSubgroupAllEqual(T value) { return simd_all(all(value == simd_broadcast_first(value))); } template<> inline bool spvSubgroupAllEqual(bool value) { return simd_all(value) || !simd_any(value); } template inline bool spvSubgroupAllEqual(vec value) { return simd_all(all(value == (vec)simd_broadcast_first((vec)value))); } template inline T spvSubgroupShuffle(T value, ushort lane) { return simd_shuffle(value, lane); } template<> inline bool spvSubgroupShuffle(bool value, ushort lane) { return !!simd_shuffle((ushort)value, lane); } template inline vec spvSubgroupShuffle(vec value, ushort lane) { return (vec)simd_shuffle((vec)value, lane); } template inline T spvSubgroupShuffleXor(T value, ushort mask) { return simd_shuffle_xor(value, mask); } template<> inline bool spvSubgroupShuffleXor(bool value, ushort mask) { return !!simd_shuffle_xor((ushort)value, mask); } template inline vec spvSubgroupShuffleXor(vec value, ushort mask) { return (vec)simd_shuffle_xor((vec)value, mask); } template inline T spvSubgroupShuffleUp(T value, ushort delta) { return simd_shuffle_up(value, delta); } template<> inline bool spvSubgroupShuffleUp(bool value, ushort delta) { return !!simd_shuffle_up((ushort)value, delta); } template inline vec spvSubgroupShuffleUp(vec value, ushort delta) { return (vec)simd_shuffle_up((vec)value, delta); } template inline T spvSubgroupShuffleDown(T value, ushort delta) { return simd_shuffle_down(value, delta); } template<> inline bool spvSubgroupShuffleDown(bool value, ushort delta) { return !!simd_shuffle_down((ushort)value, delta); } template inline vec spvSubgroupShuffleDown(vec value, ushort delta) { return (vec)simd_shuffle_down((vec)value, delta); } template inline T spvQuadBroadcast(T value, uint lane) { return quad_broadcast(value, lane); } template<> inline bool spvQuadBroadcast(bool value, uint lane) { return !!quad_broadcast((ushort)value, lane); } template inline vec spvQuadBroadcast(vec value, uint lane) { return (vec)quad_broadcast((vec)value, lane); } template inline T spvQuadSwap(T value, uint dir) { return quad_shuffle_xor(value, dir + 1); } template<> inline bool spvQuadSwap(bool value, uint dir) { return !!quad_shuffle_xor((ushort)value, dir + 1); } template inline vec spvQuadSwap(vec value, uint dir) { return (vec)quad_shuffle_xor((vec)value, dir + 1); } kernel void main0(device SSBO& _9 [[buffer(0)]], uint gl_NumSubgroups [[quadgroups_per_threadgroup]], uint gl_SubgroupID [[quadgroup_index_in_threadgroup]], uint gl_SubgroupSize [[thread_execution_width]], uint gl_SubgroupInvocationID [[thread_index_in_quadgroup]]) { uint4 gl_SubgroupEqMask = uint4(1 << gl_SubgroupInvocationID, uint3(0)); uint4 gl_SubgroupGeMask = uint4(insert_bits(0u, 0xFFFFFFFF, gl_SubgroupInvocationID, gl_SubgroupSize - gl_SubgroupInvocationID), uint3(0)); uint4 gl_SubgroupGtMask = uint4(insert_bits(0u, 0xFFFFFFFF, gl_SubgroupInvocationID + 1, gl_SubgroupSize - gl_SubgroupInvocationID - 1), uint3(0)); uint4 gl_SubgroupLeMask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID + 1), uint3(0)); uint4 gl_SubgroupLtMask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID), uint3(0)); _9.FragColor = float(gl_NumSubgroups); _9.FragColor = float(gl_SubgroupID); _9.FragColor = float(gl_SubgroupSize); _9.FragColor = float(gl_SubgroupInvocationID); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); simdgroup_barrier(mem_flags::mem_device); simdgroup_barrier(mem_flags::mem_threadgroup); simdgroup_barrier(mem_flags::mem_texture); bool _39 = simd_is_first(); bool elected = _39; _9.FragColor = float4(gl_SubgroupEqMask).x; _9.FragColor = float4(gl_SubgroupGeMask).x; _9.FragColor = float4(gl_SubgroupGtMask).x; _9.FragColor = float4(gl_SubgroupLeMask).x; _9.FragColor = float4(gl_SubgroupLtMask).x; float4 broadcasted = spvSubgroupBroadcast(float4(10.0), 8u); bool2 broadcasted_bool = spvSubgroupBroadcast(bool2(true), 8u); float3 first = spvSubgroupBroadcastFirst(float3(20.0)); bool4 first_bool = spvSubgroupBroadcastFirst(bool4(false)); uint4 ballot_value = spvSubgroupBallot(true); bool inverse_ballot_value = spvSubgroupBallotBitExtract(ballot_value, gl_SubgroupInvocationID); bool bit_extracted = spvSubgroupBallotBitExtract(uint4(10u), 8u); uint bit_count = spvSubgroupBallotBitCount(ballot_value, gl_SubgroupSize); uint inclusive_bit_count = spvSubgroupBallotInclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint exclusive_bit_count = spvSubgroupBallotExclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint lsb = spvSubgroupBallotFindLSB(ballot_value, gl_SubgroupSize); uint msb = spvSubgroupBallotFindMSB(ballot_value, gl_SubgroupSize); uint shuffled = spvSubgroupShuffle(10u, 8u); bool shuffled_bool = spvSubgroupShuffle(true, 9u); uint shuffled_xor = spvSubgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = spvSubgroupShuffleXor(false, 9u); uint shuffled_up = spvSubgroupShuffleUp(20u, 4u); bool shuffled_up_bool = spvSubgroupShuffleUp(true, 4u); uint shuffled_down = spvSubgroupShuffleDown(20u, 4u); bool shuffled_down_bool = spvSubgroupShuffleDown(false, 4u); bool has_all = simd_all(true); bool has_any = simd_any(true); bool has_equal = spvSubgroupAllEqual(0); has_equal = spvSubgroupAllEqual(true); has_equal = spvSubgroupAllEqual(float3(0.0, 1.0, 2.0)); has_equal = spvSubgroupAllEqual(bool4(true, true, false, true)); float4 added = simd_sum(float4(20.0)); int4 iadded = simd_sum(int4(20)); float4 multiplied = simd_product(float4(20.0)); int4 imultiplied = simd_product(int4(20)); float4 lo = simd_min(float4(20.0)); float4 hi = simd_max(float4(20.0)); int4 slo = simd_min(int4(20)); int4 shi = simd_max(int4(20)); uint4 ulo = simd_min(uint4(20u)); uint4 uhi = simd_max(uint4(20u)); uint4 anded = simd_and(ballot_value); uint4 ored = simd_or(ballot_value); uint4 xored = simd_xor(ballot_value); added = simd_prefix_inclusive_sum(added); iadded = simd_prefix_inclusive_sum(iadded); multiplied = simd_prefix_inclusive_product(multiplied); imultiplied = simd_prefix_inclusive_product(imultiplied); added = simd_prefix_exclusive_sum(multiplied); multiplied = simd_prefix_exclusive_product(multiplied); iadded = simd_prefix_exclusive_sum(imultiplied); imultiplied = simd_prefix_exclusive_product(imultiplied); added = quad_sum(added); multiplied = quad_product(multiplied); iadded = quad_sum(iadded); imultiplied = quad_product(imultiplied); lo = quad_min(lo); hi = quad_max(hi); ulo = quad_min(ulo); uhi = quad_max(uhi); slo = quad_min(slo); shi = quad_max(shi); anded = quad_and(anded); ored = quad_or(ored); xored = quad_xor(xored); float4 swap_horiz = spvQuadSwap(float4(20.0), 0u); bool4 swap_horiz_bool = spvQuadSwap(bool4(true), 0u); float4 swap_vertical = spvQuadSwap(float4(20.0), 1u); bool4 swap_vertical_bool = spvQuadSwap(bool4(true), 1u); float4 swap_diagonal = spvQuadSwap(float4(20.0), 2u); bool4 swap_diagonal_bool = spvQuadSwap(bool4(true), 2u); float4 quad_broadcast0 = spvQuadBroadcast(float4(20.0), 3u); bool4 quad_broadcast_bool = spvQuadBroadcast(bool4(true), 3u); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/components/000077500000000000000000000000001400026215700241515ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/components/fragment-input-component.frag000066400000000000000000000005511400026215700317530ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float3 Foo3 [[user(locn0)]]; float Foo1 [[user(locn0_3)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = float4(in.Foo3, in.Foo1); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/components/fragment-output-component.frag000066400000000000000000000007261400026215700321600ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor0 [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; float FragColor0 = {}; float2 FragColor1 = {}; float FragColor3 = {}; FragColor0 = 1.0; FragColor1 = float2(2.0, 3.0); FragColor3 = 4.0; out.FragColor0.x = FragColor0; out.FragColor0.yz = FragColor1; out.FragColor0.w = FragColor3; return out; } fragment-output-component.pad-fragment.frag000066400000000000000000000006021400026215700344360ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/components#include #include using namespace metal; struct main0_out { float4 FragColor0 [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; float FragColor0 = {}; float2 FragColor1 = {}; FragColor0 = 1.0; FragColor1 = float2(2.0, 3.0); out.FragColor0.x = FragColor0; out.FragColor0.yz = FragColor1; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/components/vertex-input-component.vert000066400000000000000000000007401400026215700315260ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float3 Foo [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 Foo3 [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float3 Foo3 = {}; float Foo1 = {}; Foo3 = in.Foo3.xyz; Foo1 = in.Foo3.w; out.gl_Position = float4(Foo3, Foo1); out.Foo = Foo3 + float3(Foo1); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/components/vertex-output-component.vert000066400000000000000000000006621400026215700317320ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float3 Foo3 [[user(locn0)]]; float Foo1 [[user(locn0_3)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 vFoo [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.vFoo; out.Foo3 = in.vFoo.xyz; out.Foo1 = in.vFoo.w; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/000077500000000000000000000000001400026215700227035ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/16bit-constants.invalid.frag000066400000000000000000000005051400026215700301300ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { half foo [[color(0)]]; short bar [[color(1)]]; ushort baz [[color(2)]]; }; fragment main0_out main0() { main0_out out = {}; out.foo = half(1.0); out.bar = short(2); out.baz = ushort(3); return out; } demote-to-helper.vk.nocompat.msl21.invalid.frag000066400000000000000000000002401400026215700334530ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; fragment void main0() { bool _9 = simd_is_helper_thread(); bool helper = _9; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/depth-image-gather.asm.frag000066400000000000000000000010741400026215700277610ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d g_depthTexture [[texture(0)]], sampler g_sampler [[sampler(0)]], sampler g_comp [[sampler(1)]]) { main0_out out = {}; out.out_var_SV_Target0 = g_depthTexture.gather_compare(g_comp, in.in_var_TEXCOORD0, 0.5) * g_depthTexture.gather(g_sampler, in.in_var_TEXCOORD0, int2(0)); return out; } force-active-resources.msl2.argument..force-active.discrete.frag000066400000000000000000000014631400026215700367720ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct spvDescriptorSetBuffer0 { texture2d uTexture2 [[id(0)]]; sampler uTexture2Smplr [[id(1)]]; texture2d uTexture1 [[id(2)]]; sampler uTexture1Smplr [[id(3)]]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], texture2d uTextureDiscrete2 [[texture(0)]], sampler uTextureDiscrete2Smplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = spvDescriptorSet0.uTexture2.sample(spvDescriptorSet0.uTexture2Smplr, in.vUV); out.FragColor += uTextureDiscrete2.sample(uTextureDiscrete2Smplr, in.vUV); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/fp16.desktop.invalid.frag000066400000000000000000000106321400026215700274170ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct ResType { half4 _m0; int4 _m1; }; struct main0_in { half v1 [[user(locn0)]]; half2 v2 [[user(locn1)]]; half3 v3 [[user(locn2)]]; half4 v4 [[user(locn3)]]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } // Implementation of the GLSL radians() function template inline T radians(T d) { return d * T(0.01745329251); } // Implementation of the GLSL degrees() function template inline T degrees(T r) { return r * T(57.2957795131); } static inline __attribute__((always_inline)) half2x2 test_mat2(thread const half2& a, thread const half2& b, thread const half2& c, thread const half2& d) { return half2x2(half2(a), half2(b)) * half2x2(half2(c), half2(d)); } static inline __attribute__((always_inline)) half3x3 test_mat3(thread const half3& a, thread const half3& b, thread const half3& c, thread const half3& d, thread const half3& e, thread const half3& f) { return half3x3(half3(a), half3(b), half3(c)) * half3x3(half3(d), half3(e), half3(f)); } static inline __attribute__((always_inline)) void test_constants() { half a = half(1.0); half b = half(1.5); half c = half(-1.5); half d = half(0.0 / 0.0); half e = half(1.0 / 0.0); half f = half(-1.0 / 0.0); half g = half(1014.0); half h = half(9.5367431640625e-07); } static inline __attribute__((always_inline)) half test_result() { return half(1.0); } static inline __attribute__((always_inline)) void test_conversions() { half one = test_result(); int a = int(one); uint b = uint(one); bool c = (isunordered(one, half(0.0)) || one != half(0.0)); float d = float(one); half a2 = half(a); half b2 = half(b); half c2 = half(c); half d2 = half(d); } static inline __attribute__((always_inline)) void test_builtins(thread half4& v4, thread half3& v3, thread half& v1) { half4 res = radians(v4); res = degrees(v4); res = sin(v4); res = cos(v4); res = tan(v4); res = asin(v4); res = atan2(v4, v3.xyzz); res = atan(v4); res = sinh(v4); res = cosh(v4); res = tanh(v4); res = asinh(v4); res = acosh(v4); res = atanh(v4); res = pow(v4, v4); res = exp(v4); res = log(v4); res = exp2(v4); res = log2(v4); res = sqrt(v4); res = rsqrt(v4); res = abs(v4); res = sign(v4); res = floor(v4); res = trunc(v4); res = round(v4); res = rint(v4); res = ceil(v4); res = fract(v4); res = mod(v4, v4); half4 tmp; half4 _223 = modf(v4, tmp); res = _223; res = min(v4, v4); res = max(v4, v4); res = clamp(v4, v4, v4); res = mix(v4, v4, v4); res = select(v4, v4, v4 < v4); res = step(v4, v4); res = smoothstep(v4, v4, v4); bool4 btmp = isnan(v4); btmp = isinf(v4); res = fma(v4, v4, v4); ResType _267; _267._m0 = frexp(v4, _267._m1); int4 itmp = _267._m1; res = _267._m0; res = ldexp(res, itmp); uint pack0 = as_type(v4.xy); uint pack1 = as_type(v4.zw); res = half4(as_type(pack0), as_type(pack1)); half t0 = length(v4); t0 = distance(v4, v4); t0 = dot(v4, v4); half3 res3 = cross(v3, v3); res = normalize(v4); res = faceforward(v4, v4, v4); res = reflect(v4, v4); res = refract(v4, v4, v1); btmp = v4 < v4; btmp = v4 <= v4; btmp = v4 > v4; btmp = v4 >= v4; btmp = v4 == v4; btmp = (isunordered(v4, v4) || v4 != v4); res = dfdx(v4); res = dfdy(v4); res = dfdx(v4); res = dfdy(v4); res = dfdx(v4); res = dfdy(v4); res = fwidth(v4); res = fwidth(v4); res = fwidth(v4); } fragment void main0(main0_in in [[stage_in]]) { half2 param = in.v2; half2 param_1 = in.v2; half2 param_2 = in.v3.xy; half2 param_3 = in.v3.xy; half2x2 m0 = test_mat2(param, param_1, param_2, param_3); half3 param_4 = in.v3; half3 param_5 = in.v3; half3 param_6 = in.v3; half3 param_7 = in.v4.xyz; half3 param_8 = in.v4.xyz; half3 param_9 = in.v4.yzw; half3x3 m1 = test_mat3(param_4, param_5, param_6, param_7, param_8, param_9); test_constants(); test_conversions(); test_builtins(in.v4, in.v3, in.v1); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/image-gather.frag000066400000000000000000000012571400026215700261030ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uSamp [[texture(0)]], depth2d uSampShadow [[texture(1)]], sampler uSampSmplr [[sampler(0)]], sampler uSampShadowSmplr [[sampler(1)]]) { main0_out out = {}; out.FragColor = uSamp.gather(uSampSmplr, in.vUV.xy, int2(0), component::x); out.FragColor += uSamp.gather(uSampSmplr, in.vUV.xy, int2(0), component::y); out.FragColor += uSampShadow.gather_compare(uSampShadowSmplr, in.vUV.xy, in.vUV.z); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/in_block_assign.frag000066400000000000000000000006611400026215700266730ustar00rootroot00000000000000#include #include using namespace metal; struct VOUT { float4 a; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 VOUT_a [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; VOUT Clip = {}; Clip.a = in.VOUT_a; VOUT tmp = Clip; tmp.a += float4(1.0); out.FragColor = tmp.a; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/min-max-clamp.invalid.asm.frag000066400000000000000000000042451400026215700304150ustar00rootroot00000000000000#include #include using namespace metal; struct main0_in { float v1 [[user(locn0)]]; float2 v2 [[user(locn1)]]; float3 v3 [[user(locn2)]]; float4 v4 [[user(locn3)]]; half h1 [[user(locn4)]]; half2 h2 [[user(locn5)]]; half3 h3 [[user(locn6)]]; half4 h4 [[user(locn7)]]; }; fragment void main0(main0_in in [[stage_in]]) { float res = fast::min(in.v1, in.v1); res = fast::max(in.v1, in.v1); res = fast::clamp(in.v1, in.v1, in.v1); res = precise::min(in.v1, in.v1); res = precise::max(in.v1, in.v1); res = precise::clamp(in.v1, in.v1, in.v1); float2 res2 = fast::min(in.v2, in.v2); res2 = fast::max(in.v2, in.v2); res2 = fast::clamp(in.v2, in.v2, in.v2); res2 = precise::min(in.v2, in.v2); res2 = precise::max(in.v2, in.v2); res2 = precise::clamp(in.v2, in.v2, in.v2); float3 res3 = fast::min(in.v3, in.v3); res3 = fast::max(in.v3, in.v3); res3 = fast::clamp(in.v3, in.v3, in.v3); res3 = precise::min(in.v3, in.v3); res3 = precise::max(in.v3, in.v3); res3 = precise::clamp(in.v3, in.v3, in.v3); float4 res4 = fast::min(in.v4, in.v4); res4 = fast::max(in.v4, in.v4); res4 = fast::clamp(in.v4, in.v4, in.v4); res4 = precise::min(in.v4, in.v4); res4 = precise::max(in.v4, in.v4); res4 = precise::clamp(in.v4, in.v4, in.v4); half hres = min(in.h1, in.h1); hres = max(in.h1, in.h1); hres = clamp(in.h1, in.h1, in.h1); hres = min(in.h1, in.h1); hres = max(in.h1, in.h1); hres = clamp(in.h1, in.h1, in.h1); half2 hres2 = min(in.h2, in.h2); hres2 = max(in.h2, in.h2); hres2 = clamp(in.h2, in.h2, in.h2); hres2 = min(in.h2, in.h2); hres2 = max(in.h2, in.h2); hres2 = clamp(in.h2, in.h2, in.h2); half3 hres3 = min(in.h3, in.h3); hres3 = max(in.h3, in.h3); hres3 = clamp(in.h3, in.h3, in.h3); hres3 = min(in.h3, in.h3); hres3 = max(in.h3, in.h3); hres3 = clamp(in.h3, in.h3, in.h3); half4 hres4 = min(in.h4, in.h4); hres4 = max(in.h4, in.h4); hres4 = clamp(in.h4, in.h4, in.h4); hres4 = min(in.h4, in.h4); hres4 = max(in.h4, in.h4); hres4 = clamp(in.h4, in.h4, in.h4); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/nonuniform-constructor.msl2.frag000066400000000000000000000007021400026215700311740ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; int vIndex [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], array, 10> uTex [[texture(0)]], sampler Immut [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex[in.vIndex].sample(Immut, in.vUV); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/pixel-interlock-simple-callstack.msl2.frag000066400000000000000000000014601400026215700327600ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO1 { uint values1[1]; }; struct SSBO0 { uint values0[1]; }; static inline __attribute__((always_inline)) void callee2(device SSBO1& v_14, thread float4& gl_FragCoord) { int _25 = int(gl_FragCoord.x); v_14.values1[_25]++; } static inline __attribute__((always_inline)) void callee(device SSBO1& v_14, thread float4& gl_FragCoord, device SSBO0& v_35) { int _38 = int(gl_FragCoord.x); v_35.values0[_38]++; callee2(v_14, gl_FragCoord); } fragment void main0(device SSBO1& v_14 [[buffer(0), raster_order_group(0)]], device SSBO0& v_35 [[buffer(1), raster_order_group(0)]], float4 gl_FragCoord [[position]]) { callee(v_14, gl_FragCoord, v_35); } scalar-block-layout-ubo-std430.vk.nocompat.invalid.frag000066400000000000000000000011011400026215700350130ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct UBO { float a[1]; float2 b[2]; }; struct UBOEnhancedLayout { float c[1]; float2 d[2]; char _m2_pad[9976]; float e; }; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { int vIndex [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant UBO& _17 [[buffer(0)]], constant UBOEnhancedLayout& _30 [[buffer(1)]]) { main0_out out = {}; out.FragColor = (_17.a[in.vIndex] + _30.c[in.vIndex]) + _30.e; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/shadow-compare-global-alias.invalid.frag000066400000000000000000000034771400026215700324420ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; static inline __attribute__((always_inline)) float Samp(thread const float3& uv, thread depth2d uTex, thread sampler uSamp) { return uTex.sample_compare(uSamp, uv.xy, uv.z); } static inline __attribute__((always_inline)) float Samp2(thread const float3& uv, thread depth2d uSampler, thread const sampler uSamplerSmplr, thread float3& vUV) { return uSampler.sample_compare(uSamplerSmplr, vUV.xy, vUV.z); } static inline __attribute__((always_inline)) float Samp3(thread const depth2d uT, thread const sampler uS, thread const float3& uv, thread float3& vUV) { return uT.sample_compare(uS, vUV.xy, vUV.z); } static inline __attribute__((always_inline)) float Samp4(thread const depth2d uS, thread const sampler uSSmplr, thread const float3& uv, thread float3& vUV) { return uS.sample_compare(uSSmplr, vUV.xy, vUV.z); } fragment main0_out main0(main0_in in [[stage_in]], depth2d uTex [[texture(0)]], depth2d uSampler [[texture(1)]], sampler uSamp [[sampler(0)]], sampler uSamplerSmplr [[sampler(1)]]) { main0_out out = {}; out.FragColor = uSampler.sample_compare(uSamplerSmplr, in.vUV.xy, in.vUV.z); out.FragColor += uTex.sample_compare(uSamp, in.vUV.xy, in.vUV.z); float3 param = in.vUV; out.FragColor += Samp(param, uTex, uSamp); float3 param_1 = in.vUV; out.FragColor += Samp2(param_1, uSampler, uSamplerSmplr, in.vUV); float3 param_2 = in.vUV; out.FragColor += Samp3(uTex, uSamp, param_2, in.vUV); float3 param_3 = in.vUV; out.FragColor += Samp4(uSampler, uSamplerSmplr, param_3, in.vUV); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/subgroups.nocompat.invalid.vk.msl22.frag000066400000000000000000000266331400026215700324300ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; template inline T spvSubgroupBroadcast(T value, ushort lane) { return simd_broadcast(value, lane); } template<> inline bool spvSubgroupBroadcast(bool value, ushort lane) { return !!simd_broadcast((ushort)value, lane); } template inline vec spvSubgroupBroadcast(vec value, ushort lane) { return (vec)simd_broadcast((vec)value, lane); } template inline T spvSubgroupBroadcastFirst(T value) { return simd_broadcast_first(value); } template<> inline bool spvSubgroupBroadcastFirst(bool value) { return !!simd_broadcast_first((ushort)value); } template inline vec spvSubgroupBroadcastFirst(vec value) { return (vec)simd_broadcast_first((vec)value); } inline uint4 spvSubgroupBallot(bool value) { simd_vote vote = simd_ballot(value); // simd_ballot() returns a 64-bit integer-like object, but // SPIR-V callers expect a uint4. We must convert. // FIXME: This won't include higher bits if Apple ever supports // 128 lanes in an SIMD-group. return uint4((uint)((simd_vote::vote_t)vote & 0xFFFFFFFF), (uint)(((simd_vote::vote_t)vote >> 32) & 0xFFFFFFFF), 0, 0); } inline bool spvSubgroupBallotBitExtract(uint4 ballot, uint bit) { return !!extract_bits(ballot[bit / 32], bit % 32, 1); } inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0); } inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - (clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), ballot.z == 0), ballot.w == 0); } inline uint spvPopCount4(uint4 ballot) { return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w); } inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } template inline bool spvSubgroupAllEqual(T value) { return simd_all(all(value == simd_broadcast_first(value))); } template<> inline bool spvSubgroupAllEqual(bool value) { return simd_all(value) || !simd_any(value); } template inline bool spvSubgroupAllEqual(vec value) { return simd_all(all(value == (vec)simd_broadcast_first((vec)value))); } template inline T spvSubgroupShuffle(T value, ushort lane) { return simd_shuffle(value, lane); } template<> inline bool spvSubgroupShuffle(bool value, ushort lane) { return !!simd_shuffle((ushort)value, lane); } template inline vec spvSubgroupShuffle(vec value, ushort lane) { return (vec)simd_shuffle((vec)value, lane); } template inline T spvSubgroupShuffleXor(T value, ushort mask) { return simd_shuffle_xor(value, mask); } template<> inline bool spvSubgroupShuffleXor(bool value, ushort mask) { return !!simd_shuffle_xor((ushort)value, mask); } template inline vec spvSubgroupShuffleXor(vec value, ushort mask) { return (vec)simd_shuffle_xor((vec)value, mask); } template inline T spvSubgroupShuffleUp(T value, ushort delta) { return simd_shuffle_up(value, delta); } template<> inline bool spvSubgroupShuffleUp(bool value, ushort delta) { return !!simd_shuffle_up((ushort)value, delta); } template inline vec spvSubgroupShuffleUp(vec value, ushort delta) { return (vec)simd_shuffle_up((vec)value, delta); } template inline T spvSubgroupShuffleDown(T value, ushort delta) { return simd_shuffle_down(value, delta); } template<> inline bool spvSubgroupShuffleDown(bool value, ushort delta) { return !!simd_shuffle_down((ushort)value, delta); } template inline vec spvSubgroupShuffleDown(vec value, ushort delta) { return (vec)simd_shuffle_down((vec)value, delta); } template inline T spvQuadBroadcast(T value, uint lane) { return quad_broadcast(value, lane); } template<> inline bool spvQuadBroadcast(bool value, uint lane) { return !!quad_broadcast((ushort)value, lane); } template inline vec spvQuadBroadcast(vec value, uint lane) { return (vec)quad_broadcast((vec)value, lane); } template inline T spvQuadSwap(T value, uint dir) { return quad_shuffle_xor(value, dir + 1); } template<> inline bool spvQuadSwap(bool value, uint dir) { return !!quad_shuffle_xor((ushort)value, dir + 1); } template inline vec spvQuadSwap(vec value, uint dir) { return (vec)quad_shuffle_xor((vec)value, dir + 1); } fragment main0_out main0(uint gl_SubgroupSize [[threads_per_simdgroup]], uint gl_SubgroupInvocationID [[thread_index_in_simdgroup]]) { main0_out out = {}; uint4 gl_SubgroupEqMask = gl_SubgroupInvocationID >= 32 ? uint4(0, (1 << (gl_SubgroupInvocationID - 32)), uint2(0)) : uint4(1 << gl_SubgroupInvocationID, uint3(0)); uint4 gl_SubgroupGeMask = uint4(insert_bits(0u, 0xFFFFFFFF, min(gl_SubgroupInvocationID, 32u), (uint)max(min((int)gl_SubgroupSize, 32) - (int)gl_SubgroupInvocationID, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)gl_SubgroupInvocationID - 32, 0), (uint)max((int)gl_SubgroupSize - (int)max(gl_SubgroupInvocationID, 32u), 0)), uint2(0)); uint4 gl_SubgroupGtMask = uint4(insert_bits(0u, 0xFFFFFFFF, min(gl_SubgroupInvocationID + 1, 32u), (uint)max(min((int)gl_SubgroupSize, 32) - (int)gl_SubgroupInvocationID - 1, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0), (uint)max((int)gl_SubgroupSize - (int)max(gl_SubgroupInvocationID + 1, 32u), 0)), uint2(0)); uint4 gl_SubgroupLeMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0)); uint4 gl_SubgroupLtMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0)); out.FragColor = float(gl_SubgroupSize); out.FragColor = float(gl_SubgroupInvocationID); bool _24 = simd_is_first(); bool elected = _24; out.FragColor = float4(gl_SubgroupEqMask).x; out.FragColor = float4(gl_SubgroupGeMask).x; out.FragColor = float4(gl_SubgroupGtMask).x; out.FragColor = float4(gl_SubgroupLeMask).x; out.FragColor = float4(gl_SubgroupLtMask).x; float4 broadcasted = spvSubgroupBroadcast(float4(10.0), 8u); bool2 broadcasted_bool = spvSubgroupBroadcast(bool2(true), 8u); float3 first = spvSubgroupBroadcastFirst(float3(20.0)); bool4 first_bool = spvSubgroupBroadcastFirst(bool4(false)); uint4 ballot_value = spvSubgroupBallot(true); bool inverse_ballot_value = spvSubgroupBallotBitExtract(ballot_value, gl_SubgroupInvocationID); bool bit_extracted = spvSubgroupBallotBitExtract(uint4(10u), 8u); uint bit_count = spvSubgroupBallotBitCount(ballot_value, gl_SubgroupSize); uint inclusive_bit_count = spvSubgroupBallotInclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint exclusive_bit_count = spvSubgroupBallotExclusiveBitCount(ballot_value, gl_SubgroupInvocationID); uint lsb = spvSubgroupBallotFindLSB(ballot_value, gl_SubgroupSize); uint msb = spvSubgroupBallotFindMSB(ballot_value, gl_SubgroupSize); uint shuffled = spvSubgroupShuffle(10u, 8u); bool shuffled_bool = spvSubgroupShuffle(true, 9u); uint shuffled_xor = spvSubgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = spvSubgroupShuffleXor(false, 9u); uint shuffled_up = spvSubgroupShuffleUp(20u, 4u); bool shuffled_up_bool = spvSubgroupShuffleUp(true, 4u); uint shuffled_down = spvSubgroupShuffleDown(20u, 4u); bool shuffled_down_bool = spvSubgroupShuffleDown(false, 4u); bool has_all = simd_all(true); bool has_any = simd_any(true); bool has_equal = spvSubgroupAllEqual(0); has_equal = spvSubgroupAllEqual(true); has_equal = spvSubgroupAllEqual(float3(0.0, 1.0, 2.0)); has_equal = spvSubgroupAllEqual(bool4(true, true, false, true)); float4 added = simd_sum(float4(20.0)); int4 iadded = simd_sum(int4(20)); float4 multiplied = simd_product(float4(20.0)); int4 imultiplied = simd_product(int4(20)); float4 lo = simd_min(float4(20.0)); float4 hi = simd_max(float4(20.0)); int4 slo = simd_min(int4(20)); int4 shi = simd_max(int4(20)); uint4 ulo = simd_min(uint4(20u)); uint4 uhi = simd_max(uint4(20u)); uint4 anded = simd_and(ballot_value); uint4 ored = simd_or(ballot_value); uint4 xored = simd_xor(ballot_value); added = simd_prefix_inclusive_sum(added); iadded = simd_prefix_inclusive_sum(iadded); multiplied = simd_prefix_inclusive_product(multiplied); imultiplied = simd_prefix_inclusive_product(imultiplied); added = simd_prefix_exclusive_sum(multiplied); multiplied = simd_prefix_exclusive_product(multiplied); iadded = simd_prefix_exclusive_sum(imultiplied); imultiplied = simd_prefix_exclusive_product(imultiplied); added = quad_sum(added); multiplied = quad_product(multiplied); iadded = quad_sum(iadded); imultiplied = quad_product(imultiplied); lo = quad_min(lo); hi = quad_max(hi); ulo = quad_min(ulo); uhi = quad_max(uhi); slo = quad_min(slo); shi = quad_max(shi); anded = quad_and(anded); ored = quad_or(ored); xored = quad_xor(xored); float4 swap_horiz = spvQuadSwap(float4(20.0), 0u); bool4 swap_horiz_bool = spvQuadSwap(bool4(true), 0u); float4 swap_vertical = spvQuadSwap(float4(20.0), 1u); bool4 swap_vertical_bool = spvQuadSwap(bool4(true), 1u); float4 swap_diagonal = spvQuadSwap(float4(20.0), 2u); bool4 swap_diagonal_bool = spvQuadSwap(bool4(true), 2u); float4 quad_broadcast0 = spvQuadBroadcast(float4(20.0), 3u); bool4 quad_broadcast_bool = spvQuadBroadcast(bool4(true), 3u); return out; } subpass-input-attachment-index-fallback.msl20.ios.framebuffer-fetch.frag000066400000000000000000000004001400026215700403630ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct main0_out { float4 FragColor [[color(1)]]; }; fragment main0_out main0(float4 uInput [[color(1)]]) { main0_out out = {}; out.FragColor = uInput; return out; } subpass-input-attachment-index-fallback.msl23.framebuffer-fetch.frag000066400000000000000000000004001400026215700375750ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct main0_out { float4 FragColor [[color(1)]]; }; fragment main0_out main0(float4 uInput [[color(1)]]) { main0_out out = {}; out.FragColor = uInput; return out; } subpass-input-function-argument.framebuffer-fetch.ios.frag000066400000000000000000000011611400026215700361070ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 samp3(float4 uS) { return uS; } static inline __attribute__((always_inline)) float4 samp(float4 uSub) { return uSub + samp3(uSub); } static inline __attribute__((always_inline)) float4 samp2(float4 uS) { return uS + samp3(uS); } fragment main0_out main0(float4 uSub [[color(0)]]) { main0_out out = {}; out.FragColor = samp(uSub) + samp2(uSub); return out; } subpass-input-function-argument.framebuffer-fetch.msl23.frag000066400000000000000000000011611400026215700362550ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 samp3(float4 uS) { return uS; } static inline __attribute__((always_inline)) float4 samp(float4 uSub) { return uSub + samp3(uSub); } static inline __attribute__((always_inline)) float4 samp2(float4 uS) { return uS + samp3(uS); } fragment main0_out main0(float4 uSub [[color(0)]]) { main0_out out = {}; out.FragColor = samp(uSub) + samp2(uSub); return out; } subpass-input.decoration-binding.framebuffer-fetch.msl23.argument.frag000066400000000000000000000007621400026215700401770ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct spvDescriptorSetBuffer0 { sampler uSampler [[id(8)]]; texture2d uTex [[id(9)]]; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], float4 uSub [[color(1)]]) { main0_out out = {}; out.FragColor = uSub + spvDescriptorSet0.uTex.sample(spvDescriptorSet0.uSampler, float2(0.5)); return out; } subpass-input.decoration-binding.framebuffer-fetch.msl23.frag000066400000000000000000000005501400026215700363510ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(float4 uSub [[color(1)]], texture2d uTex [[texture(9)]], sampler uSampler [[sampler(8)]]) { main0_out out = {}; out.FragColor = uSub + uTex.sample(uSampler, float2(0.5)); return out; } subpass-input.decoration-binding.ios.framebuffer-fetch.msl2.argument.frag000066400000000000000000000007621400026215700407050ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct spvDescriptorSetBuffer0 { sampler uSampler [[id(8)]]; texture2d uTex [[id(9)]]; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], float4 uSub [[color(1)]]) { main0_out out = {}; out.FragColor = uSub + spvDescriptorSet0.uTex.sample(spvDescriptorSet0.uSampler, float2(0.5)); return out; } subpass-input.decoration-binding.ios.framebuffer-fetch.msl2.frag000066400000000000000000000005501400026215700370570ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(float4 uSub [[color(1)]], texture2d uTex [[texture(9)]], sampler uSampler [[sampler(8)]]) { main0_out out = {}; out.FragColor = uSub + uTex.sample(uSampler, float2(0.5)); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/texture-access-int.swizzle.frag000066400000000000000000000162331400026215700310060ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } // Wrapper function that swizzles texture gathers. template class Tex, typename... Ts> inline vec spvGatherSwizzle(const thread Tex& t, sampler s, uint sw, component c, Ts... params) METAL_CONST_ARG(c) { if (sw) { switch (spvSwizzle((sw >> (uint(c) * 8)) & 0xFF)) { case spvSwizzle::none: break; case spvSwizzle::zero: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); case spvSwizzle::red: return t.gather(s, spvForward(params)..., component::x); case spvSwizzle::green: return t.gather(s, spvForward(params)..., component::y); case spvSwizzle::blue: return t.gather(s, spvForward(params)..., component::z); case spvSwizzle::alpha: return t.gather(s, spvForward(params)..., component::w); } } switch (c) { case component::x: return t.gather(s, spvForward(params)..., component::x); case component::y: return t.gather(s, spvForward(params)..., component::y); case component::z: return t.gather(s, spvForward(params)..., component::z); case component::w: return t.gather(s, spvForward(params)..., component::w); } } fragment void main0(constant uint* spvSwizzleConstants [[buffer(30)]], texture1d tex1d [[texture(0)]], texture2d tex2d [[texture(1)]], texture3d tex3d [[texture(2)]], texturecube texCube [[texture(3)]], texture2d_array tex2dArray [[texture(4)]], texturecube_array texCubeArray [[texture(5)]], texture2d texBuffer [[texture(6)]], sampler tex1dSmplr [[sampler(0)]], sampler tex2dSmplr [[sampler(1)]], sampler tex3dSmplr [[sampler(2)]], sampler texCubeSmplr [[sampler(3)]], sampler tex2dArraySmplr [[sampler(4)]], sampler texCubeArraySmplr [[sampler(5)]]) { constant uint& tex1dSwzl = spvSwizzleConstants[0]; constant uint& tex2dSwzl = spvSwizzleConstants[1]; constant uint& tex3dSwzl = spvSwizzleConstants[2]; constant uint& texCubeSwzl = spvSwizzleConstants[3]; constant uint& tex2dArraySwzl = spvSwizzleConstants[4]; constant uint& texCubeArraySwzl = spvSwizzleConstants[5]; float4 c = float4(spvTextureSwizzle(tex1d.sample(tex1dSmplr, 0.0), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.sample(tex2dSmplr, float2(0.0)), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.sample(tex3dSmplr, float3(0.0)), tex3dSwzl)); c = float4(spvTextureSwizzle(texCube.sample(texCubeSmplr, float3(0.0)), texCubeSwzl)); c = float4(spvTextureSwizzle(tex2dArray.sample(tex2dArraySmplr, float3(0.0).xy, uint(round(float3(0.0).z))), tex2dArraySwzl)); c = float4(spvTextureSwizzle(texCubeArray.sample(texCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w))), texCubeArraySwzl)); c = float4(spvTextureSwizzle(tex1d.sample(tex1dSmplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.sample(tex2dSmplr, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.sample(tex3dSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w), tex3dSwzl)); c = float4(spvTextureSwizzle(tex1d.sample(tex1dSmplr, 0.0), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.sample(tex2dSmplr, float2(0.0), level(0.0)), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.sample(tex3dSmplr, float3(0.0), level(0.0)), tex3dSwzl)); c = float4(spvTextureSwizzle(texCube.sample(texCubeSmplr, float3(0.0), level(0.0)), texCubeSwzl)); c = float4(spvTextureSwizzle(tex2dArray.sample(tex2dArraySmplr, float3(0.0).xy, uint(round(float3(0.0).z)), level(0.0)), tex2dArraySwzl)); c = float4(spvTextureSwizzle(texCubeArray.sample(texCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w)), level(0.0)), texCubeArraySwzl)); c = float4(spvTextureSwizzle(tex1d.sample(tex1dSmplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.sample(tex2dSmplr, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z, level(0.0)), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.sample(tex3dSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w, level(0.0)), tex3dSwzl)); c = float4(spvTextureSwizzle(tex1d.read(uint(0)), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.read(uint2(int2(0)), 0), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.read(uint3(int3(0)), 0), tex3dSwzl)); c = float4(spvTextureSwizzle(tex2dArray.read(uint2(int3(0).xy), uint(int3(0).z), 0), tex2dArraySwzl)); c = float4(texBuffer.read(spvTexelBufferCoord(0))); c = float4(spvGatherSwizzle(tex2d, tex2dSmplr, tex2dSwzl, component::x, float2(0.0), int2(0))); c = float4(spvGatherSwizzle(texCube, texCubeSmplr, texCubeSwzl, component::y, float3(0.0))); c = float4(spvGatherSwizzle(tex2dArray, tex2dArraySmplr, tex2dArraySwzl, component::z, float3(0.0).xy, uint(round(float3(0.0).z)), int2(0))); c = float4(spvGatherSwizzle(texCubeArray, texCubeArraySmplr, texCubeArraySwzl, component::w, float4(0.0).xyz, uint(round(float4(0.0).w)))); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/texture-access-leaf.swizzle.frag000066400000000000000000000267671400026215700311400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } // Wrapper function that swizzles texture gathers. template class Tex, typename... Ts> inline vec spvGatherSwizzle(const thread Tex& t, sampler s, uint sw, component c, Ts... params) METAL_CONST_ARG(c) { if (sw) { switch (spvSwizzle((sw >> (uint(c) * 8)) & 0xFF)) { case spvSwizzle::none: break; case spvSwizzle::zero: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); case spvSwizzle::red: return t.gather(s, spvForward(params)..., component::x); case spvSwizzle::green: return t.gather(s, spvForward(params)..., component::y); case spvSwizzle::blue: return t.gather(s, spvForward(params)..., component::z); case spvSwizzle::alpha: return t.gather(s, spvForward(params)..., component::w); } } switch (c) { case component::x: return t.gather(s, spvForward(params)..., component::x); case component::y: return t.gather(s, spvForward(params)..., component::y); case component::z: return t.gather(s, spvForward(params)..., component::z); case component::w: return t.gather(s, spvForward(params)..., component::w); } } // Wrapper function that swizzles depth texture gathers. template class Tex, typename... Ts> inline vec spvGatherCompareSwizzle(const thread Tex& t, sampler s, uint sw, Ts... params) { if (sw) { switch (spvSwizzle(sw & 0xFF)) { case spvSwizzle::none: case spvSwizzle::red: break; case spvSwizzle::zero: case spvSwizzle::green: case spvSwizzle::blue: case spvSwizzle::alpha: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); } } return t.gather_compare(s, spvForward(params)...); } static inline __attribute__((always_inline)) float4 doSwizzle(thread texture1d tex1d, thread const sampler tex1dSmplr, constant uint& tex1dSwzl, thread texture2d tex2d, thread const sampler tex2dSmplr, constant uint& tex2dSwzl, thread texture3d tex3d, thread const sampler tex3dSmplr, constant uint& tex3dSwzl, thread texturecube texCube, thread const sampler texCubeSmplr, constant uint& texCubeSwzl, thread texture2d_array tex2dArray, thread const sampler tex2dArraySmplr, constant uint& tex2dArraySwzl, thread texturecube_array texCubeArray, thread const sampler texCubeArraySmplr, constant uint& texCubeArraySwzl, thread depth2d depth2d, thread const sampler depth2dSmplr, constant uint& depth2dSwzl, thread depthcube depthCube, thread const sampler depthCubeSmplr, constant uint& depthCubeSwzl, thread depth2d_array depth2dArray, thread const sampler depth2dArraySmplr, constant uint& depth2dArraySwzl, thread depthcube_array depthCubeArray, thread const sampler depthCubeArraySmplr, constant uint& depthCubeArraySwzl, thread texture2d texBuffer) { float4 c = spvTextureSwizzle(tex1d.sample(tex1dSmplr, 0.0), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSmplr, float2(0.0)), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSmplr, float3(0.0)), tex3dSwzl); c = spvTextureSwizzle(texCube.sample(texCubeSmplr, float3(0.0)), texCubeSwzl); c = spvTextureSwizzle(tex2dArray.sample(tex2dArraySmplr, float3(0.0).xy, uint(round(float3(0.0).z))), tex2dArraySwzl); c = spvTextureSwizzle(texCubeArray.sample(texCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w))), texCubeArraySwzl); c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSmplr, float3(0.0, 0.0, 1.0).xy, float3(0.0, 0.0, 1.0).z), depth2dSwzl); c.x = spvTextureSwizzle(depthCube.sample_compare(depthCubeSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz, float4(0.0, 0.0, 0.0, 1.0).w), depthCubeSwzl); c.x = spvTextureSwizzle(depth2dArray.sample_compare(depth2dArraySmplr, float4(0.0, 0.0, 0.0, 1.0).xy, uint(round(float4(0.0, 0.0, 0.0, 1.0).z)), float4(0.0, 0.0, 0.0, 1.0).w), depth2dArraySwzl); c.x = spvTextureSwizzle(depthCubeArray.sample_compare(depthCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w)), 1.0), depthCubeArraySwzl); c = spvTextureSwizzle(tex1d.sample(tex1dSmplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSmplr, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w), tex3dSwzl); float4 _103 = float4(0.0, 0.0, 1.0, 1.0); _103.z = float4(0.0, 0.0, 1.0, 1.0).w; c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSmplr, _103.xy / _103.z, float4(0.0, 0.0, 1.0, 1.0).z / _103.z), depth2dSwzl); c = spvTextureSwizzle(tex1d.sample(tex1dSmplr, 0.0), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSmplr, float2(0.0), level(0.0)), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSmplr, float3(0.0), level(0.0)), tex3dSwzl); c = spvTextureSwizzle(texCube.sample(texCubeSmplr, float3(0.0), level(0.0)), texCubeSwzl); c = spvTextureSwizzle(tex2dArray.sample(tex2dArraySmplr, float3(0.0).xy, uint(round(float3(0.0).z)), level(0.0)), tex2dArraySwzl); c = spvTextureSwizzle(texCubeArray.sample(texCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w)), level(0.0)), texCubeArraySwzl); c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSmplr, float3(0.0, 0.0, 1.0).xy, float3(0.0, 0.0, 1.0).z, level(0.0)), depth2dSwzl); c = spvTextureSwizzle(tex1d.sample(tex1dSmplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSmplr, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z, level(0.0)), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w, level(0.0)), tex3dSwzl); float4 _131 = float4(0.0, 0.0, 1.0, 1.0); _131.z = float4(0.0, 0.0, 1.0, 1.0).w; c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSmplr, _131.xy / _131.z, float4(0.0, 0.0, 1.0, 1.0).z / _131.z, level(0.0)), depth2dSwzl); c = spvTextureSwizzle(tex1d.read(uint(0)), tex1dSwzl); c = spvTextureSwizzle(tex2d.read(uint2(int2(0)), 0), tex2dSwzl); c = spvTextureSwizzle(tex3d.read(uint3(int3(0)), 0), tex3dSwzl); c = spvTextureSwizzle(tex2dArray.read(uint2(int3(0).xy), uint(int3(0).z), 0), tex2dArraySwzl); c = texBuffer.read(spvTexelBufferCoord(0)); c = spvGatherSwizzle(tex2d, tex2dSmplr, tex2dSwzl, component::x, float2(0.0), int2(0)); c = spvGatherSwizzle(texCube, texCubeSmplr, texCubeSwzl, component::y, float3(0.0)); c = spvGatherSwizzle(tex2dArray, tex2dArraySmplr, tex2dArraySwzl, component::z, float3(0.0).xy, uint(round(float3(0.0).z)), int2(0)); c = spvGatherSwizzle(texCubeArray, texCubeArraySmplr, texCubeArraySwzl, component::w, float4(0.0).xyz, uint(round(float4(0.0).w))); c = spvGatherCompareSwizzle(depth2d, depth2dSmplr, depth2dSwzl, float2(0.0), 1.0); c = spvGatherCompareSwizzle(depthCube, depthCubeSmplr, depthCubeSwzl, float3(0.0), 1.0); c = spvGatherCompareSwizzle(depth2dArray, depth2dArraySmplr, depth2dArraySwzl, float3(0.0).xy, uint(round(float3(0.0).z)), 1.0); c = spvGatherCompareSwizzle(depthCubeArray, depthCubeArraySmplr, depthCubeArraySwzl, float4(0.0).xyz, uint(round(float4(0.0).w)), 1.0); return c; } fragment void main0(constant uint* spvSwizzleConstants [[buffer(30)]], texture1d tex1d [[texture(0)]], texture2d tex2d [[texture(1)]], texture3d tex3d [[texture(2)]], texturecube texCube [[texture(3)]], texture2d_array tex2dArray [[texture(4)]], texturecube_array texCubeArray [[texture(5)]], depth2d depth2d [[texture(6)]], depthcube depthCube [[texture(7)]], depth2d_array depth2dArray [[texture(8)]], depthcube_array depthCubeArray [[texture(9)]], texture2d texBuffer [[texture(10)]], sampler tex1dSmplr [[sampler(0)]], sampler tex2dSmplr [[sampler(1)]], sampler tex3dSmplr [[sampler(2)]], sampler texCubeSmplr [[sampler(3)]], sampler tex2dArraySmplr [[sampler(4)]], sampler texCubeArraySmplr [[sampler(5)]], sampler depth2dSmplr [[sampler(6)]], sampler depthCubeSmplr [[sampler(7)]], sampler depth2dArraySmplr [[sampler(8)]], sampler depthCubeArraySmplr [[sampler(9)]]) { constant uint& tex1dSwzl = spvSwizzleConstants[0]; constant uint& tex2dSwzl = spvSwizzleConstants[1]; constant uint& tex3dSwzl = spvSwizzleConstants[2]; constant uint& texCubeSwzl = spvSwizzleConstants[3]; constant uint& tex2dArraySwzl = spvSwizzleConstants[4]; constant uint& texCubeArraySwzl = spvSwizzleConstants[5]; constant uint& depth2dSwzl = spvSwizzleConstants[6]; constant uint& depthCubeSwzl = spvSwizzleConstants[7]; constant uint& depth2dArraySwzl = spvSwizzleConstants[8]; constant uint& depthCubeArraySwzl = spvSwizzleConstants[9]; float4 c = doSwizzle(tex1d, tex1dSmplr, tex1dSwzl, tex2d, tex2dSmplr, tex2dSwzl, tex3d, tex3dSmplr, tex3dSwzl, texCube, texCubeSmplr, texCubeSwzl, tex2dArray, tex2dArraySmplr, tex2dArraySwzl, texCubeArray, texCubeArraySmplr, texCubeArraySwzl, depth2d, depth2dSmplr, depth2dSwzl, depthCube, depthCubeSmplr, depthCubeSwzl, depth2dArray, depth2dArraySmplr, depth2dArraySwzl, depthCubeArray, depthCubeArraySmplr, depthCubeArraySwzl, texBuffer); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/texture-access-uint.swizzle.frag000066400000000000000000000162421400026215700311730ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } // Wrapper function that swizzles texture gathers. template class Tex, typename... Ts> inline vec spvGatherSwizzle(const thread Tex& t, sampler s, uint sw, component c, Ts... params) METAL_CONST_ARG(c) { if (sw) { switch (spvSwizzle((sw >> (uint(c) * 8)) & 0xFF)) { case spvSwizzle::none: break; case spvSwizzle::zero: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); case spvSwizzle::red: return t.gather(s, spvForward(params)..., component::x); case spvSwizzle::green: return t.gather(s, spvForward(params)..., component::y); case spvSwizzle::blue: return t.gather(s, spvForward(params)..., component::z); case spvSwizzle::alpha: return t.gather(s, spvForward(params)..., component::w); } } switch (c) { case component::x: return t.gather(s, spvForward(params)..., component::x); case component::y: return t.gather(s, spvForward(params)..., component::y); case component::z: return t.gather(s, spvForward(params)..., component::z); case component::w: return t.gather(s, spvForward(params)..., component::w); } } fragment void main0(constant uint* spvSwizzleConstants [[buffer(30)]], texture1d tex1d [[texture(0)]], texture2d tex2d [[texture(1)]], texture3d tex3d [[texture(2)]], texturecube texCube [[texture(3)]], texture2d_array tex2dArray [[texture(4)]], texturecube_array texCubeArray [[texture(5)]], texture2d texBuffer [[texture(6)]], sampler tex1dSmplr [[sampler(0)]], sampler tex2dSmplr [[sampler(1)]], sampler tex3dSmplr [[sampler(2)]], sampler texCubeSmplr [[sampler(3)]], sampler tex2dArraySmplr [[sampler(4)]], sampler texCubeArraySmplr [[sampler(5)]]) { constant uint& tex1dSwzl = spvSwizzleConstants[0]; constant uint& tex2dSwzl = spvSwizzleConstants[1]; constant uint& tex3dSwzl = spvSwizzleConstants[2]; constant uint& texCubeSwzl = spvSwizzleConstants[3]; constant uint& tex2dArraySwzl = spvSwizzleConstants[4]; constant uint& texCubeArraySwzl = spvSwizzleConstants[5]; float4 c = float4(spvTextureSwizzle(tex1d.sample(tex1dSmplr, 0.0), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.sample(tex2dSmplr, float2(0.0)), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.sample(tex3dSmplr, float3(0.0)), tex3dSwzl)); c = float4(spvTextureSwizzle(texCube.sample(texCubeSmplr, float3(0.0)), texCubeSwzl)); c = float4(spvTextureSwizzle(tex2dArray.sample(tex2dArraySmplr, float3(0.0).xy, uint(round(float3(0.0).z))), tex2dArraySwzl)); c = float4(spvTextureSwizzle(texCubeArray.sample(texCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w))), texCubeArraySwzl)); c = float4(spvTextureSwizzle(tex1d.sample(tex1dSmplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.sample(tex2dSmplr, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.sample(tex3dSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w), tex3dSwzl)); c = float4(spvTextureSwizzle(tex1d.sample(tex1dSmplr, 0.0), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.sample(tex2dSmplr, float2(0.0), level(0.0)), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.sample(tex3dSmplr, float3(0.0), level(0.0)), tex3dSwzl)); c = float4(spvTextureSwizzle(texCube.sample(texCubeSmplr, float3(0.0), level(0.0)), texCubeSwzl)); c = float4(spvTextureSwizzle(tex2dArray.sample(tex2dArraySmplr, float3(0.0).xy, uint(round(float3(0.0).z)), level(0.0)), tex2dArraySwzl)); c = float4(spvTextureSwizzle(texCubeArray.sample(texCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w)), level(0.0)), texCubeArraySwzl)); c = float4(spvTextureSwizzle(tex1d.sample(tex1dSmplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.sample(tex2dSmplr, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z, level(0.0)), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.sample(tex3dSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w, level(0.0)), tex3dSwzl)); c = float4(spvTextureSwizzle(tex1d.read(uint(0)), tex1dSwzl)); c = float4(spvTextureSwizzle(tex2d.read(uint2(int2(0)), 0), tex2dSwzl)); c = float4(spvTextureSwizzle(tex3d.read(uint3(int3(0)), 0), tex3dSwzl)); c = float4(spvTextureSwizzle(tex2dArray.read(uint2(int3(0).xy), uint(int3(0).z), 0), tex2dArraySwzl)); c = float4(texBuffer.read(spvTexelBufferCoord(0))); c = float4(spvGatherSwizzle(tex2d, tex2dSmplr, tex2dSwzl, component::x, float2(0.0), int2(0))); c = float4(spvGatherSwizzle(texCube, texCubeSmplr, texCubeSwzl, component::y, float3(0.0))); c = float4(spvGatherSwizzle(tex2dArray, tex2dArraySmplr, tex2dArraySwzl, component::z, float3(0.0).xy, uint(round(float3(0.0).z)), int2(0))); c = float4(spvGatherSwizzle(texCubeArray, texCubeArraySmplr, texCubeArraySwzl, component::w, float4(0.0).xyz, uint(round(float4(0.0).w)))); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/texture-access.swizzle.frag000066400000000000000000000236761400026215700302270ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } // Wrapper function that swizzles texture gathers. template class Tex, typename... Ts> inline vec spvGatherSwizzle(const thread Tex& t, sampler s, uint sw, component c, Ts... params) METAL_CONST_ARG(c) { if (sw) { switch (spvSwizzle((sw >> (uint(c) * 8)) & 0xFF)) { case spvSwizzle::none: break; case spvSwizzle::zero: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); case spvSwizzle::red: return t.gather(s, spvForward(params)..., component::x); case spvSwizzle::green: return t.gather(s, spvForward(params)..., component::y); case spvSwizzle::blue: return t.gather(s, spvForward(params)..., component::z); case spvSwizzle::alpha: return t.gather(s, spvForward(params)..., component::w); } } switch (c) { case component::x: return t.gather(s, spvForward(params)..., component::x); case component::y: return t.gather(s, spvForward(params)..., component::y); case component::z: return t.gather(s, spvForward(params)..., component::z); case component::w: return t.gather(s, spvForward(params)..., component::w); } } // Wrapper function that swizzles depth texture gathers. template class Tex, typename... Ts> inline vec spvGatherCompareSwizzle(const thread Tex& t, sampler s, uint sw, Ts... params) { if (sw) { switch (spvSwizzle(sw & 0xFF)) { case spvSwizzle::none: case spvSwizzle::red: break; case spvSwizzle::zero: case spvSwizzle::green: case spvSwizzle::blue: case spvSwizzle::alpha: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); } } return t.gather_compare(s, spvForward(params)...); } fragment void main0(constant uint* spvSwizzleConstants [[buffer(30)]], texture1d tex1d [[texture(0)]], texture2d tex2d [[texture(1)]], texture3d tex3d [[texture(2)]], texturecube texCube [[texture(3)]], texture2d_array tex2dArray [[texture(4)]], texturecube_array texCubeArray [[texture(5)]], depth2d depth2d [[texture(6)]], depthcube depthCube [[texture(7)]], depth2d_array depth2dArray [[texture(8)]], depthcube_array depthCubeArray [[texture(9)]], texture2d texBuffer [[texture(10)]], sampler tex1dSmplr [[sampler(0)]], sampler tex2dSmplr [[sampler(1)]], sampler tex3dSmplr [[sampler(2)]], sampler texCubeSmplr [[sampler(3)]], sampler tex2dArraySmplr [[sampler(4)]], sampler texCubeArraySmplr [[sampler(5)]], sampler depth2dSmplr [[sampler(6)]], sampler depthCubeSmplr [[sampler(7)]], sampler depth2dArraySmplr [[sampler(8)]], sampler depthCubeArraySmplr [[sampler(9)]]) { constant uint& tex1dSwzl = spvSwizzleConstants[0]; constant uint& tex2dSwzl = spvSwizzleConstants[1]; constant uint& tex3dSwzl = spvSwizzleConstants[2]; constant uint& texCubeSwzl = spvSwizzleConstants[3]; constant uint& tex2dArraySwzl = spvSwizzleConstants[4]; constant uint& texCubeArraySwzl = spvSwizzleConstants[5]; constant uint& depth2dSwzl = spvSwizzleConstants[6]; constant uint& depthCubeSwzl = spvSwizzleConstants[7]; constant uint& depth2dArraySwzl = spvSwizzleConstants[8]; constant uint& depthCubeArraySwzl = spvSwizzleConstants[9]; float4 c = spvTextureSwizzle(tex1d.sample(tex1dSmplr, 0.0), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSmplr, float2(0.0)), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSmplr, float3(0.0)), tex3dSwzl); c = spvTextureSwizzle(texCube.sample(texCubeSmplr, float3(0.0)), texCubeSwzl); c = spvTextureSwizzle(tex2dArray.sample(tex2dArraySmplr, float3(0.0).xy, uint(round(float3(0.0).z))), tex2dArraySwzl); c = spvTextureSwizzle(texCubeArray.sample(texCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w))), texCubeArraySwzl); c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSmplr, float3(0.0, 0.0, 1.0).xy, float3(0.0, 0.0, 1.0).z), depth2dSwzl); c.x = spvTextureSwizzle(depthCube.sample_compare(depthCubeSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz, float4(0.0, 0.0, 0.0, 1.0).w), depthCubeSwzl); c.x = spvTextureSwizzle(depth2dArray.sample_compare(depth2dArraySmplr, float4(0.0, 0.0, 0.0, 1.0).xy, uint(round(float4(0.0, 0.0, 0.0, 1.0).z)), float4(0.0, 0.0, 0.0, 1.0).w), depth2dArraySwzl); c.x = spvTextureSwizzle(depthCubeArray.sample_compare(depthCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w)), 1.0), depthCubeArraySwzl); c = spvTextureSwizzle(tex1d.sample(tex1dSmplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSmplr, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w), tex3dSwzl); float4 _100 = float4(0.0, 0.0, 1.0, 1.0); _100.z = float4(0.0, 0.0, 1.0, 1.0).w; c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSmplr, _100.xy / _100.z, float4(0.0, 0.0, 1.0, 1.0).z / _100.z), depth2dSwzl); c = spvTextureSwizzle(tex1d.sample(tex1dSmplr, 0.0), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSmplr, float2(0.0), level(0.0)), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSmplr, float3(0.0), level(0.0)), tex3dSwzl); c = spvTextureSwizzle(texCube.sample(texCubeSmplr, float3(0.0), level(0.0)), texCubeSwzl); c = spvTextureSwizzle(tex2dArray.sample(tex2dArraySmplr, float3(0.0).xy, uint(round(float3(0.0).z)), level(0.0)), tex2dArraySwzl); c = spvTextureSwizzle(texCubeArray.sample(texCubeArraySmplr, float4(0.0).xyz, uint(round(float4(0.0).w)), level(0.0)), texCubeArraySwzl); c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSmplr, float3(0.0, 0.0, 1.0).xy, float3(0.0, 0.0, 1.0).z, level(0.0)), depth2dSwzl); c = spvTextureSwizzle(tex1d.sample(tex1dSmplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), tex1dSwzl); c = spvTextureSwizzle(tex2d.sample(tex2dSmplr, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z, level(0.0)), tex2dSwzl); c = spvTextureSwizzle(tex3d.sample(tex3dSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w, level(0.0)), tex3dSwzl); float4 _128 = float4(0.0, 0.0, 1.0, 1.0); _128.z = float4(0.0, 0.0, 1.0, 1.0).w; c.x = spvTextureSwizzle(depth2d.sample_compare(depth2dSmplr, _128.xy / _128.z, float4(0.0, 0.0, 1.0, 1.0).z / _128.z, level(0.0)), depth2dSwzl); c = spvTextureSwizzle(tex1d.read(uint(0)), tex1dSwzl); c = spvTextureSwizzle(tex2d.read(uint2(int2(0)), 0), tex2dSwzl); c = spvTextureSwizzle(tex3d.read(uint3(int3(0)), 0), tex3dSwzl); c = spvTextureSwizzle(tex2dArray.read(uint2(int3(0).xy), uint(int3(0).z), 0), tex2dArraySwzl); c = texBuffer.read(spvTexelBufferCoord(0)); c = spvGatherSwizzle(tex2d, tex2dSmplr, tex2dSwzl, component::x, float2(0.0), int2(0)); c = spvGatherSwizzle(texCube, texCubeSmplr, texCubeSwzl, component::y, float3(0.0)); c = spvGatherSwizzle(tex2dArray, tex2dArraySmplr, tex2dArraySwzl, component::z, float3(0.0).xy, uint(round(float3(0.0).z)), int2(0)); c = spvGatherSwizzle(texCubeArray, texCubeArraySmplr, texCubeArraySwzl, component::w, float4(0.0).xyz, uint(round(float4(0.0).w))); c = spvGatherCompareSwizzle(depth2d, depth2dSmplr, depth2dSwzl, float2(0.0), 1.0); c = spvGatherCompareSwizzle(depthCube, depthCubeSmplr, depthCubeSwzl, float3(0.0), 1.0); c = spvGatherCompareSwizzle(depth2dArray, depth2dArraySmplr, depth2dArraySwzl, float3(0.0).xy, uint(round(float3(0.0).z)), 1.0); c = spvGatherCompareSwizzle(depthCubeArray, depthCubeArraySmplr, depthCubeArraySwzl, float4(0.0).xyz, uint(round(float4(0.0).w)), 1.0); } ubo-array-multiple-structs-access-chain.argument.msl2.frag000066400000000000000000000007101400026215700357360ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct Foo { float4 v; }; struct UBO { Foo foo; }; struct spvDescriptorSetBuffer0 { constant UBO* ubos [[id(0)]][2]; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]]) { main0_out out = {}; out.FragColor = spvDescriptorSet0.ubos[1]->foo.v; return out; } ubo-array-multiple-structs-access-chain.frag000066400000000000000000000006721400026215700332500ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag#include #include using namespace metal; struct Foo { float4 v; }; struct UBO { Foo foo; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant UBO* ubos_0 [[buffer(0)]], constant UBO* ubos_1 [[buffer(1)]]) { constant UBO* ubos[] = { ubos_0, ubos_1, }; main0_out out = {}; out.FragColor = ubos[1]->foo.v; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/ubo-offset-out-of-order.frag000066400000000000000000000006341400026215700301400ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 v; float4x4 m; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant UBO& _13 [[buffer(0)]]) { main0_out out = {}; out.FragColor = (_13.m * in.vColor) + _13.v; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/frag/variables.zero-initialize.frag000066400000000000000000000011511400026215700306270ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { int a; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; int uninit_function_int = {}; int uninit_int = {}; int4 uninit_vector = {}; float4x4 uninit_matrix = {}; Foo uninit_foo = {}; if (in.vColor.x > 10.0) { uninit_function_int = 10; } else { uninit_function_int = 20; } out.FragColor = in.vColor; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/000077500000000000000000000000001400026215700234005ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/array-of-vec3.comp000066400000000000000000000004121400026215700266330ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { packed_float3 v[16]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _13 [[buffer(0)]]) { _13.v[1] = float3(_13.v[0]); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/array-of-vec4.comp000066400000000000000000000003731400026215700266420ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 v[16]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _13 [[buffer(0)]]) { _13.v[1] = _13.v[0]; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/isolated-scalar-access.comp000066400000000000000000000010501400026215700305620ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 v; float4x4 cm; float4x4 rm; packed_float3 v3; float f; }; kernel void main0(device SSBO& _12 [[buffer(0)]]) { threadgroup float4 shared_vec4; threadgroup float3 shared_vec3; ((device float*)&_12.v)[0u] = 10.0; _12.v3[1u] = 40.0; ((device float*)&_12.cm[1])[2u] = 20.0; ((device float*)&_12.rm[1u])[3] = 30.0; ((threadgroup float*)&shared_vec4)[2u] = 40.0; ((threadgroup float*)&shared_vec3)[1u] = 1.0; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/load-store-col-rows.comp000066400000000000000000000034521400026215700301000ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; typedef packed_float3 packed_float2x3[2]; typedef packed_float3 packed_rm_float3x2[2]; struct SSBO1 { float2x4 a; float2x4 a2; }; struct SSBO2 { packed_float2x3 b; packed_rm_float3x2 b2; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_column(device SSBO1& v_21) { float2 u = v_21.a[0].xy; float2 v = v_21.a[1].xy; u += v; (device float2&)v_21.a[0] = u; (device float2&)v_21.a[1] = v; } static inline __attribute__((always_inline)) void load_store_row(device SSBO1& v_21) { float2 u = float2(v_21.a2[0][0], v_21.a2[1][0]); float2 v = float2(v_21.a2[0][1], v_21.a2[1][1]); u += v; ((device float*)&v_21.a2[0])[0] = u.x; ((device float*)&v_21.a2[1])[0] = u.y; ((device float*)&v_21.a2[0])[1] = v.x; ((device float*)&v_21.a2[1])[1] = v.y; } static inline __attribute__((always_inline)) void load_store_packed_column(device SSBO2& v_58) { float3 u = float3(v_58.b[0]); float3 v = float3(v_58.b[1]); u += v; v_58.b[0] = u; v_58.b[1] = v; } static inline __attribute__((always_inline)) void load_store_packed_row(device SSBO2& v_58) { float2 u = float2(v_58.b2[0][0], v_58.b2[1][0]); float2 v = float2(v_58.b2[0][1], v_58.b2[1][1]); u += v; ((device float*)&v_58.b2[0])[0] = u.x; ((device float*)&v_58.b2[1])[0] = u.y; ((device float*)&v_58.b2[0])[1] = v.x; ((device float*)&v_58.b2[1])[1] = v.y; } kernel void main0(device SSBO1& v_21 [[buffer(0)]], device SSBO2& v_58 [[buffer(1)]]) { load_store_column(v_21); load_store_row(v_21); load_store_packed_column(v_58); load_store_packed_row(v_58); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-2x2-scalar.comp000066400000000000000000000044561400026215700274510ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float2x2 col_major0; float2x2 col_major1; }; struct SSBORow { float2x2 row_major0; float2x2 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float2x2 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float2x2 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-2x2-std140.comp000066400000000000000000000067751400026215700272310ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float2x4 col_major0; float2x4 col_major1; }; struct SSBORow { float2x4 row_major0; float2x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float2x2 loaded = float2x2(v_29.col_major0[0].xy, v_29.col_major0[1].xy); (device float2&)v_29.col_major1[0] = loaded[0]; (device float2&)v_29.col_major1[1] = loaded[1]; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float2x2 loaded = transpose(float2x2(v_41.row_major0[0].xy, v_41.row_major0[1].xy)); (device float2&)v_41.row_major0[0] = float2(loaded[0][0], loaded[1][0]); (device float2&)v_41.row_major0[1] = float2(loaded[0][1], loaded[1][1]); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { (device float2&)v_29.col_major0[0] = float2x2(v_29.col_major1[0].xy, v_29.col_major1[1].xy)[0]; (device float2&)v_29.col_major0[1] = float2x2(v_29.col_major1[0].xy, v_29.col_major1[1].xy)[1]; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { (device float2&)v_41.row_major0[0] = float2(float2x2(v_29.col_major0[0].xy, v_29.col_major0[1].xy)[0][0], float2x2(v_29.col_major0[0].xy, v_29.col_major0[1].xy)[1][0]); (device float2&)v_41.row_major0[1] = float2(float2x2(v_29.col_major0[0].xy, v_29.col_major0[1].xy)[0][1], float2x2(v_29.col_major0[0].xy, v_29.col_major0[1].xy)[1][1]); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { (device float2&)v_29.col_major0[0] = float2(float2x2(v_41.row_major0[0].xy, v_41.row_major0[1].xy)[0][0], float2x2(v_41.row_major0[0].xy, v_41.row_major0[1].xy)[1][0]); (device float2&)v_29.col_major0[1] = float2(float2x2(v_41.row_major0[0].xy, v_41.row_major0[1].xy)[0][1], float2x2(v_41.row_major0[0].xy, v_41.row_major0[1].xy)[1][1]); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { (device float2&)v_41.row_major0[0] = float2x2(v_41.row_major1[0].xy, v_41.row_major1[1].xy)[0]; (device float2&)v_41.row_major0[1] = float2x2(v_41.row_major1[0].xy, v_41.row_major1[1].xy)[1]; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { (device float2&)v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); ((device float*)&v_41.row_major0[0])[1] = v_29.col_major0[1].x; ((device float*)&v_41.row_major0[1])[1] = v_29.col_major0[1].y; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-2x2-std430.comp000066400000000000000000000044561400026215700272250ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float2x2 col_major0; float2x2 col_major1; }; struct SSBORow { float2x2 row_major0; float2x2 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float2x2 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float2x2 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-2x3-scalar.comp000066400000000000000000000055121400026215700274440ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; typedef packed_float3 packed_float2x3[2]; struct SSBOCol { packed_float2x3 col_major0; packed_float2x3 col_major1; }; struct SSBORow { float3x2 row_major0; float3x2 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float2x3 loaded = float2x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1])); v_29.col_major1[0] = loaded[0]; v_29.col_major1[1] = loaded[1]; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float2x3 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0[0] = float2x3(float3(v_29.col_major1[0]), float3(v_29.col_major1[1]))[0]; v_29.col_major0[1] = float2x3(float3(v_29.col_major1[0]), float3(v_29.col_major1[1]))[1]; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(float2x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]))); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[0] = float3(v_41.row_major0[0][0], v_41.row_major0[1][0], v_41.row_major0[2][0]); v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); v_41.row_major0[0][1] = v_29.col_major0[1][0]; v_41.row_major0[1][1] = v_29.col_major0[1][1]; v_41.row_major0[2][1] = v_29.col_major0[1][2]; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[0][1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = v_29.col_major0[0][1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-2x3-std140.comp000066400000000000000000000064341400026215700272220ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float2x3 col_major0; float2x3 col_major1; }; struct SSBORow { float3x4 row_major0; float3x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float2x3 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float2x3 loaded = transpose(float3x2(v_41.row_major0[0].xy, v_41.row_major0[1].xy, v_41.row_major0[2].xy)); (device float2&)v_41.row_major0[0] = float2(loaded[0][0], loaded[1][0]); (device float2&)v_41.row_major0[1] = float2(loaded[0][1], loaded[1][1]); (device float2&)v_41.row_major0[2] = float2(loaded[0][2], loaded[1][2]); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { (device float2&)v_41.row_major0[0] = float2(v_29.col_major0[0][0], v_29.col_major0[1][0]); (device float2&)v_41.row_major0[1] = float2(v_29.col_major0[0][1], v_29.col_major0[1][1]); (device float2&)v_41.row_major0[2] = float2(v_29.col_major0[0][2], v_29.col_major0[1][2]); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(float3x2(v_41.row_major0[0].xy, v_41.row_major0[1].xy, v_41.row_major0[2].xy)); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { (device float2&)v_41.row_major0[0] = float3x2(v_41.row_major1[0].xy, v_41.row_major1[1].xy, v_41.row_major1[2].xy)[0]; (device float2&)v_41.row_major0[1] = float3x2(v_41.row_major1[0].xy, v_41.row_major1[1].xy, v_41.row_major1[2].xy)[1]; (device float2&)v_41.row_major0[2] = float3x2(v_41.row_major1[0].xy, v_41.row_major1[1].xy, v_41.row_major1[2].xy)[2]; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); ((device float*)&v_41.row_major0[0])[1] = v_29.col_major0[1].x; ((device float*)&v_41.row_major0[1])[1] = v_29.col_major0[1].y; ((device float*)&v_41.row_major0[2])[1] = v_29.col_major0[1].z; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-2x3-std430.comp000066400000000000000000000045671400026215700272310ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float2x3 col_major0; float2x3 col_major1; }; struct SSBORow { float3x2 row_major0; float3x2 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float2x3 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float2x3 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-2x4-scalar.comp000066400000000000000000000047001400026215700274430ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float2x4 col_major0; float2x4 col_major1; }; struct SSBORow { float4x2 row_major0; float4x2 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float2x4 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float2x4 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float4(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1], v_41.row_major0[3][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; v_41.row_major0[3][1] = v_29.col_major0[1].w; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-2x4-std140.comp000066400000000000000000000074501400026215700272220ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float2x4 col_major0; float2x4 col_major1; }; struct SSBORow { float4x4 row_major0; float4x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float2x4 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float2x4 loaded = transpose(float4x2(v_41.row_major0[0].xy, v_41.row_major0[1].xy, v_41.row_major0[2].xy, v_41.row_major0[3].xy)); (device float2&)v_41.row_major0[0] = float2(loaded[0][0], loaded[1][0]); (device float2&)v_41.row_major0[1] = float2(loaded[0][1], loaded[1][1]); (device float2&)v_41.row_major0[2] = float2(loaded[0][2], loaded[1][2]); (device float2&)v_41.row_major0[3] = float2(loaded[0][3], loaded[1][3]); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { (device float2&)v_41.row_major0[0] = float2(v_29.col_major0[0][0], v_29.col_major0[1][0]); (device float2&)v_41.row_major0[1] = float2(v_29.col_major0[0][1], v_29.col_major0[1][1]); (device float2&)v_41.row_major0[2] = float2(v_29.col_major0[0][2], v_29.col_major0[1][2]); (device float2&)v_41.row_major0[3] = float2(v_29.col_major0[0][3], v_29.col_major0[1][3]); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(float4x2(v_41.row_major0[0].xy, v_41.row_major0[1].xy, v_41.row_major0[2].xy, v_41.row_major0[3].xy)); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { (device float2&)v_41.row_major0[0] = float4x2(v_41.row_major1[0].xy, v_41.row_major1[1].xy, v_41.row_major1[2].xy, v_41.row_major1[3].xy)[0]; (device float2&)v_41.row_major0[1] = float4x2(v_41.row_major1[0].xy, v_41.row_major1[1].xy, v_41.row_major1[2].xy, v_41.row_major1[3].xy)[1]; (device float2&)v_41.row_major0[2] = float4x2(v_41.row_major1[0].xy, v_41.row_major1[1].xy, v_41.row_major1[2].xy, v_41.row_major1[3].xy)[2]; (device float2&)v_41.row_major0[3] = float4x2(v_41.row_major1[0].xy, v_41.row_major1[1].xy, v_41.row_major1[2].xy, v_41.row_major1[3].xy)[3]; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float4(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1], v_41.row_major0[3][1]); ((device float*)&v_41.row_major0[0])[1] = v_29.col_major0[1].x; ((device float*)&v_41.row_major0[1])[1] = v_29.col_major0[1].y; ((device float*)&v_41.row_major0[2])[1] = v_29.col_major0[1].z; ((device float*)&v_41.row_major0[3])[1] = v_29.col_major0[1].w; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-2x4-std430.comp000066400000000000000000000047001400026215700272170ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float2x4 col_major0; float2x4 col_major1; }; struct SSBORow { float4x2 row_major0; float4x2 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float2x4 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float2x4 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float4(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1], v_41.row_major0[3][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; v_41.row_major0[3][1] = v_29.col_major0[1].w; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-3x2-scalar.comp000066400000000000000000000055561400026215700274540ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; typedef packed_float3 packed_rm_float3x2[2]; struct SSBOCol { float3x2 col_major0; float3x2 col_major1; }; struct SSBORow { packed_rm_float3x2 row_major0; packed_rm_float3x2 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float3x2 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float3x2 loaded = transpose(float2x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]))); v_41.row_major0[0] = float3(loaded[0][0], loaded[1][0], loaded[2][0]); v_41.row_major0[1] = float3(loaded[0][1], loaded[1][1], loaded[2][1]); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0[0] = float3(v_29.col_major0[0][0], v_29.col_major0[1][0], v_29.col_major0[2][0]); v_41.row_major0[1] = float3(v_29.col_major0[0][1], v_29.col_major0[1][1], v_29.col_major0[2][1]); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(float2x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]))); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0[0] = float2x3(float3(v_41.row_major1[0]), float3(v_41.row_major1[1]))[0]; v_41.row_major0[1] = float2x3(float3(v_41.row_major1[0]), float3(v_41.row_major1[1]))[1]; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); ((device float*)&v_41.row_major0[0])[1] = v_29.col_major0[1].x; ((device float*)&v_41.row_major0[1])[1] = v_29.col_major0[1].y; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = v_41.row_major0[1u][0]; v_41.row_major0[1u][0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-3x2-std140.comp000066400000000000000000000061551400026215700272220ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float3x4 col_major0; float3x4 col_major1; }; struct SSBORow { float2x3 row_major0; float2x3 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float3x2 loaded = float3x2(v_29.col_major0[0].xy, v_29.col_major0[1].xy, v_29.col_major0[2].xy); (device float2&)v_29.col_major1[0] = loaded[0]; (device float2&)v_29.col_major1[1] = loaded[1]; (device float2&)v_29.col_major1[2] = loaded[2]; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float3x2 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { (device float2&)v_29.col_major0[0] = float3x2(v_29.col_major1[0].xy, v_29.col_major1[1].xy, v_29.col_major1[2].xy)[0]; (device float2&)v_29.col_major0[1] = float3x2(v_29.col_major1[0].xy, v_29.col_major1[1].xy, v_29.col_major1[2].xy)[1]; (device float2&)v_29.col_major0[2] = float3x2(v_29.col_major1[0].xy, v_29.col_major1[1].xy, v_29.col_major1[2].xy)[2]; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(float3x2(v_29.col_major0[0].xy, v_29.col_major0[1].xy, v_29.col_major0[2].xy)); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { (device float2&)v_29.col_major0[0] = float2(v_41.row_major0[0][0], v_41.row_major0[1][0]); (device float2&)v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); (device float2&)v_29.col_major0[2] = float2(v_41.row_major0[0][2], v_41.row_major0[1][2]); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { (device float2&)v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-3x2-std430.comp000066400000000000000000000044561400026215700272260ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float3x2 col_major0; float3x2 col_major1; }; struct SSBORow { float2x3 row_major0; float2x3 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float3x2 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float3x2 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-3x3-scalar.comp000066400000000000000000000125721400026215700274510ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; typedef packed_float3 packed_float3x3[3]; typedef packed_float3 packed_rm_float3x3[3]; struct SSBOCol { packed_float3x3 col_major0; packed_float3x3 col_major1; }; struct SSBORow { packed_rm_float3x3 row_major0; packed_rm_float3x3 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float3x3 loaded = float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2])); v_29.col_major1[0] = loaded[0]; v_29.col_major1[1] = loaded[1]; v_29.col_major1[2] = loaded[2]; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float3x3 loaded = transpose(float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))); v_41.row_major0[0] = float3(loaded[0][0], loaded[1][0], loaded[2][0]); v_41.row_major0[1] = float3(loaded[0][1], loaded[1][1], loaded[2][1]); v_41.row_major0[2] = float3(loaded[0][2], loaded[1][2], loaded[2][2]); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0[0] = float3x3(float3(v_29.col_major1[0]), float3(v_29.col_major1[1]), float3(v_29.col_major1[2]))[0]; v_29.col_major0[1] = float3x3(float3(v_29.col_major1[0]), float3(v_29.col_major1[1]), float3(v_29.col_major1[2]))[1]; v_29.col_major0[2] = float3x3(float3(v_29.col_major1[0]), float3(v_29.col_major1[1]), float3(v_29.col_major1[2]))[2]; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0[0] = float3(float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]))[0][0], float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]))[1][0], float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]))[2][0]); v_41.row_major0[1] = float3(float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]))[0][1], float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]))[1][1], float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]))[2][1]); v_41.row_major0[2] = float3(float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]))[0][2], float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]))[1][2], float3x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]))[2][2]); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[0] = float3(float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))[0][0], float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))[1][0], float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))[2][0]); v_29.col_major0[1] = float3(float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))[0][1], float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))[1][1], float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))[2][1]); v_29.col_major0[2] = float3(float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))[0][2], float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))[1][2], float3x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]))[2][2]); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0[0] = float3x3(float3(v_41.row_major1[0]), float3(v_41.row_major1[1]), float3(v_41.row_major1[2]))[0]; v_41.row_major0[1] = float3x3(float3(v_41.row_major1[0]), float3(v_41.row_major1[1]), float3(v_41.row_major1[2]))[1]; v_41.row_major0[2] = float3x3(float3(v_41.row_major1[0]), float3(v_41.row_major1[1]), float3(v_41.row_major1[2]))[2]; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); ((device float*)&v_41.row_major0[0])[1] = v_29.col_major0[1][0]; ((device float*)&v_41.row_major0[1])[1] = v_29.col_major0[1][1]; ((device float*)&v_41.row_major0[2])[1] = v_29.col_major0[1][2]; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[0][1u] = v_41.row_major0[1u][0]; v_41.row_major0[1u][0] = v_29.col_major0[0][1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-3x3-std140.comp000066400000000000000000000045671400026215700272300ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float3x3 col_major0; float3x3 col_major1; }; struct SSBORow { float3x3 row_major0; float3x3 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float3x3 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float3x3 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-3x3-std430.comp000066400000000000000000000045671400026215700272320ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float3x3 col_major0; float3x3 col_major1; }; struct SSBORow { float3x3 row_major0; float3x3 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float3x3 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float3x3 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-3x4-scalar.comp000066400000000000000000000076221400026215700274520ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; typedef packed_float3 packed_rm_float3x4[4]; struct SSBOCol { float3x4 col_major0; float3x4 col_major1; }; struct SSBORow { packed_rm_float3x4 row_major0; packed_rm_float3x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float3x4 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float3x4 loaded = transpose(float4x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]), float3(v_41.row_major0[3]))); v_41.row_major0[0] = float3(loaded[0][0], loaded[1][0], loaded[2][0]); v_41.row_major0[1] = float3(loaded[0][1], loaded[1][1], loaded[2][1]); v_41.row_major0[2] = float3(loaded[0][2], loaded[1][2], loaded[2][2]); v_41.row_major0[3] = float3(loaded[0][3], loaded[1][3], loaded[2][3]); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0[0] = float3(v_29.col_major0[0][0], v_29.col_major0[1][0], v_29.col_major0[2][0]); v_41.row_major0[1] = float3(v_29.col_major0[0][1], v_29.col_major0[1][1], v_29.col_major0[2][1]); v_41.row_major0[2] = float3(v_29.col_major0[0][2], v_29.col_major0[1][2], v_29.col_major0[2][2]); v_41.row_major0[3] = float3(v_29.col_major0[0][3], v_29.col_major0[1][3], v_29.col_major0[2][3]); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(float4x3(float3(v_41.row_major0[0]), float3(v_41.row_major0[1]), float3(v_41.row_major0[2]), float3(v_41.row_major0[3]))); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0[0] = float4x3(float3(v_41.row_major1[0]), float3(v_41.row_major1[1]), float3(v_41.row_major1[2]), float3(v_41.row_major1[3]))[0]; v_41.row_major0[1] = float4x3(float3(v_41.row_major1[0]), float3(v_41.row_major1[1]), float3(v_41.row_major1[2]), float3(v_41.row_major1[3]))[1]; v_41.row_major0[2] = float4x3(float3(v_41.row_major1[0]), float3(v_41.row_major1[1]), float3(v_41.row_major1[2]), float3(v_41.row_major1[3]))[2]; v_41.row_major0[3] = float4x3(float3(v_41.row_major1[0]), float3(v_41.row_major1[1]), float3(v_41.row_major1[2]), float3(v_41.row_major1[3]))[3]; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float4(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1], v_41.row_major0[3][1]); ((device float*)&v_41.row_major0[0])[1] = v_29.col_major0[1].x; ((device float*)&v_41.row_major0[1])[1] = v_29.col_major0[1].y; ((device float*)&v_41.row_major0[2])[1] = v_29.col_major0[1].z; ((device float*)&v_41.row_major0[3])[1] = v_29.col_major0[1].w; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = v_41.row_major0[1u][0]; v_41.row_major0[1u][0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-3x4-std140.comp000066400000000000000000000047001400026215700272160ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float3x4 col_major0; float3x4 col_major1; }; struct SSBORow { float4x3 row_major0; float4x3 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float3x4 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float3x4 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float4(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1], v_41.row_major0[3][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; v_41.row_major0[3][1] = v_29.col_major0[1].w; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-3x4-std430.comp000066400000000000000000000047001400026215700272200ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float3x4 col_major0; float3x4 col_major1; }; struct SSBORow { float4x3 row_major0; float4x3 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float3x4 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float3x4 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float4(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1], v_41.row_major0[3][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; v_41.row_major0[3][1] = v_29.col_major0[1].w; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-4x2-scalar.comp000066400000000000000000000044561400026215700274530ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float4x2 col_major0; float4x2 col_major1; }; struct SSBORow { float2x4 row_major0; float2x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float4x2 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float4x2 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-4x2-std140.comp000066400000000000000000000070051400026215700272160ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float4x4 col_major0; float4x4 col_major1; }; struct SSBORow { float2x4 row_major0; float2x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float4x2 loaded = float4x2(v_29.col_major0[0].xy, v_29.col_major0[1].xy, v_29.col_major0[2].xy, v_29.col_major0[3].xy); (device float2&)v_29.col_major1[0] = loaded[0]; (device float2&)v_29.col_major1[1] = loaded[1]; (device float2&)v_29.col_major1[2] = loaded[2]; (device float2&)v_29.col_major1[3] = loaded[3]; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float4x2 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { (device float2&)v_29.col_major0[0] = float4x2(v_29.col_major1[0].xy, v_29.col_major1[1].xy, v_29.col_major1[2].xy, v_29.col_major1[3].xy)[0]; (device float2&)v_29.col_major0[1] = float4x2(v_29.col_major1[0].xy, v_29.col_major1[1].xy, v_29.col_major1[2].xy, v_29.col_major1[3].xy)[1]; (device float2&)v_29.col_major0[2] = float4x2(v_29.col_major1[0].xy, v_29.col_major1[1].xy, v_29.col_major1[2].xy, v_29.col_major1[3].xy)[2]; (device float2&)v_29.col_major0[3] = float4x2(v_29.col_major1[0].xy, v_29.col_major1[1].xy, v_29.col_major1[2].xy, v_29.col_major1[3].xy)[3]; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(float4x2(v_29.col_major0[0].xy, v_29.col_major0[1].xy, v_29.col_major0[2].xy, v_29.col_major0[3].xy)); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { (device float2&)v_29.col_major0[0] = float2(v_41.row_major0[0][0], v_41.row_major0[1][0]); (device float2&)v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); (device float2&)v_29.col_major0[2] = float2(v_41.row_major0[0][2], v_41.row_major0[1][2]); (device float2&)v_29.col_major0[3] = float2(v_41.row_major0[0][3], v_41.row_major0[1][3]); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { (device float2&)v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-4x2-std430.comp000066400000000000000000000044561400026215700272270ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float4x2 col_major0; float4x2 col_major1; }; struct SSBORow { float2x4 row_major0; float2x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float4x2 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float4x2 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float2(v_41.row_major0[0][1], v_41.row_major0[1][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-4x3-scalar.comp000066400000000000000000000071521400026215700274500ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; typedef packed_float3 packed_float4x3[4]; struct SSBOCol { packed_float4x3 col_major0; packed_float4x3 col_major1; }; struct SSBORow { float3x4 row_major0; float3x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float4x3 loaded = float4x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]), float3(v_29.col_major0[3])); v_29.col_major1[0] = loaded[0]; v_29.col_major1[1] = loaded[1]; v_29.col_major1[2] = loaded[2]; v_29.col_major1[3] = loaded[3]; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float4x3 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0[0] = float4x3(float3(v_29.col_major1[0]), float3(v_29.col_major1[1]), float3(v_29.col_major1[2]), float3(v_29.col_major1[3]))[0]; v_29.col_major0[1] = float4x3(float3(v_29.col_major1[0]), float3(v_29.col_major1[1]), float3(v_29.col_major1[2]), float3(v_29.col_major1[3]))[1]; v_29.col_major0[2] = float4x3(float3(v_29.col_major1[0]), float3(v_29.col_major1[1]), float3(v_29.col_major1[2]), float3(v_29.col_major1[3]))[2]; v_29.col_major0[3] = float4x3(float3(v_29.col_major1[0]), float3(v_29.col_major1[1]), float3(v_29.col_major1[2]), float3(v_29.col_major1[3]))[3]; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(float4x3(float3(v_29.col_major0[0]), float3(v_29.col_major0[1]), float3(v_29.col_major0[2]), float3(v_29.col_major0[3]))); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[0] = float3(v_41.row_major0[0][0], v_41.row_major0[1][0], v_41.row_major0[2][0]); v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); v_29.col_major0[2] = float3(v_41.row_major0[0][2], v_41.row_major0[1][2], v_41.row_major0[2][2]); v_29.col_major0[3] = float3(v_41.row_major0[0][3], v_41.row_major0[1][3], v_41.row_major0[2][3]); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); v_41.row_major0[0][1] = v_29.col_major0[1][0]; v_41.row_major0[1][1] = v_29.col_major0[1][1]; v_41.row_major0[2][1] = v_29.col_major0[1][2]; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[0][1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = v_29.col_major0[0][1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-4x3-std140.comp000066400000000000000000000045671400026215700272310ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float4x3 col_major0; float4x3 col_major1; }; struct SSBORow { float3x4 row_major0; float3x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float4x3 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float4x3 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-4x3-std430.comp000066400000000000000000000045671400026215700272330ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float4x3 col_major0; float4x3 col_major1; }; struct SSBORow { float3x4 row_major0; float3x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float4x3 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float4x3 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float3(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-4x4-scalar.comp000066400000000000000000000047001400026215700274450ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float4x4 col_major0; float4x4 col_major1; }; struct SSBORow { float4x4 row_major0; float4x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float4x4 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float4x4 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float4(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1], v_41.row_major0[3][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; v_41.row_major0[3][1] = v_29.col_major0[1].w; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-4x4-std140.comp000066400000000000000000000047001400026215700272170ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float4x4 col_major0; float4x4 col_major1; }; struct SSBORow { float4x4 row_major0; float4x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float4x4 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float4x4 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float4(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1], v_41.row_major0[3][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; v_41.row_major0[3][1] = v_29.col_major0[1].w; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-4x4-std430.comp000066400000000000000000000047001400026215700272210ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBOCol { float4x4 col_major0; float4x4 col_major1; }; struct SSBORow { float4x4 row_major0; float4x4 row_major1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void load_store_to_variable_col_major(device SSBOCol& v_29) { float4x4 loaded = v_29.col_major0; v_29.col_major1 = loaded; } static inline __attribute__((always_inline)) void load_store_to_variable_row_major(device SSBORow& v_41) { float4x4 loaded = transpose(v_41.row_major0); v_41.row_major0 = transpose(loaded); } static inline __attribute__((always_inline)) void copy_col_major_to_col_major(device SSBOCol& v_29) { v_29.col_major0 = v_29.col_major1; } static inline __attribute__((always_inline)) void copy_col_major_to_row_major(device SSBOCol& v_29, device SSBORow& v_41) { v_41.row_major0 = transpose(v_29.col_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_col_major(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0 = transpose(v_41.row_major0); } static inline __attribute__((always_inline)) void copy_row_major_to_row_major(device SSBORow& v_41) { v_41.row_major0 = v_41.row_major1; } static inline __attribute__((always_inline)) void copy_columns(device SSBOCol& v_29, device SSBORow& v_41) { v_29.col_major0[1] = float4(v_41.row_major0[0][1], v_41.row_major0[1][1], v_41.row_major0[2][1], v_41.row_major0[3][1]); v_41.row_major0[0][1] = v_29.col_major0[1].x; v_41.row_major0[1][1] = v_29.col_major0[1].y; v_41.row_major0[2][1] = v_29.col_major0[1].z; v_41.row_major0[3][1] = v_29.col_major0[1].w; } static inline __attribute__((always_inline)) void copy_elements(device SSBOCol& v_29, device SSBORow& v_41) { ((device float*)&v_29.col_major0[0])[1u] = ((device float*)&v_41.row_major0[1u])[0]; ((device float*)&v_41.row_major0[1u])[0] = ((device float*)&v_29.col_major0[0])[1u]; } kernel void main0(device SSBOCol& v_29 [[buffer(0)]], device SSBORow& v_41 [[buffer(1)]]) { load_store_to_variable_col_major(v_29); load_store_to_variable_row_major(v_41); copy_col_major_to_col_major(v_29); copy_col_major_to_row_major(v_29, v_41); copy_row_major_to_col_major(v_29, v_41); copy_row_major_to_row_major(v_41); copy_columns(v_29, v_41); copy_elements(v_29, v_41); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-multiply-row-major.comp000066400000000000000000000005421400026215700313550ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float3x3 m0; float3x3 m1; float3 v0; float3 v1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _11 [[buffer(0)]]) { _11.v0 = _11.v1 * (_11.m1 * _11.m0); _11.v0 = (_11.v1 * _11.m1) * _11.m0; } matrix-multiply-unpacked-col-major-2.comp000066400000000000000000000017631400026215700332010ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing#include #include using namespace metal; typedef packed_float3 packed_float3x3[3]; struct SSBO { packed_float3x3 m0; packed_float3x3 m1; packed_float3 v0; packed_float3 v1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _11 [[buffer(0)]]) { _11.v0 = (float3x3(float3(_11.m0[0]), float3(_11.m0[1]), float3(_11.m0[2])) * float3x3(float3(_11.m1[0]), float3(_11.m1[1]), float3(_11.m1[2]))) * float3(_11.v1); _11.v0 = float3x3(float3(_11.m0[0]), float3(_11.m0[1]), float3(_11.m0[2])) * (float3x3(float3(_11.m1[0]), float3(_11.m1[1]), float3(_11.m1[2])) * float3(_11.v1)); _11.v0 = (float3(_11.v1) * float3x3(float3(_11.m0[0]), float3(_11.m0[1]), float3(_11.m0[2]))) * float3x3(float3(_11.m1[0]), float3(_11.m1[1]), float3(_11.m1[2])); _11.v0 = float3(_11.v1) * (float3x3(float3(_11.m0[0]), float3(_11.m0[1]), float3(_11.m0[2])) * float3x3(float3(_11.m1[0]), float3(_11.m1[1]), float3(_11.m1[2]))); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-multiply-unpacked-col-major.comp000066400000000000000000000012441400026215700331130ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float2x4 m0; float2x4 m1; float2 v0; float2 v1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _11 [[buffer(0)]]) { _11.v0 = (float2x2(_11.m0[0].xy, _11.m0[1].xy) * float2x2(_11.m1[0].xy, _11.m1[1].xy)) * _11.v1; _11.v0 = float2x2(_11.m0[0].xy, _11.m0[1].xy) * (float2x2(_11.m1[0].xy, _11.m1[1].xy) * _11.v1); _11.v0 = (_11.v1 * float2x2(_11.m0[0].xy, _11.m0[1].xy)) * float2x2(_11.m1[0].xy, _11.m1[1].xy); _11.v0 = _11.v1 * (float2x2(_11.m0[0].xy, _11.m0[1].xy) * float2x2(_11.m1[0].xy, _11.m1[1].xy)); } matrix-multiply-unpacked-row-major-2.comp000066400000000000000000000017741400026215700332350ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing#include #include using namespace metal; typedef packed_float3 packed_rm_float3x3[3]; struct SSBO { packed_rm_float3x3 m0; packed_rm_float3x3 m1; packed_float3 v0; packed_float3 v1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _11 [[buffer(0)]]) { _11.v0 = float3(_11.v1) * (float3x3(float3(_11.m1[0]), float3(_11.m1[1]), float3(_11.m1[2])) * float3x3(float3(_11.m0[0]), float3(_11.m0[1]), float3(_11.m0[2]))); _11.v0 = (float3(_11.v1) * float3x3(float3(_11.m1[0]), float3(_11.m1[1]), float3(_11.m1[2]))) * float3x3(float3(_11.m0[0]), float3(_11.m0[1]), float3(_11.m0[2])); _11.v0 = float3x3(float3(_11.m1[0]), float3(_11.m1[1]), float3(_11.m1[2])) * (float3x3(float3(_11.m0[0]), float3(_11.m0[1]), float3(_11.m0[2])) * float3(_11.v1)); _11.v0 = (float3x3(float3(_11.m1[0]), float3(_11.m1[1]), float3(_11.m1[2])) * float3x3(float3(_11.m0[0]), float3(_11.m0[1]), float3(_11.m0[2]))) * float3(_11.v1); } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/matrix-multiply-unpacked-row-major.comp000066400000000000000000000012441400026215700331450ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float2x4 m0; float2x4 m1; float2 v0; float2 v1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _11 [[buffer(0)]]) { _11.v0 = _11.v1 * (float2x2(_11.m1[0].xy, _11.m1[1].xy) * float2x2(_11.m0[0].xy, _11.m0[1].xy)); _11.v0 = (_11.v1 * float2x2(_11.m1[0].xy, _11.m1[1].xy)) * float2x2(_11.m0[0].xy, _11.m0[1].xy); _11.v0 = float2x2(_11.m1[0].xy, _11.m1[1].xy) * (float2x2(_11.m0[0].xy, _11.m0[1].xy) * _11.v1); _11.v0 = (float2x2(_11.m1[0].xy, _11.m1[1].xy) * float2x2(_11.m0[0].xy, _11.m0[1].xy)) * _11.v1; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/member-padding.comp000066400000000000000000000004671400026215700271420ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { char _m0_pad[16]; float a; char _m1_pad[20]; float b; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _9 [[buffer(0)]]) { _9.a = 10.0; _9.b = 20.0; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/std140-array-of-vectors.comp000066400000000000000000000022251400026215700305010ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 v1[4]; float4 v2[4]; float3 v3[4]; float4 v4[4]; float4 v1_array_of_array[4][4]; float4 v2_array_of_array[4][4]; float3 v3_array_of_array[4][4]; float4 v4_array_of_array[4][4]; float4 v_unsized[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _29 [[buffer(0)]]) { float loaded1 = _29.v1[1].x; (device float&)_29.v1[2] = loaded1; float2 loaded2 = _29.v2[1].xy; (device float2&)_29.v2[2] = loaded2; float3 loaded3 = _29.v3[1]; _29.v3[2] = loaded3; float4 loaded4 = _29.v4[1]; _29.v4[2] = loaded4; loaded1 = _29.v1_array_of_array[1][2].x; (device float&)_29.v1_array_of_array[2][3] = loaded1; loaded2 = _29.v2_array_of_array[1][2].xy; (device float2&)_29.v2_array_of_array[2][3] = loaded2; loaded3 = _29.v3_array_of_array[1][2]; _29.v3_array_of_array[2][3] = loaded3; loaded4 = _29.v4_array_of_array[1][2]; _29.v4_array_of_array[2][3] = loaded4; loaded1 = _29.v_unsized[1].x; (device float&)_29.v_unsized[2] = loaded1; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/struct-alignment.comp000066400000000000000000000005721400026215700275640ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { packed_float3 a; float b; }; struct SSBO { float2 a; float b; char _m2_pad[4]; Foo foo; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _12 [[buffer(0)]]) { ((device float*)&_12.a)[0u] = 10.0; _12.b = 20.0; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/struct-packing-array-of-scalar.comp000066400000000000000000000004761400026215700322060ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { packed_float3 a; }; struct SSBOScalar { Foo v[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBOScalar& buffer_scalar [[buffer(0)]]) { buffer_scalar.v[1].a[1u] = 1.0; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/struct-packing-recursive.comp000066400000000000000000000006061400026215700312250ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { packed_float4 a; }; struct Bar { Foo a; }; struct Baz { Bar a; }; struct SSBOScalar { float v; Baz baz; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBOScalar& buffer_scalar [[buffer(0)]]) { buffer_scalar.baz.a.a.a[3u] = 10.0; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/struct-packing.comp000066400000000000000000000006241400026215700272200ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { packed_float3 a; }; struct Bar { packed_float3 a; }; struct SSBOScalar { Foo foo; Bar bar; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBOScalar& buffer_scalar [[buffer(0)]]) { buffer_scalar.foo.a[0u] = 10.0; buffer_scalar.bar.a[0u] = 20.0; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/struct-size-padding-array-of-array.comp000066400000000000000000000013451400026215700330150ustar00rootroot00000000000000#include #include using namespace metal; struct A { float v; char _m0_final_padding[12]; }; struct B { float2 v; char _m0_final_padding[8]; }; struct C { float3 v; }; struct D { float4 v; }; struct E { float4 a; float2 b; char _m0_final_padding[8]; }; struct SSBO { A a[2][4]; B b[2][4]; C c[2][4]; D d[2][4]; float2x4 e[2][4]; E f[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _32 [[buffer(0)]]) { _32.f[0].a = float4(2.0); float2x2 tmp = float2x2(_32.e[0][1][0].xy, _32.e[0][1][1].xy); (device float2&)_32.e[1][2][0] = tmp[0]; (device float2&)_32.e[1][2][1] = tmp[1]; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/packing/struct-size-padding.comp000066400000000000000000000013121400026215700301550ustar00rootroot00000000000000#include #include using namespace metal; struct A { float v; char _m0_final_padding[12]; }; struct B { float2 v; char _m0_final_padding[8]; }; struct C { float3 v; }; struct D { float4 v; }; struct E { float4 a; float2 b; char _m0_final_padding[8]; }; struct SSBO { A a[4]; B b[4]; C c[4]; D d[4]; float2x4 e[4]; E f[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _26 [[buffer(0)]]) { _26.f[0].a = float4(2.0); float2x2 tmp = float2x2(_26.e[1][0].xy, _26.e[1][1].xy); (device float2&)_26.e[2][0] = tmp[0]; (device float2&)_26.e[2][1] = tmp[1]; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vert/000077500000000000000000000000001400026215700227445ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vert/functions_nested.vert000066400000000000000000000150011400026215700272150ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct attr_desc { int type; int attribute_size; int starting_offset; int stride; int swap_bytes; int is_volatile; }; struct VertexBuffer { float4x4 scale_offset_mat; uint vertex_base_index; int4 input_attributes[16]; }; struct VertexConstantsBuffer { float4 vc[16]; }; struct main0_out { float4 tc0 [[user(locn0)]]; float4 back_color [[user(locn10)]]; float4 gl_Position [[position]]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } static inline __attribute__((always_inline)) attr_desc fetch_desc(thread const int& location, constant VertexBuffer& v_227) { int attribute_flags = v_227.input_attributes[location].w; attr_desc result; result.type = v_227.input_attributes[location].x; result.attribute_size = v_227.input_attributes[location].y; result.starting_offset = v_227.input_attributes[location].z; result.stride = attribute_flags & 255; result.swap_bytes = (attribute_flags >> 8) & 1; result.is_volatile = (attribute_flags >> 9) & 1; return result; } static inline __attribute__((always_inline)) uint get_bits(thread const uint4& v, thread const int& swap) { if (swap != 0) { return ((v.w | (v.z << uint(8))) | (v.y << uint(16))) | (v.x << uint(24)); } return ((v.x | (v.y << uint(8))) | (v.z << uint(16))) | (v.w << uint(24)); } static inline __attribute__((always_inline)) float4 fetch_attr(thread const attr_desc& desc, thread const int& vertex_id, thread const texture2d input_stream) { float4 result = float4(0.0, 0.0, 0.0, 1.0); bool reverse_order = false; int first_byte = (vertex_id * desc.stride) + desc.starting_offset; uint4 tmp; for (int n = 0; n < 4; n++) { if (n == desc.attribute_size) { break; } switch (desc.type) { case 0: { int _131 = first_byte; first_byte = _131 + 1; tmp.x = input_stream.read(spvTexelBufferCoord(_131)).x; int _138 = first_byte; first_byte = _138 + 1; tmp.y = input_stream.read(spvTexelBufferCoord(_138)).x; uint4 param = tmp; int param_1 = desc.swap_bytes; result[n] = float(get_bits(param, param_1)); break; } case 1: { int _156 = first_byte; first_byte = _156 + 1; tmp.x = input_stream.read(spvTexelBufferCoord(_156)).x; int _163 = first_byte; first_byte = _163 + 1; tmp.y = input_stream.read(spvTexelBufferCoord(_163)).x; int _170 = first_byte; first_byte = _170 + 1; tmp.z = input_stream.read(spvTexelBufferCoord(_170)).x; int _177 = first_byte; first_byte = _177 + 1; tmp.w = input_stream.read(spvTexelBufferCoord(_177)).x; uint4 param_2 = tmp; int param_3 = desc.swap_bytes; result[n] = as_type(get_bits(param_2, param_3)); break; } case 2: { int _195 = first_byte; first_byte = _195 + 1; result[n] = float(input_stream.read(spvTexelBufferCoord(_195)).x); reverse_order = desc.swap_bytes != 0; break; } } } float4 _210; if (reverse_order) { _210 = result.wzyx; } else { _210 = result; } return _210; } static inline __attribute__((always_inline)) float4 read_location(thread const int& location, constant VertexBuffer& v_227, thread uint& gl_VertexIndex, thread texture2d buff_in_2, thread texture2d buff_in_1) { int param = location; attr_desc desc = fetch_desc(param, v_227); int vertex_id = int(gl_VertexIndex) - int(v_227.vertex_base_index); if (desc.is_volatile != 0) { attr_desc param_1 = desc; int param_2 = vertex_id; return fetch_attr(param_1, param_2, buff_in_2); } else { attr_desc param_3 = desc; int param_4 = vertex_id; return fetch_attr(param_3, param_4, buff_in_1); } } static inline __attribute__((always_inline)) void vs_adjust(thread float4& dst_reg0, thread float4& dst_reg1, thread float4& dst_reg7, constant VertexBuffer& v_227, thread uint& gl_VertexIndex, thread texture2d buff_in_2, thread texture2d buff_in_1, constant VertexConstantsBuffer& v_309) { int param = 3; float4 in_diff_color = read_location(param, v_227, gl_VertexIndex, buff_in_2, buff_in_1); int param_1 = 0; float4 in_pos = read_location(param_1, v_227, gl_VertexIndex, buff_in_2, buff_in_1); int param_2 = 8; float4 in_tc0 = read_location(param_2, v_227, gl_VertexIndex, buff_in_2, buff_in_1); dst_reg1 = in_diff_color * v_309.vc[13]; float4 tmp0; tmp0.x = float4(dot(float4(in_pos.xyz, 1.0), v_309.vc[4])).x; tmp0.y = float4(dot(float4(in_pos.xyz, 1.0), v_309.vc[5])).y; tmp0.z = float4(dot(float4(in_pos.xyz, 1.0), v_309.vc[6])).z; float4 tmp1; tmp1 = float4(in_tc0.xy.x, in_tc0.xy.y, tmp1.z, tmp1.w); tmp1.z = v_309.vc[15].x; dst_reg7.y = float4(dot(float4(tmp1.xyz, 1.0), v_309.vc[8])).y; dst_reg7.x = float4(dot(float4(tmp1.xyz, 1.0), v_309.vc[7])).x; dst_reg0.y = float4(dot(float4(tmp0.xyz, 1.0), v_309.vc[1])).y; dst_reg0.x = float4(dot(float4(tmp0.xyz, 1.0), v_309.vc[0])).x; } vertex main0_out main0(constant VertexBuffer& v_227 [[buffer(0)]], constant VertexConstantsBuffer& v_309 [[buffer(1)]], texture2d buff_in_2 [[texture(0)]], texture2d buff_in_1 [[texture(1)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; float4 dst_reg0 = float4(0.0, 0.0, 0.0, 1.0); float4 dst_reg1 = float4(0.0); float4 dst_reg7 = float4(0.0); float4 param = dst_reg0; float4 param_1 = dst_reg1; float4 param_2 = dst_reg7; vs_adjust(param, param_1, param_2, v_227, gl_VertexIndex, buff_in_2, buff_in_1, v_309); dst_reg0 = param; dst_reg1 = param_1; dst_reg7 = param_2; out.gl_Position = dst_reg0; out.back_color = dst_reg1; out.tc0 = dst_reg7; out.gl_Position *= v_227.scale_offset_mat; return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vert/layer.msl11.invalid.vert000066400000000000000000000006261400026215700273470ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; uint gl_Layer [[render_target_array_index]]; }; struct main0_in { float4 coord [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.coord; out.gl_Layer = uint(int(in.coord.z)); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vert/pass-array-by-value.force-native-array.vert000066400000000000000000000073761400026215700331640ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; constant float4 _68[4] = { float4(0.0), float4(1.0), float4(2.0), float4(3.0) }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { int Index1 [[attribute(0)]]; int Index2 [[attribute(1)]]; }; template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } static inline __attribute__((always_inline)) float4 consume_constant_arrays2(thread const float4 (&positions)[4], thread const float4 (&positions2)[4], thread int& Index1, thread int& Index2) { float4 indexable[4]; spvArrayCopyFromStackToStack1(indexable, positions); float4 indexable_1[4]; spvArrayCopyFromStackToStack1(indexable_1, positions2); return indexable[Index1] + indexable_1[Index2]; } static inline __attribute__((always_inline)) float4 consume_constant_arrays(thread const float4 (&positions)[4], thread const float4 (&positions2)[4], thread int& Index1, thread int& Index2) { return consume_constant_arrays2(positions, positions2, Index1, Index2); } vertex main0_out main0(main0_in in [[stage_in]]) { float4 _68_array_copy[4] = { float4(0.0), float4(1.0), float4(2.0), float4(3.0) }; main0_out out = {}; float4 LUT2[4]; LUT2[0] = float4(10.0); LUT2[1] = float4(11.0); LUT2[2] = float4(12.0); LUT2[3] = float4(13.0); out.gl_Position = consume_constant_arrays(_68_array_copy, LUT2, in.Index1, in.Index2); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vert/pass-array-by-value.vert000066400000000000000000000043461400026215700274610ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _68 = spvUnsafeArray({ float4(0.0), float4(1.0), float4(2.0), float4(3.0) }); struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { int Index1 [[attribute(0)]]; int Index2 [[attribute(1)]]; }; static inline __attribute__((always_inline)) float4 consume_constant_arrays2(spvUnsafeArray positions, spvUnsafeArray positions2, thread int& Index1, thread int& Index2) { spvUnsafeArray indexable; indexable = positions; spvUnsafeArray indexable_1; indexable_1 = positions2; return indexable[Index1] + indexable_1[Index2]; } static inline __attribute__((always_inline)) float4 consume_constant_arrays(spvUnsafeArray positions, spvUnsafeArray positions2, thread int& Index1, thread int& Index2) { return consume_constant_arrays2(positions, positions2, Index1, Index2); } vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray LUT2; LUT2[0] = float4(10.0); LUT2[1] = float4(11.0); LUT2[2] = float4(12.0); LUT2[3] = float4(13.0); out.gl_Position = consume_constant_arrays(_68, LUT2, in.Index1, in.Index2); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vert/uninitialized-vertex-output.vert000066400000000000000000000004151400026215700313670ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 Pos [[user(locn0)]]; float4 gl_Position [[position]]; }; vertex main0_out main0() { main0_out out = {}; out.gl_Position = float4(1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vert/unused-subgroup-builtin.msl22.vert000066400000000000000000000001411400026215700314130ustar00rootroot00000000000000#include #include using namespace metal; vertex void main0() { } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vert/viewport-index.msl2.invalid.vert000066400000000000000000000006411400026215700311340ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; uint gl_ViewportIndex [[viewport_array_index]]; }; struct main0_in { float4 coord [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.coord; out.gl_ViewportIndex = uint(int(in.coord.z)); return out; } spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vulkan/000077500000000000000000000000001400026215700232645ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vulkan/frag/000077500000000000000000000000001400026215700242035ustar00rootroot00000000000000texture-access-function.swizzle.vk.frag000066400000000000000000000256221400026215700337030ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl-no-opt/vulkan/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 fragColor [[color(0)]]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } // Wrapper function that swizzles texture gathers. template class Tex, typename... Ts> inline vec spvGatherSwizzle(const thread Tex& t, sampler s, uint sw, component c, Ts... params) METAL_CONST_ARG(c) { if (sw) { switch (spvSwizzle((sw >> (uint(c) * 8)) & 0xFF)) { case spvSwizzle::none: break; case spvSwizzle::zero: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); case spvSwizzle::red: return t.gather(s, spvForward(params)..., component::x); case spvSwizzle::green: return t.gather(s, spvForward(params)..., component::y); case spvSwizzle::blue: return t.gather(s, spvForward(params)..., component::z); case spvSwizzle::alpha: return t.gather(s, spvForward(params)..., component::w); } } switch (c) { case component::x: return t.gather(s, spvForward(params)..., component::x); case component::y: return t.gather(s, spvForward(params)..., component::y); case component::z: return t.gather(s, spvForward(params)..., component::z); case component::w: return t.gather(s, spvForward(params)..., component::w); } } // Wrapper function that swizzles depth texture gathers. template class Tex, typename... Ts> inline vec spvGatherCompareSwizzle(const thread Tex& t, sampler s, uint sw, Ts... params) { if (sw) { switch (spvSwizzle(sw & 0xFF)) { case spvSwizzle::none: case spvSwizzle::red: break; case spvSwizzle::zero: case spvSwizzle::green: case spvSwizzle::blue: case spvSwizzle::alpha: return vec(0, 0, 0, 0); case spvSwizzle::one: return vec(1, 1, 1, 1); } } return t.gather_compare(s, spvForward(params)...); } static inline __attribute__((always_inline)) float4 do_samples(thread const texture1d t1, thread const sampler t1Smplr, constant uint& t1Swzl, thread const texture2d t2, constant uint& t2Swzl, thread const texture3d t3, thread const sampler t3Smplr, constant uint& t3Swzl, thread const texturecube tc, constant uint& tcSwzl, thread const texture2d_array t2a, thread const sampler t2aSmplr, constant uint& t2aSwzl, thread const texturecube_array tca, thread const sampler tcaSmplr, constant uint& tcaSwzl, thread const texture2d tb, thread const depth2d d2, thread const sampler d2Smplr, constant uint& d2Swzl, thread const depthcube dc, thread const sampler dcSmplr, constant uint& dcSwzl, thread const depth2d_array d2a, constant uint& d2aSwzl, thread const depthcube_array dca, thread const sampler dcaSmplr, constant uint& dcaSwzl, thread sampler defaultSampler, thread sampler shadowSampler) { float4 c = spvTextureSwizzle(t1.sample(t1Smplr, 0.0), t1Swzl); c = spvTextureSwizzle(t2.sample(defaultSampler, float2(0.0)), t2Swzl); c = spvTextureSwizzle(t3.sample(t3Smplr, float3(0.0)), t3Swzl); c = spvTextureSwizzle(tc.sample(defaultSampler, float3(0.0)), tcSwzl); c = spvTextureSwizzle(t2a.sample(t2aSmplr, float3(0.0).xy, uint(round(float3(0.0).z))), t2aSwzl); c = spvTextureSwizzle(tca.sample(tcaSmplr, float4(0.0).xyz, uint(round(float4(0.0).w))), tcaSwzl); c.x = spvTextureSwizzle(d2.sample_compare(d2Smplr, float3(0.0, 0.0, 1.0).xy, float3(0.0, 0.0, 1.0).z), d2Swzl); c.x = spvTextureSwizzle(dc.sample_compare(dcSmplr, float4(0.0, 0.0, 0.0, 1.0).xyz, float4(0.0, 0.0, 0.0, 1.0).w), dcSwzl); c.x = spvTextureSwizzle(d2a.sample_compare(shadowSampler, float4(0.0, 0.0, 0.0, 1.0).xy, uint(round(float4(0.0, 0.0, 0.0, 1.0).z)), float4(0.0, 0.0, 0.0, 1.0).w), d2aSwzl); c.x = spvTextureSwizzle(dca.sample_compare(dcaSmplr, float4(0.0).xyz, uint(round(float4(0.0).w)), 1.0), dcaSwzl); c = spvTextureSwizzle(t1.sample(t1Smplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), t1Swzl); c = spvTextureSwizzle(t2.sample(defaultSampler, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z), t2Swzl); c = spvTextureSwizzle(t3.sample(t3Smplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w), t3Swzl); float4 _119 = float4(0.0, 0.0, 1.0, 1.0); _119.z = float4(0.0, 0.0, 1.0, 1.0).w; c.x = spvTextureSwizzle(d2.sample_compare(d2Smplr, _119.xy / _119.z, float4(0.0, 0.0, 1.0, 1.0).z / _119.z), d2Swzl); c = spvTextureSwizzle(t1.sample(t1Smplr, 0.0), t1Swzl); c = spvTextureSwizzle(t2.sample(defaultSampler, float2(0.0), level(0.0)), t2Swzl); c = spvTextureSwizzle(t3.sample(t3Smplr, float3(0.0), level(0.0)), t3Swzl); c = spvTextureSwizzle(tc.sample(defaultSampler, float3(0.0), level(0.0)), tcSwzl); c = spvTextureSwizzle(t2a.sample(t2aSmplr, float3(0.0).xy, uint(round(float3(0.0).z)), level(0.0)), t2aSwzl); c = spvTextureSwizzle(tca.sample(tcaSmplr, float4(0.0).xyz, uint(round(float4(0.0).w)), level(0.0)), tcaSwzl); c.x = spvTextureSwizzle(d2.sample_compare(d2Smplr, float3(0.0, 0.0, 1.0).xy, float3(0.0, 0.0, 1.0).z, level(0.0)), d2Swzl); c = spvTextureSwizzle(t1.sample(t1Smplr, float2(0.0, 1.0).x / float2(0.0, 1.0).y), t1Swzl); c = spvTextureSwizzle(t2.sample(defaultSampler, float3(0.0, 0.0, 1.0).xy / float3(0.0, 0.0, 1.0).z, level(0.0)), t2Swzl); c = spvTextureSwizzle(t3.sample(t3Smplr, float4(0.0, 0.0, 0.0, 1.0).xyz / float4(0.0, 0.0, 0.0, 1.0).w, level(0.0)), t3Swzl); float4 _153 = float4(0.0, 0.0, 1.0, 1.0); _153.z = float4(0.0, 0.0, 1.0, 1.0).w; c.x = spvTextureSwizzle(d2.sample_compare(d2Smplr, _153.xy / _153.z, float4(0.0, 0.0, 1.0, 1.0).z / _153.z, level(0.0)), d2Swzl); c = spvTextureSwizzle(t1.read(uint(0)), t1Swzl); c = spvTextureSwizzle(t2.read(uint2(int2(0)), 0), t2Swzl); c = spvTextureSwizzle(t3.read(uint3(int3(0)), 0), t3Swzl); c = spvTextureSwizzle(t2a.read(uint2(int3(0).xy), uint(int3(0).z), 0), t2aSwzl); c = tb.read(spvTexelBufferCoord(0)); c = spvGatherSwizzle(t2, defaultSampler, t2Swzl, component::x, float2(0.0), int2(0)); c = spvGatherSwizzle(tc, defaultSampler, tcSwzl, component::y, float3(0.0)); c = spvGatherSwizzle(t2a, t2aSmplr, t2aSwzl, component::z, float3(0.0).xy, uint(round(float3(0.0).z)), int2(0)); c = spvGatherSwizzle(tca, tcaSmplr, tcaSwzl, component::w, float4(0.0).xyz, uint(round(float4(0.0).w))); c = spvGatherCompareSwizzle(d2, d2Smplr, d2Swzl, float2(0.0), 1.0); c = spvGatherCompareSwizzle(dc, dcSmplr, dcSwzl, float3(0.0), 1.0); c = spvGatherCompareSwizzle(d2a, shadowSampler, d2aSwzl, float3(0.0).xy, uint(round(float3(0.0).z)), 1.0); c = spvGatherCompareSwizzle(dca, dcaSmplr, dcaSwzl, float4(0.0).xyz, uint(round(float4(0.0).w)), 1.0); return c; } fragment main0_out main0(constant uint* spvSwizzleConstants [[buffer(30)]], texture1d tex1d [[texture(0)]], texture2d tex2d [[texture(1)]], texture3d tex3d [[texture(2)]], texturecube texCube [[texture(3)]], texture2d_array tex2dArray [[texture(4)]], texturecube_array texCubeArray [[texture(5)]], texture2d texBuffer [[texture(6)]], depth2d depth2d [[texture(7)]], depthcube depthCube [[texture(8)]], depth2d_array depth2dArray [[texture(9)]], depthcube_array depthCubeArray [[texture(10)]], sampler defaultSampler [[sampler(0)]], sampler shadowSampler [[sampler(1)]], sampler tex1dSmplr [[sampler(2)]], sampler tex3dSmplr [[sampler(3)]], sampler tex2dArraySmplr [[sampler(4)]], sampler texCubeArraySmplr [[sampler(5)]], sampler depth2dSmplr [[sampler(6)]], sampler depthCubeSmplr [[sampler(7)]], sampler depthCubeArraySmplr [[sampler(8)]]) { main0_out out = {}; constant uint& tex1dSwzl = spvSwizzleConstants[0]; constant uint& tex2dSwzl = spvSwizzleConstants[1]; constant uint& tex3dSwzl = spvSwizzleConstants[2]; constant uint& texCubeSwzl = spvSwizzleConstants[3]; constant uint& tex2dArraySwzl = spvSwizzleConstants[4]; constant uint& texCubeArraySwzl = spvSwizzleConstants[5]; constant uint& depth2dSwzl = spvSwizzleConstants[7]; constant uint& depthCubeSwzl = spvSwizzleConstants[8]; constant uint& depth2dArraySwzl = spvSwizzleConstants[9]; constant uint& depthCubeArraySwzl = spvSwizzleConstants[10]; out.fragColor = do_samples(tex1d, tex1dSmplr, tex1dSwzl, tex2d, tex2dSwzl, tex3d, tex3dSmplr, tex3dSwzl, texCube, texCubeSwzl, tex2dArray, tex2dArraySmplr, tex2dArraySwzl, texCubeArray, texCubeArraySmplr, texCubeArraySwzl, texBuffer, depth2d, depth2dSmplr, depth2dSwzl, depthCube, depthCubeSmplr, depthCubeSwzl, depth2dArray, depth2dArraySwzl, depthCubeArray, depthCubeArraySmplr, depthCubeArraySwzl, defaultSampler, shadowSampler); return out; } spirv-cross-2021.01.15/reference/shaders-msl/000077500000000000000000000000001400026215700205525ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/amd/000077500000000000000000000000001400026215700213135ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/amd/shader_trinary_minmax.msl21.comp000066400000000000000000000004031400026215700275140ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(64u, 1u, 1u); kernel void main0() { int t11 = min3(0, 3, 2); int t12 = max3(0, 3, 2); int t13 = median3(0, 3, 2); } spirv-cross-2021.01.15/reference/shaders-msl/asm/000077500000000000000000000000001400026215700213325ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/000077500000000000000000000000001400026215700222705ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/atomic-decrement.asm.comp000066400000000000000000000015761400026215700271600ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct u0_counters { uint c; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } kernel void main0(device u0_counters& u0_counter [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint _29 = atomic_fetch_sub_explicit((device atomic_uint*)&u0_counter.c, 1, memory_order_relaxed); float4 r0; r0.x = as_type(_29); u0.write(uint4(uint(int(gl_GlobalInvocationID.x))), spvTexelBufferCoord(((uint(as_type(r0.x)) * 1u) + (uint(0) >> 2u)))); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/atomic-increment.asm.comp000066400000000000000000000015761400026215700271760ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct u0_counters { uint c; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } kernel void main0(device u0_counters& u0_counter [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint _29 = atomic_fetch_add_explicit((device atomic_uint*)&u0_counter.c, 1, memory_order_relaxed); float4 r0; r0.x = as_type(_29); u0.write(uint4(uint(int(gl_GlobalInvocationID.x))), spvTexelBufferCoord(((uint(as_type(r0.x)) * 1u) + (uint(0) >> 2u)))); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/bitcast_iadd.asm.comp000066400000000000000000000010341400026215700263370ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& restrict _5 [[buffer(0)]], device _4& restrict _6 [[buffer(1)]]) { _6._m0 = _5._m1 + uint4(_5._m0); _6._m0 = uint4(_5._m0) + _5._m1; _6._m0 = _5._m1 + _5._m1; _6._m0 = uint4(_5._m0 + _5._m0); _6._m1 = int4(_5._m1 + _5._m1); _6._m1 = _5._m0 + _5._m0; _6._m1 = int4(_5._m1) + _5._m0; _6._m1 = _5._m0 + int4(_5._m1); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/bitcast_icmp.asm.comp000066400000000000000000000014351400026215700263730ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& restrict _5 [[buffer(0)]], device _4& restrict _6 [[buffer(1)]]) { _6._m0 = select(uint4(0u), uint4(1u), int4(_5._m1) < _5._m0); _6._m0 = select(uint4(0u), uint4(1u), int4(_5._m1) <= _5._m0); _6._m0 = select(uint4(0u), uint4(1u), _5._m1 < uint4(_5._m0)); _6._m0 = select(uint4(0u), uint4(1u), _5._m1 <= uint4(_5._m0)); _6._m0 = select(uint4(0u), uint4(1u), int4(_5._m1) > _5._m0); _6._m0 = select(uint4(0u), uint4(1u), int4(_5._m1) >= _5._m0); _6._m0 = select(uint4(0u), uint4(1u), _5._m1 > uint4(_5._m0)); _6._m0 = select(uint4(0u), uint4(1u), _5._m1 >= uint4(_5._m0)); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/bitcast_sar.asm.comp000066400000000000000000000010661400026215700262300ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& _5 [[buffer(0)]], device _4& _6 [[buffer(1)]]) { int4 _22 = _5._m0; uint4 _23 = _5._m1; _6._m0 = uint4(int4(_23) >> _22); _6._m0 = uint4(_22 >> int4(_23)); _6._m0 = uint4(int4(_23) >> int4(_23)); _6._m0 = uint4(_22 >> _22); _6._m1 = int4(_23) >> int4(_23); _6._m1 = _22 >> _22; _6._m1 = int4(_23) >> _22; _6._m1 = _22 >> int4(_23); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/bitcast_sdiv.asm.comp000066400000000000000000000010561400026215700264070ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& _5 [[buffer(0)]], device _4& _6 [[buffer(1)]]) { int4 _22 = _5._m0; uint4 _23 = _5._m1; _6._m0 = uint4(int4(_23) / _22); _6._m0 = uint4(_22 / int4(_23)); _6._m0 = uint4(int4(_23) / int4(_23)); _6._m0 = uint4(_22 / _22); _6._m1 = int4(_23) / int4(_23); _6._m1 = _22 / _22; _6._m1 = int4(_23) / _22; _6._m1 = _22 / int4(_23); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/bitcast_slr.asm.comp000066400000000000000000000010721400026215700262400ustar00rootroot00000000000000#include #include using namespace metal; struct _3 { int4 _m0; uint4 _m1; }; struct _4 { uint4 _m0; int4 _m1; }; kernel void main0(device _3& _5 [[buffer(0)]], device _4& _6 [[buffer(1)]]) { int4 _22 = _5._m0; uint4 _23 = _5._m1; _6._m0 = _23 >> uint4(_22); _6._m0 = uint4(_22) >> _23; _6._m0 = _23 >> _23; _6._m0 = uint4(_22) >> uint4(_22); _6._m1 = int4(_23 >> _23); _6._m1 = int4(uint4(_22) >> uint4(_22)); _6._m1 = int4(_23 >> uint4(_22)); _6._m1 = int4(uint4(_22) >> _23); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/block-name-alias-global.asm.comp000066400000000000000000000014711400026215700302670ustar00rootroot00000000000000#include #include using namespace metal; struct A { int a; int b; }; struct A_1 { A Data[1]; }; struct A_2 { int a; int b; char _m0_final_padding[8]; }; struct A_3 { A_2 Data[1024]; }; struct B { A Data[1]; }; struct B_1 { A_2 Data[1024]; }; kernel void main0(device A_1& C1 [[buffer(0)]], constant A_3& C2 [[buffer(1)]], device B& C3 [[buffer(2)]], constant B_1& C4 [[buffer(3)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { C1.Data[gl_GlobalInvocationID.x].a = C2.Data[gl_GlobalInvocationID.x].a; C1.Data[gl_GlobalInvocationID.x].b = C2.Data[gl_GlobalInvocationID.x].b; C3.Data[gl_GlobalInvocationID.x].a = C4.Data[gl_GlobalInvocationID.x].a; C3.Data[gl_GlobalInvocationID.x].b = C4.Data[gl_GlobalInvocationID.x].b; } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/buffer-write-relative-addr.asm.comp000066400000000000000000000017651400026215700310620ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct cb5_struct { float4 _m0[5]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } kernel void main0(constant cb5_struct& cb0_5 [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { float4 r0; r0.x = as_type(int(gl_LocalInvocationID.x) << 4); r0.y = as_type(int(gl_LocalInvocationID.x)); uint _44 = as_type(r0.x) >> 2u; uint4 _51 = as_type(cb0_5._m0[uint(as_type(r0.y)) + 1u]); u0.write(_51.xxxx, spvTexelBufferCoord(_44)); u0.write(_51.yyyy, spvTexelBufferCoord((_44 + 1u))); u0.write(_51.zzzz, spvTexelBufferCoord((_44 + 2u))); u0.write(_51.wwww, spvTexelBufferCoord((_44 + 3u))); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/buffer-write.asm.comp000066400000000000000000000012671400026215700263360ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct cb { float value; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } kernel void main0(constant cb& _6 [[buffer(0)]], texture2d _buffer [[texture(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { _buffer.write(float4(_6.value), spvTexelBufferCoord(((32u * gl_WorkGroupID.x) + gl_LocalInvocationIndex))); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/global-parameter-name-alias.asm.comp000066400000000000000000000015041400026215700311520ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct ssbo { uint _data[1]; }; static inline __attribute__((always_inline)) void Load(thread const uint& size, const device ssbo& ssbo_1) { int byteAddrTemp = int(size >> uint(2)); uint4 data = uint4(ssbo_1._data[byteAddrTemp], ssbo_1._data[byteAddrTemp + 1], ssbo_1._data[byteAddrTemp + 2], ssbo_1._data[byteAddrTemp + 3]); } static inline __attribute__((always_inline)) void _main(thread const uint3& id, const device ssbo& ssbo_1) { uint param = 4u; Load(param, ssbo_1); } kernel void main0(const device ssbo& ssbo_1 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint3 id = gl_GlobalInvocationID; uint3 param = id; _main(param, ssbo_1); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/image-load-store-short-vector.invalid.asm.comp000066400000000000000000000012431400026215700331420ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; static inline __attribute__((always_inline)) void _main(thread const uint3& id, thread texture2d TargetTexture) { float2 loaded = TargetTexture.read(uint2(id.xy)).xy; float2 storeTemp = loaded + float2(1.0); TargetTexture.write(storeTemp.xyyy, uint2((id.xy + uint2(1u)))); } kernel void main0(texture2d TargetTexture [[texture(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]]) { uint3 id = gl_WorkGroupID; uint3 param = id; _main(param, TargetTexture); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/multiple-entry.asm.comp000066400000000000000000000010341400026215700267170ustar00rootroot00000000000000#include #include using namespace metal; struct _6 { int4 _m0; uint4 _m1; }; struct _7 { uint4 _m0; int4 _m1; }; kernel void main0(device _6& restrict _8 [[buffer(0)]], device _7& restrict _9 [[buffer(1)]]) { _9._m0 = _8._m1 + uint4(_8._m0); _9._m0 = uint4(_8._m0) + _8._m1; _9._m0 = _8._m1 + _8._m1; _9._m0 = uint4(_8._m0 + _8._m0); _9._m1 = int4(_8._m1 + _8._m1); _9._m1 = _8._m0 + _8._m0; _9._m1 = int4(_8._m1) + _8._m0; _9._m1 = _8._m0 + int4(_8._m1); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/quantize.asm.comp000066400000000000000000000006251400026215700255720ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO0 { float scalar; float2 vec2_val; float3 vec3_val; float4 vec4_val; }; kernel void main0(device SSBO0& _4 [[buffer(0)]]) { _4.scalar = float(half(_4.scalar)); _4.vec2_val = float2(half2(_4.vec2_val)); _4.vec3_val = float3(half3(_4.vec3_val)); _4.vec4_val = float4(half4(_4.vec4_val)); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/relaxed-block-layout.asm.comp000066400000000000000000000013031400026215700277530ustar00rootroot00000000000000#include #include using namespace metal; struct foo { uint bar; packed_float3 baz; uchar quux; packed_uchar4 blah; packed_half2 wibble; }; kernel void main0(device foo& _8 [[buffer(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_NumWorkGroups [[threadgroups_per_grid]]) { _8.bar = gl_LocalInvocationID.x; _8.baz = float3(gl_GlobalInvocationID); _8.blah = uchar4(uint4(uint4(uchar4(_8.blah)).xyz + gl_WorkGroupID, 0u)); _8.wibble = half2(float2(half2(_8.wibble)) * float2(gl_NumWorkGroups.xy)); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/specialization-constant-workgroup.asm.comp000066400000000000000000000007441400026215700326360ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float a; }; constant uint _5_tmp [[function_constant(10)]]; constant uint _5 = is_function_constant_defined(_5_tmp) ? _5_tmp : 9u; constant uint _6_tmp [[function_constant(12)]]; constant uint _6 = is_function_constant_defined(_6_tmp) ? _6_tmp : 4u; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(_5, 20u, _6); kernel void main0(device SSBO& _4 [[buffer(0)]]) { _4.a += 1.0; } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/struct-resource-name-aliasing.asm.comp000066400000000000000000000006611400026215700316060ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct bufA { uint _data[1]; }; static inline __attribute__((always_inline)) void _main(device bufA& bufA_1, device bufA& bufB) { bufA_1._data[0] = 0u; bufB._data[0] = 0u; } kernel void main0(device bufA& bufA_1 [[buffer(0)]], device bufA& bufB [[buffer(1)]]) { _main(bufA_1, bufB); } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/variable-pointers-2.asm.comp000066400000000000000000000026511400026215700275200ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct foo { int a[128]; uint b; float2 c; }; struct bar { int d; }; static inline __attribute__((always_inline)) device foo* select_buffer(device foo& a, constant bar& cb) { return (cb.d != 0) ? &a : nullptr; } static inline __attribute__((always_inline)) thread uint3* select_input(thread uint3& gl_GlobalInvocationID, thread uint3& gl_LocalInvocationID, constant bar& cb) { return (cb.d != 0) ? &gl_GlobalInvocationID : &gl_LocalInvocationID; } kernel void main0(device foo& buf [[buffer(0)]], constant bar& cb [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { device foo* _46 = select_buffer(buf, cb); device foo* _45 = _46; thread uint3* _47 = select_input(gl_GlobalInvocationID, gl_LocalInvocationID, cb); device foo* _48 = _45; device int* _52; device int* _55; _52 = &_48->a[0u]; _55 = &buf.a[0u]; int _57; int _58; for (;;) { _57 = *_52; _58 = *_55; if (_57 != _58) { int _66 = (_57 + _58) + int((*_47).x); *_52 = _66; *_55 = _66; _52 = &_52[1u]; _55 = &_55[1u]; continue; } else { break; } } } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/variable-pointers-store-forwarding.asm.comp000066400000000000000000000012131400026215700326440ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct foo { int a; }; struct bar { int b; }; static inline __attribute__((always_inline)) device int* _24(device foo& a, device bar& b, thread uint3& gl_GlobalInvocationID) { return (gl_GlobalInvocationID.x != 0u) ? &a.a : &b.b; } kernel void main0(device foo& x [[buffer(0)]], device bar& y [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { device int* _34 = _24(x, y, gl_GlobalInvocationID); device int* _33 = _34; int _37 = x.a; *_33 = 0; y.b = _37 + _37; } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/vector-builtin-type-cast-func.asm.comp000066400000000000000000000020221400026215700315310ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct cb1_struct { float4 _RESERVED_IDENTIFIER_FIXUP_m0[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(16u, 16u, 1u); static inline __attribute__((always_inline)) int2 get_texcoord(thread const int2& base, thread const int2& index, thread uint3& gl_LocalInvocationID) { return (base * int3(gl_LocalInvocationID).xy) + index; } kernel void main0(constant cb1_struct& cb0_1 [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { int2 r0 = int2(int2(u0.get_width(), u0.get_height()) >> int2(uint2(4u))); for (int i = 0; i < r0.y; i++) { for (int j = 0; j < r0.x; j++) { int2 param = r0; int2 param_1 = int2(i, j); u0.write(cb0_1._RESERVED_IDENTIFIER_FIXUP_m0[0].xxxx, uint2(get_texcoord(param, param_1, gl_LocalInvocationID))); } } } spirv-cross-2021.01.15/reference/shaders-msl/asm/comp/vector-builtin-type-cast.asm.comp000066400000000000000000000013001400026215700305760ustar00rootroot00000000000000#include #include using namespace metal; struct cb1_struct { float4 _RESERVED_IDENTIFIER_FIXUP_m0[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(16u, 16u, 1u); kernel void main0(constant cb1_struct& cb0_1 [[buffer(0)]], texture2d u0 [[texture(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { int2 r0 = int2(int2(u0.get_width(), u0.get_height()) >> int2(uint2(4u))); for (int i = 0; i < r0.y; i++) { for (int j = 0; j < r0.x; j++) { u0.write(cb0_1._RESERVED_IDENTIFIER_FIXUP_m0[0].xxxx, uint2(((r0 * int3(gl_LocalInvocationID).xy) + int2(i, j)))); } } } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/000077500000000000000000000000001400026215700222515ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/combined-sampler-reuse.asm.frag000066400000000000000000000007171400026215700302400ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uTex [[texture(0)]], sampler uSampler [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample(uSampler, in.vUV); out.FragColor += uTex.sample(uSampler, in.vUV, int2(1)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/default-member-names.asm.frag000066400000000000000000000007761400026215700276750ustar00rootroot00000000000000#include #include using namespace metal; struct _9 { float _m0; }; struct _10 { float _m0; float _m1; float _m2; float _m3; float _m4; float _m5; float _m6; float _m7; float _m8; float _m9; float _m10; float _m11; _9 _m12; }; struct main0_out { float4 m_3 [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; _10 _21; out.m_3 = float4(_21._m0, _21._m1, _21._m2, _21._m3); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/descriptor-array-unnamed.asm.frag000066400000000000000000000015631400026215700306150ustar00rootroot00000000000000#include #include using namespace metal; struct _4 { float4 _m0; }; struct _6 { int _m0; }; struct _7 { float4 _m0; }; struct main0_out { float4 m_3 [[color(0)]]; }; fragment main0_out main0(const device _4* _5_0 [[buffer(0)]], const device _4* _5_1 [[buffer(1)]], const device _4* _5_2 [[buffer(2)]], const device _4* _5_3 [[buffer(3)]], constant _6& _20 [[buffer(4)]], constant _7* _8_0 [[buffer(5)]], constant _7* _8_1 [[buffer(6)]], constant _7* _8_2 [[buffer(7)]], constant _7* _8_3 [[buffer(8)]]) { const device _4* _5[] = { _5_0, _5_1, _5_2, _5_3, }; constant _7* _8[] = { _8_0, _8_1, _8_2, _8_3, }; main0_out out = {}; out.m_3 = _5[_20._m0]->_m0 + (_8[_20._m0]->_m0 * float4(0.20000000298023223876953125)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/disable-renamed-output.frag-output.asm.frag000066400000000000000000000013521400026215700325200ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 o1 [[color(1)]]; float4 o3 [[color(3)]]; float4 o6 [[color(6)]]; float4 o7 [[color(7)]]; }; fragment main0_out main0() { float4 o0; float4 o2; float4 o4; float4 o5; float gl_FragDepth; int gl_FragStencilRefARB; main0_out out = {}; o0 = float4(0.0, 0.0, 0.0, 1.0); out.o1 = float4(1.0, 0.0, 0.0, 1.0); o2 = float4(0.0, 1.0, 0.0, 1.0); out.o3 = float4(0.0, 0.0, 1.0, 1.0); o4 = float4(1.0, 0.0, 1.0, 0.5); o5 = float4(0.25); out.o6 = float4(0.75); out.o7 = float4(1.0); gl_FragDepth = 0.89999997615814208984375; gl_FragStencilRefARB = uint(127); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/empty-struct.asm.frag000066400000000000000000000010151400026215700263460ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct EmptyStructTest { }; static inline __attribute__((always_inline)) float GetValue(thread const EmptyStructTest& self) { return 0.0; } static inline __attribute__((always_inline)) float GetValue_1(EmptyStructTest self) { return 0.0; } fragment void main0() { EmptyStructTest emptyStruct; float value = GetValue(emptyStruct); value = GetValue_1(EmptyStructTest{ }); } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/extract-packed-from-composite.asm.frag000066400000000000000000000015561400026215700315400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Foo { float3 a; float b; }; struct Foo_1 { packed_float3 a; float b; }; struct buf { Foo_1 results[16]; float4 bar; }; struct main0_out { float4 _entryPointOutput [[color(0)]]; }; static inline __attribute__((always_inline)) float4 _main(thread const float4& pos, constant buf& v_11) { int _46 = int(pos.x) % 16; Foo foo; foo.a = float3(v_11.results[_46].a); foo.b = v_11.results[_46].b; return float4(dot(foo.a, v_11.bar.xyz), foo.b, 0.0, 0.0); } fragment main0_out main0(constant buf& v_11 [[buffer(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; float4 pos = gl_FragCoord; float4 param = pos; out._entryPointOutput = _main(param, v_11); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/frem.asm.frag000066400000000000000000000005361400026215700246260ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vA [[user(locn0)]]; float4 vB [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = fmod(in.vA, in.vB); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/function-overload-alias.asm.frag000066400000000000000000000020501400026215700304130ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 foo(thread const float4& foo_1) { return foo_1 + float4(1.0); } static inline __attribute__((always_inline)) float4 foo(thread const float3& foo_1) { return foo_1.xyzz + float4(1.0); } static inline __attribute__((always_inline)) float4 foo_1(thread const float4& foo_2) { return foo_2 + float4(2.0); } static inline __attribute__((always_inline)) float4 foo(thread const float2& foo_2) { return foo_2.xyxy + float4(2.0); } fragment main0_out main0() { main0_out out = {}; float4 foo_3 = float4(1.0); float4 foo_2 = foo(foo_3); float3 foo_5 = float3(1.0); float4 foo_4 = foo(foo_5); float4 foo_7 = float4(1.0); float4 foo_6 = foo_1(foo_7); float2 foo_9 = float2(1.0); float4 foo_8 = foo(foo_9); out.FragColor = ((foo_2 + foo_4) + foo_6) + foo_8; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/image-extract-reuse.asm.frag000066400000000000000000000006111400026215700275420ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { int2 Size [[color(0)]]; }; fragment main0_out main0(texture2d uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]]) { main0_out out = {}; out.Size = int2(uTexture.get_width(), uTexture.get_height()) + int2(uTexture.get_width(1), uTexture.get_height(1)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/implicit-read-dep-phi.asm.frag000066400000000000000000000016171400026215700277450ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 v0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uImage [[texture(0)]], sampler uImageSmplr [[sampler(0)]]) { main0_out out = {}; int i = 0; float phi; float4 _36; phi = 1.0; _36 = float4(1.0, 2.0, 1.0, 2.0); for (;;) { out.FragColor = _36; if (i < 4) { if (in.v0[i] > 0.0) { float2 _48 = float2(phi); i++; phi += 2.0; _36 = uImage.sample(uImageSmplr, _48, level(0.0)); continue; } else { break; } } else { break; } } return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/inf-nan-constant.asm.frag000066400000000000000000000004751400026215700270540ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float3 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float3(as_type(0x7f800000u), as_type(0xff800000u), as_type(0x7fc00000u)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/interpolation-qualifiers-struct.asm.frag000066400000000000000000000020271400026215700322450ustar00rootroot00000000000000#include #include using namespace metal; struct Input { float2 v0; float2 v1; float3 v2; float4 v3; float v4; float v5; float v6; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 Input_v0 [[user(locn0)]]; float2 Input_v1 [[user(locn1), center_no_perspective]]; float3 Input_v2 [[user(locn2), centroid_perspective]]; float4 Input_v3 [[user(locn3), centroid_no_perspective]]; float Input_v4 [[user(locn4), sample_perspective]]; float Input_v5 [[user(locn5), sample_no_perspective]]; float Input_v6 [[user(locn6), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; Input inp = {}; inp.v0 = in.Input_v0; inp.v1 = in.Input_v1; inp.v2 = in.Input_v2; inp.v3 = in.Input_v3; inp.v4 = in.Input_v4; inp.v5 = in.Input_v5; inp.v6 = in.Input_v6; out.FragColor = float4(inp.v0.x + inp.v1.y, inp.v2.xy, ((inp.v3.w * inp.v4) + inp.v5) - inp.v6); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/line-directive.line.asm.frag000066400000000000000000000031711400026215700275240ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float vColor [[user(locn0)]]; }; #line 6 "test.frag" static inline __attribute__((always_inline)) void func(thread float& FragColor, thread float& vColor) { #line 8 "test.frag" FragColor = 1.0; #line 9 "test.frag" FragColor = 2.0; #line 10 "test.frag" if (vColor < 0.0) { #line 12 "test.frag" FragColor = 3.0; } else { #line 16 "test.frag" FragColor = 4.0; } #line 19 "test.frag" for (int i = 0; float(i) < (40.0 + vColor); i += (int(vColor) + 5)) { #line 21 "test.frag" FragColor += 0.20000000298023223876953125; #line 22 "test.frag" FragColor += 0.300000011920928955078125; } #line 25 "test.frag" switch (int(vColor)) { case 0: { #line 28 "test.frag" FragColor += 0.20000000298023223876953125; #line 29 "test.frag" break; } case 1: { #line 32 "test.frag" FragColor += 0.4000000059604644775390625; #line 33 "test.frag" break; } default: { #line 36 "test.frag" FragColor += 0.800000011920928955078125; #line 37 "test.frag" break; } } do { #line 42 "test.frag" FragColor += (10.0 + vColor); } while (FragColor < 100.0); } #line 46 "test.frag" fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; #line 48 "test.frag" func(out.FragColor, in.vColor); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/locations-components.asm.frag000066400000000000000000000014411400026215700300470ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 o0 [[color(0)]]; }; struct main0_in { float2 m_2 [[user(locn1)]]; float m_3 [[user(locn1_2)]]; float m_4 [[user(locn2), flat]]; uint m_5 [[user(locn2_1)]]; uint m_6 [[user(locn2_2)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float4 v1; v1 = float4(in.m_2.x, in.m_2.y, v1.z, v1.w); v1.z = in.m_3; float4 v2; v2.x = in.m_4; v2.y = as_type(in.m_5); v2.z = as_type(in.m_6); float4 r0; r0.x = as_type(as_type(v2.y) + as_type(v2.z)); out.o0.y = float(as_type(r0.x)); out.o0.x = v1.y + v2.x; out.o0 = float4(out.o0.x, out.o0.y, v1.z, v1.x); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/lut-promotion-initializer.asm.frag000066400000000000000000000044751400026215700310540ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _46 = spvUnsafeArray({ 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0 }); constant spvUnsafeArray _76 = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); constant spvUnsafeArray _90 = spvUnsafeArray({ float4(20.0), float4(30.0), float4(50.0), float4(60.0) }); struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { int index [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { spvUnsafeArray foobar = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); spvUnsafeArray baz = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); main0_out out = {}; out.FragColor = _46[in.index]; if (in.index < 10) { out.FragColor += _46[in.index ^ 1]; } else { out.FragColor += _46[in.index & 1]; } if (in.index > 30) { out.FragColor += _76[in.index & 3].y; } else { out.FragColor += _76[in.index & 1].x; } if (in.index > 30) { foobar[1].z = 20.0; } out.FragColor += foobar[in.index & 3].z; baz = _90; out.FragColor += baz[in.index & 3].z; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/min-lod.msl22.asm.frag000066400000000000000000000006701400026215700261710ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = uSampler.sample(uSamplerSmplr, in.vUV, min_lod_clamp(4.0)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/op-constant-null.asm.frag000066400000000000000000000027011400026215700271060ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct D { float4 a; float b; }; constant spvUnsafeArray _14 = spvUnsafeArray({ float4(0.0), float4(0.0), float4(0.0), float4(0.0) }); struct main0_out { float FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; float a = 0.0; float4 b = float4(0.0); float2x3 c = float2x3(float3(0.0), float3(0.0)); D d = D{ float4(0.0), 0.0 }; out.FragColor = a; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/op-image-sampled-image.asm.frag000066400000000000000000000010721400026215700300720ustar00rootroot00000000000000#include #include using namespace metal; struct push_cb { float4 cb0[1]; }; struct main0_out { float4 o0 [[color(0)]]; }; fragment main0_out main0(constant push_cb& _19 [[buffer(0)]], texture2d t0 [[texture(0)]], sampler dummy_sampler [[sampler(0)]]) { main0_out out = {}; float4 r0; r0 = float4(_19.cb0[0u].z, _19.cb0[0u].w, r0.z, r0.w); r0 = float4(r0.x, r0.y, float2(0.0).x, float2(0.0).y); out.o0 = t0.read(uint2(as_type(r0.xy)) + uint2(int2(-1, -2)), as_type(r0.w)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/pass-by-value.asm.frag000066400000000000000000000007551400026215700263700ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Registers { float foo; }; struct main0_out { float FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float add_value(float v, float w) { return v + w; } fragment main0_out main0(constant Registers& registers [[buffer(0)]]) { main0_out out = {}; out.FragColor = add_value(10.0, registers.foo); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/phi-loop-variable.asm.frag000066400000000000000000000002271400026215700272040ustar00rootroot00000000000000#include #include using namespace metal; fragment void main0() { for (int _22 = 35; _22 >= 0; _22--) { } } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/pull-model-interpolation.asm.msl23.frag000066400000000000000000000220551400026215700315730ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct _13 { float4 x; float4 y; float4 z; spvUnsafeArray u; spvUnsafeArray v; spvUnsafeArray w; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { interpolant foo [[user(locn0)]]; interpolant bar [[user(locn1)]]; interpolant baz [[user(locn2)]]; int sid [[user(locn3)]]; interpolant a_0 [[user(locn4)]]; interpolant a_1 [[user(locn5)]]; interpolant b_0 [[user(locn6)]]; interpolant b_1 [[user(locn7)]]; interpolant c_0 [[user(locn8)]]; interpolant c_1 [[user(locn9)]]; interpolant m_13_x [[user(locn10)]]; interpolant m_13_y [[user(locn11)]]; interpolant m_13_z [[user(locn12)]]; interpolant m_13_u_0 [[user(locn13)]]; interpolant m_13_u_1 [[user(locn14)]]; interpolant m_13_v_0 [[user(locn15)]]; interpolant m_13_v_1 [[user(locn16)]]; interpolant m_13_w_0 [[user(locn17)]]; interpolant m_13_w_1 [[user(locn18)]]; interpolant m_13_w_2 [[user(locn19)]]; }; static inline __attribute__((always_inline)) void func(thread float4& FragColor, thread float2 baz, thread spvUnsafeArray (&a), thread _13& s, thread main0_in& in) { float2 _237 = FragColor.xy + baz; FragColor = float4(_237.x, _237.y, FragColor.z, FragColor.w); FragColor.x += in.baz.interpolate_at_centroid().x; FragColor.y += in.baz.interpolate_at_sample(3).y; FragColor.z += in.baz.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375).y; float2 _262 = FragColor.xy + in.a_1.interpolate_at_centroid(); FragColor = float4(_262.x, _262.y, FragColor.z, FragColor.w); float2 _269 = FragColor.xy + in.a_0.interpolate_at_sample(2); FragColor = float4(_269.x, _269.y, FragColor.z, FragColor.w); float2 _276 = FragColor.xy + in.a_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); FragColor = float4(_276.x, _276.y, FragColor.z, FragColor.w); FragColor += s.z; float2 _288 = FragColor.xy + in.m_13_z.interpolate_at_centroid().yy; FragColor = float4(_288.x, _288.y, FragColor.z, FragColor.w); float2 _296 = FragColor.yz + in.m_13_z.interpolate_at_sample(3).xy; FragColor = float4(FragColor.x, _296.x, _296.y, FragColor.w); float2 _304 = FragColor.zw + in.m_13_z.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375).wx; FragColor = float4(FragColor.x, FragColor.y, _304.x, _304.y); FragColor += s.u[0]; FragColor += in.m_13_u_1.interpolate_at_centroid(); FragColor += in.m_13_u_0.interpolate_at_sample(2); FragColor += in.m_13_u_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); } fragment main0_out main0(main0_in in [[stage_in]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; spvUnsafeArray a = {}; _13 s = {}; spvUnsafeArray b = {}; spvUnsafeArray c = {}; a[0] = in.a_0.interpolate_at_center(); a[1] = in.a_1.interpolate_at_center(); s.x = in.m_13_x.interpolate_at_center(); s.y = in.m_13_y.interpolate_at_centroid(); s.z = in.m_13_z.interpolate_at_sample(gl_SampleID); s.u[0] = in.m_13_u_0.interpolate_at_centroid(); s.u[1] = in.m_13_u_1.interpolate_at_centroid(); s.v[0] = in.m_13_v_0.interpolate_at_sample(gl_SampleID); s.v[1] = in.m_13_v_1.interpolate_at_sample(gl_SampleID); s.w[0] = in.m_13_w_0.interpolate_at_center(); s.w[1] = in.m_13_w_1.interpolate_at_center(); s.w[2] = in.m_13_w_2.interpolate_at_center(); b[0] = in.b_0.interpolate_at_centroid(); b[1] = in.b_1.interpolate_at_centroid(); c[0] = in.c_0.interpolate_at_sample(gl_SampleID); c[1] = in.c_1.interpolate_at_sample(gl_SampleID); out.FragColor = in.foo.interpolate_at_center(); out.FragColor += in.foo.interpolate_at_centroid(); out.FragColor += in.foo.interpolate_at_sample(in.sid); out.FragColor += in.foo.interpolate_at_offset(float2(0.100000001490116119384765625) + 0.4375); float3 _65 = out.FragColor.xyz + in.bar.interpolate_at_centroid(); out.FragColor = float4(_65.x, _65.y, _65.z, out.FragColor.w); float3 _71 = out.FragColor.xyz + in.bar.interpolate_at_centroid(); out.FragColor = float4(_71.x, _71.y, _71.z, out.FragColor.w); float3 _78 = out.FragColor.xyz + in.bar.interpolate_at_sample(in.sid); out.FragColor = float4(_78.x, _78.y, _78.z, out.FragColor.w); float3 _84 = out.FragColor.xyz + in.bar.interpolate_at_offset(float2(-0.100000001490116119384765625) + 0.4375); out.FragColor = float4(_84.x, _84.y, _84.z, out.FragColor.w); float2 _91 = out.FragColor.xy + b[0]; out.FragColor = float4(_91.x, _91.y, out.FragColor.z, out.FragColor.w); float2 _98 = out.FragColor.xy + in.b_1.interpolate_at_centroid(); out.FragColor = float4(_98.x, _98.y, out.FragColor.z, out.FragColor.w); float2 _105 = out.FragColor.xy + in.b_0.interpolate_at_sample(2); out.FragColor = float4(_105.x, _105.y, out.FragColor.z, out.FragColor.w); float2 _112 = out.FragColor.xy + in.b_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); out.FragColor = float4(_112.x, _112.y, out.FragColor.z, out.FragColor.w); float2 _119 = out.FragColor.xy + c[0]; out.FragColor = float4(_119.x, _119.y, out.FragColor.z, out.FragColor.w); float2 _127 = out.FragColor.xy + in.c_1.interpolate_at_centroid().xy; out.FragColor = float4(_127.x, _127.y, out.FragColor.z, out.FragColor.w); float2 _135 = out.FragColor.xy + in.c_0.interpolate_at_sample(2).yx; out.FragColor = float4(_135.x, _135.y, out.FragColor.z, out.FragColor.w); float2 _143 = out.FragColor.xy + in.c_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375).xx; out.FragColor = float4(_143.x, _143.y, out.FragColor.z, out.FragColor.w); out.FragColor += s.x; out.FragColor += in.m_13_x.interpolate_at_centroid(); out.FragColor += in.m_13_x.interpolate_at_sample(in.sid); out.FragColor += in.m_13_x.interpolate_at_offset(float2(0.100000001490116119384765625) + 0.4375); out.FragColor += s.y; out.FragColor += in.m_13_y.interpolate_at_centroid(); out.FragColor += in.m_13_y.interpolate_at_sample(in.sid); out.FragColor += in.m_13_y.interpolate_at_offset(float2(-0.100000001490116119384765625) + 0.4375); float2 _184 = out.FragColor.xy + s.v[0]; out.FragColor = float4(_184.x, _184.y, out.FragColor.z, out.FragColor.w); float2 _191 = out.FragColor.xy + in.m_13_v_1.interpolate_at_centroid(); out.FragColor = float4(_191.x, _191.y, out.FragColor.z, out.FragColor.w); float2 _198 = out.FragColor.xy + in.m_13_v_0.interpolate_at_sample(2); out.FragColor = float4(_198.x, _198.y, out.FragColor.z, out.FragColor.w); float2 _205 = out.FragColor.xy + in.m_13_v_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); out.FragColor = float4(_205.x, _205.y, out.FragColor.z, out.FragColor.w); out.FragColor.x += s.w[0]; out.FragColor.x += in.m_13_w_1.interpolate_at_centroid(); out.FragColor.x += in.m_13_w_0.interpolate_at_sample(2); out.FragColor.x += in.m_13_w_1.interpolate_at_offset(float2(-0.100000001490116119384765625, 0.100000001490116119384765625) + 0.4375); func(out.FragColor, in.baz.interpolate_at_sample(gl_SampleID), a, s, in); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/sample-and-compare.asm.frag000066400000000000000000000011131400026215700273320ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float out_var_SV_Target [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d g_Texture [[texture(0)]], sampler g_Sampler [[sampler(0)]], sampler g_CompareSampler [[sampler(1)]]) { main0_out out = {}; out.out_var_SV_Target = float4(g_Texture.sample(g_Sampler, in.in_var_TEXCOORD0)).x + g_Texture.sample_compare(g_CompareSampler, in.in_var_TEXCOORD0, 0.5, level(0.0)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/single-function-private-lut.asm.frag000066400000000000000000000034231400026215700312510ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct myType { float data; }; struct main0_out { float4 o_color [[color(0)]]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } fragment main0_out main0(float4 gl_FragCoord [[position]]) { spvUnsafeArray _21 = spvUnsafeArray({ myType{ 0.0 }, myType{ 1.0 }, myType{ 0.0 }, myType{ 1.0 }, myType{ 0.0 } }); main0_out out = {}; float2 uv = gl_FragCoord.xy; int index = int(mod(uv.x, 4.0)); myType elt = _21[index]; if (elt.data > 0.0) { out.o_color = float4(0.0, 1.0, 0.0, 1.0); } else { out.o_color = float4(1.0, 0.0, 0.0, 1.0); } return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/srem.asm.frag000066400000000000000000000005571400026215700246460ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int4 vA [[user(locn0)]]; int4 vB [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = float4(in.vA - in.vB * (in.vA / in.vB)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/storage-class-output-initializer.asm.frag000066400000000000000000000030371400026215700323220ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _20 = spvUnsafeArray({ float4(1.0, 2.0, 3.0, 4.0), float4(10.0) }); struct main0_out { float4 FragColors_0 [[color(0)]]; float4 FragColors_1 [[color(1)]]; float4 FragColor [[color(2)]]; }; fragment main0_out main0() { main0_out out = {}; spvUnsafeArray FragColors = spvUnsafeArray({ float4(1.0, 2.0, 3.0, 4.0), float4(10.0) }); out.FragColor = float4(5.0); out.FragColors_0 = FragColors[0]; out.FragColors_1 = FragColors[1]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/texel-fetch-no-lod.asm.frag000066400000000000000000000005761400026215700272770ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = uTexture.read(uint2(int2(gl_FragCoord.xy)), 0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/texture-atomics.asm.frag000066400000000000000000000074141400026215700270340ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_StructuredBuffer_v4float { spvUnsafeArray _m0; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device type_StructuredBuffer_v4float& CulledObjectBoxBounds [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d RWShadowTileNumCulledObjects [[texture(2)]], device atomic_uint* RWShadowTileNumCulledObjects_atomic [[buffer(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float((_Globals.ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2(_Globals.ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _107 = _103 + 1u; if (all(CulledObjectBoxBounds._m0[_107].xy > _96.xy) && all(CulledObjectBoxBounds._m0[_103].xyz < _102)) { float _122 = _96.x; float _123 = _96.y; spvUnsafeArray _73; _73[0] = float3(_122, _123, -1000.0); float _126 = _100.x; _73[1] = float3(_126, _123, -1000.0); float _129 = _100.y; _73[2] = float3(_122, _129, -1000.0); _73[3] = float3(_126, _129, -1000.0); _73[4] = float3(_122, _123, 1.0); _73[5] = float3(_126, _123, 1.0); _73[6] = float3(_122, _129, 1.0); _73[7] = float3(_126, _129, 1.0); float3 _155; float3 _158; _155 = float3(-500000.0); _158 = float3(500000.0); for (int _160 = 0; _160 < 8; ) { float3 _166 = _73[_160] - (float3(0.5) * (CulledObjectBoxBounds._m0[_103].xyz + CulledObjectBoxBounds._m0[_107].xyz)); float3 _170 = float3(dot(_166, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); _155 = fast::max(_155, _170); _158 = fast::min(_158, _170); _160++; continue; } if (all(_158 < float3(1.0)) && all(_155 > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&RWShadowTileNumCulledObjects_atomic[(_78 * _Globals.ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } texture-atomics.asm.graphics-robust-access.frag000066400000000000000000000074141400026215700333270ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/asm/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_StructuredBuffer_v4float { spvUnsafeArray _m0; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device type_StructuredBuffer_v4float& CulledObjectBoxBounds [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d RWShadowTileNumCulledObjects [[texture(2)]], device atomic_uint* RWShadowTileNumCulledObjects_atomic [[buffer(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float((_Globals.ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2(_Globals.ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _107 = _103 + 1u; if (all(CulledObjectBoxBounds._m0[_107].xy > _96.xy) && all(CulledObjectBoxBounds._m0[_103].xyz < _102)) { float _122 = _96.x; float _123 = _96.y; spvUnsafeArray _73; _73[0] = float3(_122, _123, -1000.0); float _126 = _100.x; _73[1] = float3(_126, _123, -1000.0); float _129 = _100.y; _73[2] = float3(_122, _129, -1000.0); _73[3] = float3(_126, _129, -1000.0); _73[4] = float3(_122, _123, 1.0); _73[5] = float3(_126, _123, 1.0); _73[6] = float3(_122, _129, 1.0); _73[7] = float3(_126, _129, 1.0); float3 _155; float3 _158; _155 = float3(-500000.0); _158 = float3(500000.0); for (int _160 = 0; _160 < 8; ) { float3 _166 = _73[_160] - (float3(0.5) * (CulledObjectBoxBounds._m0[_103].xyz + CulledObjectBoxBounds._m0[_107].xyz)); float3 _170 = float3(dot(_166, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); _155 = fast::max(_155, _170); _158 = fast::min(_158, _170); _160++; continue; } if (all(_158 < float3(1.0)) && all(_155 > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&RWShadowTileNumCulledObjects_atomic[(_78 * _Globals.ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/texture-sampling-fp16.asm.frag000066400000000000000000000006571400026215700277630ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { half4 FragColor [[color(0)]]; }; struct main0_in { half2 UV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = half4(uTexture.sample(uTextureSmplr, float2(in.UV))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/undef-variable-store.asm.frag000066400000000000000000000011571400026215700277130ustar00rootroot00000000000000#include #include using namespace metal; constant float4 _38 = {}; constant float4 _47 = {}; struct main0_out { float4 _entryPointOutput [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; float4 _27; do { float2 _26 = float2(0.0); if (_26.x != 0.0) { _27 = float4(1.0, 0.0, 0.0, 1.0); break; } else { _27 = float4(1.0, 1.0, 0.0, 1.0); break; } _27 = _38; break; } while (false); out._entryPointOutput = _27; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/unknown-depth-state.asm.frag000066400000000000000000000020071400026215700276070ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; static inline __attribute__((always_inline)) float sample_combined(thread float3& vUV, thread depth2d uShadow, thread const sampler uShadowSmplr) { return uShadow.sample_compare(uShadowSmplr, vUV.xy, vUV.z); } static inline __attribute__((always_inline)) float sample_separate(thread float3& vUV, thread depth2d uTexture, thread sampler uSampler) { return uTexture.sample_compare(uSampler, vUV.xy, vUV.z); } fragment main0_out main0(main0_in in [[stage_in]], depth2d uShadow [[texture(0)]], depth2d uTexture [[texture(1)]], sampler uShadowSmplr [[sampler(0)]], sampler uSampler [[sampler(1)]]) { main0_out out = {}; out.FragColor = sample_combined(in.vUV, uShadow, uShadowSmplr) + sample_separate(in.vUV, uTexture, uSampler); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/unord-relational-op.asm.frag000066400000000000000000000040111400026215700275600ustar00rootroot00000000000000#include #include using namespace metal; constant float a_tmp [[function_constant(1)]]; constant float a = is_function_constant_defined(a_tmp) ? a_tmp : 1.0; constant float b_tmp [[function_constant(2)]]; constant float b = is_function_constant_defined(b_tmp) ? b_tmp : 2.0; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 c [[user(locn2)]]; float2 d [[user(locn3)]]; float3 e [[user(locn4)]]; float3 f [[user(locn5)]]; float4 g [[user(locn6)]]; float4 h [[user(locn7)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float t0 = a; float t1 = b; bool c1 = (isunordered(a, b) || a == b); bool c2 = (isunordered(a, b) || a != b); bool c3 = (isunordered(a, b) || a < b); bool c4 = (isunordered(a, b) || a > b); bool c5 = (isunordered(a, b) || a <= b); bool c6 = (isunordered(a, b) || a >= b); bool2 c7 = (isunordered(in.c, in.d) || in.c == in.d); bool2 c8 = (isunordered(in.c, in.d) || in.c != in.d); bool2 c9 = (isunordered(in.c, in.d) || in.c < in.d); bool2 c10 = (isunordered(in.c, in.d) || in.c > in.d); bool2 c11 = (isunordered(in.c, in.d) || in.c <= in.d); bool2 c12 = (isunordered(in.c, in.d) || in.c >= in.d); bool3 c13 = (isunordered(in.e, in.f) || in.e == in.f); bool3 c14 = (isunordered(in.e, in.f) || in.e != in.f); bool3 c15 = (isunordered(in.e, in.f) || in.e < in.f); bool3 c16 = (isunordered(in.e, in.f) || in.e > in.f); bool3 c17 = (isunordered(in.e, in.f) || in.e <= in.f); bool3 c18 = (isunordered(in.e, in.f) || in.e >= in.f); bool4 c19 = (isunordered(in.g, in.h) || in.g == in.h); bool4 c20 = (isunordered(in.g, in.h) || in.g != in.h); bool4 c21 = (isunordered(in.g, in.h) || in.g < in.h); bool4 c22 = (isunordered(in.g, in.h) || in.g > in.h); bool4 c23 = (isunordered(in.g, in.h) || in.g <= in.h); bool4 c24 = (isunordered(in.g, in.h) || in.g >= in.h); out.FragColor = float4(t0 + t1); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/unreachable.asm.frag000066400000000000000000000011161400026215700261410ustar00rootroot00000000000000#include #include using namespace metal; constant float4 _21 = {}; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int counter [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float4 _24; _24 = _21; float4 _33; for (;;) { if (in.counter == 10) { _33 = float4(10.0); break; } else { _33 = float4(30.0); break; } } out.FragColor = _33; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/frag/vector-shuffle-oom.asm.frag000066400000000000000000000241361400026215700274230ustar00rootroot00000000000000#include #include using namespace metal; struct _28 { float4 _m0; }; struct _6 { float4 _m0; float _m1; float4 _m2; }; struct _10 { float3 _m0; packed_float3 _m1; float _m2; packed_float3 _m3; float _m4; packed_float3 _m5; float _m6; packed_float3 _m7; float _m8; packed_float3 _m9; float _m10; packed_float3 _m11; float _m12; float2 _m13; float2 _m14; packed_float3 _m15; float _m16; float _m17; float _m18; float _m19; float _m20; float4 _m21; float4 _m22; float4x4 _m23; float4 _m24; }; struct _18 { float4x4 _m0; float4x4 _m1; float4x4 _m2; float4x4 _m3; float4 _m4; float4 _m5; float _m6; float _m7; float _m8; float _m9; packed_float3 _m10; float _m11; packed_float3 _m12; float _m13; packed_float3 _m14; float _m15; packed_float3 _m16; float _m17; float _m18; float _m19; float2 _m20; float2 _m21; float2 _m22; float4 _m23; float2 _m24; float2 _m25; float2 _m26; char _m27_pad[8]; packed_float3 _m27; float _m28; float _m29; float _m30; float _m31; float _m32; float2 _m33; float _m34; float _m35; float3 _m36; float4x4 _m37[2]; float4 _m38[2]; }; struct _20 { float4 _m0; float4 _m1; float2 _m2; float2 _m3; float3 _m4; float _m5; float3 _m6; float _m7; float4 _m8; float4 _m9; float4 _m10; float3 _m11; float _m12; float3 _m13; float _m14; float3 _m15; float4 _m16; float3 _m17; float _m18; float3 _m19; float2 _m20; }; struct _21 { float4 _m0; }; constant _28 _74 = {}; struct main0_out { float4 m_5 [[color(0)]]; }; fragment main0_out main0(constant _6& _7 [[buffer(0)]], constant _10& _11 [[buffer(1)]], constant _18& _19 [[buffer(2)]], texture2d _8 [[texture(0)]], texture2d _12 [[texture(1)]], texture2d _14 [[texture(2)]], sampler _9 [[sampler(0)]], sampler _13 [[sampler(1)]], sampler _15 [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; _28 _77 = _74; _77._m0 = float4(0.0); float2 _82 = gl_FragCoord.xy * _19._m23.xy; float4 _88 = _7._m2 * _7._m0.xyxy; float2 _97 = fast::clamp(_82 + (float3(0.0, -2.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); float3 _109 = float3(_11._m5) * fast::clamp(_8.sample(_9, _97, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _113 = _12.sample(_13, _97, level(0.0)); float3 _129; if (_113.y > 0.0) { _129 = _109 + (_14.sample(_15, _97, level(0.0)).xyz * fast::clamp(_113.y * _113.z, 0.0, 1.0)); } else { _129 = _109; } float3 _133 = float4(0.0).xyz + (_129 * 0.5); float4 _134 = float4(_133.x, _133.y, _133.z, float4(0.0).w); _28 _135 = _77; _135._m0 = _134; float2 _144 = fast::clamp(_82 + (float3(-1.0, -1.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); float3 _156 = float3(_11._m5) * fast::clamp(_8.sample(_9, _144, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _160 = _12.sample(_13, _144, level(0.0)); float3 _176; if (_160.y > 0.0) { _176 = _156 + (_14.sample(_15, _144, level(0.0)).xyz * fast::clamp(_160.y * _160.z, 0.0, 1.0)); } else { _176 = _156; } float3 _180 = _134.xyz + (_176 * 0.5); float4 _181 = float4(_180.x, _180.y, _180.z, _134.w); _28 _182 = _135; _182._m0 = _181; float2 _191 = fast::clamp(_82 + (float3(0.0, -1.0, 0.75).xy * _7._m0.xy), _88.xy, _88.zw); float3 _203 = float3(_11._m5) * fast::clamp(_8.sample(_9, _191, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _207 = _12.sample(_13, _191, level(0.0)); float3 _223; if (_207.y > 0.0) { _223 = _203 + (_14.sample(_15, _191, level(0.0)).xyz * fast::clamp(_207.y * _207.z, 0.0, 1.0)); } else { _223 = _203; } float3 _227 = _181.xyz + (_223 * 0.75); float4 _228 = float4(_227.x, _227.y, _227.z, _181.w); _28 _229 = _182; _229._m0 = _228; float2 _238 = fast::clamp(_82 + (float3(1.0, -1.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); float3 _250 = float3(_11._m5) * fast::clamp(_8.sample(_9, _238, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _254 = _12.sample(_13, _238, level(0.0)); float3 _270; if (_254.y > 0.0) { _270 = _250 + (_14.sample(_15, _238, level(0.0)).xyz * fast::clamp(_254.y * _254.z, 0.0, 1.0)); } else { _270 = _250; } float3 _274 = _228.xyz + (_270 * 0.5); float4 _275 = float4(_274.x, _274.y, _274.z, _228.w); _28 _276 = _229; _276._m0 = _275; float2 _285 = fast::clamp(_82 + (float3(-2.0, 0.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); float3 _297 = float3(_11._m5) * fast::clamp(_8.sample(_9, _285, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _301 = _12.sample(_13, _285, level(0.0)); float3 _317; if (_301.y > 0.0) { _317 = _297 + (_14.sample(_15, _285, level(0.0)).xyz * fast::clamp(_301.y * _301.z, 0.0, 1.0)); } else { _317 = _297; } float3 _321 = _275.xyz + (_317 * 0.5); float4 _322 = float4(_321.x, _321.y, _321.z, _275.w); _28 _323 = _276; _323._m0 = _322; float2 _332 = fast::clamp(_82 + (float3(-1.0, 0.0, 0.75).xy * _7._m0.xy), _88.xy, _88.zw); float3 _344 = float3(_11._m5) * fast::clamp(_8.sample(_9, _332, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _348 = _12.sample(_13, _332, level(0.0)); float3 _364; if (_348.y > 0.0) { _364 = _344 + (_14.sample(_15, _332, level(0.0)).xyz * fast::clamp(_348.y * _348.z, 0.0, 1.0)); } else { _364 = _344; } float3 _368 = _322.xyz + (_364 * 0.75); float4 _369 = float4(_368.x, _368.y, _368.z, _322.w); _28 _370 = _323; _370._m0 = _369; float2 _379 = fast::clamp(_82 + (float3(0.0, 0.0, 1.0).xy * _7._m0.xy), _88.xy, _88.zw); float3 _391 = float3(_11._m5) * fast::clamp(_8.sample(_9, _379, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _395 = _12.sample(_13, _379, level(0.0)); float3 _411; if (_395.y > 0.0) { _411 = _391 + (_14.sample(_15, _379, level(0.0)).xyz * fast::clamp(_395.y * _395.z, 0.0, 1.0)); } else { _411 = _391; } float3 _415 = _369.xyz + (_411 * 1.0); float4 _416 = float4(_415.x, _415.y, _415.z, _369.w); _28 _417 = _370; _417._m0 = _416; float2 _426 = fast::clamp(_82 + (float3(1.0, 0.0, 0.75).xy * _7._m0.xy), _88.xy, _88.zw); float3 _438 = float3(_11._m5) * fast::clamp(_8.sample(_9, _426, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _442 = _12.sample(_13, _426, level(0.0)); float3 _458; if (_442.y > 0.0) { _458 = _438 + (_14.sample(_15, _426, level(0.0)).xyz * fast::clamp(_442.y * _442.z, 0.0, 1.0)); } else { _458 = _438; } float3 _462 = _416.xyz + (_458 * 0.75); float4 _463 = float4(_462.x, _462.y, _462.z, _416.w); _28 _464 = _417; _464._m0 = _463; float2 _473 = fast::clamp(_82 + (float3(2.0, 0.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); float3 _485 = float3(_11._m5) * fast::clamp(_8.sample(_9, _473, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _489 = _12.sample(_13, _473, level(0.0)); float3 _505; if (_489.y > 0.0) { _505 = _485 + (_14.sample(_15, _473, level(0.0)).xyz * fast::clamp(_489.y * _489.z, 0.0, 1.0)); } else { _505 = _485; } float3 _509 = _463.xyz + (_505 * 0.5); float4 _510 = float4(_509.x, _509.y, _509.z, _463.w); _28 _511 = _464; _511._m0 = _510; float2 _520 = fast::clamp(_82 + (float3(-1.0, 1.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); float3 _532 = float3(_11._m5) * fast::clamp(_8.sample(_9, _520, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _536 = _12.sample(_13, _520, level(0.0)); float3 _552; if (_536.y > 0.0) { _552 = _532 + (_14.sample(_15, _520, level(0.0)).xyz * fast::clamp(_536.y * _536.z, 0.0, 1.0)); } else { _552 = _532; } float3 _556 = _510.xyz + (_552 * 0.5); float4 _557 = float4(_556.x, _556.y, _556.z, _510.w); _28 _558 = _511; _558._m0 = _557; float2 _567 = fast::clamp(_82 + (float3(0.0, 1.0, 0.75).xy * _7._m0.xy), _88.xy, _88.zw); float3 _579 = float3(_11._m5) * fast::clamp(_8.sample(_9, _567, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _583 = _12.sample(_13, _567, level(0.0)); float3 _599; if (_583.y > 0.0) { _599 = _579 + (_14.sample(_15, _567, level(0.0)).xyz * fast::clamp(_583.y * _583.z, 0.0, 1.0)); } else { _599 = _579; } float3 _603 = _557.xyz + (_599 * 0.75); float4 _604 = float4(_603.x, _603.y, _603.z, _557.w); _28 _605 = _558; _605._m0 = _604; float2 _614 = fast::clamp(_82 + (float3(1.0, 1.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); float3 _626 = float3(_11._m5) * fast::clamp(_8.sample(_9, _614, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _630 = _12.sample(_13, _614, level(0.0)); float3 _646; if (_630.y > 0.0) { _646 = _626 + (_14.sample(_15, _614, level(0.0)).xyz * fast::clamp(_630.y * _630.z, 0.0, 1.0)); } else { _646 = _626; } float3 _650 = _604.xyz + (_646 * 0.5); float4 _651 = float4(_650.x, _650.y, _650.z, _604.w); _28 _652 = _605; _652._m0 = _651; float2 _661 = fast::clamp(_82 + (float3(0.0, 2.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); float3 _673 = float3(_11._m5) * fast::clamp(_8.sample(_9, _661, level(0.0)).w * _7._m1, 0.0, 1.0); float4 _677 = _12.sample(_13, _661, level(0.0)); float3 _693; if (_677.y > 0.0) { _693 = _673 + (_14.sample(_15, _661, level(0.0)).xyz * fast::clamp(_677.y * _677.z, 0.0, 1.0)); } else { _693 = _673; } float3 _697 = _651.xyz + (_693 * 0.5); float4 _698 = float4(_697.x, _697.y, _697.z, _651.w); _28 _699 = _652; _699._m0 = _698; float3 _702 = _698.xyz / float3(((((((((((((0.0 + 0.5) + 0.5) + 0.75) + 0.5) + 0.5) + 0.75) + 1.0) + 0.75) + 0.5) + 0.5) + 0.75) + 0.5) + 0.5); _28 _704 = _699; _704._m0 = float4(_702.x, _702.y, _702.z, _698.w); _28 _705 = _704; _705._m0.w = 1.0; out.m_5 = _705._m0; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/tesc/000077500000000000000000000000001400026215700222705ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/asm/tesc/tess-level-overrun.asm.tesc000066400000000000000000000015151400026215700275120ustar00rootroot00000000000000#include #include using namespace metal; struct TessLevels { float inner0; float inner1; float outer0; float outer1; float outer2; float outer3; }; kernel void main0(const device TessLevels& sb_levels [[buffer(0)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(sb_levels.inner0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(sb_levels.outer0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(sb_levels.outer1); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(sb_levels.outer2); } spirv-cross-2021.01.15/reference/shaders-msl/asm/tesc/tess-level-overrun.multi-patch.asm.tesc000066400000000000000000000015541400026215700317430ustar00rootroot00000000000000#include #include using namespace metal; struct TessLevels { float inner0; float inner1; float outer0; float outer1; float outer2; float outer3; }; kernel void main0(const device TessLevels& sb_levels [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1]); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(sb_levels.inner0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(sb_levels.outer0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(sb_levels.outer1); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(sb_levels.outer2); } spirv-cross-2021.01.15/reference/shaders-msl/asm/tese/000077500000000000000000000000001400026215700222725ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/asm/tese/unnamed-builtin-array.asm.tese000066400000000000000000000014371400026215700301470ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_patchIn { float2 gl_TessLevelInner [[attribute(0)]]; float4 gl_TessLevelOuter [[attribute(1)]]; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; out.gl_Position = float4(((gl_TessCoord.x * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.x) + (((1.0 - gl_TessCoord.x) * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.z), ((gl_TessCoord.y * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.y) + (((1.0 - gl_TessCoord.y) * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.w), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/000077500000000000000000000000001400026215700223125ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/clip-distance-plain-variable.asm.vert000066400000000000000000000017761400026215700314110ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct VSOut { float4 pos; float2 clip; }; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; float gl_ClipDistance_0 [[user(clip0)]]; float gl_ClipDistance_1 [[user(clip1)]]; }; struct main0_in { float4 pos [[attribute(0)]]; }; static inline __attribute__((always_inline)) VSOut _main(thread const float4& pos) { VSOut vout; vout.pos = pos; vout.clip = pos.xy; return vout; } vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float4 pos = in.pos; float4 param = pos; VSOut flattenTemp = _main(param); out.gl_Position = flattenTemp.pos; out.gl_ClipDistance[0] = flattenTemp.clip.x; out.gl_ClipDistance[1] = flattenTemp.clip.y; out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; out.gl_ClipDistance_1 = out.gl_ClipDistance[1]; return out; } clip-distance-plain-variable.no-user-varying.asm.vert000066400000000000000000000014741400026215700343710ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/asm/vert#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct VSOut { float4 pos; float2 clip; }; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; }; struct main0_in { float4 pos [[attribute(0)]]; }; static inline __attribute__((always_inline)) VSOut _main(thread const float4& pos) { VSOut vout; vout.pos = pos; vout.clip = pos.xy; return vout; } vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float4 pos = in.pos; float4 param = pos; VSOut flattenTemp = _main(param); out.gl_Position = flattenTemp.pos; out.gl_ClipDistance[0] = flattenTemp.clip.x; out.gl_ClipDistance[1] = flattenTemp.clip.y; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/copy-memory-interface.asm.vert000066400000000000000000000006101400026215700302060ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 o1 [[user(locn1)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 v0 [[attribute(0)]]; float4 v1 [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.v0; out.o1 = in.v1; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/extract-transposed-matrix-from-struct.asm.vert000066400000000000000000000027031400026215700334140ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct V2F { float4 Position; float4 Color; }; struct InstanceData { float4x4 MATRIX_MVP; float4 Color; }; struct InstanceData_1 { float4x4 MATRIX_MVP; float4 Color; }; struct gInstanceData { InstanceData_1 _data[1]; }; struct main0_out { float4 _entryPointOutput_Color [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 PosL [[attribute(0)]]; }; static inline __attribute__((always_inline)) V2F _VS(thread const float3& PosL, thread const uint& instanceID, const device gInstanceData& gInstanceData_1) { InstanceData instData; instData.MATRIX_MVP = transpose(gInstanceData_1._data[instanceID].MATRIX_MVP); instData.Color = gInstanceData_1._data[instanceID].Color; V2F v2f; v2f.Position = instData.MATRIX_MVP * float4(PosL, 1.0); v2f.Color = instData.Color; return v2f; } vertex main0_out main0(main0_in in [[stage_in]], const device gInstanceData& gInstanceData_1 [[buffer(0)]], uint gl_InstanceIndex [[instance_id]]) { main0_out out = {}; float3 PosL = in.PosL; uint instanceID = gl_InstanceIndex; float3 param = PosL; uint param_1 = instanceID; V2F flattenTemp = _VS(param, param_1, gInstanceData_1); out.gl_Position = flattenTemp.Position; out._entryPointOutput_Color = flattenTemp.Color; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/fake-builtin-input.asm.vert000066400000000000000000000006161400026215700275050ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { half4 out_var_SV_Target [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float2 in_var_POSITION [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = float4(in.in_var_POSITION, 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/invariant.msl21.asm.vert000066400000000000000000000006341400026215700267260ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 gl_Position [[position, invariant]]; }; static inline __attribute__((always_inline)) float4 _main() { return float4(1.0); } vertex main0_out main0() { main0_out out = {}; float4 _14 = _main(); out.gl_Position = _14; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/packed-bool-to-uint.asm.vert000066400000000000000000000013211400026215700275450ustar00rootroot00000000000000#include #include using namespace metal; struct Struct { uint flags[1]; }; struct defaultUniformsVS { Struct flags; float4 uquad[4]; float4x4 umatrix; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant defaultUniformsVS& _9 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.gl_Position = _9.umatrix * float4(_9.uquad[int(gl_VertexIndex)].x, _9.uquad[int(gl_VertexIndex)].y, in.a_position.z, in.a_position.w); if (_9.flags.flags[0] != 0u) { out.gl_Position.z = 0.0; } return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/packed-bool2-to-packed_uint2.asm.vert000066400000000000000000000013241400026215700312230ustar00rootroot00000000000000#include #include using namespace metal; struct Struct { uint2 flags[1]; }; struct defaultUniformsVS { Struct flags; float4 uquad[4]; float4x4 umatrix; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant defaultUniformsVS& _9 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.gl_Position = _9.umatrix * float4(_9.uquad[int(gl_VertexIndex)].x, _9.uquad[int(gl_VertexIndex)].y, in.a_position.z, in.a_position.w); if (_9.flags.flags[0].x != 0u) { out.gl_Position.z = 0.0; } return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/packing-test.asm.vert000066400000000000000000000002761400026215700263710ustar00rootroot00000000000000#include #include using namespace metal; struct TestStruct { float4x4 transforms[6]; }; struct CB0 { TestStruct CB0[16]; }; vertex void main0() { } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/spec-constant-op-composite.asm.vert000066400000000000000000000017721400026215700311770ustar00rootroot00000000000000#include #include using namespace metal; constant int _7_tmp [[function_constant(201)]]; constant int _7 = is_function_constant_defined(_7_tmp) ? _7_tmp : -10; constant int _20 = (_7 + 2); constant uint _8_tmp [[function_constant(202)]]; constant uint _8 = is_function_constant_defined(_8_tmp) ? _8_tmp : 100u; constant uint _25 = (_8 % 5u); constant int4 _30 = int4(20, 30, _20, _20); constant int2 _32 = int2(_30.y, _30.x); constant int _33 = _30.y; constant float _9_tmp [[function_constant(200)]]; constant float _9 = is_function_constant_defined(_9_tmp) ? _9_tmp : 3.141590118408203125; struct main0_out { int m_4 [[user(locn0)]]; float4 gl_Position [[position]]; }; vertex main0_out main0() { main0_out out = {}; float4 pos = float4(0.0); pos.y += float(_20); pos.z += float(_25); pos += float4(_30); float2 _56 = pos.xy + float2(_32); pos = float4(_56.x, _56.y, pos.z, pos.w); out.gl_Position = pos; out.m_4 = _33; return out; } spirv-cross-2021.01.15/reference/shaders-msl/asm/vert/uint-vertex-id-instance-id.asm.vert000066400000000000000000000011721400026215700310540ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; static inline __attribute__((always_inline)) float4 _main(thread const uint& vid, thread const uint& iid) { return float4(float(vid + iid)); } vertex main0_out main0(uint gl_VertexIndex [[vertex_id]], uint gl_InstanceIndex [[instance_id]]) { main0_out out = {}; uint vid = gl_VertexIndex; uint iid = gl_InstanceIndex; uint param = vid; uint param_1 = iid; out.gl_Position = _main(param, param_1); return out; } spirv-cross-2021.01.15/reference/shaders-msl/comp/000077500000000000000000000000001400026215700215105ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/comp/access-private-workgroup-in-function.comp000066400000000000000000000012161400026215700315650ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) void set_f(thread int& f) { f = 40; } static inline __attribute__((always_inline)) void set_shared_u(threadgroup int& u) { u = 50; } kernel void main0(uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { threadgroup int u; int f; set_f(f); set_shared_u(u); if (gl_LocalInvocationIndex == 0u) { f = 10; } else { f = 30; u = 20; } } argument-buffers-discrete.msl2.argument.discrete.comp000066400000000000000000000013471400026215700336700ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/comp#include #include using namespace metal; struct SSBO3 { float4 v; }; struct SSBO0 { float4 v; }; struct SSBO1 { float4 v; }; struct SSBO2 { float4 v; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); struct spvDescriptorSetBuffer0 { const device SSBO0* ssbo0 [[id(0)]]; }; struct spvDescriptorSetBuffer1 { const device SSBO1* ssbo1 [[id(0)]]; }; kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], device SSBO3& ssbo3 [[buffer(2)]], const device SSBO2& ssbo2 [[buffer(3)]]) { ssbo3.v = ((*spvDescriptorSet0.ssbo0).v + (*spvDescriptorSet1.ssbo1).v) + ssbo2.v; } argument-buffers-image-load-store.ios.msl2.argument.comp000066400000000000000000000005531400026215700342050ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/comp#include #include using namespace metal; kernel void main0(texture2d uImage [[texture(0)]], texture2d uImageRead [[texture(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { int2 coord = int2(gl_GlobalInvocationID.xy); uImage.write(uImageRead.read(uint2(coord)), uint2(coord)); } argument-buffers-image-load-store.msl2.argument.comp000066400000000000000000000007651400026215700334210ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/comp#include #include using namespace metal; struct spvDescriptorSetBuffer0 { texture2d uImage [[id(0)]]; texture2d uImageRead [[id(1)]]; }; kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { int2 coord = int2(gl_GlobalInvocationID.xy); spvDescriptorSet0.uImage.write(spvDescriptorSet0.uImageRead.read(uint2(coord)), uint2(coord)); } spirv-cross-2021.01.15/reference/shaders-msl/comp/array-length.comp000066400000000000000000000017451400026215700247740ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { uint size; float4 v[1]; }; struct SSBO1 { float bz[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) uint get_size(device SSBO& v_14, constant uint& v_14BufferSize, device SSBO1* (&ssbos)[2], constant uint* ssbosBufferSize) { return uint(int((v_14BufferSize - 16) / 16) + int((ssbosBufferSize[1] - 0) / 4)); } kernel void main0(constant uint* spvBufferSizeConstants [[buffer(25)]], device SSBO& v_14 [[buffer(0)]], device SSBO1* ssbos_0 [[buffer(1)]], device SSBO1* ssbos_1 [[buffer(2)]]) { device SSBO1* ssbos[] = { ssbos_0, ssbos_1, }; constant uint& v_14BufferSize = spvBufferSizeConstants[0]; constant uint* ssbosBufferSize = &spvBufferSizeConstants[1]; v_14.size = get_size(v_14, v_14BufferSize, ssbos, ssbosBufferSize); } spirv-cross-2021.01.15/reference/shaders-msl/comp/array-length.msl2.argument.discrete.comp000066400000000000000000000040411400026215700312620ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { uint size; float4 v[1]; }; struct SSBO1 { float bz[1]; }; struct SSBO2 { uint size2; float4 w[1]; }; struct SSBO3 { float bz[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); struct spvDescriptorSetBuffer0 { device SSBO* v_16 [[id(0)]]; constant uint* spvBufferSizeConstants [[id(1)]]; }; struct spvDescriptorSetBuffer1 { device SSBO1* ssbos [[id(0)]][2]; constant uint* spvBufferSizeConstants [[id(2)]]; }; static inline __attribute__((always_inline)) uint get_size(device SSBO& v_16, constant uint& v_16BufferSize, device SSBO1* constant (&ssbos)[2], constant uint* ssbosBufferSize, device SSBO2& v_38, constant uint& v_38BufferSize, device SSBO3* (&ssbos2)[2], constant uint* ssbos2BufferSize) { uint len = uint(int((v_16BufferSize - 16) / 16)); len += uint(int((ssbosBufferSize[1] - 0) / 4)); len += uint(int((v_38BufferSize - 16) / 16)); len += uint(int((ssbos2BufferSize[0] - 0) / 4)); return len; } kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], constant uint* spvBufferSizeConstants [[buffer(25)]], device SSBO2& v_38 [[buffer(2)]], device SSBO3* ssbos2_0 [[buffer(3)]], device SSBO3* ssbos2_1 [[buffer(4)]]) { device SSBO3* ssbos2[] = { ssbos2_0, ssbos2_1, }; constant uint& spvDescriptorSet0_v_16BufferSize = spvDescriptorSet0.spvBufferSizeConstants[0]; constant uint* spvDescriptorSet1_ssbosBufferSize = &spvDescriptorSet1.spvBufferSizeConstants[0]; constant uint& v_38BufferSize = spvBufferSizeConstants[2]; constant uint* ssbos2BufferSize = &spvBufferSizeConstants[3]; (*spvDescriptorSet0.v_16).size = get_size((*spvDescriptorSet0.v_16), spvDescriptorSet0_v_16BufferSize, spvDescriptorSet1.ssbos, spvDescriptorSet1_ssbosBufferSize, v_38, v_38BufferSize, ssbos2, ssbos2BufferSize); } spirv-cross-2021.01.15/reference/shaders-msl/comp/atomic.comp000066400000000000000000000077521400026215700236570ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { uint u32; int i32; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& ssbo [[buffer(0)]]) { threadgroup uint shared_u32; threadgroup int shared_i32; uint _16 = atomic_fetch_add_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _18 = atomic_fetch_or_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _20 = atomic_fetch_xor_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _22 = atomic_fetch_and_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _24 = atomic_fetch_min_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _26 = atomic_fetch_max_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _28 = atomic_exchange_explicit((device atomic_uint*)&ssbo.u32, 1u, memory_order_relaxed); uint _32; do { _32 = 10u; } while (!atomic_compare_exchange_weak_explicit((device atomic_uint*)&ssbo.u32, &_32, 2u, memory_order_relaxed, memory_order_relaxed) && _32 == 10u); int _36 = atomic_fetch_add_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _38 = atomic_fetch_or_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _40 = atomic_fetch_xor_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _42 = atomic_fetch_and_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _44 = atomic_fetch_min_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _46 = atomic_fetch_max_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _48 = atomic_exchange_explicit((device atomic_int*)&ssbo.i32, 1, memory_order_relaxed); int _52; do { _52 = 10; } while (!atomic_compare_exchange_weak_explicit((device atomic_int*)&ssbo.i32, &_52, 2, memory_order_relaxed, memory_order_relaxed) && _52 == 10); shared_u32 = 10u; shared_i32 = 10; uint _57 = atomic_fetch_add_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _58 = atomic_fetch_or_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _59 = atomic_fetch_xor_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _60 = atomic_fetch_and_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _61 = atomic_fetch_min_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _62 = atomic_fetch_max_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _63 = atomic_exchange_explicit((threadgroup atomic_uint*)&shared_u32, 1u, memory_order_relaxed); uint _64; do { _64 = 10u; } while (!atomic_compare_exchange_weak_explicit((threadgroup atomic_uint*)&shared_u32, &_64, 2u, memory_order_relaxed, memory_order_relaxed) && _64 == 10u); int _65 = atomic_fetch_add_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _66 = atomic_fetch_or_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _67 = atomic_fetch_xor_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _68 = atomic_fetch_and_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _69 = atomic_fetch_min_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _70 = atomic_fetch_max_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _71 = atomic_exchange_explicit((threadgroup atomic_int*)&shared_i32, 1, memory_order_relaxed); int _72; do { _72 = 10; } while (!atomic_compare_exchange_weak_explicit((threadgroup atomic_int*)&shared_i32, &_72, 2, memory_order_relaxed, memory_order_relaxed) && _72 == 10); } spirv-cross-2021.01.15/reference/shaders-msl/comp/barriers.comp000066400000000000000000000040021400026215700241750ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(4u, 1u, 1u); static inline __attribute__((always_inline)) void barrier_shared() { threadgroup_barrier(mem_flags::mem_threadgroup); } static inline __attribute__((always_inline)) void full_barrier() { threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); } static inline __attribute__((always_inline)) void image_barrier() { threadgroup_barrier(mem_flags::mem_texture); } static inline __attribute__((always_inline)) void buffer_barrier() { threadgroup_barrier(mem_flags::mem_device); } static inline __attribute__((always_inline)) void group_barrier() { threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); } static inline __attribute__((always_inline)) void barrier_shared_exec() { threadgroup_barrier(mem_flags::mem_threadgroup); } static inline __attribute__((always_inline)) void full_barrier_exec() { threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); } static inline __attribute__((always_inline)) void image_barrier_exec() { threadgroup_barrier(mem_flags::mem_texture); } static inline __attribute__((always_inline)) void buffer_barrier_exec() { threadgroup_barrier(mem_flags::mem_device); } static inline __attribute__((always_inline)) void group_barrier_exec() { threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture); } static inline __attribute__((always_inline)) void exec_barrier() { threadgroup_barrier(mem_flags::mem_threadgroup); } kernel void main0() { barrier_shared(); full_barrier(); image_barrier(); buffer_barrier(); group_barrier(); barrier_shared_exec(); full_barrier_exec(); image_barrier_exec(); buffer_barrier_exec(); group_barrier_exec(); exec_barrier(); } spirv-cross-2021.01.15/reference/shaders-msl/comp/basic.comp000066400000000000000000000014721400026215700234550ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; struct SSBO3 { uint counter; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(const device SSBO& _23 [[buffer(0)]], device SSBO2& _45 [[buffer(1)]], device SSBO3& _48 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; float4 idata = _23.in_data[ident]; if (dot(idata, float4(1.0, 5.0, 6.0, 2.0)) > 8.19999980926513671875) { uint _52 = atomic_fetch_add_explicit((device atomic_uint*)&_48.counter, 1u, memory_order_relaxed); _45.out_data[_52] = idata; } } spirv-cross-2021.01.15/reference/shaders-msl/comp/basic.dispatchbase.comp000066400000000000000000000022531400026215700261040ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; struct SSBO3 { uint counter; }; constant uint _59_tmp [[function_constant(10)]]; constant uint _59 = is_function_constant_defined(_59_tmp) ? _59_tmp : 1u; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(_59, 1u, 1u); kernel void main0(const device SSBO& _27 [[buffer(0)]], device SSBO2& _49 [[buffer(1)]], device SSBO3& _52 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 spvDispatchBase [[grid_origin]]) { gl_GlobalInvocationID += spvDispatchBase * gl_WorkGroupSize; gl_WorkGroupID += spvDispatchBase; uint ident = gl_GlobalInvocationID.x; uint workgroup = gl_WorkGroupID.x; float4 idata = _27.in_data[ident]; if (dot(idata, float4(1.0, 5.0, 6.0, 2.0)) > 8.19999980926513671875) { uint _56 = atomic_fetch_add_explicit((device atomic_uint*)&_52.counter, 1u, memory_order_relaxed); _49.out_data[_56] = idata; } } spirv-cross-2021.01.15/reference/shaders-msl/comp/basic.dispatchbase.msl11.comp000066400000000000000000000020601400026215700270340ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; struct SSBO3 { uint counter; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(constant uint3& spvDispatchBase [[buffer(29)]], const device SSBO& _27 [[buffer(0)]], device SSBO2& _49 [[buffer(1)]], device SSBO3& _52 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]]) { gl_GlobalInvocationID += spvDispatchBase * gl_WorkGroupSize; gl_WorkGroupID += spvDispatchBase; uint ident = gl_GlobalInvocationID.x; uint workgroup = gl_WorkGroupID.x; float4 idata = _27.in_data[ident]; if (dot(idata, float4(1.0, 5.0, 6.0, 2.0)) > 8.19999980926513671875) { uint _56 = atomic_fetch_add_explicit((device atomic_uint*)&_52.counter, 1u, memory_order_relaxed); _49.out_data[_56] = idata; } } spirv-cross-2021.01.15/reference/shaders-msl/comp/basic.inline-block.msl2.comp000066400000000000000000000017541400026215700267010ustar00rootroot00000000000000#include #include using namespace metal; typedef packed_float4 packed_float4x4[4]; struct Baz { int f; int g; }; struct X { int x; int y; float z; }; struct Foo { int a; int b; packed_float4x4 c; X x[2]; }; struct Bar { int d; int e; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(3u, 3u, 2u); struct spvDescriptorSetBuffer0 { constant Bar* m_38 [[id(0)]]; Foo m_32 [[id(1)]]; }; struct spvDescriptorSetBuffer1 { device Baz* baz [[id(0)]][3]; }; kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint3 coords = gl_GlobalInvocationID; spvDescriptorSet1.baz[coords.x]->f = spvDescriptorSet0.m_32.a + (*spvDescriptorSet0.m_38).d; spvDescriptorSet1.baz[coords.x]->g = spvDescriptorSet0.m_32.b * (*spvDescriptorSet0.m_38).e; } spirv-cross-2021.01.15/reference/shaders-msl/comp/builtins.comp000066400000000000000000000013231400026215700242200ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(8u, 4u, 2u); kernel void main0(uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]], uint3 gl_NumWorkGroups [[threadgroups_per_grid]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]]) { uint3 local_id = gl_LocalInvocationID; uint3 global_id = gl_GlobalInvocationID; uint local_index = gl_LocalInvocationIndex; uint3 work_group_size = gl_WorkGroupSize; uint3 num_work_groups = gl_NumWorkGroups; uint3 work_group_id = gl_WorkGroupID; } spirv-cross-2021.01.15/reference/shaders-msl/comp/cfg-preserve-parameter.comp000066400000000000000000000026101400026215700267350ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; static inline __attribute__((always_inline)) void out_test_0(thread const int& cond, thread int& i) { if (cond == 0) { i = 40; } else { i = 60; } } static inline __attribute__((always_inline)) void out_test_1(thread const int& cond, thread int& i) { switch (cond) { case 40: { i = 40; break; } default: { i = 70; break; } } } static inline __attribute__((always_inline)) void inout_test_0(thread const int& cond, thread int& i) { if (cond == 0) { i = 40; } } static inline __attribute__((always_inline)) void inout_test_1(thread const int& cond, thread int& i) { switch (cond) { case 40: { i = 40; break; } } } kernel void main0() { int cond = 40; int i = 50; int param = cond; int param_1 = i; out_test_0(param, param_1); i = param_1; int param_2 = cond; int param_3 = i; out_test_1(param_2, param_3); i = param_3; int param_4 = cond; int param_5 = i; inout_test_0(param_4, param_5); i = param_5; int param_6 = cond; int param_7 = i; inout_test_1(param_6, param_7); i = param_7; } spirv-cross-2021.01.15/reference/shaders-msl/comp/coherent-block.comp000066400000000000000000000004111400026215700252630ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 value; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(volatile device SSBO& _10 [[buffer(0)]]) { _10.value = float4(20.0); } spirv-cross-2021.01.15/reference/shaders-msl/comp/coherent-image.comp000066400000000000000000000004751400026215700252650ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { int4 value; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(volatile device SSBO& _10 [[buffer(0)]], texture2d uImage [[texture(0)]]) { _10.value = uImage.read(uint2(int2(10))); } spirv-cross-2021.01.15/reference/shaders-msl/comp/complex-composite-constant-array.comp000066400000000000000000000030651400026215700310060ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct SSBO { float4x4 a; uint index; }; constant spvUnsafeArray _32 = spvUnsafeArray({ float4x4(float4(1.0, 0.0, 0.0, 0.0), float4(0.0, 1.0, 0.0, 0.0), float4(0.0, 0.0, 1.0, 0.0), float4(0.0, 0.0, 0.0, 1.0)), float4x4(float4(2.0, 0.0, 0.0, 0.0), float4(0.0, 2.0, 0.0, 0.0), float4(0.0, 0.0, 2.0, 0.0), float4(0.0, 0.0, 0.0, 2.0)) }); static inline __attribute__((always_inline)) void write_global(device SSBO& v_14) { v_14.a = _32[v_14.index]; } kernel void main0(device SSBO& v_14 [[buffer(0)]]) { write_global(v_14); } spirv-cross-2021.01.15/reference/shaders-msl/comp/complex-type-alias.comp000066400000000000000000000021561400026215700261110ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Foo0 { float a; }; struct Foo1 { Foo0 a; }; struct Foo2 { Foo1 a; float weight; }; struct Foo0_1 { float a; }; struct Foo1_1 { Foo0_1 a; }; struct Foo2_1 { Foo1_1 a; float weight; }; struct SSBO { Foo2_1 outputs[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(8u, 8u, 1u); static inline __attribute__((always_inline)) void Zero(thread Foo0& v) { v.a = 0.0; } kernel void main0(device SSBO& _53 [[buffer(0)]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]]) { threadgroup Foo2 coeffs[64]; Foo2 data; data.weight = 0.0; Foo0 param; Zero(param); data.a.a = param; coeffs[gl_LocalInvocationIndex] = data; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_LocalInvocationIndex == 0u) { _53.outputs[gl_WorkGroupID.x].a.a.a = coeffs[0].a.a.a; _53.outputs[gl_WorkGroupID.x].weight = coeffs[0].weight; } } spirv-cross-2021.01.15/reference/shaders-msl/comp/composite-array-initialization.comp000066400000000000000000000043031400026215700305330ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Data { float a; float b; }; constant float X_tmp [[function_constant(0)]]; constant float X = is_function_constant_defined(X_tmp) ? X_tmp : 4.0; struct Data_1 { float a; float b; }; struct SSBO { Data_1 outdata[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(2u, 1u, 1u); constant spvUnsafeArray _25 = spvUnsafeArray({ Data{ 1.0, 2.0 }, Data{ 3.0, 4.0 } }); static inline __attribute__((always_inline)) Data combine(thread const Data& a, thread const Data& b) { return Data{ a.a + b.a, a.b + b.b }; } kernel void main0(device SSBO& _53 [[buffer(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { spvUnsafeArray data = spvUnsafeArray({ Data{ 1.0, 2.0 }, Data{ 3.0, 4.0 } }); spvUnsafeArray _31 = spvUnsafeArray({ Data{ X, 2.0 }, Data{ 3.0, 5.0 } }); spvUnsafeArray data2; data2 = _31; Data param = data[gl_LocalInvocationID.x]; Data param_1 = data2[gl_LocalInvocationID.x]; Data _73 = combine(param, param_1); _53.outdata[gl_WorkGroupID.x].a = _73.a; _53.outdata[gl_WorkGroupID.x].b = _73.b; } composite-array-initialization.force-native-array.comp000066400000000000000000000070531400026215700341560ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Data { float a; float b; }; constant float X_tmp [[function_constant(0)]]; constant float X = is_function_constant_defined(X_tmp) ? X_tmp : 4.0; struct Data_1 { float a; float b; }; struct SSBO { Data_1 outdata[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(2u, 1u, 1u); constant Data _25[2] = { Data{ 1.0, 2.0 }, Data{ 3.0, 4.0 } }; template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } static inline __attribute__((always_inline)) Data combine(thread const Data& a, thread const Data& b) { return Data{ a.a + b.a, a.b + b.b }; } kernel void main0(device SSBO& _53 [[buffer(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { Data data[2] = { Data{ 1.0, 2.0 }, Data{ 3.0, 4.0 } }; Data _31[2] = { Data{ X, 2.0 }, Data{ 3.0, 5.0 } }; Data data2[2]; spvArrayCopyFromStackToStack1(data2, _31); Data param = data[gl_LocalInvocationID.x]; Data param_1 = data2[gl_LocalInvocationID.x]; Data _73 = combine(param, param_1); _53.outdata[gl_WorkGroupID.x].a = _73.a; _53.outdata[gl_WorkGroupID.x].b = _73.b; } spirv-cross-2021.01.15/reference/shaders-msl/comp/composite-construct.comp000066400000000000000000000034431400026215700264200ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct SSBO0 { float4 as[1]; }; struct SSBO1 { float4 bs[1]; }; struct Composite { float4 a; float4 b; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); constant spvUnsafeArray _43 = spvUnsafeArray({ float4(20.0), float4(40.0) }); kernel void main0(device SSBO0& _16 [[buffer(0)]], device SSBO1& _32 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { spvUnsafeArray _37 = spvUnsafeArray({ _16.as[gl_GlobalInvocationID.x], _32.bs[gl_GlobalInvocationID.x] }); spvUnsafeArray values; values = _37; Composite c = Composite{ values[0], _43[1] }; _16.as[0] = values[gl_LocalInvocationIndex]; _32.bs[1] = c.b; } spirv-cross-2021.01.15/reference/shaders-msl/comp/copy-array-of-arrays.comp000066400000000000000000000055441400026215700263670ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct BUF { int a; float b; float c; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); constant spvUnsafeArray _16 = spvUnsafeArray({ 1.0, 2.0 }); constant spvUnsafeArray _19 = spvUnsafeArray({ 3.0, 4.0 }); constant spvUnsafeArray, 2> _20 = spvUnsafeArray, 2>({ spvUnsafeArray({ 1.0, 2.0 }), spvUnsafeArray({ 3.0, 4.0 }) }); constant spvUnsafeArray, 2>, 2> _21 = spvUnsafeArray, 2>, 2>({ spvUnsafeArray, 2>({ spvUnsafeArray({ 1.0, 2.0 }), spvUnsafeArray({ 3.0, 4.0 }) }), spvUnsafeArray, 2>({ spvUnsafeArray({ 1.0, 2.0 }), spvUnsafeArray({ 3.0, 4.0 }) }) }); kernel void main0(device BUF& o [[buffer(0)]]) { spvUnsafeArray, 2>, 2> c; c = _21; o.a = int(c[1][1][1]); spvUnsafeArray _43 = spvUnsafeArray({ o.b, o.c }); spvUnsafeArray _48 = spvUnsafeArray({ o.b, o.b }); spvUnsafeArray, 2> _49 = spvUnsafeArray, 2>({ _43, _48 }); spvUnsafeArray _54 = spvUnsafeArray({ o.c, o.c }); spvUnsafeArray _59 = spvUnsafeArray({ o.c, o.b }); spvUnsafeArray, 2> _60 = spvUnsafeArray, 2>({ _54, _59 }); spvUnsafeArray, 2>, 2> _61 = spvUnsafeArray, 2>, 2>({ _49, _60 }); spvUnsafeArray, 2>, 2> d; d = _61; spvUnsafeArray, 2>, 2> e; e = d; o.b = e[1][0][1]; } spirv-cross-2021.01.15/reference/shaders-msl/comp/copy-array-of-arrays.force-native-array.comp000066400000000000000000000227151400026215700320630ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct BUF { int a; float b; float c; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); constant float _16[2] = { 1.0, 2.0 }; constant float _19[2] = { 3.0, 4.0 }; constant float _20[2][2] = { { 1.0, 2.0 }, { 3.0, 4.0 } }; constant float _21[2][2][2] = { { { 1.0, 2.0 }, { 3.0, 4.0 } }, { { 1.0, 2.0 }, { 3.0, 4.0 } } }; template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToStack2(thread T (&dst)[A][B], constant T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromConstantToStack1(dst[i], src[i]); } } template inline void spvArrayCopyFromConstantToThreadGroup2(threadgroup T (&dst)[A][B], constant T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromConstantToThreadGroup1(dst[i], src[i]); } } template inline void spvArrayCopyFromStackToStack2(thread T (&dst)[A][B], thread const T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromStackToStack1(dst[i], src[i]); } } template inline void spvArrayCopyFromStackToThreadGroup2(threadgroup T (&dst)[A][B], thread const T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromStackToThreadGroup1(dst[i], src[i]); } } template inline void spvArrayCopyFromThreadGroupToStack2(thread T (&dst)[A][B], threadgroup const T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromThreadGroupToStack1(dst[i], src[i]); } } template inline void spvArrayCopyFromThreadGroupToThreadGroup2(threadgroup T (&dst)[A][B], threadgroup const T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromThreadGroupToThreadGroup1(dst[i], src[i]); } } template inline void spvArrayCopyFromDeviceToDevice2(device T (&dst)[A][B], device const T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromDeviceToDevice1(dst[i], src[i]); } } template inline void spvArrayCopyFromConstantToDevice2(device T (&dst)[A][B], constant T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromConstantToDevice1(dst[i], src[i]); } } template inline void spvArrayCopyFromStackToDevice2(device T (&dst)[A][B], thread const T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromStackToDevice1(dst[i], src[i]); } } template inline void spvArrayCopyFromThreadGroupToDevice2(device T (&dst)[A][B], threadgroup const T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromThreadGroupToDevice1(dst[i], src[i]); } } template inline void spvArrayCopyFromDeviceToStack2(thread T (&dst)[A][B], device const T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromDeviceToStack1(dst[i], src[i]); } } template inline void spvArrayCopyFromDeviceToThreadGroup2(threadgroup T (&dst)[A][B], device const T (&src)[A][B]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromDeviceToThreadGroup1(dst[i], src[i]); } } template inline void spvArrayCopyFromConstantToStack3(thread T (&dst)[A][B][C], constant T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromConstantToStack2(dst[i], src[i]); } } template inline void spvArrayCopyFromConstantToThreadGroup3(threadgroup T (&dst)[A][B][C], constant T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromConstantToThreadGroup2(dst[i], src[i]); } } template inline void spvArrayCopyFromStackToStack3(thread T (&dst)[A][B][C], thread const T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromStackToStack2(dst[i], src[i]); } } template inline void spvArrayCopyFromStackToThreadGroup3(threadgroup T (&dst)[A][B][C], thread const T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromStackToThreadGroup2(dst[i], src[i]); } } template inline void spvArrayCopyFromThreadGroupToStack3(thread T (&dst)[A][B][C], threadgroup const T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromThreadGroupToStack2(dst[i], src[i]); } } template inline void spvArrayCopyFromThreadGroupToThreadGroup3(threadgroup T (&dst)[A][B][C], threadgroup const T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromThreadGroupToThreadGroup2(dst[i], src[i]); } } template inline void spvArrayCopyFromDeviceToDevice3(device T (&dst)[A][B][C], device const T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromDeviceToDevice2(dst[i], src[i]); } } template inline void spvArrayCopyFromConstantToDevice3(device T (&dst)[A][B][C], constant T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromConstantToDevice2(dst[i], src[i]); } } template inline void spvArrayCopyFromStackToDevice3(device T (&dst)[A][B][C], thread const T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromStackToDevice2(dst[i], src[i]); } } template inline void spvArrayCopyFromThreadGroupToDevice3(device T (&dst)[A][B][C], threadgroup const T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromThreadGroupToDevice2(dst[i], src[i]); } } template inline void spvArrayCopyFromDeviceToStack3(thread T (&dst)[A][B][C], device const T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromDeviceToStack2(dst[i], src[i]); } } template inline void spvArrayCopyFromDeviceToThreadGroup3(threadgroup T (&dst)[A][B][C], device const T (&src)[A][B][C]) { for (uint i = 0; i < A; i++) { spvArrayCopyFromDeviceToThreadGroup2(dst[i], src[i]); } } kernel void main0(device BUF& o [[buffer(0)]]) { float c[2][2][2]; spvArrayCopyFromConstantToStack3(c, _21); o.a = int(c[1][1][1]); float _43[2] = { o.b, o.c }; float _48[2] = { o.b, o.b }; float _49[2][2] = { { _43[0], _43[1] }, { _48[0], _48[1] } }; float _54[2] = { o.c, o.c }; float _59[2] = { o.c, o.b }; float _60[2][2] = { { _54[0], _54[1] }, { _59[0], _59[1] } }; float _61[2][2][2] = { { { _49[0][0], _49[0][1] }, { _49[1][0], _49[1][1] } }, { { _60[0][0], _60[0][1] }, { _60[1][0], _60[1][1] } } }; float d[2][2][2]; spvArrayCopyFromStackToStack3(d, _61); float e[2][2][2]; spvArrayCopyFromStackToStack3(e, d); o.b = e[1][0][1]; } spirv-cross-2021.01.15/reference/shaders-msl/comp/culling.comp000066400000000000000000000014101400026215700240210ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float in_data[1]; }; struct SSBO2 { float out_data[1]; }; struct SSBO3 { uint count; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(4u, 1u, 1u); kernel void main0(const device SSBO& _22 [[buffer(0)]], device SSBO2& _38 [[buffer(1)]], device SSBO3& _41 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; float idata = _22.in_data[ident]; if (idata > 12.0) { uint _45 = atomic_fetch_add_explicit((device atomic_uint*)&_41.count, 1u, memory_order_relaxed); _38.out_data[_45] = idata; } } spirv-cross-2021.01.15/reference/shaders-msl/comp/defer-parens.comp000066400000000000000000000010131400026215700247360ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 data; int index; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _13 [[buffer(0)]]) { float4 d = _13.data; _13.data = float4(d.x, d.yz + float2(10.0), d.w); _13.data = (d + d) + d; _13.data = (d.yz + float2(10.0)).xxyy; float t = (d.yz + float2(10.0)).y; _13.data = float4(t); t = (d.zw + float2(10.0))[_13.index]; _13.data = float4(t); } spirv-cross-2021.01.15/reference/shaders-msl/comp/dowhile.comp000066400000000000000000000011221400026215700240170ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4x4 mvp; float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(const device SSBO& _28 [[buffer(0)]], device SSBO2& _52 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; int i = 0; float4 idat = _28.in_data[ident]; do { idat = _28.mvp * idat; i++; } while (i < 16); _52.out_data[ident] = idat; } spirv-cross-2021.01.15/reference/shaders-msl/comp/force-recompile-hooks.swizzle.comp000066400000000000000000000041571400026215700303010ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } kernel void main0(constant uint* spvSwizzleConstants [[buffer(30)]], texture2d foo [[texture(0)]], texture2d bar [[texture(1)]], sampler fooSmplr [[sampler(0)]]) { constant uint& fooSwzl = spvSwizzleConstants[0]; float4 a = spvTextureSwizzle(foo.sample(fooSmplr, float2(1.0), level(0.0)), fooSwzl); bar.write(a, uint2(int2(0))); } spirv-cross-2021.01.15/reference/shaders-msl/comp/functions.comp000066400000000000000000000004671400026215700244070ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; static inline __attribute__((always_inline)) void myfunc(threadgroup int (&foo)[1337]) { foo[0] = 13; } kernel void main0() { threadgroup int foo[1337]; myfunc(foo); } global-invocation-id-writable-ssbo-in-function.comp000066400000000000000000000015001400026215700333100ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/comp#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b[1]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } static inline __attribute__((always_inline)) float getB(device myBlock& myStorage, thread uint3& gl_GlobalInvocationID) { return myStorage.b[gl_GlobalInvocationID.x]; } kernel void main0(device myBlock& myStorage [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_GlobalInvocationID.x] = mod(getB(myStorage, gl_GlobalInvocationID) + 0.0199999995529651641845703125, 1.0); } spirv-cross-2021.01.15/reference/shaders-msl/comp/global-invocation-id.comp000066400000000000000000000012201400026215700263640ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b[1]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(device myBlock& myStorage [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_GlobalInvocationID.x] = mod(myStorage.b[gl_GlobalInvocationID.x] + 0.0199999995529651641845703125, 1.0); } spirv-cross-2021.01.15/reference/shaders-msl/comp/image-atomic-automatic-bindings.argument.msl2.comp000066400000000000000000000031411400026215700331770ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 outdata; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); struct spvDescriptorSetBuffer0 { texture2d uImage [[id(0)]]; device atomic_uint* uImage_atomic [[id(1)]]; device SSBO* m_31 [[id(2)]]; texture2d uTexture [[id(3)]]; sampler uTextureSmplr [[id(4)]]; }; // The required alignment of a linear texture of R32Uint format. constant uint spvLinearTextureAlignmentOverride [[function_constant(65535)]]; constant uint spvLinearTextureAlignment = is_function_constant_defined(spvLinearTextureAlignmentOverride) ? spvLinearTextureAlignmentOverride : 4; // Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics #define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + spvLinearTextureAlignment / 4 - 1) & ~( spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x) kernel void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint _26 = atomic_fetch_add_explicit((device atomic_uint*)&spvDescriptorSet0.uImage_atomic[spvImage2DAtomicCoord(int2(gl_GlobalInvocationID.xy), spvDescriptorSet0.uImage)], 10u, memory_order_relaxed); uint ret = _26; (*spvDescriptorSet0.m_31).outdata = spvDescriptorSet0.uTexture.sample(spvDescriptorSet0.uTextureSmplr, float2(gl_GlobalInvocationID.xy), level(0.0)) + float4(float(ret)); } spirv-cross-2021.01.15/reference/shaders-msl/comp/image-atomic-automatic-bindings.comp000066400000000000000000000026351400026215700305110ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct SSBO { float4 outdata; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); // The required alignment of a linear texture of R32Uint format. constant uint spvLinearTextureAlignmentOverride [[function_constant(65535)]]; constant uint spvLinearTextureAlignment = is_function_constant_defined(spvLinearTextureAlignmentOverride) ? spvLinearTextureAlignmentOverride : 4; // Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics #define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + spvLinearTextureAlignment / 4 - 1) & ~( spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x) kernel void main0(device SSBO& _31 [[buffer(1)]], texture2d uImage [[texture(0)]], device atomic_uint* uImage_atomic [[buffer(0)]], texture2d uTexture [[texture(1)]], sampler uTextureSmplr [[sampler(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint _26 = atomic_fetch_add_explicit((device atomic_uint*)&uImage_atomic[spvImage2DAtomicCoord(int2(gl_GlobalInvocationID.xy), uImage)], 10u, memory_order_relaxed); uint ret = _26; _31.outdata = uTexture.sample(uTextureSmplr, float2(gl_GlobalInvocationID.xy), level(0.0)) + float4(float(ret)); } spirv-cross-2021.01.15/reference/shaders-msl/comp/image-cube-array-load-store.comp000066400000000000000000000007451400026215700275570ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(texturecube_array uImageIn [[texture(0)]], texturecube_array uImageOut [[texture(1)]]) { int3 coord = int3(9, 7, 11); float4 indata = uImageIn.read(uint2(coord.xy), uint(coord.z) % 6u, uint(coord.z) / 6u); uImageOut.write(indata, uint2(coord.xy), uint(coord.z) % 6u, uint(coord.z) / 6u); } spirv-cross-2021.01.15/reference/shaders-msl/comp/image.comp000066400000000000000000000007651400026215700234620ustar00rootroot00000000000000#include #include using namespace metal; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(texture2d uImageIn [[texture(0)]], texture2d uImageOut [[texture(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { float4 v = uImageIn.read(uint2((int2(gl_GlobalInvocationID.xy) + int2(uImageIn.get_width(), uImageIn.get_height())))); uImageOut.write(v, uint2(int2(gl_GlobalInvocationID.xy))); } spirv-cross-2021.01.15/reference/shaders-msl/comp/insert.comp000066400000000000000000000007461400026215700237030ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _27 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { float4 v; v.x = 10.0; v.y = 30.0; v.z = 70.0; v.w = 90.0; _27.out_data[gl_GlobalInvocationID.x] = v; ((device float*)&_27.out_data[gl_GlobalInvocationID.x])[1u] = 20.0; } spirv-cross-2021.01.15/reference/shaders-msl/comp/inverse.comp000066400000000000000000000133701400026215700240470ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct MatrixOut { float2x2 m2out; float3x3 m3out; float4x4 m4out; }; struct MatrixIn { float2x2 m2in; float3x3 m3in; float4x4 m4in; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); // Returns the determinant of a 2x2 matrix. static inline __attribute__((always_inline)) float spvDet2x2(float a1, float a2, float b1, float b2) { return a1 * b2 - b1 * a2; } // Returns the determinant of a 3x3 matrix. static inline __attribute__((always_inline)) float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) { return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3); } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float4x4 spvInverse4x4(float4x4 m) { float4x4 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]); adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]); adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]); adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]); adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]); adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]); adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]); adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] * m[3][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float3x3 spvInverse3x3(float3x3 m) { float3x3 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]); adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]); adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]); adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]); adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]); adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]); adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]); adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]); adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float2x2 spvInverse2x2(float2x2 m) { float2x2 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = m[1][1]; adj[0][1] = -m[0][1]; adj[1][0] = -m[1][0]; adj[1][1] = m[0][0]; // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } kernel void main0(device MatrixOut& _15 [[buffer(0)]], const device MatrixIn& _20 [[buffer(1)]]) { _15.m2out = spvInverse2x2(_20.m2in); _15.m3out = spvInverse3x3(_20.m3in); _15.m4out = spvInverse4x4(_20.m4in); } spirv-cross-2021.01.15/reference/shaders-msl/comp/local-invocation-id.comp000066400000000000000000000012241400026215700262220ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b[1]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(device myBlock& myStorage [[buffer(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_LocalInvocationID.x] = mod(myStorage.b[gl_LocalInvocationID.x] + 0.0199999995529651641845703125, 1.0); } spirv-cross-2021.01.15/reference/shaders-msl/comp/local-invocation-index.comp000066400000000000000000000012251400026215700267360ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b[1]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(device myBlock& myStorage [[buffer(0)]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_LocalInvocationIndex] = mod(myStorage.b[gl_LocalInvocationIndex] + 0.0199999995529651641845703125, 1.0); } spirv-cross-2021.01.15/reference/shaders-msl/comp/mat3.comp000066400000000000000000000006351400026215700232400ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO2 { float3x3 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO2& _22 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; _22.out_data[ident] = float3x3(float3(10.0), float3(20.0), float3(40.0)); } spirv-cross-2021.01.15/reference/shaders-msl/comp/mod.comp000066400000000000000000000017731400026215700231570ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(const device SSBO& _23 [[buffer(0)]], device SSBO2& _33 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; float4 v = mod(_23.in_data[ident], _33.out_data[ident]); _33.out_data[ident] = v; uint4 vu = as_type(_23.in_data[ident]) % as_type(_33.out_data[ident]); _33.out_data[ident] = as_type(vu); int4 vi = as_type(_23.in_data[ident]) % as_type(_33.out_data[ident]); _33.out_data[ident] = as_type(vi); } spirv-cross-2021.01.15/reference/shaders-msl/comp/modf.comp000066400000000000000000000010111400026215700233060ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(const device SSBO& _23 [[buffer(0)]], device SSBO2& _35 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; float4 i; float4 _31 = modf(_23.in_data[ident], i); float4 v = _31; _35.out_data[ident] = v; } spirv-cross-2021.01.15/reference/shaders-msl/comp/outer-product.comp000066400000000000000000000022701400026215700252050ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float2x2 m22; float2x3 m23; float2x4 m24; float3x2 m32; float3x3 m33; float3x4 m34; float4x2 m42; float4x3 m43; float4x4 m44; }; struct ReadSSBO { float2 v2; float3 v3; float4 v4; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _21 [[buffer(0)]], const device ReadSSBO& _26 [[buffer(1)]]) { _21.m22 = float2x2(_26.v2 * _26.v2.x, _26.v2 * _26.v2.y); _21.m23 = float2x3(_26.v3 * _26.v2.x, _26.v3 * _26.v2.y); _21.m24 = float2x4(_26.v4 * _26.v2.x, _26.v4 * _26.v2.y); _21.m32 = float3x2(_26.v2 * _26.v3.x, _26.v2 * _26.v3.y, _26.v2 * _26.v3.z); _21.m33 = float3x3(_26.v3 * _26.v3.x, _26.v3 * _26.v3.y, _26.v3 * _26.v3.z); _21.m34 = float3x4(_26.v4 * _26.v3.x, _26.v4 * _26.v3.y, _26.v4 * _26.v3.z); _21.m42 = float4x2(_26.v2 * _26.v4.x, _26.v2 * _26.v4.y, _26.v2 * _26.v4.z, _26.v2 * _26.v4.w); _21.m43 = float4x3(_26.v3 * _26.v4.x, _26.v3 * _26.v4.y, _26.v3 * _26.v4.z, _26.v3 * _26.v4.w); _21.m44 = float4x4(_26.v4 * _26.v4.x, _26.v4 * _26.v4.y, _26.v4 * _26.v4.z, _26.v4 * _26.v4.w); } spirv-cross-2021.01.15/reference/shaders-msl/comp/packing-test-1.comp000066400000000000000000000011261400026215700251170ustar00rootroot00000000000000#include #include using namespace metal; struct T1 { float3 a; float b; }; struct T1_1 { packed_float3 a; float b; }; struct Buffer0 { T1_1 buf0[1]; }; struct Buffer1 { float buf1[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(32u, 1u, 1u); kernel void main0(device Buffer0& _15 [[buffer(0)]], device Buffer1& _34 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { T1 v; v.a = float3(_15.buf0[0].a); v.b = _15.buf0[0].b; float x = v.b; _34.buf1[gl_GlobalInvocationID.x] = x; } spirv-cross-2021.01.15/reference/shaders-msl/comp/packing-test-2.comp000066400000000000000000000007551400026215700251270ustar00rootroot00000000000000#include #include using namespace metal; struct T1 { packed_float3 a; float b; }; struct Buffer0 { T1 buf0[1]; }; struct Buffer1 { float buf1[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(32u, 1u, 1u); kernel void main0(device Buffer0& _14 [[buffer(0)]], device Buffer1& _24 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { float x = _14.buf0[0].b; _24.buf1[gl_GlobalInvocationID.x] = x; } spirv-cross-2021.01.15/reference/shaders-msl/comp/read-write-only.comp000066400000000000000000000007721400026215700254200ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO2 { float4 data4; float4 data5; }; struct SSBO0 { float4 data0; float4 data1; }; struct SSBO1 { float4 data2; float4 data3; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO2& _10 [[buffer(0)]], const device SSBO0& _15 [[buffer(1)]], device SSBO1& _21 [[buffer(2)]]) { _10.data4 = _15.data0 + _21.data2; _10.data5 = _15.data1 + _21.data3; } spirv-cross-2021.01.15/reference/shaders-msl/comp/rmw-matrix.comp000066400000000000000000000005571400026215700245060ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float a; float4 b; float4x4 c; float a1; float4 b1; float4x4 c1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _11 [[buffer(0)]]) { _11.a *= _11.a1; _11.b *= _11.b1; _11.c = _11.c * _11.c1; } spirv-cross-2021.01.15/reference/shaders-msl/comp/rmw-opt.comp000066400000000000000000000007441400026215700240020ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { int a; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _9 [[buffer(0)]]) { _9.a += 10; _9.a -= 10; _9.a *= 10; _9.a /= 10; _9.a = _9.a << 2; _9.a = _9.a >> 3; _9.a &= 40; _9.a ^= 10; _9.a %= 40; _9.a |= 1; bool c = false; bool d = true; c = c && d; d = d || c; _9.a = int(c && d); } spirv-cross-2021.01.15/reference/shaders-msl/comp/scalar-std450-distance-length-normalize.comp000066400000000000000000000006241400026215700317250ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float a; float b; float c; float d; float e; float f; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _9 [[buffer(0)]]) { _9.c = abs(_9.a - _9.b); _9.d = abs(_9.a); _9.e = sign(_9.a); _9.f = abs((_9.a - 1.0) - (_9.b - 2.0)); } spirv-cross-2021.01.15/reference/shaders-msl/comp/shared-array-of-arrays.comp000066400000000000000000000022571400026215700266610ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(4u, 4u, 1u); static inline __attribute__((always_inline)) void work(threadgroup float (&foo)[4][4], thread uint3& gl_LocalInvocationID, thread uint& gl_LocalInvocationIndex, device SSBO& v_67, thread uint3& gl_GlobalInvocationID) { foo[gl_LocalInvocationID.x][gl_LocalInvocationID.y] = float(gl_LocalInvocationIndex); threadgroup_barrier(mem_flags::mem_threadgroup); float x = 0.0; x += foo[gl_LocalInvocationID.x][0]; x += foo[gl_LocalInvocationID.x][1]; x += foo[gl_LocalInvocationID.x][2]; x += foo[gl_LocalInvocationID.x][3]; v_67.out_data[gl_GlobalInvocationID.x] = x; } kernel void main0(device SSBO& v_67 [[buffer(0)]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { threadgroup float foo[4][4]; work(foo, gl_LocalInvocationID, gl_LocalInvocationIndex, v_67, gl_GlobalInvocationID); } spirv-cross-2021.01.15/reference/shaders-msl/comp/shared.comp000066400000000000000000000013231400026215700236350ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float in_data[1]; }; struct SSBO2 { float out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(4u, 1u, 1u); kernel void main0(const device SSBO& _22 [[buffer(0)]], device SSBO2& _44 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint gl_LocalInvocationIndex [[thread_index_in_threadgroup]]) { threadgroup float sShared[4]; uint ident = gl_GlobalInvocationID.x; float idata = _22.in_data[ident]; sShared[gl_LocalInvocationIndex] = idata; threadgroup_barrier(mem_flags::mem_threadgroup); _44.out_data[ident] = sShared[(4u - gl_LocalInvocationIndex) - 1u]; } spirv-cross-2021.01.15/reference/shaders-msl/comp/spec-constant-op-member-array.comp000066400000000000000000000017761400026215700301610ustar00rootroot00000000000000#include #include using namespace metal; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 100 #endif constant int a = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 200 #endif constant int b = SPIRV_CROSS_CONSTANT_ID_1; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 300 #endif constant int c = SPIRV_CROSS_CONSTANT_ID_2; constant int d = (c + 50); struct SSBO { A member_a; B member_b; int v[a]; int w[d]; }; constant int e_tmp [[function_constant(3)]]; constant int e = is_function_constant_defined(e_tmp) ? e_tmp : 400; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _22 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _22.w[gl_GlobalInvocationID.x] += (_22.v[gl_GlobalInvocationID.x] + e); } spirv-cross-2021.01.15/reference/shaders-msl/comp/spec-constant-work-group-size.comp000066400000000000000000000035301400026215700302340ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 2 #endif constant int b = SPIRV_CROSS_CONSTANT_ID_1; constant int a_tmp [[function_constant(0)]]; constant int a = is_function_constant_defined(a_tmp) ? a_tmp : 1; struct SSBO { int v[1]; }; constant uint _21 = (uint(a) + 0u); constant uint _22_tmp [[function_constant(10)]]; constant uint _22 = is_function_constant_defined(_22_tmp) ? _22_tmp : 1u; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(_22, 20u, 1u); constant uint _27 = gl_WorkGroupSize.x; constant uint _28 = (_21 + _27); constant uint _29 = gl_WorkGroupSize.y; constant uint _30 = (_28 + _29); constant int _32 = (1 - a); kernel void main0(device SSBO& _17 [[buffer(0)]]) { spvUnsafeArray spec_const_array_size; spec_const_array_size[a] = a; _17.v[_30] = b + spec_const_array_size[_32]; } spirv-cross-2021.01.15/reference/shaders-msl/comp/storage-buffer-std140-vector-array.comp000066400000000000000000000052441400026215700307410ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Sub { spvUnsafeArray f; spvUnsafeArray f2; spvUnsafeArray f3; spvUnsafeArray f4; }; struct Sub_1 { float4 f[2]; float4 f2[2]; float3 f3[2]; float4 f4[2]; }; struct SSBO { Sub_1 sub[2]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO& _27 [[buffer(0)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { Sub foo; foo.f[0] = _27.sub[gl_WorkGroupID.x].f[0].x; foo.f[1] = _27.sub[gl_WorkGroupID.x].f[1].x; foo.f2[0] = _27.sub[gl_WorkGroupID.x].f2[0].xy; foo.f2[1] = _27.sub[gl_WorkGroupID.x].f2[1].xy; foo.f3[0] = _27.sub[gl_WorkGroupID.x].f3[0]; foo.f3[1] = _27.sub[gl_WorkGroupID.x].f3[1]; foo.f4[0] = _27.sub[gl_WorkGroupID.x].f4[0]; foo.f4[1] = _27.sub[gl_WorkGroupID.x].f4[1]; foo.f[gl_GlobalInvocationID.x] += 1.0; foo.f2[gl_GlobalInvocationID.x] += float2(2.0); foo.f3[gl_GlobalInvocationID.x] += float3(3.0); foo.f4[gl_GlobalInvocationID.x] += float4(4.0); (device float&)_27.sub[gl_WorkGroupID.x].f[0] = foo.f[0]; (device float&)_27.sub[gl_WorkGroupID.x].f[1] = foo.f[1]; (device float2&)_27.sub[gl_WorkGroupID.x].f2[0] = foo.f2[0]; (device float2&)_27.sub[gl_WorkGroupID.x].f2[1] = foo.f2[1]; _27.sub[gl_WorkGroupID.x].f3[0] = foo.f3[0]; _27.sub[gl_WorkGroupID.x].f3[1] = foo.f3[1]; _27.sub[gl_WorkGroupID.x].f4[0] = foo.f4[0]; _27.sub[gl_WorkGroupID.x].f4[1] = foo.f4[1]; (device float&)_27.sub[0].f[0] = _27.sub[0].f[0].x + 5.0; (device float2&)_27.sub[0].f2[1] = _27.sub[0].f2[1].xy + float2(5.0); } spirv-cross-2021.01.15/reference/shaders-msl/comp/struct-layout.comp000066400000000000000000000010001400026215700252160ustar00rootroot00000000000000#include #include using namespace metal; struct Foo { float4x4 m; }; struct SSBO2 { Foo out_data[1]; }; struct SSBO { Foo in_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO2& _23 [[buffer(0)]], const device SSBO& _30 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; _23.out_data[ident].m = _30.in_data[ident].m * _30.in_data[ident].m; } spirv-cross-2021.01.15/reference/shaders-msl/comp/struct-nested.comp000066400000000000000000000006441400026215700252000ustar00rootroot00000000000000#include #include using namespace metal; struct s1 { int a; }; struct s2 { s1 b; }; struct s1_1 { int a; }; struct s2_1 { s1_1 b; }; struct dstbuffer { s2_1 test[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device dstbuffer& _19 [[buffer(0)]]) { s2 testVal; testVal.b.a = 0; _19.test[0].b.a = testVal.b.a; } spirv-cross-2021.01.15/reference/shaders-msl/comp/struct-packing.comp000066400000000000000000000052151400026215700253310ustar00rootroot00000000000000#include #include using namespace metal; struct S0 { float2 a[1]; float b; char _m0_final_padding[4]; }; struct S1 { packed_float3 a; float b; }; struct S2 { float3 a[1]; float b; char _m0_final_padding[12]; }; struct S3 { float2 a; float b; }; struct S4 { float2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; S4 m3s[8]; char _m0_final_padding[8]; }; struct SSBO1 { Content content; Content content1[2]; Content content2; float2x2 m0; float2x2 m1; float2x3 m2[4]; float3x2 m3; float2x2 m4; float2x2 m5[9]; float3x2 m6[4][2]; float2x3 m7; float array[1]; }; struct S0_1 { float2 a[1]; char _m1_pad[8]; float b; char _m0_final_padding[12]; }; struct S1_1 { packed_float3 a; float b; }; struct S2_1 { float3 a[1]; float b; char _m0_final_padding[12]; }; struct S3_1 { float2 a; float b; }; struct S4_1 { float2 c; char _m0_final_padding[8]; }; struct Content_1 { S0_1 m0s[1]; S1_1 m1s[1]; S2_1 m2s[1]; S0_1 m0; S1_1 m1; S2_1 m2; S3_1 m3; float m4; char _m8_pad[8]; S4_1 m3s[8]; }; struct SSBO0 { Content_1 content; Content_1 content1[2]; Content_1 content2; float4 array[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO1& ssbo_430 [[buffer(0)]], device SSBO0& ssbo_140 [[buffer(1)]]) { Content_1 _60 = ssbo_140.content; ssbo_430.content.m0s[0].a[0] = _60.m0s[0].a[0]; ssbo_430.content.m0s[0].b = _60.m0s[0].b; ssbo_430.content.m1s[0].a = float3(_60.m1s[0].a); ssbo_430.content.m1s[0].b = _60.m1s[0].b; ssbo_430.content.m2s[0].a[0] = _60.m2s[0].a[0]; ssbo_430.content.m2s[0].b = _60.m2s[0].b; ssbo_430.content.m0.a[0] = _60.m0.a[0]; ssbo_430.content.m0.b = _60.m0.b; ssbo_430.content.m1.a = float3(_60.m1.a); ssbo_430.content.m1.b = _60.m1.b; ssbo_430.content.m2.a[0] = _60.m2.a[0]; ssbo_430.content.m2.b = _60.m2.b; ssbo_430.content.m3.a = _60.m3.a; ssbo_430.content.m3.b = _60.m3.b; ssbo_430.content.m4 = _60.m4; ssbo_430.content.m3s[0].c = _60.m3s[0].c; ssbo_430.content.m3s[1].c = _60.m3s[1].c; ssbo_430.content.m3s[2].c = _60.m3s[2].c; ssbo_430.content.m3s[3].c = _60.m3s[3].c; ssbo_430.content.m3s[4].c = _60.m3s[4].c; ssbo_430.content.m3s[5].c = _60.m3s[5].c; ssbo_430.content.m3s[6].c = _60.m3s[6].c; ssbo_430.content.m3s[7].c = _60.m3s[7].c; ssbo_430.content.m1.a = ssbo_430.content.m3.a * ssbo_430.m6[1][1]; } spirv-cross-2021.01.15/reference/shaders-msl/comp/torture-loop.comp000066400000000000000000000016771400026215700250560ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO { float4x4 mvp; float4 in_data[1]; }; struct SSBO2 { float4 out_data[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(const device SSBO& _24 [[buffer(0)]], device SSBO2& _89 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { uint ident = gl_GlobalInvocationID.x; float4 idat = _24.in_data[ident]; int k = 0; for (;;) { int _39 = k; int _40 = _39 + 1; k = _40; if (_40 < 10) { idat *= 2.0; k++; continue; } else { break; } } for (uint i = 0u; i < 16u; i++, k++) { for (uint j = 0u; j < 30u; j++) { idat = _24.mvp * idat; } } do { k++; } while (k > 10); _89.out_data[ident] = idat; } spirv-cross-2021.01.15/reference/shaders-msl/comp/type-alias.comp000066400000000000000000000020351400026215700244400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct S0 { float4 a; }; struct S1 { float4 a; }; struct S0_1 { float4 a; }; struct SSBO0 { S0_1 s0s[1]; }; struct S1_1 { float4 a; }; struct SSBO1 { S1_1 s1s[1]; }; struct SSBO2 { float4 outputs[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); static inline __attribute__((always_inline)) float4 overload(thread const S0& s0) { return s0.a; } static inline __attribute__((always_inline)) float4 overload(thread const S1& s1) { return s1.a; } kernel void main0(device SSBO0& _36 [[buffer(0)]], device SSBO1& _55 [[buffer(1)]], device SSBO2& _66 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { S0 s0; s0.a = _36.s0s[gl_GlobalInvocationID.x].a; S1 s1; s1.a = _55.s1s[gl_GlobalInvocationID.x].a; S0 param = s0; S1 param_1 = s1; _66.outputs[gl_GlobalInvocationID.x] = overload(param) + overload(param_1); } spirv-cross-2021.01.15/reference/shaders-msl/comp/udiv.comp000066400000000000000000000006741400026215700233460ustar00rootroot00000000000000#include #include using namespace metal; struct SSBO2 { uint outputs[1]; }; struct SSBO { uint inputs[1]; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBO2& _10 [[buffer(0)]], device SSBO& _23 [[buffer(1)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) { _10.outputs[gl_GlobalInvocationID.x] = _23.inputs[gl_GlobalInvocationID.x] / 29u; } spirv-cross-2021.01.15/reference/shaders-msl/comp/writable-ssbo.comp000066400000000000000000000010421400026215700251420ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct myBlock { int a; float b; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } kernel void main0(device myBlock& myStorage [[buffer(0)]]) { myStorage.a = (myStorage.a + 1) % 256; myStorage.b = mod(myStorage.b + 0.0199999995529651641845703125, 1.0); } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/000077500000000000000000000000001400026215700232025ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/comp/000077500000000000000000000000001400026215700241405ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/comp/extended-arithmetic.desktop.comp000066400000000000000000000062611400026215700324240ustar00rootroot00000000000000#include #include using namespace metal; struct SSBOUint { uint a; uint b; uint c; uint d; uint2 a2; uint2 b2; uint2 c2; uint2 d2; uint3 a3; uint3 b3; uint3 c3; uint3 d3; uint4 a4; uint4 b4; uint4 c4; uint4 d4; }; struct ResType { uint _m0; uint _m1; }; struct ResType_1 { uint2 _m0; uint2 _m1; }; struct ResType_2 { uint3 _m0; uint3 _m1; }; struct ResType_3 { uint4 _m0; uint4 _m1; }; struct SSBOInt { int a; int b; int c; int d; int2 a2; int2 b2; int2 c2; int2 d2; int3 a3; int3 b3; int3 c3; int3 d3; int4 a4; int4 b4; int4 c4; int4 d4; }; struct ResType_4 { int _m0; int _m1; }; struct ResType_5 { int2 _m0; int2 _m1; }; struct ResType_6 { int3 _m0; int3 _m1; }; struct ResType_7 { int4 _m0; int4 _m1; }; constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u); kernel void main0(device SSBOUint& u [[buffer(0)]], device SSBOInt& i [[buffer(1)]]) { ResType _25; _25._m0 = u.a + u.b; _25._m1 = select(uint(1), uint(0), _25._m0 >= max(u.a, u.b)); u.d = _25._m1; u.c = _25._m0; ResType_1 _40; _40._m0 = u.a2 + u.b2; _40._m1 = select(uint2(1), uint2(0), _40._m0 >= max(u.a2, u.b2)); u.d2 = _40._m1; u.c2 = _40._m0; ResType_2 _55; _55._m0 = u.a3 + u.b3; _55._m1 = select(uint3(1), uint3(0), _55._m0 >= max(u.a3, u.b3)); u.d3 = _55._m1; u.c3 = _55._m0; ResType_3 _70; _70._m0 = u.a4 + u.b4; _70._m1 = select(uint4(1), uint4(0), _70._m0 >= max(u.a4, u.b4)); u.d4 = _70._m1; u.c4 = _70._m0; ResType _79; _79._m0 = u.a - u.b; _79._m1 = select(uint(1), uint(0), u.a >= u.b); u.d = _79._m1; u.c = _79._m0; ResType_1 _88; _88._m0 = u.a2 - u.b2; _88._m1 = select(uint2(1), uint2(0), u.a2 >= u.b2); u.d2 = _88._m1; u.c2 = _88._m0; ResType_2 _97; _97._m0 = u.a3 - u.b3; _97._m1 = select(uint3(1), uint3(0), u.a3 >= u.b3); u.d3 = _97._m1; u.c3 = _97._m0; ResType_3 _106; _106._m0 = u.a4 - u.b4; _106._m1 = select(uint4(1), uint4(0), u.a4 >= u.b4); u.d4 = _106._m1; u.c4 = _106._m0; ResType _116; _116._m0 = u.a * u.b; _116._m1 = mulhi(u.a, u.b); u.d = _116._m0; u.c = _116._m1; ResType_1 _125; _125._m0 = u.a2 * u.b2; _125._m1 = mulhi(u.a2, u.b2); u.d2 = _125._m0; u.c2 = _125._m1; ResType_2 _134; _134._m0 = u.a3 * u.b3; _134._m1 = mulhi(u.a3, u.b3); u.d3 = _134._m0; u.c3 = _134._m1; ResType_3 _143; _143._m0 = u.a4 * u.b4; _143._m1 = mulhi(u.a4, u.b4); u.d4 = _143._m0; u.c4 = _143._m1; ResType_4 _160; _160._m0 = i.a * i.b; _160._m1 = mulhi(i.a, i.b); i.d = _160._m0; i.c = _160._m1; ResType_5 _171; _171._m0 = i.a2 * i.b2; _171._m1 = mulhi(i.a2, i.b2); i.d2 = _171._m0; i.c2 = _171._m1; ResType_6 _182; _182._m0 = i.a3 * i.b3; _182._m1 = mulhi(i.a3, i.b3); i.d3 = _182._m0; i.c3 = _182._m1; ResType_7 _193; _193._m0 = i.a4 * i.b4; _193._m1 = mulhi(i.a4, i.b4); i.d4 = _193._m0; i.c4 = _193._m1; } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/frag/000077500000000000000000000000001400026215700241215ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/frag/image-ms.desktop.frag000066400000000000000000000010031400026215700301230ustar00rootroot00000000000000#include #include using namespace metal; fragment void main0(texture2d_ms uImageMS [[texture(0)]], texture2d_array uImageArray [[texture(1)]], texture2d uImage [[texture(2)]]) { float4 a = uImageMS.read(uint2(int2(1, 2)), 2); float4 b = uImageArray.read(uint2(int3(1, 2, 4).xy), uint(int3(1, 2, 4).z)); uImage.write(a, uint2(int2(2, 3))); uImageArray.write(b, uint2(int3(2, 3, 7).xy), uint(int3(2, 3, 7).z)); } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/frag/query-levels.desktop.frag000066400000000000000000000005371400026215700310740ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = float4(float(int(uSampler.get_num_mip_levels()))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/frag/sampler-ms-query.desktop.frag000066400000000000000000000006521400026215700316600ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d_ms uSampler [[texture(0)]], texture2d_ms uImage [[texture(1)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = float4(float(int(uSampler.get_num_samples()) + int(uImage.get_num_samples()))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/tesc/000077500000000000000000000000001400026215700241405ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/tesc/arrayed-output.desktop.sso.tesc000066400000000000000000000051731400026215700322660ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float3 vVertex; }; struct main0_patchOut { spvUnsafeArray vPatch; }; struct main0_in { float3 vInput [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; gl_out[gl_InvocationID].vVertex = gl_in[gl_InvocationID].vInput + gl_in[gl_InvocationID ^ 1].vInput; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0) { patchOut.vPatch[0] = float3(10.0); patchOut.vPatch[1] = float3(20.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0); } } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/tesc/basic.desktop.sso.multi-patch.tesc000066400000000000000000000036361400026215700326120ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 gl_Position; }; struct main0_patchOut { float3 vFoo; }; struct main0_in { uint3 m_78; ushort2 m_82; float4 gl_Position; }; static inline __attribute__((always_inline)) void set_position(device main0_out* thread & gl_out, thread uint& gl_InvocationID, device main0_in* thread & gl_in) { gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position; } kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 1]; device main0_patchOut& patchOut = spvPatchOut[gl_GlobalInvocationID.x / 1]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 1; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1]); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625); patchOut.vFoo = float3(1.0); set_position(gl_out, gl_InvocationID, gl_in); } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/tesc/basic.desktop.sso.tesc000066400000000000000000000035561400026215700303650ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 gl_Position; }; struct main0_patchOut { float3 vFoo; }; struct main0_in { float4 gl_Position [[attribute(0)]]; }; static inline __attribute__((always_inline)) void set_position(device main0_out* thread & gl_out, thread uint& gl_InvocationID, threadgroup main0_in* thread & gl_in) { gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position; } kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 1]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 1) return; spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625); patchOut.vFoo = float3(1.0); set_position(gl_out, gl_InvocationID, gl_in); } struct-copy.desktop.sso.multi-patch.tesc000066400000000000000000000025731400026215700337450ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/tesc#include #include using namespace metal; struct Boo { float3 a; uint3 b; }; struct main0_out { Boo vVertex; }; struct main0_in { float3 Boo_a; uint3 Boo_b; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); Boo _26 = Boo{ gl_in[gl_InvocationID].Boo_a, gl_in[gl_InvocationID].Boo_b }; gl_out[gl_InvocationID].vVertex = _26; spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0); } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/tesc/struct-copy.desktop.sso.tesc000066400000000000000000000026101400026215700315660ustar00rootroot00000000000000#include #include using namespace metal; struct Boo { float3 a; float3 b; }; struct main0_out { Boo vVertex; }; struct main0_in { float3 Boo_a [[attribute(0)]]; float3 Boo_b [[attribute(1)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; Boo _25 = Boo{ gl_in[gl_InvocationID].Boo_a, gl_in[gl_InvocationID].Boo_b }; gl_out[gl_InvocationID].vVertex = _25; spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0); } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/tese/000077500000000000000000000000001400026215700241425ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/tese/triangle.desktop.sso.tese000066400000000000000000000011401400026215700311000ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 gl_Position [[attribute(0)]]; }; struct main0_patchIn { patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; out.gl_Position = ((patchIn.gl_in[0].gl_Position * gl_TessCoord.x) + (patchIn.gl_in[1].gl_Position * gl_TessCoord.y)) + (patchIn.gl_in[2].gl_Position * gl_TessCoord.z); return out; } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/vert/000077500000000000000000000000001400026215700241625ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/vert/basic.desktop.sso.vert000066400000000000000000000007661400026215700304310ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; return out; } clip-cull-distance..no-user-varying.desktop.vert000066400000000000000000000005431400026215700352550ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/vert#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; }; vertex main0_out main0() { main0_out out = {}; out.gl_Position = float4(10.0); out.gl_ClipDistance[0] = 1.0; out.gl_ClipDistance[1] = 4.0; return out; } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/vert/clip-cull-distance.desktop.vert000066400000000000000000000010451400026215700322100ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; float gl_ClipDistance_0 [[user(clip0)]]; float gl_ClipDistance_1 [[user(clip1)]]; }; vertex main0_out main0() { main0_out out = {}; out.gl_Position = float4(10.0); out.gl_ClipDistance[0] = 1.0; out.gl_ClipDistance[1] = 4.0; out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; out.gl_ClipDistance_1 = out.gl_ClipDistance[1]; return out; } shader-draw-parameters.desktop.for-tess.vert000066400000000000000000000012561400026215700345640ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/vert#include #include using namespace metal; struct main0_out { float4 gl_Position; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 spvStageInputSize [[grid_size]], uint3 spvDispatchBase [[grid_origin]], device main0_out* spvOut [[buffer(28)]]) { device main0_out& out = spvOut[gl_GlobalInvocationID.y * spvStageInputSize.x + gl_GlobalInvocationID.x]; if (any(gl_GlobalInvocationID >= spvStageInputSize)) return; uint gl_BaseVertex = spvDispatchBase.x; uint gl_BaseInstance = spvDispatchBase.y; out.gl_Position = float4(float(int(gl_BaseVertex)), float(int(gl_BaseInstance)), 0.0, 1.0); } spirv-cross-2021.01.15/reference/shaders-msl/desktop-only/vert/shader-draw-parameters.desktop.vert000066400000000000000000000005641400026215700331030ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0(uint gl_BaseVertex [[base_vertex]], uint gl_BaseInstance [[base_instance]]) { main0_out out = {}; out.gl_Position = float4(float(int(gl_BaseVertex)), float(int(gl_BaseInstance)), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/flatten/000077500000000000000000000000001400026215700222075ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/flatten/basic.flatten.vert000066400000000000000000000007661400026215700256370ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; return out; } spirv-cross-2021.01.15/reference/shaders-msl/flatten/multiindex.flatten.vert000066400000000000000000000006351400026215700267330ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 Data[3][5]; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { int2 aIndex [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _20 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _20.Data[in.aIndex.x][in.aIndex.y]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/flatten/push-constant.flatten.vert000066400000000000000000000011011400026215700273440ustar00rootroot00000000000000#include #include using namespace metal; struct PushMe { float4x4 MVP; float2x2 Rot; float Arr[4]; }; struct main0_out { float2 vRot [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float2 Rot [[attribute(0)]]; float4 Pos [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant PushMe& registers [[buffer(0)]]) { main0_out out = {}; out.gl_Position = registers.MVP * in.Pos; out.vRot = (registers.Rot * in.Rot) + float2(registers.Arr[2]); return out; } spirv-cross-2021.01.15/reference/shaders-msl/flatten/rowmajor.flatten.vert000066400000000000000000000010731400026215700264060ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVPR; float4x4 uMVPC; float4x4 uMVP; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]]) { main0_out out = {}; float2 v = float4x2(_18.uMVP[0].xy, _18.uMVP[1].xy, _18.uMVP[2].xy, _18.uMVP[3].xy) * in.aVertex; out.gl_Position = (_18.uMVPR * in.aVertex) + (in.aVertex * _18.uMVPC); return out; } spirv-cross-2021.01.15/reference/shaders-msl/flatten/struct.flatten.vert000066400000000000000000000014321400026215700260710ustar00rootroot00000000000000#include #include using namespace metal; struct Light { packed_float3 Position; float Radius; float4 Color; }; struct UBO { float4x4 uMVP; Light light; }; struct main0_out { float4 vColor [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _18.uMVP * in.aVertex; out.vColor = float4(0.0); float3 L = in.aVertex.xyz - float3(_18.light.Position); out.vColor += ((_18.light.Color * fast::clamp(1.0 - (length(L) / _18.light.Radius), 0.0, 1.0)) * dot(in.aNormal, normalize(L))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/flatten/swizzle.flatten.vert000066400000000000000000000020061400026215700262520ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 A; float2 B0; float2 B1; float C0; float3 C1; packed_float3 D0; float D1; float E0; float E1; float E2; float E3; float F0; float2 F1; float F2; }; struct main0_out { float4 oA [[user(locn0)]]; float4 oB [[user(locn1)]]; float4 oC [[user(locn2)]]; float4 oD [[user(locn3)]]; float4 oE [[user(locn4)]]; float4 oF [[user(locn5)]]; float4 gl_Position [[position]]; }; vertex main0_out main0(constant UBO& _22 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = float4(0.0); out.oA = _22.A; out.oB = float4(_22.B0, _22.B1); out.oC = float4(_22.C0, _22.C1) + float4(_22.C1.xy, _22.C1.z, _22.C0); out.oD = float4(_22.D0[0], _22.D0[1], _22.D0[2], _22.D1) + float4(float2(_22.D0[0], _22.D0[1]), _22.D0[2u], _22.D1); out.oE = float4(_22.E0, _22.E1, _22.E2, _22.E3); out.oF = float4(_22.F0, _22.F1, _22.F2); return out; } spirv-cross-2021.01.15/reference/shaders-msl/flatten/types.flatten.frag000066400000000000000000000010351400026215700256470ustar00rootroot00000000000000#include #include using namespace metal; struct UBO1 { int4 c; int4 d; }; struct UBO2 { uint4 e; uint4 f; }; struct UBO0 { float4 a; float4 b; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant UBO1& _14 [[buffer(0)]], constant UBO2& _29 [[buffer(1)]], constant UBO0& _41 [[buffer(2)]]) { main0_out out = {}; out.FragColor = ((((float4(_14.c) + float4(_14.d)) + float4(_29.e)) + float4(_29.f)) + _41.a) + _41.b; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/000077500000000000000000000000001400026215700214715ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/frag/argument-buffers.msl2.argument.frag000066400000000000000000000062221400026215700303050ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float4 ssbo; }; struct SSBOs { float4 ssbo; }; struct Push { float4 push; }; struct UBO { float4 ubo; }; struct UBOs { float4 ubo; }; struct spvDescriptorSetBuffer0 { texture2d uTexture [[id(0)]]; sampler uTextureSmplr [[id(1)]]; array, 2> uTextures [[id(2)]]; array uTexturesSmplr [[id(4)]]; constant UBO* v_90 [[id(6)]]; }; struct spvDescriptorSetBuffer1 { array, 4> uTexture2 [[id(0)]]; array uSampler [[id(4)]]; device SSBO* v_60 [[id(6)]]; const device SSBOs* ssbos [[id(7)]][2]; }; struct spvDescriptorSetBuffer2 { constant UBOs* ubos [[id(0)]][4]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; static inline __attribute__((always_inline)) float4 sample_in_function2(thread texture2d uTexture, thread const sampler uTextureSmplr, thread float2& vUV, thread const array, 4> uTexture2, thread const array uSampler, thread const array, 2> uTextures, thread const array uTexturesSmplr, device SSBO& v_60, const device SSBOs* constant (&ssbos)[2], constant Push& registers) { float4 ret = uTexture.sample(uTextureSmplr, vUV); ret += uTexture2[2].sample(uSampler[1], vUV); ret += uTextures[1].sample(uTexturesSmplr[1], vUV); ret += v_60.ssbo; ret += ssbos[0]->ssbo; ret += registers.push; return ret; } static inline __attribute__((always_inline)) float4 sample_in_function(thread texture2d uTexture, thread const sampler uTextureSmplr, thread float2& vUV, thread const array, 4> uTexture2, thread const array uSampler, thread const array, 2> uTextures, thread const array uTexturesSmplr, device SSBO& v_60, const device SSBOs* constant (&ssbos)[2], constant Push& registers, constant UBO& v_90, constant UBOs* constant (&ubos)[4]) { float4 ret = sample_in_function2(uTexture, uTextureSmplr, vUV, uTexture2, uSampler, uTextures, uTexturesSmplr, v_60, ssbos, registers); ret += v_90.ubo; ret += ubos[0]->ubo; return ret; } fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], constant spvDescriptorSetBuffer2& spvDescriptorSet2 [[buffer(2)]], constant Push& registers [[buffer(3)]]) { main0_out out = {}; out.FragColor = sample_in_function(spvDescriptorSet0.uTexture, spvDescriptorSet0.uTextureSmplr, in.vUV, spvDescriptorSet1.uTexture2, spvDescriptorSet1.uSampler, spvDescriptorSet0.uTextures, spvDescriptorSet0.uTexturesSmplr, (*spvDescriptorSet1.v_60), spvDescriptorSet1.ssbos, registers, (*spvDescriptorSet0.v_90), spvDescriptorSet2.ubos); out.FragColor += (*spvDescriptorSet0.v_90).ubo; out.FragColor += (*spvDescriptorSet1.v_60).ssbo; out.FragColor += spvDescriptorSet2.ubos[1]->ubo; out.FragColor += registers.push; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/array-lut-no-loop-variable.frag000066400000000000000000000024541400026215700274230ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _17 = spvUnsafeArray({ 1.0, 2.0, 3.0, 4.0, 5.0 }); struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; for (int i = 0; i < 4; i++, out.FragColor += float4(_17[i])) { } return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/array-of-array-lut.frag000066400000000000000000000032141400026215700257700ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _17 = spvUnsafeArray({ 1.0, 2.0, 3.0 }); constant spvUnsafeArray _21 = spvUnsafeArray({ 4.0, 5.0, 6.0 }); constant spvUnsafeArray, 2> _22 = spvUnsafeArray, 2>({ spvUnsafeArray({ 1.0, 2.0, 3.0 }), spvUnsafeArray({ 4.0, 5.0, 6.0 }) }); struct main0_out { float vOutput [[color(0)]]; }; struct main0_in { int vIndex1 [[user(locn0)]]; int vIndex2 [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.vOutput = _22[in.vIndex1][in.vIndex2]; return out; } array-of-texture-swizzle-nonconstant-uniform.msl2.argument.discrete.swizzle.frag000066400000000000000000000067221400026215700412300ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { uint index; }; struct UBO2 { uint index2; }; struct spvDescriptorSetBuffer0 { array, 4> uSampler [[id(0)]]; array uSamplerSmplr [[id(4)]]; constant UBO* uUBO [[id(8)]]; constant UBO2* m_50 [[id(9)]]; constant uint* spvSwizzleConstants [[id(10)]]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } static inline __attribute__((always_inline)) float4 sample_in_func(thread const array, 4> uSampler, thread const array uSamplerSmplr, constant uint* uSamplerSwzl, constant UBO& uUBO, thread float2& vUV) { return spvTextureSwizzle(uSampler[uUBO.index].sample(uSamplerSmplr[uUBO.index], vUV), uSamplerSwzl[uUBO.index]); } static inline __attribute__((always_inline)) float4 sample_single_in_func(thread const texture2d s, thread const sampler sSmplr, constant uint& sSwzl, thread float2& vUV) { return spvTextureSwizzle(s.sample(sSmplr, vUV), sSwzl); } fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant uint* spvSwizzleConstants [[buffer(30)]]) { main0_out out = {}; constant uint* spvDescriptorSet0_uSamplerSwzl = &spvDescriptorSet0.spvSwizzleConstants[0]; out.FragColor = sample_in_func(spvDescriptorSet0.uSampler, spvDescriptorSet0.uSamplerSmplr, spvDescriptorSet0_uSamplerSwzl, (*spvDescriptorSet0.uUBO), in.vUV); out.FragColor += sample_single_in_func(spvDescriptorSet0.uSampler[(*spvDescriptorSet0.m_50).index2], spvDescriptorSet0.uSamplerSmplr[(*spvDescriptorSet0.m_50).index2], spvDescriptorSet0_uSamplerSwzl[(*spvDescriptorSet0.m_50).index2], in.vUV); return out; } array-of-texture-swizzle-nonconstant-uniform.msl2.swizzle.frag000066400000000000000000000061211400026215700355770ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { uint index; }; struct UBO2 { uint index2; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } static inline __attribute__((always_inline)) float4 sample_in_func(thread const array, 4> uSampler, thread const array uSamplerSmplr, constant uint* uSamplerSwzl, constant UBO& uUBO, thread float2& vUV) { return spvTextureSwizzle(uSampler[uUBO.index].sample(uSamplerSmplr[uUBO.index], vUV), uSamplerSwzl[uUBO.index]); } static inline __attribute__((always_inline)) float4 sample_single_in_func(thread const texture2d s, thread const sampler sSmplr, constant uint& sSwzl, thread float2& vUV) { return spvTextureSwizzle(s.sample(sSmplr, vUV), sSwzl); } fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvSwizzleConstants [[buffer(30)]], constant UBO& uUBO [[buffer(0)]], constant UBO2& _50 [[buffer(1)]], array, 4> uSampler [[texture(0)]], array uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; constant uint* uSamplerSwzl = &spvSwizzleConstants[0]; out.FragColor = sample_in_func(uSampler, uSamplerSmplr, uSamplerSwzl, uUBO, in.vUV); out.FragColor += sample_single_in_func(uSampler[_50.index2], uSamplerSmplr[_50.index2], uSamplerSwzl[_50.index2], in.vUV); return out; } array-of-texture-swizzle.msl2.argument.discrete.swizzle.frag000066400000000000000000000074201400026215700352050ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct spvDescriptorSetBuffer0 { array, 4> uSampler0 [[id(0)]]; array uSampler0Smplr [[id(4)]]; constant uint* spvSwizzleConstants [[id(8)]]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } static inline __attribute__((always_inline)) float4 sample_in_func_1(thread const array, 4> uSampler0, thread const array uSampler0Smplr, constant uint* uSampler0Swzl, thread float2& vUV) { return spvTextureSwizzle(uSampler0[2].sample(uSampler0Smplr[2], vUV), uSampler0Swzl[2]); } static inline __attribute__((always_inline)) float4 sample_in_func_2(thread float2& vUV, thread texture2d uSampler1, thread const sampler uSampler1Smplr, constant uint& uSampler1Swzl) { return spvTextureSwizzle(uSampler1.sample(uSampler1Smplr, vUV), uSampler1Swzl); } static inline __attribute__((always_inline)) float4 sample_single_in_func(thread const texture2d s, thread const sampler sSmplr, constant uint& sSwzl, thread float2& vUV) { return spvTextureSwizzle(s.sample(sSmplr, vUV), sSwzl); } fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], constant uint* spvSwizzleConstants [[buffer(30)]], texture2d uSampler1 [[texture(0)]], sampler uSampler1Smplr [[sampler(0)]]) { main0_out out = {}; constant uint* spvDescriptorSet0_uSampler0Swzl = &spvDescriptorSet0.spvSwizzleConstants[0]; constant uint& uSampler1Swzl = spvSwizzleConstants[0]; out.FragColor = sample_in_func_1(spvDescriptorSet0.uSampler0, spvDescriptorSet0.uSampler0Smplr, spvDescriptorSet0_uSampler0Swzl, in.vUV); out.FragColor += sample_in_func_2(in.vUV, uSampler1, uSampler1Smplr, uSampler1Swzl); out.FragColor += sample_single_in_func(spvDescriptorSet0.uSampler0[1], spvDescriptorSet0.uSampler0Smplr[1], spvDescriptorSet0_uSampler0Swzl[1], in.vUV); out.FragColor += sample_single_in_func(uSampler1, uSampler1Smplr, uSampler1Swzl, in.vUV); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/array-of-texture-swizzle.msl2.swizzle.frag000066400000000000000000000055711400026215700316470ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template struct spvRemoveReference { typedef T type; }; template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type& x) { return static_cast(x); } template inline constexpr thread T&& spvForward(thread typename spvRemoveReference::type&& x) { return static_cast(x); } enum class spvSwizzle : uint { none = 0, zero, one, red, green, blue, alpha }; template inline T spvGetSwizzle(vec x, T c, spvSwizzle s) { switch (s) { case spvSwizzle::none: return c; case spvSwizzle::zero: return 0; case spvSwizzle::one: return 1; case spvSwizzle::red: return x.r; case spvSwizzle::green: return x.g; case spvSwizzle::blue: return x.b; case spvSwizzle::alpha: return x.a; } } // Wrapper function that swizzles texture samples and fetches. template inline vec spvTextureSwizzle(vec x, uint s) { if (!s) return x; return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) & 0xFF)), spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF))); } template inline T spvTextureSwizzle(T x, uint s) { return spvTextureSwizzle(vec(x, 0, 0, 1), s).x; } static inline __attribute__((always_inline)) float4 sample_in_func(thread const array, 4> uSampler, thread const array uSamplerSmplr, constant uint* uSamplerSwzl, thread float2& vUV) { return spvTextureSwizzle(uSampler[2].sample(uSamplerSmplr[2], vUV), uSamplerSwzl[2]); } static inline __attribute__((always_inline)) float4 sample_single_in_func(thread const texture2d s, thread const sampler sSmplr, constant uint& sSwzl, thread float2& vUV) { return spvTextureSwizzle(s.sample(sSmplr, vUV), sSwzl); } fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvSwizzleConstants [[buffer(30)]], array, 4> uSampler [[texture(0)]], array uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; constant uint* uSamplerSwzl = &spvSwizzleConstants[0]; out.FragColor = sample_in_func(uSampler, uSamplerSmplr, uSamplerSwzl, in.vUV); out.FragColor += sample_single_in_func(uSampler[1], uSamplerSmplr[1], uSamplerSwzl[1], in.vUV); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/barycentric-nv-nopersp.msl22.frag000066400000000000000000000013361400026215700277050ustar00rootroot00000000000000#include #include using namespace metal; struct Vertices { float2 uvs[1]; }; struct main0_out { float2 value [[color(0)]]; }; struct main0_in { float3 gl_BaryCoordNoPerspNV [[barycentric_coord, center_no_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device Vertices& _19 [[buffer(0)]], uint gl_PrimitiveID [[primitive_id]]) { main0_out out = {}; int prim = int(gl_PrimitiveID); float2 uv0 = _19.uvs[(3 * prim) + 0]; float2 uv1 = _19.uvs[(3 * prim) + 1]; float2 uv2 = _19.uvs[(3 * prim) + 2]; out.value = ((uv0 * in.gl_BaryCoordNoPerspNV.x) + (uv1 * in.gl_BaryCoordNoPerspNV.y)) + (uv2 * in.gl_BaryCoordNoPerspNV.z); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/barycentric-nv.msl22.frag000066400000000000000000000012771400026215700262250ustar00rootroot00000000000000#include #include using namespace metal; struct Vertices { float2 uvs[1]; }; struct main0_out { float2 value [[color(0)]]; }; struct main0_in { float3 gl_BaryCoordNV [[barycentric_coord, center_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device Vertices& _19 [[buffer(0)]], uint gl_PrimitiveID [[primitive_id]]) { main0_out out = {}; int prim = int(gl_PrimitiveID); float2 uv0 = _19.uvs[(3 * prim) + 0]; float2 uv1 = _19.uvs[(3 * prim) + 1]; float2 uv2 = _19.uvs[(3 * prim) + 2]; out.value = ((uv0 * in.gl_BaryCoordNV.x) + (uv1 * in.gl_BaryCoordNV.y)) + (uv2 * in.gl_BaryCoordNV.z); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/basic.force-sample.frag000066400000000000000000000007451400026215700257750ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; out.FragColor = in.vColor * uTex.sample(uTexSmplr, in.vTex); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/basic.frag000066400000000000000000000007051400026215700234150ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = in.vColor * uTex.sample(uTexSmplr, in.vTex); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/binary-func-unpack-pack-arguments.frag000066400000000000000000000006431400026215700307500ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { packed_float3 color; float v; }; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vIn [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant UBO& _15 [[buffer(0)]]) { main0_out out = {}; out.FragColor = dot(in.vIn, float3(_15.color)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/binary-unpack-pack-arguments.frag000066400000000000000000000006571400026215700300240ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { packed_float3 color; float v; }; struct main0_out { float3 FragColor [[color(0)]]; }; struct main0_in { float3 vIn [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant UBO& _15 [[buffer(0)]]) { main0_out out = {}; out.FragColor = cross(in.vIn, float3(_15.color) - in.vIn); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/bitcasting.1d-as-2d.frag000066400000000000000000000020161400026215700256670ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor0 [[color(0)]]; float4 FragColor1 [[color(1)]]; }; struct main0_in { float4 VertGeom [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d TextureBase [[texture(0)]], texture2d TextureDetail [[texture(1)]], sampler TextureBaseSmplr [[sampler(0)]], sampler TextureDetailSmplr [[sampler(1)]]) { main0_out out = {}; float4 texSample0 = TextureBase.sample(TextureBaseSmplr, float2(in.VertGeom.x, 0.5)); float4 texSample1 = TextureDetail.sample(TextureDetailSmplr, float2(in.VertGeom.x, 0.5), int2(3, 0)); int4 iResult0 = as_type(texSample0); int4 iResult1 = as_type(texSample1); out.FragColor0 = as_type(iResult0) * as_type(iResult1); uint4 uResult0 = as_type(texSample0); uint4 uResult1 = as_type(texSample1); out.FragColor1 = as_type(uResult0) * as_type(uResult1); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/bitcasting.frag000066400000000000000000000017661400026215700244730ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor0 [[color(0)]]; float4 FragColor1 [[color(1)]]; }; struct main0_in { float4 VertGeom [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d TextureBase [[texture(0)]], texture2d TextureDetail [[texture(1)]], sampler TextureBaseSmplr [[sampler(0)]], sampler TextureDetailSmplr [[sampler(1)]]) { main0_out out = {}; float4 texSample0 = TextureBase.sample(TextureBaseSmplr, in.VertGeom.xy); float4 texSample1 = TextureDetail.sample(TextureDetailSmplr, in.VertGeom.xy, int2(3, 2)); int4 iResult0 = as_type(texSample0); int4 iResult1 = as_type(texSample1); out.FragColor0 = as_type(iResult0) * as_type(iResult1); uint4 uResult0 = as_type(texSample0); uint4 uResult1 = as_type(texSample1); out.FragColor1 = as_type(uResult0) * as_type(uResult1); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/buffer-read-write.frag000066400000000000000000000013021400026215700256400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } fragment main0_out main0(texture2d buf [[texture(0)]], texture2d bufOut [[texture(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = buf.read(spvTexelBufferCoord(0)); bufOut.write(out.FragColor, spvTexelBufferCoord(int(gl_FragCoord.x))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/buffer-read-write.texture-buffer-native.msl21.frag000066400000000000000000000006631400026215700330400ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture_buffer buf [[texture(0)]], texture_buffer bufOut [[texture(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = buf.read(uint(0)); bufOut.write(out.FragColor, uint(int(gl_FragCoord.x))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/builtins.frag000066400000000000000000000006561400026215700241720ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; float gl_FragDepth [[depth(any)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = gl_FragCoord + in.vColor; out.gl_FragDepth = 0.5; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/clip-distance-varying.frag000066400000000000000000000027451400026215700265360ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float gl_ClipDistance_0 [[user(clip0)]]; float gl_ClipDistance_1 [[user(clip1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray gl_ClipDistance = {}; gl_ClipDistance[0] = in.gl_ClipDistance_0; gl_ClipDistance[1] = in.gl_ClipDistance_1; out.FragColor = float4((1.0 - gl_ClipDistance[0]) - gl_ClipDistance[1]); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/complex-expression-in-access-chain.frag000066400000000000000000000012771400026215700311300ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 results[1024]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int vIn [[user(locn0)]]; int vIn2 [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], device UBO& _34 [[buffer(0)]], texture2d Buf [[texture(0)]], sampler BufSmplr [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; int4 coords = Buf.read(uint2(int2(gl_FragCoord.xy)), 0); float4 foo = _34.results[coords.x % 16]; int c = in.vIn * in.vIn; int d = in.vIn2 * in.vIn2; out.FragColor = (foo + foo) + _34.results[c + d]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/composite-extract-forced-temporary.frag000066400000000000000000000007131400026215700312650ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vTexCoord [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d Texture [[texture(0)]], sampler TextureSmplr [[sampler(0)]]) { main0_out out = {}; float f = Texture.sample(TextureSmplr, in.vTexCoord).x; out.FragColor = float4(f * f); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/constant-array.frag000066400000000000000000000042611400026215700253020ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Foobar { float a; float b; }; constant spvUnsafeArray _37 = spvUnsafeArray({ float4(1.0), float4(2.0), float4(3.0) }); constant spvUnsafeArray _49 = spvUnsafeArray({ float4(1.0), float4(2.0) }); constant spvUnsafeArray _54 = spvUnsafeArray({ float4(8.0), float4(10.0) }); constant spvUnsafeArray, 2> _55 = spvUnsafeArray, 2>({ spvUnsafeArray({ float4(1.0), float4(2.0) }), spvUnsafeArray({ float4(8.0), float4(10.0) }) }); constant spvUnsafeArray _75 = spvUnsafeArray({ Foobar{ 10.0, 40.0 }, Foobar{ 90.0, 70.0 } }); struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int index [[user(locn0)]]; }; static inline __attribute__((always_inline)) float4 resolve(thread const Foobar& f) { return float4(f.a + f.b); } fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; Foobar param = Foobar{ 10.0, 20.0 }; Foobar param_1 = _75[in.index]; out.FragColor = ((_37[in.index] + _55[in.index][in.index + 1]) + resolve(param)) + resolve(param_1); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/constant-composites.frag000066400000000000000000000030451400026215700263500ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Foo { float a; float b; }; constant spvUnsafeArray _16 = spvUnsafeArray({ 1.0, 4.0, 3.0, 2.0 }); struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int line [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { spvUnsafeArray _28 = spvUnsafeArray({ Foo{ 10.0, 20.0 }, Foo{ 30.0, 40.0 } }); main0_out out = {}; out.FragColor = float4(_16[in.line]); out.FragColor += float4(_28[in.line].a * _28[1 - in.line].a); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/control-dependent-in-branch.desktop.frag000066400000000000000000000020771400026215700312730ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vInput [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = in.vInput; float4 t = uSampler.sample(uSamplerSmplr, in.vInput.xy); float4 d0 = dfdx(in.vInput); float4 d1 = dfdy(in.vInput); float4 d2 = fwidth(in.vInput); float4 d3 = dfdx(in.vInput); float4 d4 = dfdy(in.vInput); float4 d5 = fwidth(in.vInput); float4 d6 = dfdx(in.vInput); float4 d7 = dfdy(in.vInput); float4 d8 = fwidth(in.vInput); if (in.vInput.y > 10.0) { out.FragColor += t; out.FragColor += d0; out.FragColor += d1; out.FragColor += d2; out.FragColor += d3; out.FragColor += d4; out.FragColor += d5; out.FragColor += d6; out.FragColor += d7; out.FragColor += d8; } return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/depth-greater-than.frag000066400000000000000000000003561400026215700260210ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float gl_FragDepth [[depth(greater)]]; }; fragment main0_out main0() { main0_out out = {}; out.gl_FragDepth = 0.5; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/depth-less-than.frag000066400000000000000000000003531400026215700253330ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float gl_FragDepth [[depth(less)]]; }; fragment main0_out main0() { main0_out out = {}; out.gl_FragDepth = 0.5; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/disable-frag-output.frag-output.frag000066400000000000000000000014121400026215700304620ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 buf1 [[color(1)]]; float4 buf3 [[color(3)]]; float4 buf6 [[color(6)]]; float4 buf7 [[color(7)]]; }; fragment main0_out main0() { float4 buf0; float4 buf2; float4 buf4; float4 buf5; float gl_FragDepth; int gl_FragStencilRefARB; main0_out out = {}; buf0 = float4(0.0, 0.0, 0.0, 1.0); out.buf1 = float4(1.0, 0.0, 0.0, 1.0); buf2 = float4(0.0, 1.0, 0.0, 1.0); out.buf3 = float4(0.0, 0.0, 1.0, 1.0); buf4 = float4(1.0, 0.0, 1.0, 0.5); buf5 = float4(0.25); out.buf6 = float4(0.75); out.buf7 = float4(1.0); gl_FragDepth = 0.89999997615814208984375; gl_FragStencilRefARB = uint(127); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/dual-source-blending.frag000066400000000000000000000005071400026215700263370ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor0 [[color(0), index(0)]]; float4 FragColor1 [[color(0), index(1)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor0 = float4(1.0); out.FragColor1 = float4(2.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/early-fragment-tests.frag000066400000000000000000000004061400026215700264070ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; [[ early_fragment_tests ]] fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/false-loop-init.frag000066400000000000000000000010231400026215700253300ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 result [[color(0)]]; }; struct main0_in { float4 accum [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.result = float4(0.0); uint j; for (int i = 0; i < 4; i += int(j)) { if (in.accum.y > 10.0) { j = 40u; } else { j = 30u; } out.result += in.accum; } return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/flush_params.frag000066400000000000000000000011061400026215700250140ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Structy { float4 c; }; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) void foo2(thread Structy& f) { f.c = float4(10.0); } static inline __attribute__((always_inline)) Structy foo() { Structy param; foo2(param); Structy f = param; return f; } fragment main0_out main0() { main0_out out = {}; Structy s = foo(); out.FragColor = s.c; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/for-loop-continue-control-flow.frag000066400000000000000000000012401400026215700303310ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(0.0); int i = 0; int _36; for (;;) { if (i < 3) { int a = i; out.FragColor[a] += float(i); if (false) { _36 = 1; } else { int _41 = i; i = _41 + 1; _36 = _41; } continue; } else { break; } } return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/for-loop-init.frag000066400000000000000000000016571400026215700250410ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { int FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = 16; for (int i = 0; i < 25; i++) { out.FragColor += 10; } for (int i_1 = 1, j = 4; i_1 < 30; i_1++, j += 4) { out.FragColor += 11; } int k = 0; for (; k < 20; k++) { out.FragColor += 12; } k += 3; out.FragColor += k; int l; if (k == 40) { l = 0; for (; l < 40; l++) { out.FragColor += 13; } return out; } else { l = k; out.FragColor += l; } int2 i_2 = int2(0); for (; i_2.x < 10; i_2.x += 4) { out.FragColor += i_2.y; } int o = k; for (int m = k; m < 40; m++) { out.FragColor += m; } out.FragColor += o; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/fp16-packing.frag000066400000000000000000000006771400026215700245320ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float2 FP32Out [[color(0)]]; uint FP16Out [[color(1)]]; }; struct main0_in { uint FP16 [[user(locn0)]]; float2 FP32 [[user(locn1), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FP32Out = float2(as_type(in.FP16)); out.FP16Out = as_type(half2(in.FP32)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/fragment-component-padding.pad-fragment.frag000066400000000000000000000037001400026215700321050ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColors_0 [[color(0)]]; float4 FragColors_1 [[color(1)]]; float4 FragColor2 [[color(2)]]; float4 FragColor3 [[color(3)]]; }; struct main0_in { float3 vColor [[user(locn0)]]; }; static inline __attribute__((always_inline)) void set_globals(thread spvUnsafeArray (&FragColors), thread float3& vColor, thread float2& FragColor2, thread float3& FragColor3) { FragColors[0] = vColor.x; FragColors[1] = vColor.y; FragColor2 = vColor.xz; FragColor3 = vColor.zzz; } fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray FragColors = {}; float2 FragColor2 = {}; float3 FragColor3 = {}; set_globals(FragColors, in.vColor, FragColor2, FragColor3); out.FragColors_0 = float4(FragColors[0]); out.FragColors_1 = float4(FragColors[1]); out.FragColor2.xy = FragColor2; out.FragColor3.xyz = FragColor3; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/front-facing.frag000066400000000000000000000007231400026215700247110ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vA [[user(locn0)]]; float4 vB [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], bool gl_FrontFacing [[front_facing]]) { main0_out out = {}; if (gl_FrontFacing) { out.FragColor = in.vA; } else { out.FragColor = in.vB; } return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/gather-dref.frag000066400000000000000000000006371400026215700245300ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d uT [[texture(0)]], sampler uTSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = uT.gather_compare(uTSmplr, in.vUV.xy, in.vUV.z); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/gather-offset.frag000066400000000000000000000005301400026215700250660ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uT [[texture(0)]], sampler uTSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = uT.gather(uTSmplr, float2(0.5), int2(0), component::w); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/helper-invocation.msl21.frag000066400000000000000000000016421400026215700267200ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; static inline __attribute__((always_inline)) float4 foo(thread bool& gl_HelperInvocation, thread texture2d uSampler, thread const sampler uSamplerSmplr, thread float2& vUV) { float4 color; if (!gl_HelperInvocation) { color = uSampler.sample(uSamplerSmplr, vUV, level(0.0)); } else { color = float4(1.0); } return color; } fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; bool gl_HelperInvocation = simd_is_helper_thread(); out.FragColor = foo(gl_HelperInvocation, uSampler, uSamplerSmplr, in.vUV); return out; } huge-argument-buffer.device-argument-buffer.argument.msl2.frag000066400000000000000000000031531400026215700353160ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4 v; }; struct spvDescriptorSetBuffer0 { array, 10000> uSamplers [[id(0)]]; array uSamplersSmplr [[id(10000)]]; }; struct spvDescriptorSetBuffer1 { constant UBO* vs [[id(0)]][10000]; }; struct spvDescriptorSetBuffer2 { texture2d uSampler [[id(0)]]; sampler uSamplerSmplr [[id(1)]]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vUV [[user(locn0)]]; }; static inline __attribute__((always_inline)) float4 samp_array(thread const array, 10000> uSamplers, thread const array uSamplersSmplr, thread float2& vUV, constant UBO* const device (&vs)[10000]) { return uSamplers[9999].sample(uSamplersSmplr[9999], vUV) + vs[5000]->v; } static inline __attribute__((always_inline)) float4 samp_single(thread float2& vUV, thread texture2d uSampler, thread const sampler uSamplerSmplr) { return uSampler.sample(uSamplerSmplr, vUV); } fragment main0_out main0(main0_in in [[stage_in]], const device spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], const device spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(1)]], constant spvDescriptorSetBuffer2& spvDescriptorSet2 [[buffer(2)]]) { main0_out out = {}; out.FragColor = samp_array(spvDescriptorSet0.uSamplers, spvDescriptorSet0.uSamplersSmplr, in.vUV, spvDescriptorSet1.vs) + samp_single(in.vUV, spvDescriptorSet2.uSampler, spvDescriptorSet2.uSamplerSmplr); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/illegal-name-test-0.frag000066400000000000000000000006331400026215700257750ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; float4 fragment0 = float4(10.0); float4 compute0 = float4(10.0); float4 kernel0 = float4(10.0); float4 vertex0 = float4(10.0); out.FragColor = ((fragment0 + compute0) + kernel0) + vertex0; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/image-query-lod.msl22.frag000066400000000000000000000070221400026215700262720ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float2 FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; static inline __attribute__((always_inline)) void from_function(thread float2& FragColor, thread texture2d uSampler2D, thread const sampler uSampler2DSmplr, thread float3& vUV, thread texture3d uSampler3D, thread const sampler uSampler3DSmplr, thread texturecube uSamplerCube, thread const sampler uSamplerCubeSmplr, thread texture2d uTexture2D, thread sampler uSampler, thread texture3d uTexture3D, thread texturecube uTextureCube) { float2 _22; _22.x = uSampler2D.calculate_clamped_lod(uSampler2DSmplr, vUV.xy); _22.y = uSampler2D.calculate_unclamped_lod(uSampler2DSmplr, vUV.xy); FragColor += _22; float2 _31; _31.x = uSampler3D.calculate_clamped_lod(uSampler3DSmplr, vUV); _31.y = uSampler3D.calculate_unclamped_lod(uSampler3DSmplr, vUV); FragColor += _31; float2 _40; _40.x = uSamplerCube.calculate_clamped_lod(uSamplerCubeSmplr, vUV); _40.y = uSamplerCube.calculate_unclamped_lod(uSamplerCubeSmplr, vUV); FragColor += _40; float2 _53; _53.x = uTexture2D.calculate_clamped_lod(uSampler, vUV.xy); _53.y = uTexture2D.calculate_unclamped_lod(uSampler, vUV.xy); FragColor += _53; float2 _62; _62.x = uTexture3D.calculate_clamped_lod(uSampler, vUV); _62.y = uTexture3D.calculate_unclamped_lod(uSampler, vUV); FragColor += _62; float2 _71; _71.x = uTextureCube.calculate_clamped_lod(uSampler, vUV); _71.y = uTextureCube.calculate_unclamped_lod(uSampler, vUV); FragColor += _71; } fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler2D [[texture(0)]], texture3d uSampler3D [[texture(1)]], texturecube uSamplerCube [[texture(2)]], texture2d uTexture2D [[texture(3)]], texture3d uTexture3D [[texture(4)]], texturecube uTextureCube [[texture(5)]], sampler uSampler2DSmplr [[sampler(0)]], sampler uSampler3DSmplr [[sampler(1)]], sampler uSamplerCubeSmplr [[sampler(2)]], sampler uSampler [[sampler(3)]]) { main0_out out = {}; out.FragColor = float2(0.0); float2 _79; _79.x = uSampler2D.calculate_clamped_lod(uSampler2DSmplr, in.vUV.xy); _79.y = uSampler2D.calculate_unclamped_lod(uSampler2DSmplr, in.vUV.xy); out.FragColor += _79; float2 _84; _84.x = uSampler3D.calculate_clamped_lod(uSampler3DSmplr, in.vUV); _84.y = uSampler3D.calculate_unclamped_lod(uSampler3DSmplr, in.vUV); out.FragColor += _84; float2 _89; _89.x = uSamplerCube.calculate_clamped_lod(uSamplerCubeSmplr, in.vUV); _89.y = uSamplerCube.calculate_unclamped_lod(uSamplerCubeSmplr, in.vUV); out.FragColor += _89; float2 _97; _97.x = uTexture2D.calculate_clamped_lod(uSampler, in.vUV.xy); _97.y = uTexture2D.calculate_unclamped_lod(uSampler, in.vUV.xy); out.FragColor += _97; float2 _104; _104.x = uTexture3D.calculate_clamped_lod(uSampler, in.vUV); _104.y = uTexture3D.calculate_unclamped_lod(uSampler, in.vUV); out.FragColor += _104; float2 _111; _111.x = uTextureCube.calculate_clamped_lod(uSampler, in.vUV); _111.y = uTextureCube.calculate_unclamped_lod(uSampler, in.vUV); out.FragColor += _111; from_function(out.FragColor, uSampler2D, uSampler2DSmplr, in.vUV, uSampler3D, uSampler3DSmplr, uSamplerCube, uSamplerCubeSmplr, uTexture2D, uSampler, uTexture3D, uTextureCube); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/in_block.frag000066400000000000000000000010521400026215700241100ustar00rootroot00000000000000#include #include using namespace metal; struct VertexOut { float4 color; float4 color2; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 VertexOut_color [[user(locn2)]]; float4 VertexOut_color2 [[user(locn3)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; VertexOut inputs = {}; inputs.color = in.VertexOut_color; inputs.color2 = in.VertexOut_color2; out.FragColor = inputs.color + inputs.color2; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/in_mat.frag000066400000000000000000000021111400026215700235740ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 outFragColor [[color(0)]]; }; struct main0_in { float3 inPos [[user(locn0)]]; float3 inNormal [[user(locn1)]]; float4 inInvModelView_0 [[user(locn2)]]; float4 inInvModelView_1 [[user(locn3)]]; float4 inInvModelView_2 [[user(locn4)]]; float4 inInvModelView_3 [[user(locn5)]]; float inLodBias [[user(locn6)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texturecube samplerColor [[texture(0)]], sampler samplerColorSmplr [[sampler(0)]]) { main0_out out = {}; float4x4 inInvModelView = {}; inInvModelView[0] = in.inInvModelView_0; inInvModelView[1] = in.inInvModelView_1; inInvModelView[2] = in.inInvModelView_2; inInvModelView[3] = in.inInvModelView_3; float3 cI = normalize(in.inPos); float3 cR = reflect(cI, normalize(in.inNormal)); cR = float3((inInvModelView * float4(cR, 0.0)).xyz); cR.x *= (-1.0); out.outFragColor = samplerColor.sample(samplerColorSmplr, cR, bias(in.inLodBias)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/input-attachment-ms.arrayed-subpass.msl21.frag000066400000000000000000000017731400026215700323050ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 load_subpasses(thread const texture2d_ms_array uInput, thread uint& gl_SampleID, thread float4& gl_FragCoord, thread uint& gl_Layer) { float4 _24 = uInput.read(uint2(gl_FragCoord.xy), gl_Layer, gl_SampleID); return _24; } fragment main0_out main0(texture2d_ms_array uSubpass0 [[texture(0)]], texture2d_ms_array uSubpass1 [[texture(1)]], uint gl_SampleID [[sample_id]], float4 gl_FragCoord [[position]], uint gl_Layer [[render_target_array_index]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; out.FragColor = (uSubpass0.read(uint2(gl_FragCoord.xy), gl_Layer, 1) + uSubpass1.read(uint2(gl_FragCoord.xy), gl_Layer, 2)) + load_subpasses(uSubpass0, gl_SampleID, gl_FragCoord, gl_Layer); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/input-attachment-ms.frag000066400000000000000000000015751400026215700262440ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 load_subpasses(thread const texture2d_ms uInput, thread uint& gl_SampleID, thread float4& gl_FragCoord) { float4 _24 = uInput.read(uint2(gl_FragCoord.xy), gl_SampleID); return _24; } fragment main0_out main0(texture2d_ms uSubpass0 [[texture(0)]], texture2d_ms uSubpass1 [[texture(1)]], uint gl_SampleID [[sample_id]], float4 gl_FragCoord [[position]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; out.FragColor = (uSubpass0.read(uint2(gl_FragCoord.xy), 1) + uSubpass1.read(uint2(gl_FragCoord.xy), 2)) + load_subpasses(uSubpass0, gl_SampleID, gl_FragCoord); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/input-attachment-ms.multiview.msl21.frag000066400000000000000000000021421400026215700312140ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 load_subpasses(thread const texture2d_ms_array uInput, thread uint& gl_SampleID, thread float4& gl_FragCoord, thread uint& gl_ViewIndex) { float4 _24 = uInput.read(uint2(gl_FragCoord.xy), gl_ViewIndex, gl_SampleID); return _24; } fragment main0_out main0(constant uint* spvViewMask [[buffer(24)]], texture2d_ms_array uSubpass0 [[texture(0)]], texture2d_ms_array uSubpass1 [[texture(1)]], uint gl_SampleID [[sample_id]], float4 gl_FragCoord [[position]], uint gl_ViewIndex [[render_target_array_index]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; gl_ViewIndex += spvViewMask[0]; out.FragColor = (uSubpass0.read(uint2(gl_FragCoord.xy), gl_ViewIndex, 1) + uSubpass1.read(uint2(gl_FragCoord.xy), gl_ViewIndex, 2)) + load_subpasses(uSubpass0, gl_SampleID, gl_FragCoord, gl_ViewIndex); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/input-attachment.arrayed-subpass.frag000066400000000000000000000014161400026215700307250ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 load_subpasses(thread const texture2d_array uInput, thread float4& gl_FragCoord, thread uint& gl_Layer) { return uInput.read(uint2(gl_FragCoord.xy), gl_Layer); } fragment main0_out main0(texture2d_array uSubpass0 [[texture(0)]], texture2d_array uSubpass1 [[texture(1)]], float4 gl_FragCoord [[position]], uint gl_Layer [[render_target_array_index]]) { main0_out out = {}; out.FragColor = uSubpass0.read(uint2(gl_FragCoord.xy), gl_Layer) + load_subpasses(uSubpass1, gl_FragCoord, gl_Layer); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/input-attachment.frag000066400000000000000000000012321400026215700256150ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 load_subpasses(thread const texture2d uInput, thread float4& gl_FragCoord) { return uInput.read(uint2(gl_FragCoord.xy)); } fragment main0_out main0(texture2d uSubpass0 [[texture(0)]], texture2d uSubpass1 [[texture(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = uSubpass0.read(uint2(gl_FragCoord.xy)) + load_subpasses(uSubpass1, gl_FragCoord); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/input-attachment.multiview.frag000066400000000000000000000015611400026215700276460ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 load_subpasses(thread const texture2d_array uInput, thread float4& gl_FragCoord, thread uint& gl_ViewIndex) { return uInput.read(uint2(gl_FragCoord.xy), gl_ViewIndex); } fragment main0_out main0(constant uint* spvViewMask [[buffer(24)]], texture2d_array uSubpass0 [[texture(0)]], texture2d_array uSubpass1 [[texture(1)]], float4 gl_FragCoord [[position]], uint gl_ViewIndex [[render_target_array_index]]) { main0_out out = {}; gl_ViewIndex += spvViewMask[0]; out.FragColor = uSubpass0.read(uint2(gl_FragCoord.xy), gl_ViewIndex) + load_subpasses(uSubpass1, gl_FragCoord, gl_ViewIndex); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/interpolation-qualifiers-block.frag000066400000000000000000000021171400026215700304540ustar00rootroot00000000000000#include #include using namespace metal; struct Input { float2 v0; float2 v1; float3 v2; float4 v3; float v4; float v5; float v6; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 Input_v0 [[user(locn0), centroid_no_perspective]]; float2 Input_v1 [[user(locn1), centroid_no_perspective]]; float3 Input_v2 [[user(locn2), centroid_no_perspective]]; float4 Input_v3 [[user(locn3), centroid_no_perspective]]; float Input_v4 [[user(locn4), centroid_no_perspective]]; float Input_v5 [[user(locn5), centroid_no_perspective]]; float Input_v6 [[user(locn6), centroid_no_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; Input inp = {}; inp.v0 = in.Input_v0; inp.v1 = in.Input_v1; inp.v2 = in.Input_v2; inp.v3 = in.Input_v3; inp.v4 = in.Input_v4; inp.v5 = in.Input_v5; inp.v6 = in.Input_v6; out.FragColor = float4(inp.v0.x + inp.v1.y, inp.v2.xy, ((inp.v3.w * inp.v4) + inp.v5) - inp.v6); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/interpolation-qualifiers.frag000066400000000000000000000012431400026215700273630ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 v0 [[user(locn0)]]; float2 v1 [[user(locn1), center_no_perspective]]; float3 v2 [[user(locn2), centroid_perspective]]; float4 v3 [[user(locn3), centroid_no_perspective]]; float v4 [[user(locn4), sample_perspective]]; float v5 [[user(locn5), sample_no_perspective]]; float v6 [[user(locn6), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = float4(in.v0.x + in.v1.y, in.v2.xy, ((in.v3.w * in.v4) + in.v5) - in.v6); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/lut-promotion.frag000066400000000000000000000044771400026215700251760ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _16 = spvUnsafeArray({ 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0 }); constant spvUnsafeArray _60 = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); constant spvUnsafeArray _104 = spvUnsafeArray({ float4(20.0), float4(30.0), float4(50.0), float4(60.0) }); struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { int index [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = _16[in.index]; if (in.index < 10) { out.FragColor += _16[in.index ^ 1]; } else { out.FragColor += _16[in.index & 1]; } if (in.index > 30) { out.FragColor += _60[in.index & 3].y; } else { out.FragColor += _60[in.index & 1].x; } spvUnsafeArray foobar = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); if (in.index > 30) { foobar[1].z = 20.0; } out.FragColor += foobar[in.index & 3].z; spvUnsafeArray baz = spvUnsafeArray({ float4(0.0), float4(1.0), float4(8.0), float4(5.0) }); baz = _104; out.FragColor += baz[in.index & 3].z; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/mix.frag000066400000000000000000000012141400026215700231250ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vIn0 [[user(locn0)]]; float4 vIn1 [[user(locn1)]]; float vIn2 [[user(locn2)]]; float vIn3 [[user(locn3)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; bool4 l = bool4(false, true, false, false); out.FragColor = select(in.vIn0, in.vIn1, l); bool f = true; out.FragColor = float4(f ? in.vIn3 : in.vIn2); out.FragColor = select(in.vIn1, in.vIn0, bool4(f)); out.FragColor = float4(f ? in.vIn2 : in.vIn3); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/mrt-array.frag000066400000000000000000000043751400026215700242610ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor_0 [[color(0)]]; float4 FragColor_1 [[color(1)]]; float4 FragColor_2 [[color(2)]]; float4 FragColor_3 [[color(3)]]; }; struct main0_in { float4 vA [[user(locn0)]]; float4 vB [[user(locn1)]]; }; // Implementation of the GLSL mod() function, which is slightly different than Metal fmod() template inline Tx mod(Tx x, Ty y) { return x - y * floor(x / y); } static inline __attribute__((always_inline)) void write_deeper_in_function(thread spvUnsafeArray (&FragColor), thread float4& vA, thread float4& vB) { FragColor[3] = vA * vB; } static inline __attribute__((always_inline)) void write_in_function(thread spvUnsafeArray (&FragColor), thread float4& vA, thread float4& vB) { FragColor[2] = vA - vB; write_deeper_in_function(FragColor, vA, vB); } fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray FragColor = {}; FragColor[0] = mod(in.vA, in.vB); FragColor[1] = in.vA + in.vB; write_in_function(FragColor, in.vA, in.vB); out.FragColor_0 = FragColor[0]; out.FragColor_1 = FragColor[1]; out.FragColor_2 = FragColor[2]; out.FragColor_3 = FragColor[3]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/nonuniform-qualifier.msl2.frag000066400000000000000000000024461400026215700273650ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4 v[64]; }; struct SSBO { float4 v[1]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int vIndex [[user(locn0)]]; float2 vUV [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant UBO* ubos_0 [[buffer(0)]], constant UBO* ubos_1 [[buffer(1)]], const device SSBO* ssbos_0 [[buffer(2)]], const device SSBO* ssbos_1 [[buffer(3)]], array, 8> uSamplers [[texture(0)]], array, 8> uCombinedSamplers [[texture(8)]], array uSamps [[sampler(0)]], array uCombinedSamplersSmplr [[sampler(7)]]) { constant UBO* ubos[] = { ubos_0, ubos_1, }; const device SSBO* ssbos[] = { ssbos_0, ssbos_1, }; main0_out out = {}; int i = in.vIndex; int _25 = i + 10; int _37 = i + 40; out.FragColor = uSamplers[_25].sample(uSamps[_37], in.vUV); int _53 = i + 10; out.FragColor = uCombinedSamplers[_53].sample(uCombinedSamplersSmplr[_53], in.vUV); int _69 = i + 20; int _73 = i + 40; out.FragColor += ubos[(_69)]->v[_73]; int _87 = i + 50; int _91 = i + 60; out.FragColor += ssbos[(_87)]->v[_91]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/packed-expression-vector-shuffle.frag000066400000000000000000000006221400026215700307100ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { packed_float3 color; float v; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant UBO& _15 [[buffer(0)]]) { main0_out out = {}; float4 f = float4(1.0); f = float4(_15.color[0], _15.color[1], _15.color[2], f.w); out.FragColor = f; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/packing-test-3.frag000066400000000000000000000021551400026215700250660ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct VertexOutput { float4 HPosition; }; struct TestStruct { float3 position; float radius; }; struct TestStruct_1 { packed_float3 position; float radius; }; struct CB0 { TestStruct_1 CB0[16]; }; struct main0_out { float4 _entryPointOutput [[color(0)]]; }; static inline __attribute__((always_inline)) float4 _main(thread const VertexOutput& IN, constant CB0& _RESERVED_IDENTIFIER_FIXUP_24) { TestStruct st; st.position = float3(_RESERVED_IDENTIFIER_FIXUP_24.CB0[1].position); st.radius = _RESERVED_IDENTIFIER_FIXUP_24.CB0[1].radius; float4 col = float4(st.position, st.radius); return col; } fragment main0_out main0(constant CB0& _RESERVED_IDENTIFIER_FIXUP_24 [[buffer(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; VertexOutput IN; IN.HPosition = gl_FragCoord; VertexOutput param = IN; VertexOutput param_1 = param; out._entryPointOutput = _main(param_1, _RESERVED_IDENTIFIER_FIXUP_24); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/pixel-interlock-ordered.msl2.argument.frag000066400000000000000000000040121400026215700315570ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct Buffer3 { int baz; }; struct Buffer { int foo; uint bar; }; struct Buffer2 { uint quux; }; struct spvDescriptorSetBuffer0 { device Buffer3* m_9 [[id(0)]]; texture2d img4 [[id(1)]]; texture2d img [[id(2), raster_order_group(0)]]; texture2d img3 [[id(3), raster_order_group(0)]]; texture2d img2 [[id(4), raster_order_group(0)]]; device atomic_uint* img2_atomic [[id(5), raster_order_group(0)]]; volatile device Buffer* m_42 [[id(6), raster_order_group(0)]]; device Buffer2* m_52 [[id(7), raster_order_group(0)]]; }; // The required alignment of a linear texture of R32Uint format. constant uint spvLinearTextureAlignmentOverride [[function_constant(65535)]]; constant uint spvLinearTextureAlignment = is_function_constant_defined(spvLinearTextureAlignmentOverride) ? spvLinearTextureAlignmentOverride : 4; // Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics #define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + spvLinearTextureAlignment / 4 - 1) & ~( spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x) fragment void main0(constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]]) { (*spvDescriptorSet0.m_9).baz = 0; spvDescriptorSet0.img4.write(float4(1.0, 0.0, 0.0, 1.0), uint2(int2(1))); spvDescriptorSet0.img.write(spvDescriptorSet0.img3.read(uint2(int2(0))), uint2(int2(0))); uint _39 = atomic_fetch_add_explicit((device atomic_uint*)&spvDescriptorSet0.img2_atomic[spvImage2DAtomicCoord(int2(0), spvDescriptorSet0.img2)], 1u, memory_order_relaxed); (*spvDescriptorSet0.m_42).foo += 42; uint _55 = atomic_fetch_and_explicit((volatile device atomic_uint*)&(*spvDescriptorSet0.m_42).bar, (*spvDescriptorSet0.m_52).quux, memory_order_relaxed); } spirv-cross-2021.01.15/reference/shaders-msl/frag/pixel-interlock-ordered.msl2.frag000066400000000000000000000033611400026215700277440ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct Buffer3 { int baz; }; struct Buffer { int foo; uint bar; }; struct Buffer2 { uint quux; }; // The required alignment of a linear texture of R32Uint format. constant uint spvLinearTextureAlignmentOverride [[function_constant(65535)]]; constant uint spvLinearTextureAlignment = is_function_constant_defined(spvLinearTextureAlignmentOverride) ? spvLinearTextureAlignmentOverride : 4; // Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics #define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + spvLinearTextureAlignment / 4 - 1) & ~( spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x) fragment void main0(device Buffer3& _9 [[buffer(0)]], volatile device Buffer& _42 [[buffer(2), raster_order_group(0)]], device Buffer2& _52 [[buffer(3), raster_order_group(0)]], texture2d img4 [[texture(0)]], texture2d img [[texture(1), raster_order_group(0)]], texture2d img3 [[texture(2), raster_order_group(0)]], texture2d img2 [[texture(3), raster_order_group(0)]], device atomic_uint* img2_atomic [[buffer(1), raster_order_group(0)]]) { _9.baz = 0; img4.write(float4(1.0, 0.0, 0.0, 1.0), uint2(int2(1))); img.write(img3.read(uint2(int2(0))), uint2(int2(0))); uint _39 = atomic_fetch_add_explicit((device atomic_uint*)&img2_atomic[spvImage2DAtomicCoord(int2(0), img2)], 1u, memory_order_relaxed); _42.foo += 42; uint _55 = atomic_fetch_and_explicit((volatile device atomic_uint*)&_42.bar, _52.quux, memory_order_relaxed); } spirv-cross-2021.01.15/reference/shaders-msl/frag/pls.frag000066400000000000000000000011611400026215700231270ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 PLSOut0 [[color(0)]]; float4 PLSOut1 [[color(1)]]; float4 PLSOut2 [[color(2)]]; float4 PLSOut3 [[color(3)]]; }; struct main0_in { float4 PLSIn0 [[user(locn0)]]; float4 PLSIn1 [[user(locn1)]]; float4 PLSIn2 [[user(locn2)]]; float4 PLSIn3 [[user(locn3)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.PLSOut0 = in.PLSIn0 * 2.0; out.PLSOut1 = in.PLSIn1 * 6.0; out.PLSOut2 = in.PLSIn2 * 7.0; out.PLSOut3 = in.PLSIn3 * 4.0; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/post-depth-coverage.ios.msl2.frag000066400000000000000000000005221400026215700276560ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; [[ early_fragment_tests ]] fragment main0_out main0(uint gl_SampleMaskIn [[sample_mask, post_depth_coverage]]) { main0_out out = {}; out.FragColor = float4(float(gl_SampleMaskIn)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/post-depth-coverage.msl23.frag000066400000000000000000000005221400026215700271500ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; [[ early_fragment_tests ]] fragment main0_out main0(uint gl_SampleMaskIn [[sample_mask, post_depth_coverage]]) { main0_out out = {}; out.FragColor = float4(float(gl_SampleMaskIn)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/private-variable-prototype-declaration.frag000066400000000000000000000013231400026215700321140ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct AStruct { float4 foobar; }; struct main0_out { float3 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) void someFunction(thread AStruct& s) { s.foobar = float4(1.0); } static inline __attribute__((always_inline)) void otherFunction(thread float3& global_variable) { global_variable = float3(1.0); } fragment main0_out main0() { main0_out out = {}; AStruct param; someFunction(param); AStruct inputs = param; float3 global_variable; otherFunction(global_variable); out.FragColor = global_variable; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/readonly-ssbo.frag000066400000000000000000000007671400026215700251250ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { float4 v; }; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 read_from_function(const device SSBO& v_13) { return v_13.v; } fragment main0_out main0(const device SSBO& v_13 [[buffer(0)]]) { main0_out out = {}; out.FragColor = v_13.v + read_from_function(v_13); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-depth-propagate-state-from-resource.frag000066400000000000000000000022441400026215700326030ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; static inline __attribute__((always_inline)) float sample_normal2(thread const depth2d tex, thread sampler uSampler, thread float3& vUV) { return float4(tex.sample(uSampler, vUV.xy)).x; } static inline __attribute__((always_inline)) float sample_normal(thread const depth2d tex, thread sampler uSampler, thread float3& vUV) { return sample_normal2(tex, uSampler, vUV); } static inline __attribute__((always_inline)) float sample_comp(thread const depth2d tex, thread float3& vUV, thread sampler uSamplerShadow) { return tex.sample_compare(uSamplerShadow, vUV.xy, vUV.z); } fragment main0_out main0(main0_in in [[stage_in]], depth2d uTexture [[texture(0)]], sampler uSampler [[sampler(0)]], sampler uSamplerShadow [[sampler(1)]]) { main0_out out = {}; out.FragColor = sample_normal(uTexture, uSampler, in.vUV); out.FragColor += sample_comp(uTexture, in.vUV, uSamplerShadow); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-depth-separate-image-sampler.frag000066400000000000000000000016211400026215700312400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float sample_depth_from_function(thread const depth2d uT, thread const sampler uS) { return uT.sample_compare(uS, float3(0.5).xy, float3(0.5).z); } static inline __attribute__((always_inline)) float sample_color_from_function(thread const texture2d uT, thread const sampler uS) { return uT.sample(uS, float2(0.5)).x; } fragment main0_out main0(depth2d uDepth [[texture(0)]], texture2d uColor [[texture(1)]], sampler uSamplerShadow [[sampler(0)]], sampler uSampler [[sampler(1)]]) { main0_out out = {}; out.FragColor = sample_depth_from_function(uDepth, uSamplerShadow) + sample_color_from_function(uColor, uSampler); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-mask-in-and-out.fixed-sample-mask.frag000066400000000000000000000005751400026215700320320ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; fragment main0_out main0(uint gl_SampleMaskIn [[sample_mask]]) { main0_out out = {}; out.FragColor = float4(1.0); out.gl_SampleMask = gl_SampleMaskIn; out.gl_SampleMask &= 34; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-mask-not-used.fixed-sample-mask.frag000066400000000000000000000004571400026215700316140ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(1.0); out.gl_SampleMask = 34; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-mask.fixed-sample-mask.frag000066400000000000000000000005131400026215700300510ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(1.0); out.gl_SampleMask = 0; out.gl_SampleMask &= 34; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-mask.frag000066400000000000000000000004561400026215700245510ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float4(1.0); out.gl_SampleMask = 0; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-position-func.frag000066400000000000000000000012611400026215700264060ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int index [[user(locn0)]]; }; static inline __attribute__((always_inline)) float4 getColor(thread const int& i, thread float2& gl_SamplePosition) { return float4(gl_SamplePosition, float(i), 1.0); } fragment main0_out main0(main0_in in [[stage_in]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; float2 gl_SamplePosition = get_sample_position(gl_SampleID); int param = in.index; out.FragColor = getColor(param, gl_SamplePosition); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-position.frag000066400000000000000000000005611400026215700254570ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(uint gl_SampleID [[sample_id]]) { main0_out out = {}; float2 gl_SamplePosition = get_sample_position(gl_SampleID); out.FragColor = float4(gl_SamplePosition, float(gl_SampleID), 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-rate-frag-coord-sample-id.frag000066400000000000000000000010311400026215700304310ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d_array tex [[texture(0)]], sampler texSmplr [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float3 _28 = float3(gl_FragCoord.xy, float(gl_SampleID)); out.FragColor = tex.sample(texSmplr, _28.xy, uint(round(_28.z))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-rate-frag-coord-sample-input.frag000066400000000000000000000011601400026215700311770ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float foo [[user(locn0), sample_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d_array tex [[texture(0)]], sampler texSmplr [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float3 _26 = float3(gl_FragCoord.xy, in.foo); out.FragColor = tex.sample(texSmplr, _26.xy, uint(round(_26.z))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-rate-frag-coord-sample-pos.frag000066400000000000000000000010411400026215700306370ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d tex [[texture(0)]], sampler texSmplr [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float2 gl_SamplePosition = get_sample_position(gl_SampleID); out.FragColor = tex.sample(texSmplr, (gl_FragCoord.xy - gl_SamplePosition)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sample-rate-frag-coord.force-sample.frag000066400000000000000000000007121400026215700311410ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d tex [[texture(0)]], sampler texSmplr [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; out.FragColor = tex.sample(texSmplr, gl_FragCoord.xy); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sampler-1d-lod.1d-as-2d.frag000066400000000000000000000011301400026215700262550ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float vTex [[user(locn0), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor += ((uSampler.sample(uSamplerSmplr, float2(in.vTex, 0.5), bias(2.0)) + uSampler.sample(uSamplerSmplr, float2(in.vTex, 0.5), level(3.0))) + uSampler.sample(uSamplerSmplr, float2(in.vTex, 0.5), gradient2d(5.0, 8.0))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sampler-1d-lod.frag000066400000000000000000000010041400026215700250460ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float vTex [[user(locn0), flat]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture1d uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor += ((uSampler.sample(uSamplerSmplr, in.vTex) + uSampler.sample(uSamplerSmplr, in.vTex)) + uSampler.sample(uSamplerSmplr, in.vTex)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sampler-compare-bias.msl23.1d-as-2d.frag000066400000000000000000000007261400026215700305100ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d_array uTex [[texture(0)]], sampler uShadow [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample_compare(uShadow, float2(in.vUV.x, 0.5), uint(round(in.vUV.y)), in.vUV.z, bias(1.0)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sampler-compare-cascade-gradient.frag000066400000000000000000000007111400026215700305740ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d_array uTex [[texture(0)]], sampler uShadow [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample_compare(uShadow, in.vUV.xy, uint(round(in.vUV.z)), in.vUV.w, level(0)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sampler-compare-cascade-gradient.ios.frag000066400000000000000000000007451400026215700313740ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d_array uTex [[texture(0)]], sampler uShadow [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample_compare(uShadow, in.vUV.xy, uint(round(in.vUV.z)), in.vUV.w, gradient2d(float2(0.0), float2(0.0))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sampler-compare-cascade-gradient.msl23.frag000066400000000000000000000010721400026215700315340ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d_array uTex [[texture(0)]], sampler uShadow [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTex.sample_compare(uShadow, in.vUV.xy, uint(round(in.vUV.z)), in.vUV.w, level(0)) + uTex.sample_compare(uShadow, in.vUV.xy, uint(round(in.vUV.z)), in.vUV.w, gradient2d(float2(1.0), float2(1.0))); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sampler-image-arrays.msl2.frag000066400000000000000000000035721400026215700272370ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float2 vTex [[user(locn0), flat]]; int vIndex [[user(locn1)]]; }; static inline __attribute__((always_inline)) float4 sample_from_global(thread int& vIndex, thread float2& vTex, thread const array, 4> uSampler, thread const array uSamplerSmplr) { return uSampler[vIndex].sample(uSamplerSmplr[vIndex], (vTex + float2(0.100000001490116119384765625))); } static inline __attribute__((always_inline)) float4 sample_from_argument(thread const array, 4> samplers, thread const array samplersSmplr, thread int& vIndex, thread float2& vTex) { return samplers[vIndex].sample(samplersSmplr[vIndex], (vTex + float2(0.20000000298023223876953125))); } static inline __attribute__((always_inline)) float4 sample_single_from_argument(thread const texture2d samp, thread const sampler sampSmplr, thread float2& vTex) { return samp.sample(sampSmplr, (vTex + float2(0.300000011920928955078125))); } fragment main0_out main0(main0_in in [[stage_in]], array, 4> uSampler [[texture(0)]], array, 4> uTextures [[texture(4)]], array uSamplerSmplr [[sampler(0)]], array uSamplers [[sampler(4)]]) { main0_out out = {}; out.FragColor = float4(0.0); out.FragColor += uTextures[2].sample(uSamplers[1], in.vTex); out.FragColor += uSampler[in.vIndex].sample(uSamplerSmplr[in.vIndex], in.vTex); out.FragColor += sample_from_global(in.vIndex, in.vTex, uSampler, uSamplerSmplr); out.FragColor += sample_from_argument(uSampler, uSamplerSmplr, in.vIndex, in.vTex); out.FragColor += sample_single_from_argument(uSampler[3], uSamplerSmplr[3], in.vTex); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sampler-ms.frag000066400000000000000000000010001400026215700244010ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d_ms uSampler [[texture(0)]], sampler uSamplerSmplr [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; int2 coord = int2(gl_FragCoord.xy); out.FragColor = ((uSampler.read(uint2(coord), 0) + uSampler.read(uint2(coord), 1)) + uSampler.read(uint2(coord), 2)) + uSampler.read(uint2(coord), 3); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/sampler.frag000066400000000000000000000013511400026215700237750ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex [[user(locn1)]]; }; static inline __attribute__((always_inline)) float4 sample_texture(thread const texture2d tex, thread const sampler texSmplr, thread const float2& uv) { return tex.sample(texSmplr, uv); } fragment main0_out main0(main0_in in [[stage_in]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]]) { main0_out out = {}; float2 param = in.vTex; out.FragColor = in.vColor * sample_texture(uTex, uTexSmplr, param); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/scalar-refract-reflect.frag000066400000000000000000000017331400026215700266510ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vRefract [[user(locn0)]]; }; template inline T spvReflect(T i, T n) { return i - T(2) * i * n * n; } template inline T spvRefract(T i, T n, T eta) { T NoI = n * i; T NoI2 = NoI * NoI; T k = T(1) - eta * eta * (T(1) - NoI2); if (k < T(0)) { return T(0); } else { return eta * i - (eta * NoI + sqrt(k)) * n; } } fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = spvRefract(in.vRefract.x, in.vRefract.y, in.vRefract.z); out.FragColor += spvReflect(in.vRefract.x, in.vRefract.y); out.FragColor += refract(in.vRefract.xy, in.vRefract.yz, in.vRefract.z).y; out.FragColor += reflect(in.vRefract.xy, in.vRefract.zy).y; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/separate-image-sampler-argument.frag000066400000000000000000000010221400026215700304720ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; static inline __attribute__((always_inline)) float4 samp(thread const texture2d t, thread const sampler s) { return t.sample(s, float2(0.5)); } fragment main0_out main0(texture2d uDepth [[texture(0)]], sampler uSampler [[sampler(0)]]) { main0_out out = {}; out.FragColor = samp(uDepth, uSampler); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/shader-arithmetic-8bit.frag000066400000000000000000000046441400026215700266030ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct SSBO { char i8[16]; uchar u8[16]; }; struct Push { char i8; uchar u8; }; struct UBO { char i8; uchar u8; }; struct main0_out { int4 FragColorInt [[color(0)]]; uint4 FragColorUint [[color(1)]]; }; struct main0_in { int4 vColor [[user(locn0)]]; }; static inline __attribute__((always_inline)) void packing_int8(device SSBO& ssbo) { short i16 = short(10); int i32 = 20; char2 i8_2 = as_type(i16); char4 i8_4 = as_type(i32); i16 = as_type(i8_2); i32 = as_type(i8_4); ssbo.i8[0] = i8_4.x; ssbo.i8[1] = i8_4.y; ssbo.i8[2] = i8_4.z; ssbo.i8[3] = i8_4.w; } static inline __attribute__((always_inline)) void packing_uint8(device SSBO& ssbo) { ushort u16 = ushort(10); uint u32 = 20u; uchar2 u8_2 = as_type(u16); uchar4 u8_4 = as_type(u32); u16 = as_type(u8_2); u32 = as_type(u8_4); ssbo.u8[0] = u8_4.x; ssbo.u8[1] = u8_4.y; ssbo.u8[2] = u8_4.z; ssbo.u8[3] = u8_4.w; } static inline __attribute__((always_inline)) void compute_int8(device SSBO& ssbo, thread int4& vColor, constant Push& registers, constant UBO& ubo, thread int4& FragColorInt) { char4 tmp = char4(vColor); tmp += char4(registers.i8); tmp += char4(char(-40)); tmp += char4(-50); tmp += char4(char(10), char(20), char(30), char(40)); tmp += char4(ssbo.i8[4]); tmp += char4(ubo.i8); FragColorInt = int4(tmp); } static inline __attribute__((always_inline)) void compute_uint8(device SSBO& ssbo, thread int4& vColor, constant Push& registers, constant UBO& ubo, thread uint4& FragColorUint) { uchar4 tmp = uchar4(char4(vColor)); tmp += uchar4(registers.u8); tmp += uchar4(uchar(216)); tmp += uchar4(206); tmp += uchar4(uchar(10), uchar(20), uchar(30), uchar(40)); tmp += uchar4(ssbo.u8[4]); tmp += uchar4(ubo.u8); FragColorUint = uint4(tmp); } fragment main0_out main0(main0_in in [[stage_in]], device SSBO& ssbo [[buffer(0)]], constant Push& registers [[buffer(1)]], constant UBO& ubo [[buffer(2)]]) { main0_out out = {}; packing_int8(ssbo); packing_uint8(ssbo); compute_int8(ssbo, in.vColor, registers, ubo, out.FragColorInt); compute_uint8(ssbo, in.vColor, registers, ubo, out.FragColorUint); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/spec-constant-block-size.frag000066400000000000000000000010461400026215700271540ustar00rootroot00000000000000#include #include using namespace metal; #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 2 #endif constant int Value = SPIRV_CROSS_CONSTANT_ID_10; struct SpecConstArray { float4 samples[Value]; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int Index [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant SpecConstArray& _15 [[buffer(0)]]) { main0_out out = {}; out.FragColor = _15.samples[in.Index]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/spec-constant-ternary.frag000066400000000000000000000006351400026215700266010ustar00rootroot00000000000000#include #include using namespace metal; constant uint s_tmp [[function_constant(0)]]; constant uint s = is_function_constant_defined(s_tmp) ? s_tmp : 10u; constant bool _13 = (s > 20u); constant uint f = _13 ? 30u : 50u; struct main0_out { float FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; out.FragColor = float(f); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/stencil-export.msl21.frag000066400000000000000000000012201400026215700262420ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 MRT0 [[color(0)]]; float4 MRT1 [[color(1)]]; uint gl_FragStencilRefARB [[stencil]]; }; static inline __attribute__((always_inline)) void update_stencil(thread uint& gl_FragStencilRefARB) { gl_FragStencilRefARB = uint(int(gl_FragStencilRefARB) + 10); } fragment main0_out main0() { main0_out out = {}; out.MRT0 = float4(1.0); out.MRT1 = float4(1.0, 0.0, 1.0, 1.0); out.gl_FragStencilRefARB = uint(100); update_stencil(out.gl_FragStencilRefARB); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/subgroup-builtins.msl22.frag000066400000000000000000000006111400026215700267630ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { uint2 FragColor [[color(0)]]; }; fragment main0_out main0(uint gl_SubgroupSize [[threads_per_simdgroup]], uint gl_SubgroupInvocationID [[thread_index_in_simdgroup]]) { main0_out out = {}; out.FragColor.x = gl_SubgroupSize; out.FragColor.y = gl_SubgroupInvocationID; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/subgroup-globals-extract.msl22.frag000066400000000000000000000064721400026215700302400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { uint2 FragColor [[color(0)]]; }; inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0); } inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); ballot &= mask; return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - (clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), ballot.z == 0), ballot.w == 0); } inline uint spvPopCount4(uint4 ballot) { return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w); } inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID) { uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0)); return spvPopCount4(ballot & mask); } static inline __attribute__((always_inline)) uint sub1(thread uint& gl_SubgroupSize) { return spvSubgroupBallotFindLSB(uint4(1u, 2u, 3u, 4u), gl_SubgroupSize); } static inline __attribute__((always_inline)) uint sub2(thread uint& gl_SubgroupSize) { return spvSubgroupBallotFindMSB(uint4(1u, 2u, 3u, 4u), gl_SubgroupSize); } static inline __attribute__((always_inline)) uint sub3(thread uint& gl_SubgroupSize) { return spvSubgroupBallotBitCount(uint4(1u, 2u, 3u, 4u), gl_SubgroupSize); } static inline __attribute__((always_inline)) uint sub4(thread uint& gl_SubgroupInvocationID) { return spvSubgroupBallotInclusiveBitCount(uint4(1u, 2u, 3u, 4u), gl_SubgroupInvocationID); } static inline __attribute__((always_inline)) uint sub5(thread uint& gl_SubgroupInvocationID) { return spvSubgroupBallotExclusiveBitCount(uint4(1u, 2u, 3u, 4u), gl_SubgroupInvocationID); } fragment main0_out main0(uint gl_SubgroupInvocationID [[thread_index_in_simdgroup]], uint gl_SubgroupSize [[threads_per_simdgroup]]) { main0_out out = {}; out.FragColor.x = (((sub1(gl_SubgroupSize) + sub2(gl_SubgroupSize)) + sub3(gl_SubgroupSize)) + sub4(gl_SubgroupInvocationID)) + sub5(gl_SubgroupInvocationID); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/switch-unsigned-case.frag000066400000000000000000000011211400026215700263510ustar00rootroot00000000000000#include #include using namespace metal; struct Buff { uint TestVal; }; struct main0_out { float4 fsout_Color [[color(0)]]; }; fragment main0_out main0(constant Buff& _15 [[buffer(0)]]) { main0_out out = {}; out.fsout_Color = float4(1.0); switch (_15.TestVal) { case 0u: { out.fsout_Color = float4(0.100000001490116119384765625); break; } case 1u: { out.fsout_Color = float4(0.20000000298023223876953125); break; } } return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/swizzle.frag000066400000000000000000000015521400026215700240440ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float3 vNormal [[user(locn1)]]; float2 vUV [[user(locn2)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d samp [[texture(0)]], sampler sampSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = float4(samp.sample(sampSmplr, in.vUV).xyz, 1.0); out.FragColor = float4(samp.sample(sampSmplr, in.vUV).xz, 1.0, 4.0); out.FragColor = float4(samp.sample(sampSmplr, in.vUV).xx, samp.sample(sampSmplr, (in.vUV + float2(0.100000001490116119384765625))).yy); out.FragColor = float4(in.vNormal, 1.0); out.FragColor = float4(in.vNormal + float3(1.7999999523162841796875), 1.0); out.FragColor = float4(in.vUV, in.vUV + float2(1.7999999523162841796875)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/texel-fetch-offset.1d-as-2d.frag000066400000000000000000000011031400026215700272300ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uTexture [[texture(0)]], texture2d uTexture2 [[texture(1)]], sampler uTextureSmplr [[sampler(0)]], sampler uTexture2Smplr [[sampler(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = uTexture.read(uint2(int2(gl_FragCoord.xy)) + uint2(int2(1)), 0); out.FragColor += uTexture2.read(uint2(uint(int(gl_FragCoord.x)), 0) + uint2(uint(-1), 0), 0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/texel-fetch-offset.frag000066400000000000000000000007511400026215700260310ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(texture2d uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; out.FragColor = uTexture.read(uint2(int2(gl_FragCoord.xy)) + uint2(int2(1)), 0); out.FragColor += uTexture.read(uint2(int2(gl_FragCoord.xy)) + uint2(int2(-1, 1)), 0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/texture-cube-array.frag000066400000000000000000000015471400026215700260710ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texturecube cubeSampler [[texture(0)]], texturecube_array cubeArraySampler [[texture(1)]], texture2d_array texArraySampler [[texture(2)]], sampler cubeSamplerSmplr [[sampler(0)]], sampler cubeArraySamplerSmplr [[sampler(1)]], sampler texArraySamplerSmplr [[sampler(2)]]) { main0_out out = {}; float4 a = cubeSampler.sample(cubeSamplerSmplr, in.vUV.xyz); float4 b = cubeArraySampler.sample(cubeArraySamplerSmplr, in.vUV.xyz, uint(round(in.vUV.w))); float4 c = texArraySampler.sample(texArraySamplerSmplr, in.vUV.xyz.xy, uint(round(in.vUV.xyz.z))); out.FragColor = (a + b) + c; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/texture-cube-array.ios.emulate-cube-array.frag000066400000000000000000000035051400026215700323410ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vUV [[user(locn0)]]; }; static inline __attribute__((always_inline)) float3 spvCubemapTo2DArrayFace(float3 P) { float3 Coords = abs(P.xyz); float CubeFace = 0; float ProjectionAxis = 0; float u = 0; float v = 0; if (Coords.x >= Coords.y && Coords.x >= Coords.z) { CubeFace = P.x >= 0 ? 0 : 1; ProjectionAxis = Coords.x; u = P.x >= 0 ? -P.z : P.z; v = -P.y; } else if (Coords.y >= Coords.x && Coords.y >= Coords.z) { CubeFace = P.y >= 0 ? 2 : 3; ProjectionAxis = Coords.y; u = P.x; v = P.y >= 0 ? P.z : -P.z; } else { CubeFace = P.z >= 0 ? 4 : 5; ProjectionAxis = Coords.z; u = P.z >= 0 ? P.x : -P.x; v = -P.y; } u = 0.5 * (u/ProjectionAxis + 1); v = 0.5 * (v/ProjectionAxis + 1); return float3(u, v, CubeFace); } fragment main0_out main0(main0_in in [[stage_in]], texturecube cubeSampler [[texture(0)]], texture2d_array cubeArraySampler [[texture(1)]], texture2d_array texArraySampler [[texture(2)]], sampler cubeSamplerSmplr [[sampler(0)]], sampler cubeArraySamplerSmplr [[sampler(1)]], sampler texArraySamplerSmplr [[sampler(2)]]) { main0_out out = {}; float4 a = cubeSampler.sample(cubeSamplerSmplr, in.vUV.xyz); float4 b = cubeArraySampler.sample(cubeArraySamplerSmplr, spvCubemapTo2DArrayFace(in.vUV.xyz).xy, uint(spvCubemapTo2DArrayFace(in.vUV.xyz).z) + (uint(round(in.vUV.w)) * 6u)); float4 c = texArraySampler.sample(texArraySamplerSmplr, in.vUV.xyz.xy, uint(round(in.vUV.xyz.z))); out.FragColor = (a + b) + c; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/texture-multisample-array.msl21.frag000066400000000000000000000007521400026215700304410ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { int3 vCoord [[user(locn0)]]; int vSample [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]], texture2d_ms_array uTexture [[texture(0)]], sampler uTextureSmplr [[sampler(0)]]) { main0_out out = {}; out.FragColor = uTexture.read(uint2(in.vCoord.xy), uint(in.vCoord.z), in.vSample); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/texture-proj-shadow.frag000066400000000000000000000021061400026215700262640ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; }; struct main0_in { float3 vClip3 [[user(locn0)]]; float4 vClip4 [[user(locn1)]]; float2 vClip2 [[user(locn2)]]; }; fragment main0_out main0(main0_in in [[stage_in]], depth2d uShadow2D [[texture(0)]], texture1d uSampler1D [[texture(1)]], texture2d uSampler2D [[texture(2)]], texture3d uSampler3D [[texture(3)]], sampler uShadow2DSmplr [[sampler(0)]], sampler uSampler1DSmplr [[sampler(1)]], sampler uSampler2DSmplr [[sampler(2)]], sampler uSampler3DSmplr [[sampler(3)]]) { main0_out out = {}; float4 _20 = in.vClip4; _20.z = in.vClip4.w; out.FragColor = uShadow2D.sample_compare(uShadow2DSmplr, _20.xy / _20.z, in.vClip4.z / _20.z); out.FragColor = uSampler1D.sample(uSampler1DSmplr, in.vClip2.x / in.vClip2.y).x; out.FragColor = uSampler2D.sample(uSampler2DSmplr, in.vClip3.xy / in.vClip3.z).x; out.FragColor = uSampler3D.sample(uSampler3DSmplr, in.vClip4.xyz / in.vClip4.w).x; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/ubo_layout.frag000066400000000000000000000010241400026215700245110ustar00rootroot00000000000000#include #include using namespace metal; struct Str { float4x4 foo; }; struct UBO1 { Str foo; }; struct Str_1 { float4x4 foo; }; struct UBO2 { Str_1 foo; }; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0(constant UBO1& ubo1 [[buffer(0)]], constant UBO2& ubo0 [[buffer(1)]]) { main0_out out = {}; out.FragColor = float4(ubo1.foo.foo[0][0], ubo1.foo.foo[1][0], ubo1.foo.foo[2][0], ubo1.foo.foo[3][0]) + ubo0.foo.foo[0]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/unary-enclose.frag000066400000000000000000000006241400026215700251200ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vIn [[user(locn0)]]; int4 vIn1 [[user(locn1)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.FragColor = -(-in.vIn); int4 a = ~(~in.vIn1); bool b = false; b = !(!b); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/vecsize-mismatch.shader-inputs.frag000066400000000000000000000032171400026215700303750ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { ushort2 a [[user(locn0)]]; uint3 b [[user(locn1)]]; ushort c_0 [[user(locn2)]]; ushort c_1 [[user(locn3)]]; uint4 e_0 [[user(locn4)]]; uint4 e_1 [[user(locn5)]]; float4 d [[user(locn6)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray c = {}; spvUnsafeArray e = {}; c[0] = in.c_0; c[1] = in.c_1; e[0] = in.e_0; e[1] = in.e_1; out.FragColor = float4(float(int(in.a.x)), float(in.b.x), float2(float(uint(c[1])), float(e[0].w)) + in.d.xy); return out; } spirv-cross-2021.01.15/reference/shaders-msl/frag/write-depth-in-function.frag000066400000000000000000000007771400026215700270300ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float FragColor [[color(0)]]; float gl_FragDepth [[depth(any)]]; }; static inline __attribute__((always_inline)) void set_output_depth(thread float& gl_FragDepth) { gl_FragDepth = 0.20000000298023223876953125; } fragment main0_out main0() { main0_out out = {}; out.FragColor = 1.0; set_output_depth(out.gl_FragDepth); return out; } spirv-cross-2021.01.15/reference/shaders-msl/intel/000077500000000000000000000000001400026215700216655ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/intel/shader-integer-functions2.asm.comp000066400000000000000000000011761400026215700303220ustar00rootroot00000000000000#include #include using namespace metal; struct foo { uint a; uint b; int c; int d; }; kernel void main0(device foo& _4 [[buffer(0)]]) { _4.a = clz(_4.a); _4.a = ctz(_4.a); _4.a = absdiff(_4.c, _4.d); _4.a = absdiff(_4.a, _4.b); _4.c = addsat(_4.c, _4.d); _4.a = addsat(_4.a, _4.b); _4.c = hadd(_4.c, _4.d); _4.a = hadd(_4.a, _4.b); _4.c = rhadd(_4.c, _4.d); _4.a = rhadd(_4.a, _4.b); _4.c = subsat(_4.c, _4.d); _4.a = subsat(_4.a, _4.b); _4.c = int(short(_4.c)) * int(short(_4.d)); _4.a = uint(ushort(_4.a)) * uint(ushort(_4.b)); } spirv-cross-2021.01.15/reference/shaders-msl/legacy/000077500000000000000000000000001400026215700220165ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/legacy/vert/000077500000000000000000000000001400026215700227765ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/legacy/vert/transpose.legacy.vert000066400000000000000000000012531400026215700271620ustar00rootroot00000000000000#include #include using namespace metal; struct Buffer { float4x4 MVPRowMajor; float4x4 MVPColMajor; float4x4 M; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant Buffer& _13 [[buffer(0)]]) { main0_out out = {}; float4 c0 = _13.M * (in.Position * _13.MVPRowMajor); float4 c1 = _13.M * (_13.MVPColMajor * in.Position); float4 c2 = _13.M * (_13.MVPRowMajor * in.Position); float4 c3 = _13.M * (in.Position * _13.MVPColMajor); out.gl_Position = ((c0 + c1) + c2) + c3; return out; } spirv-cross-2021.01.15/reference/shaders-msl/tesc/000077500000000000000000000000001400026215700215105ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/tesc/basic.multi-patch.tesc000066400000000000000000000021301400026215700256730ustar00rootroot00000000000000#include #include using namespace metal; struct main0_patchOut { float3 vFoo; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { device main0_patchOut& patchOut = spvPatchOut[gl_GlobalInvocationID.x / 1]; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1]); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625); patchOut.vFoo = float3(1.0); } spirv-cross-2021.01.15/reference/shaders-msl/tesc/basic.tesc000066400000000000000000000020541400026215700234520ustar00rootroot00000000000000#include #include using namespace metal; struct main0_patchOut { float3 vFoo; }; kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]]) { device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625); patchOut.vFoo = float3(1.0); } load-control-point-array-of-matrix.multi-patch.tesc000066400000000000000000000047361400026215700333150ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4x4 vOutputs; }; struct main0_in { float4x4 vInputs; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); spvUnsafeArray _16 = spvUnsafeArray({ gl_in[0].vInputs, gl_in[1].vInputs, gl_in[2].vInputs, gl_in[3].vInputs, gl_in[4].vInputs, gl_in[5].vInputs, gl_in[6].vInputs, gl_in[7].vInputs, gl_in[8].vInputs, gl_in[9].vInputs, gl_in[10].vInputs, gl_in[11].vInputs, gl_in[12].vInputs, gl_in[13].vInputs, gl_in[14].vInputs, gl_in[15].vInputs, gl_in[16].vInputs, gl_in[17].vInputs, gl_in[18].vInputs, gl_in[19].vInputs, gl_in[20].vInputs, gl_in[21].vInputs, gl_in[22].vInputs, gl_in[23].vInputs, gl_in[24].vInputs, gl_in[25].vInputs, gl_in[26].vInputs, gl_in[27].vInputs, gl_in[28].vInputs, gl_in[29].vInputs, gl_in[30].vInputs, gl_in[31].vInputs }); spvUnsafeArray tmp; tmp = _16; gl_out[gl_InvocationID].vOutputs = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/reference/shaders-msl/tesc/load-control-point-array-of-matrix.tesc000066400000000000000000000116171400026215700311420ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4x4 vOutputs; }; struct main0_in { float4 vInputs_0 [[attribute(0)]]; float4 vInputs_1 [[attribute(1)]]; float4 vInputs_2 [[attribute(2)]]; float4 vInputs_3 [[attribute(3)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; spvUnsafeArray _16 = spvUnsafeArray({ float4x4(gl_in[0].vInputs_0, gl_in[0].vInputs_1, gl_in[0].vInputs_2, gl_in[0].vInputs_3), float4x4(gl_in[1].vInputs_0, gl_in[1].vInputs_1, gl_in[1].vInputs_2, gl_in[1].vInputs_3), float4x4(gl_in[2].vInputs_0, gl_in[2].vInputs_1, gl_in[2].vInputs_2, gl_in[2].vInputs_3), float4x4(gl_in[3].vInputs_0, gl_in[3].vInputs_1, gl_in[3].vInputs_2, gl_in[3].vInputs_3), float4x4(gl_in[4].vInputs_0, gl_in[4].vInputs_1, gl_in[4].vInputs_2, gl_in[4].vInputs_3), float4x4(gl_in[5].vInputs_0, gl_in[5].vInputs_1, gl_in[5].vInputs_2, gl_in[5].vInputs_3), float4x4(gl_in[6].vInputs_0, gl_in[6].vInputs_1, gl_in[6].vInputs_2, gl_in[6].vInputs_3), float4x4(gl_in[7].vInputs_0, gl_in[7].vInputs_1, gl_in[7].vInputs_2, gl_in[7].vInputs_3), float4x4(gl_in[8].vInputs_0, gl_in[8].vInputs_1, gl_in[8].vInputs_2, gl_in[8].vInputs_3), float4x4(gl_in[9].vInputs_0, gl_in[9].vInputs_1, gl_in[9].vInputs_2, gl_in[9].vInputs_3), float4x4(gl_in[10].vInputs_0, gl_in[10].vInputs_1, gl_in[10].vInputs_2, gl_in[10].vInputs_3), float4x4(gl_in[11].vInputs_0, gl_in[11].vInputs_1, gl_in[11].vInputs_2, gl_in[11].vInputs_3), float4x4(gl_in[12].vInputs_0, gl_in[12].vInputs_1, gl_in[12].vInputs_2, gl_in[12].vInputs_3), float4x4(gl_in[13].vInputs_0, gl_in[13].vInputs_1, gl_in[13].vInputs_2, gl_in[13].vInputs_3), float4x4(gl_in[14].vInputs_0, gl_in[14].vInputs_1, gl_in[14].vInputs_2, gl_in[14].vInputs_3), float4x4(gl_in[15].vInputs_0, gl_in[15].vInputs_1, gl_in[15].vInputs_2, gl_in[15].vInputs_3), float4x4(gl_in[16].vInputs_0, gl_in[16].vInputs_1, gl_in[16].vInputs_2, gl_in[16].vInputs_3), float4x4(gl_in[17].vInputs_0, gl_in[17].vInputs_1, gl_in[17].vInputs_2, gl_in[17].vInputs_3), float4x4(gl_in[18].vInputs_0, gl_in[18].vInputs_1, gl_in[18].vInputs_2, gl_in[18].vInputs_3), float4x4(gl_in[19].vInputs_0, gl_in[19].vInputs_1, gl_in[19].vInputs_2, gl_in[19].vInputs_3), float4x4(gl_in[20].vInputs_0, gl_in[20].vInputs_1, gl_in[20].vInputs_2, gl_in[20].vInputs_3), float4x4(gl_in[21].vInputs_0, gl_in[21].vInputs_1, gl_in[21].vInputs_2, gl_in[21].vInputs_3), float4x4(gl_in[22].vInputs_0, gl_in[22].vInputs_1, gl_in[22].vInputs_2, gl_in[22].vInputs_3), float4x4(gl_in[23].vInputs_0, gl_in[23].vInputs_1, gl_in[23].vInputs_2, gl_in[23].vInputs_3), float4x4(gl_in[24].vInputs_0, gl_in[24].vInputs_1, gl_in[24].vInputs_2, gl_in[24].vInputs_3), float4x4(gl_in[25].vInputs_0, gl_in[25].vInputs_1, gl_in[25].vInputs_2, gl_in[25].vInputs_3), float4x4(gl_in[26].vInputs_0, gl_in[26].vInputs_1, gl_in[26].vInputs_2, gl_in[26].vInputs_3), float4x4(gl_in[27].vInputs_0, gl_in[27].vInputs_1, gl_in[27].vInputs_2, gl_in[27].vInputs_3), float4x4(gl_in[28].vInputs_0, gl_in[28].vInputs_1, gl_in[28].vInputs_2, gl_in[28].vInputs_3), float4x4(gl_in[29].vInputs_0, gl_in[29].vInputs_1, gl_in[29].vInputs_2, gl_in[29].vInputs_3), float4x4(gl_in[30].vInputs_0, gl_in[30].vInputs_1, gl_in[30].vInputs_2, gl_in[30].vInputs_3), float4x4(gl_in[31].vInputs_0, gl_in[31].vInputs_1, gl_in[31].vInputs_2, gl_in[31].vInputs_3) }); spvUnsafeArray tmp; tmp = _16; gl_out[gl_InvocationID].vOutputs = tmp[gl_InvocationID]; } load-control-point-array-of-struct.multi-patch.tesc000066400000000000000000000156421400026215700333330ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/tesc#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct VertexData { float4x4 a; spvUnsafeArray b; float4 c; }; struct main0_out { float4 vOutputs; }; struct main0_in { float4x4 VertexData_a; spvUnsafeArray VertexData_b; float4 VertexData_c; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); spvUnsafeArray _19 = spvUnsafeArray({ VertexData{ gl_in[0].VertexData_a, spvUnsafeArray({ gl_in[0].VertexData_b[0], gl_in[0].VertexData_b[1] }), gl_in[0].VertexData_c }, VertexData{ gl_in[1].VertexData_a, spvUnsafeArray({ gl_in[1].VertexData_b[0], gl_in[1].VertexData_b[1] }), gl_in[1].VertexData_c }, VertexData{ gl_in[2].VertexData_a, spvUnsafeArray({ gl_in[2].VertexData_b[0], gl_in[2].VertexData_b[1] }), gl_in[2].VertexData_c }, VertexData{ gl_in[3].VertexData_a, spvUnsafeArray({ gl_in[3].VertexData_b[0], gl_in[3].VertexData_b[1] }), gl_in[3].VertexData_c }, VertexData{ gl_in[4].VertexData_a, spvUnsafeArray({ gl_in[4].VertexData_b[0], gl_in[4].VertexData_b[1] }), gl_in[4].VertexData_c }, VertexData{ gl_in[5].VertexData_a, spvUnsafeArray({ gl_in[5].VertexData_b[0], gl_in[5].VertexData_b[1] }), gl_in[5].VertexData_c }, VertexData{ gl_in[6].VertexData_a, spvUnsafeArray({ gl_in[6].VertexData_b[0], gl_in[6].VertexData_b[1] }), gl_in[6].VertexData_c }, VertexData{ gl_in[7].VertexData_a, spvUnsafeArray({ gl_in[7].VertexData_b[0], gl_in[7].VertexData_b[1] }), gl_in[7].VertexData_c }, VertexData{ gl_in[8].VertexData_a, spvUnsafeArray({ gl_in[8].VertexData_b[0], gl_in[8].VertexData_b[1] }), gl_in[8].VertexData_c }, VertexData{ gl_in[9].VertexData_a, spvUnsafeArray({ gl_in[9].VertexData_b[0], gl_in[9].VertexData_b[1] }), gl_in[9].VertexData_c }, VertexData{ gl_in[10].VertexData_a, spvUnsafeArray({ gl_in[10].VertexData_b[0], gl_in[10].VertexData_b[1] }), gl_in[10].VertexData_c }, VertexData{ gl_in[11].VertexData_a, spvUnsafeArray({ gl_in[11].VertexData_b[0], gl_in[11].VertexData_b[1] }), gl_in[11].VertexData_c }, VertexData{ gl_in[12].VertexData_a, spvUnsafeArray({ gl_in[12].VertexData_b[0], gl_in[12].VertexData_b[1] }), gl_in[12].VertexData_c }, VertexData{ gl_in[13].VertexData_a, spvUnsafeArray({ gl_in[13].VertexData_b[0], gl_in[13].VertexData_b[1] }), gl_in[13].VertexData_c }, VertexData{ gl_in[14].VertexData_a, spvUnsafeArray({ gl_in[14].VertexData_b[0], gl_in[14].VertexData_b[1] }), gl_in[14].VertexData_c }, VertexData{ gl_in[15].VertexData_a, spvUnsafeArray({ gl_in[15].VertexData_b[0], gl_in[15].VertexData_b[1] }), gl_in[15].VertexData_c }, VertexData{ gl_in[16].VertexData_a, spvUnsafeArray({ gl_in[16].VertexData_b[0], gl_in[16].VertexData_b[1] }), gl_in[16].VertexData_c }, VertexData{ gl_in[17].VertexData_a, spvUnsafeArray({ gl_in[17].VertexData_b[0], gl_in[17].VertexData_b[1] }), gl_in[17].VertexData_c }, VertexData{ gl_in[18].VertexData_a, spvUnsafeArray({ gl_in[18].VertexData_b[0], gl_in[18].VertexData_b[1] }), gl_in[18].VertexData_c }, VertexData{ gl_in[19].VertexData_a, spvUnsafeArray({ gl_in[19].VertexData_b[0], gl_in[19].VertexData_b[1] }), gl_in[19].VertexData_c }, VertexData{ gl_in[20].VertexData_a, spvUnsafeArray({ gl_in[20].VertexData_b[0], gl_in[20].VertexData_b[1] }), gl_in[20].VertexData_c }, VertexData{ gl_in[21].VertexData_a, spvUnsafeArray({ gl_in[21].VertexData_b[0], gl_in[21].VertexData_b[1] }), gl_in[21].VertexData_c }, VertexData{ gl_in[22].VertexData_a, spvUnsafeArray({ gl_in[22].VertexData_b[0], gl_in[22].VertexData_b[1] }), gl_in[22].VertexData_c }, VertexData{ gl_in[23].VertexData_a, spvUnsafeArray({ gl_in[23].VertexData_b[0], gl_in[23].VertexData_b[1] }), gl_in[23].VertexData_c }, VertexData{ gl_in[24].VertexData_a, spvUnsafeArray({ gl_in[24].VertexData_b[0], gl_in[24].VertexData_b[1] }), gl_in[24].VertexData_c }, VertexData{ gl_in[25].VertexData_a, spvUnsafeArray({ gl_in[25].VertexData_b[0], gl_in[25].VertexData_b[1] }), gl_in[25].VertexData_c }, VertexData{ gl_in[26].VertexData_a, spvUnsafeArray({ gl_in[26].VertexData_b[0], gl_in[26].VertexData_b[1] }), gl_in[26].VertexData_c }, VertexData{ gl_in[27].VertexData_a, spvUnsafeArray({ gl_in[27].VertexData_b[0], gl_in[27].VertexData_b[1] }), gl_in[27].VertexData_c }, VertexData{ gl_in[28].VertexData_a, spvUnsafeArray({ gl_in[28].VertexData_b[0], gl_in[28].VertexData_b[1] }), gl_in[28].VertexData_c }, VertexData{ gl_in[29].VertexData_a, spvUnsafeArray({ gl_in[29].VertexData_b[0], gl_in[29].VertexData_b[1] }), gl_in[29].VertexData_c }, VertexData{ gl_in[30].VertexData_a, spvUnsafeArray({ gl_in[30].VertexData_b[0], gl_in[30].VertexData_b[1] }), gl_in[30].VertexData_c }, VertexData{ gl_in[31].VertexData_a, spvUnsafeArray({ gl_in[31].VertexData_b[0], gl_in[31].VertexData_b[1] }), gl_in[31].VertexData_c } }); spvUnsafeArray tmp; tmp = _19; int _27 = gl_InvocationID ^ 1; VertexData _30 = VertexData{ gl_in[_27].VertexData_a, spvUnsafeArray({ gl_in[_27].VertexData_b[0], gl_in[_27].VertexData_b[1] }), gl_in[_27].VertexData_c }; VertexData tmp_single = _30; gl_out[gl_InvocationID].vOutputs = ((tmp[gl_InvocationID].a[1] + tmp[gl_InvocationID].b[1]) + tmp[gl_InvocationID].c) + tmp_single.c; } spirv-cross-2021.01.15/reference/shaders-msl/tesc/load-control-point-array-of-struct.tesc000066400000000000000000000236321400026215700311620ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct VertexData { float4x4 a; spvUnsafeArray b; float4 c; }; struct main0_out { float4 vOutputs; }; struct main0_in { float4 VertexData_a_0 [[attribute(0)]]; float4 VertexData_a_1 [[attribute(1)]]; float4 VertexData_a_2 [[attribute(2)]]; float4 VertexData_a_3 [[attribute(3)]]; float4 VertexData_b_0 [[attribute(4)]]; float4 VertexData_b_1 [[attribute(5)]]; float4 VertexData_c [[attribute(6)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; spvUnsafeArray _19 = spvUnsafeArray({ VertexData{ float4x4(gl_in[0].VertexData_a_0, gl_in[0].VertexData_a_1, gl_in[0].VertexData_a_2, gl_in[0].VertexData_a_3), spvUnsafeArray({ gl_in[0].VertexData_b_0, gl_in[0].VertexData_b_1 }), gl_in[0].VertexData_c }, VertexData{ float4x4(gl_in[1].VertexData_a_0, gl_in[1].VertexData_a_1, gl_in[1].VertexData_a_2, gl_in[1].VertexData_a_3), spvUnsafeArray({ gl_in[1].VertexData_b_0, gl_in[1].VertexData_b_1 }), gl_in[1].VertexData_c }, VertexData{ float4x4(gl_in[2].VertexData_a_0, gl_in[2].VertexData_a_1, gl_in[2].VertexData_a_2, gl_in[2].VertexData_a_3), spvUnsafeArray({ gl_in[2].VertexData_b_0, gl_in[2].VertexData_b_1 }), gl_in[2].VertexData_c }, VertexData{ float4x4(gl_in[3].VertexData_a_0, gl_in[3].VertexData_a_1, gl_in[3].VertexData_a_2, gl_in[3].VertexData_a_3), spvUnsafeArray({ gl_in[3].VertexData_b_0, gl_in[3].VertexData_b_1 }), gl_in[3].VertexData_c }, VertexData{ float4x4(gl_in[4].VertexData_a_0, gl_in[4].VertexData_a_1, gl_in[4].VertexData_a_2, gl_in[4].VertexData_a_3), spvUnsafeArray({ gl_in[4].VertexData_b_0, gl_in[4].VertexData_b_1 }), gl_in[4].VertexData_c }, VertexData{ float4x4(gl_in[5].VertexData_a_0, gl_in[5].VertexData_a_1, gl_in[5].VertexData_a_2, gl_in[5].VertexData_a_3), spvUnsafeArray({ gl_in[5].VertexData_b_0, gl_in[5].VertexData_b_1 }), gl_in[5].VertexData_c }, VertexData{ float4x4(gl_in[6].VertexData_a_0, gl_in[6].VertexData_a_1, gl_in[6].VertexData_a_2, gl_in[6].VertexData_a_3), spvUnsafeArray({ gl_in[6].VertexData_b_0, gl_in[6].VertexData_b_1 }), gl_in[6].VertexData_c }, VertexData{ float4x4(gl_in[7].VertexData_a_0, gl_in[7].VertexData_a_1, gl_in[7].VertexData_a_2, gl_in[7].VertexData_a_3), spvUnsafeArray({ gl_in[7].VertexData_b_0, gl_in[7].VertexData_b_1 }), gl_in[7].VertexData_c }, VertexData{ float4x4(gl_in[8].VertexData_a_0, gl_in[8].VertexData_a_1, gl_in[8].VertexData_a_2, gl_in[8].VertexData_a_3), spvUnsafeArray({ gl_in[8].VertexData_b_0, gl_in[8].VertexData_b_1 }), gl_in[8].VertexData_c }, VertexData{ float4x4(gl_in[9].VertexData_a_0, gl_in[9].VertexData_a_1, gl_in[9].VertexData_a_2, gl_in[9].VertexData_a_3), spvUnsafeArray({ gl_in[9].VertexData_b_0, gl_in[9].VertexData_b_1 }), gl_in[9].VertexData_c }, VertexData{ float4x4(gl_in[10].VertexData_a_0, gl_in[10].VertexData_a_1, gl_in[10].VertexData_a_2, gl_in[10].VertexData_a_3), spvUnsafeArray({ gl_in[10].VertexData_b_0, gl_in[10].VertexData_b_1 }), gl_in[10].VertexData_c }, VertexData{ float4x4(gl_in[11].VertexData_a_0, gl_in[11].VertexData_a_1, gl_in[11].VertexData_a_2, gl_in[11].VertexData_a_3), spvUnsafeArray({ gl_in[11].VertexData_b_0, gl_in[11].VertexData_b_1 }), gl_in[11].VertexData_c }, VertexData{ float4x4(gl_in[12].VertexData_a_0, gl_in[12].VertexData_a_1, gl_in[12].VertexData_a_2, gl_in[12].VertexData_a_3), spvUnsafeArray({ gl_in[12].VertexData_b_0, gl_in[12].VertexData_b_1 }), gl_in[12].VertexData_c }, VertexData{ float4x4(gl_in[13].VertexData_a_0, gl_in[13].VertexData_a_1, gl_in[13].VertexData_a_2, gl_in[13].VertexData_a_3), spvUnsafeArray({ gl_in[13].VertexData_b_0, gl_in[13].VertexData_b_1 }), gl_in[13].VertexData_c }, VertexData{ float4x4(gl_in[14].VertexData_a_0, gl_in[14].VertexData_a_1, gl_in[14].VertexData_a_2, gl_in[14].VertexData_a_3), spvUnsafeArray({ gl_in[14].VertexData_b_0, gl_in[14].VertexData_b_1 }), gl_in[14].VertexData_c }, VertexData{ float4x4(gl_in[15].VertexData_a_0, gl_in[15].VertexData_a_1, gl_in[15].VertexData_a_2, gl_in[15].VertexData_a_3), spvUnsafeArray({ gl_in[15].VertexData_b_0, gl_in[15].VertexData_b_1 }), gl_in[15].VertexData_c }, VertexData{ float4x4(gl_in[16].VertexData_a_0, gl_in[16].VertexData_a_1, gl_in[16].VertexData_a_2, gl_in[16].VertexData_a_3), spvUnsafeArray({ gl_in[16].VertexData_b_0, gl_in[16].VertexData_b_1 }), gl_in[16].VertexData_c }, VertexData{ float4x4(gl_in[17].VertexData_a_0, gl_in[17].VertexData_a_1, gl_in[17].VertexData_a_2, gl_in[17].VertexData_a_3), spvUnsafeArray({ gl_in[17].VertexData_b_0, gl_in[17].VertexData_b_1 }), gl_in[17].VertexData_c }, VertexData{ float4x4(gl_in[18].VertexData_a_0, gl_in[18].VertexData_a_1, gl_in[18].VertexData_a_2, gl_in[18].VertexData_a_3), spvUnsafeArray({ gl_in[18].VertexData_b_0, gl_in[18].VertexData_b_1 }), gl_in[18].VertexData_c }, VertexData{ float4x4(gl_in[19].VertexData_a_0, gl_in[19].VertexData_a_1, gl_in[19].VertexData_a_2, gl_in[19].VertexData_a_3), spvUnsafeArray({ gl_in[19].VertexData_b_0, gl_in[19].VertexData_b_1 }), gl_in[19].VertexData_c }, VertexData{ float4x4(gl_in[20].VertexData_a_0, gl_in[20].VertexData_a_1, gl_in[20].VertexData_a_2, gl_in[20].VertexData_a_3), spvUnsafeArray({ gl_in[20].VertexData_b_0, gl_in[20].VertexData_b_1 }), gl_in[20].VertexData_c }, VertexData{ float4x4(gl_in[21].VertexData_a_0, gl_in[21].VertexData_a_1, gl_in[21].VertexData_a_2, gl_in[21].VertexData_a_3), spvUnsafeArray({ gl_in[21].VertexData_b_0, gl_in[21].VertexData_b_1 }), gl_in[21].VertexData_c }, VertexData{ float4x4(gl_in[22].VertexData_a_0, gl_in[22].VertexData_a_1, gl_in[22].VertexData_a_2, gl_in[22].VertexData_a_3), spvUnsafeArray({ gl_in[22].VertexData_b_0, gl_in[22].VertexData_b_1 }), gl_in[22].VertexData_c }, VertexData{ float4x4(gl_in[23].VertexData_a_0, gl_in[23].VertexData_a_1, gl_in[23].VertexData_a_2, gl_in[23].VertexData_a_3), spvUnsafeArray({ gl_in[23].VertexData_b_0, gl_in[23].VertexData_b_1 }), gl_in[23].VertexData_c }, VertexData{ float4x4(gl_in[24].VertexData_a_0, gl_in[24].VertexData_a_1, gl_in[24].VertexData_a_2, gl_in[24].VertexData_a_3), spvUnsafeArray({ gl_in[24].VertexData_b_0, gl_in[24].VertexData_b_1 }), gl_in[24].VertexData_c }, VertexData{ float4x4(gl_in[25].VertexData_a_0, gl_in[25].VertexData_a_1, gl_in[25].VertexData_a_2, gl_in[25].VertexData_a_3), spvUnsafeArray({ gl_in[25].VertexData_b_0, gl_in[25].VertexData_b_1 }), gl_in[25].VertexData_c }, VertexData{ float4x4(gl_in[26].VertexData_a_0, gl_in[26].VertexData_a_1, gl_in[26].VertexData_a_2, gl_in[26].VertexData_a_3), spvUnsafeArray({ gl_in[26].VertexData_b_0, gl_in[26].VertexData_b_1 }), gl_in[26].VertexData_c }, VertexData{ float4x4(gl_in[27].VertexData_a_0, gl_in[27].VertexData_a_1, gl_in[27].VertexData_a_2, gl_in[27].VertexData_a_3), spvUnsafeArray({ gl_in[27].VertexData_b_0, gl_in[27].VertexData_b_1 }), gl_in[27].VertexData_c }, VertexData{ float4x4(gl_in[28].VertexData_a_0, gl_in[28].VertexData_a_1, gl_in[28].VertexData_a_2, gl_in[28].VertexData_a_3), spvUnsafeArray({ gl_in[28].VertexData_b_0, gl_in[28].VertexData_b_1 }), gl_in[28].VertexData_c }, VertexData{ float4x4(gl_in[29].VertexData_a_0, gl_in[29].VertexData_a_1, gl_in[29].VertexData_a_2, gl_in[29].VertexData_a_3), spvUnsafeArray({ gl_in[29].VertexData_b_0, gl_in[29].VertexData_b_1 }), gl_in[29].VertexData_c }, VertexData{ float4x4(gl_in[30].VertexData_a_0, gl_in[30].VertexData_a_1, gl_in[30].VertexData_a_2, gl_in[30].VertexData_a_3), spvUnsafeArray({ gl_in[30].VertexData_b_0, gl_in[30].VertexData_b_1 }), gl_in[30].VertexData_c }, VertexData{ float4x4(gl_in[31].VertexData_a_0, gl_in[31].VertexData_a_1, gl_in[31].VertexData_a_2, gl_in[31].VertexData_a_3), spvUnsafeArray({ gl_in[31].VertexData_b_0, gl_in[31].VertexData_b_1 }), gl_in[31].VertexData_c } }); spvUnsafeArray tmp; tmp = _19; int _27 = gl_InvocationID ^ 1; VertexData _30 = VertexData{ float4x4(gl_in[_27].VertexData_a_0, gl_in[_27].VertexData_a_1, gl_in[_27].VertexData_a_2, gl_in[_27].VertexData_a_3), spvUnsafeArray({ gl_in[_27].VertexData_b_0, gl_in[_27].VertexData_b_1 }), gl_in[_27].VertexData_c }; VertexData tmp_single = _30; gl_out[gl_InvocationID].vOutputs = ((tmp[gl_InvocationID].a[1] + tmp[gl_InvocationID].b[1]) + tmp[gl_InvocationID].c) + tmp_single.c; } spirv-cross-2021.01.15/reference/shaders-msl/tesc/load-control-point-array.multi-patch.tesc000066400000000000000000000047461400026215700314710ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 vOutputs; }; struct main0_in { float4 vInputs; ushort2 m_43; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); spvUnsafeArray _15 = spvUnsafeArray({ gl_in[0].vInputs, gl_in[1].vInputs, gl_in[2].vInputs, gl_in[3].vInputs, gl_in[4].vInputs, gl_in[5].vInputs, gl_in[6].vInputs, gl_in[7].vInputs, gl_in[8].vInputs, gl_in[9].vInputs, gl_in[10].vInputs, gl_in[11].vInputs, gl_in[12].vInputs, gl_in[13].vInputs, gl_in[14].vInputs, gl_in[15].vInputs, gl_in[16].vInputs, gl_in[17].vInputs, gl_in[18].vInputs, gl_in[19].vInputs, gl_in[20].vInputs, gl_in[21].vInputs, gl_in[22].vInputs, gl_in[23].vInputs, gl_in[24].vInputs, gl_in[25].vInputs, gl_in[26].vInputs, gl_in[27].vInputs, gl_in[28].vInputs, gl_in[29].vInputs, gl_in[30].vInputs, gl_in[31].vInputs }); spvUnsafeArray tmp; tmp = _15; gl_out[gl_InvocationID].vOutputs = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/reference/shaders-msl/tesc/load-control-point-array.tesc000066400000000000000000000047161400026215700272400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 vOutputs; }; struct main0_in { float4 vInputs [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; spvUnsafeArray _15 = spvUnsafeArray({ gl_in[0].vInputs, gl_in[1].vInputs, gl_in[2].vInputs, gl_in[3].vInputs, gl_in[4].vInputs, gl_in[5].vInputs, gl_in[6].vInputs, gl_in[7].vInputs, gl_in[8].vInputs, gl_in[9].vInputs, gl_in[10].vInputs, gl_in[11].vInputs, gl_in[12].vInputs, gl_in[13].vInputs, gl_in[14].vInputs, gl_in[15].vInputs, gl_in[16].vInputs, gl_in[17].vInputs, gl_in[18].vInputs, gl_in[19].vInputs, gl_in[20].vInputs, gl_in[21].vInputs, gl_in[22].vInputs, gl_in[23].vInputs, gl_in[24].vInputs, gl_in[25].vInputs, gl_in[26].vInputs, gl_in[27].vInputs, gl_in[28].vInputs, gl_in[29].vInputs, gl_in[30].vInputs, gl_in[31].vInputs }); spvUnsafeArray tmp; tmp = _15; gl_out[gl_InvocationID].vOutputs = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/reference/shaders-msl/tesc/matrix-output.multi-patch.tesc000066400000000000000000000035311400026215700274620ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float in_te_attr; float4x3 in_te_data0; float4x3 in_te_data1; }; struct main0_in { float3 in_tc_attr; ushort2 m_103; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 3]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 3; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1]); float _15 = float(gl_InvocationID); float4x3 d = float4x3(float3(_15, 0.0, 0.0), float3(0.0, _15, 0.0), float3(0.0, 0.0, _15), float3(0.0)); gl_out[gl_InvocationID].in_te_data0 = d; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); int _42 = (gl_InvocationID + 1) % 3; gl_out[gl_InvocationID].in_te_data1 = float4x3(d[0] + gl_out[_42].in_te_data0[0], d[1] + gl_out[_42].in_te_data0[1], d[2] + gl_out[_42].in_te_data0[2], d[3] + gl_out[_42].in_te_data0[3]); gl_out[gl_InvocationID].in_te_attr = gl_in[gl_InvocationID].in_tc_attr.x; spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(1.0); } spirv-cross-2021.01.15/reference/shaders-msl/tesc/reload-tess-level.multi-patch.tesc000066400000000000000000000032071400026215700301470ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position; }; struct main0_in { uint3 m_82; ushort2 m_86; float4 gl_Position; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 4]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 4; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 4, spvIndirectParams[1]); if (gl_InvocationID == 0) { spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(4.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(5.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(mix(float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0]), float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3]), 0.5)); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(mix(float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2]), float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1]), 0.5)); } gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; } spirv-cross-2021.01.15/reference/shaders-msl/tesc/reload-tess-level.tesc000066400000000000000000000031371400026215700257230ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position; }; struct main0_in { float4 gl_Position [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 4) return; if (gl_InvocationID == 0) { spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(2.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(3.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(4.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(5.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(mix(float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0]), float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3]), 0.5)); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(mix(float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2]), float(spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1]), 0.5)); } gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; } spirv-cross-2021.01.15/reference/shaders-msl/tesc/struct-output.multi-patch.tesc000066400000000000000000000034171400026215700275050ustar00rootroot00000000000000#include #include using namespace metal; struct te_data { float a; float b; uint c; }; struct main0_out { float in_te_attr; te_data in_te_data0; te_data in_te_data1; }; struct main0_in { float3 in_tc_attr; ushort2 m_107; }; kernel void main0(uint3 gl_GlobalInvocationID [[thread_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_out* gl_out = &spvOut[gl_GlobalInvocationID.x - gl_GlobalInvocationID.x % 3]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_InvocationID = gl_GlobalInvocationID.x % 3; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 3, spvIndirectParams[1]); te_data d = te_data{ float(gl_InvocationID), float(gl_InvocationID + 1), uint(gl_InvocationID) }; gl_out[gl_InvocationID].in_te_data0 = d; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); te_data e = gl_out[(gl_InvocationID + 1) % 3].in_te_data0; gl_out[gl_InvocationID].in_te_data1 = te_data{ d.a + e.a, d.b + e.b, d.c + e.c }; gl_out[gl_InvocationID].in_te_attr = gl_in[gl_InvocationID].in_tc_attr.x; spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(1.0); } spirv-cross-2021.01.15/reference/shaders-msl/tesc/water_tess.multi-patch.tesc000066400000000000000000000126561400026215700270100ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4 uScale; float3 uCamPos; float2 uPatchSize; float2 uMaxTessLevel; float uDistanceMod; float4 uFrustum[6]; }; struct main0_patchOut { float2 vOutPatchPosBase; float4 vPatchLods; }; struct main0_in { float3 vPatchPosBase; ushort2 m_430; }; static inline __attribute__((always_inline)) bool frustum_cull(thread const float2& p0, constant UBO& v_41) { float2 min_xz = (p0 - float2(10.0)) * v_41.uScale.xy; float2 max_xz = ((p0 + v_41.uPatchSize) + float2(10.0)) * v_41.uScale.xy; float3 bb_min = float3(min_xz.x, -10.0, min_xz.y); float3 bb_max = float3(max_xz.x, 10.0, max_xz.y); float3 center = (bb_min + bb_max) * 0.5; float radius = 0.5 * length(bb_max - bb_min); float3 f0 = float3(dot(v_41.uFrustum[0], float4(center, 1.0)), dot(v_41.uFrustum[1], float4(center, 1.0)), dot(v_41.uFrustum[2], float4(center, 1.0))); float3 f1 = float3(dot(v_41.uFrustum[3], float4(center, 1.0)), dot(v_41.uFrustum[4], float4(center, 1.0)), dot(v_41.uFrustum[5], float4(center, 1.0))); bool _205 = any(f0 <= float3(-radius)); bool _215; if (!_205) { _215 = any(f1 <= float3(-radius)); } else { _215 = _205; } return !_215; } static inline __attribute__((always_inline)) float lod_factor(thread const float2& pos_, constant UBO& v_41) { float2 pos = pos_ * v_41.uScale.xy; float3 dist_to_cam = v_41.uCamPos - float3(pos.x, 0.0, pos.y); float level0 = log2((length(dist_to_cam) + 9.9999997473787516355514526367188e-05) * v_41.uDistanceMod); return fast::clamp(level0, 0.0, v_41.uMaxTessLevel.x); } static inline __attribute__((always_inline)) float4 tess_level(thread const float4& lod, constant UBO& v_41) { return exp2(-lod) * v_41.uMaxTessLevel.y; } static inline __attribute__((always_inline)) float tess_level(thread const float& lod, constant UBO& v_41) { return v_41.uMaxTessLevel.y * exp2(-lod); } static inline __attribute__((always_inline)) void compute_tess_levels(thread const float2& p0, constant UBO& v_41, device float2& vOutPatchPosBase, device float4& vPatchLods, device half (&gl_TessLevelOuter)[4], device half (&gl_TessLevelInner)[2]) { vOutPatchPosBase = p0; float2 param = p0 + (float2(-0.5) * v_41.uPatchSize); float l00 = lod_factor(param, v_41); float2 param_1 = p0 + (float2(0.5, -0.5) * v_41.uPatchSize); float l10 = lod_factor(param_1, v_41); float2 param_2 = p0 + (float2(1.5, -0.5) * v_41.uPatchSize); float l20 = lod_factor(param_2, v_41); float2 param_3 = p0 + (float2(-0.5, 0.5) * v_41.uPatchSize); float l01 = lod_factor(param_3, v_41); float2 param_4 = p0 + (float2(0.5) * v_41.uPatchSize); float l11 = lod_factor(param_4, v_41); float2 param_5 = p0 + (float2(1.5, 0.5) * v_41.uPatchSize); float l21 = lod_factor(param_5, v_41); float2 param_6 = p0 + (float2(-0.5, 1.5) * v_41.uPatchSize); float l02 = lod_factor(param_6, v_41); float2 param_7 = p0 + (float2(0.5, 1.5) * v_41.uPatchSize); float l12 = lod_factor(param_7, v_41); float2 param_8 = p0 + (float2(1.5) * v_41.uPatchSize); float l22 = lod_factor(param_8, v_41); float4 lods = float4(dot(float4(l01, l11, l02, l12), float4(0.25)), dot(float4(l00, l10, l01, l11), float4(0.25)), dot(float4(l10, l20, l11, l21), float4(0.25)), dot(float4(l11, l21, l12, l22), float4(0.25))); vPatchLods = lods; float4 outer_lods = fast::min(lods, lods.yzwx); float4 param_9 = outer_lods; float4 levels = tess_level(param_9, v_41); gl_TessLevelOuter[0] = half(levels.x); gl_TessLevelOuter[1] = half(levels.y); gl_TessLevelOuter[2] = half(levels.z); gl_TessLevelOuter[3] = half(levels.w); float min_lod = fast::min(fast::min(lods.x, lods.y), fast::min(lods.z, lods.w)); float param_10 = fast::min(min_lod, l11); float inner = tess_level(param_10, v_41); gl_TessLevelInner[0] = half(inner); gl_TessLevelInner[1] = half(inner); } kernel void main0(constant UBO& v_41 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], device main0_in* spvIn [[buffer(22)]]) { device main0_patchOut& patchOut = spvPatchOut[gl_GlobalInvocationID.x / 1]; device main0_in* gl_in = &spvIn[min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1] - 1) * spvIndirectParams[0]]; uint gl_PrimitiveID = min(gl_GlobalInvocationID.x / 1, spvIndirectParams[1]); float2 p0 = gl_in[0].vPatchPosBase.xy; float2 param = p0; if (!frustum_cull(param, v_41)) { spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(-1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(-1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(-1.0); } else { float2 param_1 = p0; compute_tess_levels(param_1, v_41, patchOut.vOutPatchPosBase, patchOut.vPatchLods, spvTessLevel[gl_PrimitiveID].edgeTessellationFactor, spvTessLevel[gl_PrimitiveID].insideTessellationFactor); } } spirv-cross-2021.01.15/reference/shaders-msl/tesc/water_tess.tesc000066400000000000000000000127401400026215700245540ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4 uScale; float3 uCamPos; float2 uPatchSize; float2 uMaxTessLevel; float uDistanceMod; float4 uFrustum[6]; }; struct main0_patchOut { float2 vOutPatchPosBase; float4 vPatchLods; }; struct main0_in { float2 vPatchPosBase [[attribute(0)]]; }; static inline __attribute__((always_inline)) bool frustum_cull(thread const float2& p0, constant UBO& v_41) { float2 min_xz = (p0 - float2(10.0)) * v_41.uScale.xy; float2 max_xz = ((p0 + v_41.uPatchSize) + float2(10.0)) * v_41.uScale.xy; float3 bb_min = float3(min_xz.x, -10.0, min_xz.y); float3 bb_max = float3(max_xz.x, 10.0, max_xz.y); float3 center = (bb_min + bb_max) * 0.5; float radius = 0.5 * length(bb_max - bb_min); float3 f0 = float3(dot(v_41.uFrustum[0], float4(center, 1.0)), dot(v_41.uFrustum[1], float4(center, 1.0)), dot(v_41.uFrustum[2], float4(center, 1.0))); float3 f1 = float3(dot(v_41.uFrustum[3], float4(center, 1.0)), dot(v_41.uFrustum[4], float4(center, 1.0)), dot(v_41.uFrustum[5], float4(center, 1.0))); bool _205 = any(f0 <= float3(-radius)); bool _215; if (!_205) { _215 = any(f1 <= float3(-radius)); } else { _215 = _205; } return !_215; } static inline __attribute__((always_inline)) float lod_factor(thread const float2& pos_, constant UBO& v_41) { float2 pos = pos_ * v_41.uScale.xy; float3 dist_to_cam = v_41.uCamPos - float3(pos.x, 0.0, pos.y); float level0 = log2((length(dist_to_cam) + 9.9999997473787516355514526367188e-05) * v_41.uDistanceMod); return fast::clamp(level0, 0.0, v_41.uMaxTessLevel.x); } static inline __attribute__((always_inline)) float4 tess_level(thread const float4& lod, constant UBO& v_41) { return exp2(-lod) * v_41.uMaxTessLevel.y; } static inline __attribute__((always_inline)) float tess_level(thread const float& lod, constant UBO& v_41) { return v_41.uMaxTessLevel.y * exp2(-lod); } static inline __attribute__((always_inline)) void compute_tess_levels(thread const float2& p0, constant UBO& v_41, device float2& vOutPatchPosBase, device float4& vPatchLods, device half (&gl_TessLevelOuter)[4], device half (&gl_TessLevelInner)[2]) { vOutPatchPosBase = p0; float2 param = p0 + (float2(-0.5) * v_41.uPatchSize); float l00 = lod_factor(param, v_41); float2 param_1 = p0 + (float2(0.5, -0.5) * v_41.uPatchSize); float l10 = lod_factor(param_1, v_41); float2 param_2 = p0 + (float2(1.5, -0.5) * v_41.uPatchSize); float l20 = lod_factor(param_2, v_41); float2 param_3 = p0 + (float2(-0.5, 0.5) * v_41.uPatchSize); float l01 = lod_factor(param_3, v_41); float2 param_4 = p0 + (float2(0.5) * v_41.uPatchSize); float l11 = lod_factor(param_4, v_41); float2 param_5 = p0 + (float2(1.5, 0.5) * v_41.uPatchSize); float l21 = lod_factor(param_5, v_41); float2 param_6 = p0 + (float2(-0.5, 1.5) * v_41.uPatchSize); float l02 = lod_factor(param_6, v_41); float2 param_7 = p0 + (float2(0.5, 1.5) * v_41.uPatchSize); float l12 = lod_factor(param_7, v_41); float2 param_8 = p0 + (float2(1.5) * v_41.uPatchSize); float l22 = lod_factor(param_8, v_41); float4 lods = float4(dot(float4(l01, l11, l02, l12), float4(0.25)), dot(float4(l00, l10, l01, l11), float4(0.25)), dot(float4(l10, l20, l11, l21), float4(0.25)), dot(float4(l11, l21, l12, l22), float4(0.25))); vPatchLods = lods; float4 outer_lods = fast::min(lods, lods.yzwx); float4 param_9 = outer_lods; float4 levels = tess_level(param_9, v_41); gl_TessLevelOuter[0] = half(levels.x); gl_TessLevelOuter[1] = half(levels.y); gl_TessLevelOuter[2] = half(levels.z); gl_TessLevelOuter[3] = half(levels.w); float min_lod = fast::min(fast::min(lods.x, lods.y), fast::min(lods.z, lods.w)); float param_10 = fast::min(min_lod, l11); float inner = tess_level(param_10, v_41); gl_TessLevelInner[0] = half(inner); gl_TessLevelInner[1] = half(inner); } kernel void main0(main0_in in [[stage_in]], constant UBO& v_41 [[buffer(0)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 1) return; float2 p0 = gl_in[0].vPatchPosBase; float2 param = p0; if (!frustum_cull(param, v_41)) { spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(-1.0); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(-1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(-1.0); spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(-1.0); } else { float2 param_1 = p0; compute_tess_levels(param_1, v_41, patchOut.vOutPatchPosBase, patchOut.vPatchLods, spvTessLevel[gl_PrimitiveID].edgeTessellationFactor, spvTessLevel[gl_PrimitiveID].insideTessellationFactor); } } spirv-cross-2021.01.15/reference/shaders-msl/tese/000077500000000000000000000000001400026215700215125ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/tese/input-array.tese000066400000000000000000000015161400026215700246520ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 Floats [[attribute(0)]]; float4 Floats2 [[attribute(2)]]; }; struct main0_patchIn { patch_control_point gl_in; }; static inline __attribute__((always_inline)) void set_position(thread float4& gl_Position, thread patch_control_point& gl_in, thread float2& gl_TessCoord) { gl_Position = (gl_in[0].Floats * gl_TessCoord.x) + (gl_in[1].Floats2 * gl_TessCoord.y); } [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; set_position(out.gl_Position, patchIn.gl_in, gl_TessCoord); return out; } spirv-cross-2021.01.15/reference/shaders-msl/tese/input-types.tese000066400000000000000000000040071400026215700246760ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Block { float4 a; float4 b; }; struct PatchBlock { float4 a; float4 b; }; struct Foo { float4 a; float4 b; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vColor [[attribute(0)]]; float4 Block_a [[attribute(4)]]; float4 Block_b [[attribute(5)]]; float4 Foo_a [[attribute(14)]]; float4 Foo_b [[attribute(15)]]; }; struct main0_patchIn { float4 vColors [[attribute(1)]]; float4 PatchBlock_a [[attribute(6)]]; float4 PatchBlock_b [[attribute(7)]]; float4 Foo_a [[attribute(8)]]; float4 Foo_b [[attribute(9)]]; patch_control_point gl_in; }; static inline __attribute__((always_inline)) void set_from_function(thread float4& gl_Position, thread patch_control_point& gl_in, thread PatchBlock& patch_block, thread float4& vColors, thread Foo& vFoo) { gl_Position = gl_in[0].Block_a; gl_Position += gl_in[0].Block_b; gl_Position += gl_in[1].Block_a; gl_Position += gl_in[1].Block_b; gl_Position += patch_block.a; gl_Position += patch_block.b; gl_Position += gl_in[0].vColor; gl_Position += gl_in[1].vColor; gl_Position += vColors; Foo foo = vFoo; gl_Position += foo.a; gl_Position += foo.b; Foo _106 = Foo{ gl_in[0].Foo_a, gl_in[0].Foo_b }; foo = _106; gl_Position += foo.a; gl_Position += foo.b; Foo _120 = Foo{ gl_in[1].Foo_a, gl_in[1].Foo_b }; foo = _120; gl_Position += foo.a; gl_Position += foo.b; } [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]]) { main0_out out = {}; PatchBlock patch_block = {}; Foo vFoo = {}; patch_block.a = patchIn.PatchBlock_a; patch_block.b = patchIn.PatchBlock_b; vFoo.a = patchIn.Foo_a; vFoo.b = patchIn.Foo_b; set_from_function(out.gl_Position, patchIn.gl_in, patch_block, patchIn.vColors, vFoo); return out; } spirv-cross-2021.01.15/reference/shaders-msl/tese/load-control-point-array-of-matrix.tese000066400000000000000000000135641400026215700311510ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vInputs_0 [[attribute(0)]]; float4 vInputs_1 [[attribute(1)]]; float4 vInputs_2 [[attribute(2)]]; float4 vInputs_3 [[attribute(3)]]; }; struct main0_patchIn { float4 vBoo_0 [[attribute(4)]]; float4 vBoo_1 [[attribute(5)]]; float4 vBoo_2 [[attribute(6)]]; float4 vBoo_3 [[attribute(7)]]; int vIndex [[attribute(8)]]; patch_control_point gl_in; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]]) { main0_out out = {}; spvUnsafeArray vBoo = {}; vBoo[0] = patchIn.vBoo_0; vBoo[1] = patchIn.vBoo_1; vBoo[2] = patchIn.vBoo_2; vBoo[3] = patchIn.vBoo_3; spvUnsafeArray _16 = spvUnsafeArray({ float4x4(patchIn.gl_in[0].vInputs_0, patchIn.gl_in[0].vInputs_1, patchIn.gl_in[0].vInputs_2, patchIn.gl_in[0].vInputs_3), float4x4(patchIn.gl_in[1].vInputs_0, patchIn.gl_in[1].vInputs_1, patchIn.gl_in[1].vInputs_2, patchIn.gl_in[1].vInputs_3), float4x4(patchIn.gl_in[2].vInputs_0, patchIn.gl_in[2].vInputs_1, patchIn.gl_in[2].vInputs_2, patchIn.gl_in[2].vInputs_3), float4x4(patchIn.gl_in[3].vInputs_0, patchIn.gl_in[3].vInputs_1, patchIn.gl_in[3].vInputs_2, patchIn.gl_in[3].vInputs_3), float4x4(patchIn.gl_in[4].vInputs_0, patchIn.gl_in[4].vInputs_1, patchIn.gl_in[4].vInputs_2, patchIn.gl_in[4].vInputs_3), float4x4(patchIn.gl_in[5].vInputs_0, patchIn.gl_in[5].vInputs_1, patchIn.gl_in[5].vInputs_2, patchIn.gl_in[5].vInputs_3), float4x4(patchIn.gl_in[6].vInputs_0, patchIn.gl_in[6].vInputs_1, patchIn.gl_in[6].vInputs_2, patchIn.gl_in[6].vInputs_3), float4x4(patchIn.gl_in[7].vInputs_0, patchIn.gl_in[7].vInputs_1, patchIn.gl_in[7].vInputs_2, patchIn.gl_in[7].vInputs_3), float4x4(patchIn.gl_in[8].vInputs_0, patchIn.gl_in[8].vInputs_1, patchIn.gl_in[8].vInputs_2, patchIn.gl_in[8].vInputs_3), float4x4(patchIn.gl_in[9].vInputs_0, patchIn.gl_in[9].vInputs_1, patchIn.gl_in[9].vInputs_2, patchIn.gl_in[9].vInputs_3), float4x4(patchIn.gl_in[10].vInputs_0, patchIn.gl_in[10].vInputs_1, patchIn.gl_in[10].vInputs_2, patchIn.gl_in[10].vInputs_3), float4x4(patchIn.gl_in[11].vInputs_0, patchIn.gl_in[11].vInputs_1, patchIn.gl_in[11].vInputs_2, patchIn.gl_in[11].vInputs_3), float4x4(patchIn.gl_in[12].vInputs_0, patchIn.gl_in[12].vInputs_1, patchIn.gl_in[12].vInputs_2, patchIn.gl_in[12].vInputs_3), float4x4(patchIn.gl_in[13].vInputs_0, patchIn.gl_in[13].vInputs_1, patchIn.gl_in[13].vInputs_2, patchIn.gl_in[13].vInputs_3), float4x4(patchIn.gl_in[14].vInputs_0, patchIn.gl_in[14].vInputs_1, patchIn.gl_in[14].vInputs_2, patchIn.gl_in[14].vInputs_3), float4x4(patchIn.gl_in[15].vInputs_0, patchIn.gl_in[15].vInputs_1, patchIn.gl_in[15].vInputs_2, patchIn.gl_in[15].vInputs_3), float4x4(patchIn.gl_in[16].vInputs_0, patchIn.gl_in[16].vInputs_1, patchIn.gl_in[16].vInputs_2, patchIn.gl_in[16].vInputs_3), float4x4(patchIn.gl_in[17].vInputs_0, patchIn.gl_in[17].vInputs_1, patchIn.gl_in[17].vInputs_2, patchIn.gl_in[17].vInputs_3), float4x4(patchIn.gl_in[18].vInputs_0, patchIn.gl_in[18].vInputs_1, patchIn.gl_in[18].vInputs_2, patchIn.gl_in[18].vInputs_3), float4x4(patchIn.gl_in[19].vInputs_0, patchIn.gl_in[19].vInputs_1, patchIn.gl_in[19].vInputs_2, patchIn.gl_in[19].vInputs_3), float4x4(patchIn.gl_in[20].vInputs_0, patchIn.gl_in[20].vInputs_1, patchIn.gl_in[20].vInputs_2, patchIn.gl_in[20].vInputs_3), float4x4(patchIn.gl_in[21].vInputs_0, patchIn.gl_in[21].vInputs_1, patchIn.gl_in[21].vInputs_2, patchIn.gl_in[21].vInputs_3), float4x4(patchIn.gl_in[22].vInputs_0, patchIn.gl_in[22].vInputs_1, patchIn.gl_in[22].vInputs_2, patchIn.gl_in[22].vInputs_3), float4x4(patchIn.gl_in[23].vInputs_0, patchIn.gl_in[23].vInputs_1, patchIn.gl_in[23].vInputs_2, patchIn.gl_in[23].vInputs_3), float4x4(patchIn.gl_in[24].vInputs_0, patchIn.gl_in[24].vInputs_1, patchIn.gl_in[24].vInputs_2, patchIn.gl_in[24].vInputs_3), float4x4(patchIn.gl_in[25].vInputs_0, patchIn.gl_in[25].vInputs_1, patchIn.gl_in[25].vInputs_2, patchIn.gl_in[25].vInputs_3), float4x4(patchIn.gl_in[26].vInputs_0, patchIn.gl_in[26].vInputs_1, patchIn.gl_in[26].vInputs_2, patchIn.gl_in[26].vInputs_3), float4x4(patchIn.gl_in[27].vInputs_0, patchIn.gl_in[27].vInputs_1, patchIn.gl_in[27].vInputs_2, patchIn.gl_in[27].vInputs_3), float4x4(patchIn.gl_in[28].vInputs_0, patchIn.gl_in[28].vInputs_1, patchIn.gl_in[28].vInputs_2, patchIn.gl_in[28].vInputs_3), float4x4(patchIn.gl_in[29].vInputs_0, patchIn.gl_in[29].vInputs_1, patchIn.gl_in[29].vInputs_2, patchIn.gl_in[29].vInputs_3), float4x4(patchIn.gl_in[30].vInputs_0, patchIn.gl_in[30].vInputs_1, patchIn.gl_in[30].vInputs_2, patchIn.gl_in[30].vInputs_3), float4x4(patchIn.gl_in[31].vInputs_0, patchIn.gl_in[31].vInputs_1, patchIn.gl_in[31].vInputs_2, patchIn.gl_in[31].vInputs_3) }); spvUnsafeArray tmp; tmp = _16; out.gl_Position = (tmp[0][patchIn.vIndex] + tmp[1][patchIn.vIndex]) + vBoo[patchIn.vIndex]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/tese/load-control-point-array.tese000066400000000000000000000052251400026215700272400ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vInputs [[attribute(0)]]; }; struct main0_patchIn { float4 vBoo_0 [[attribute(1)]]; float4 vBoo_1 [[attribute(2)]]; float4 vBoo_2 [[attribute(3)]]; float4 vBoo_3 [[attribute(4)]]; int vIndex [[attribute(5)]]; patch_control_point gl_in; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]]) { main0_out out = {}; spvUnsafeArray vBoo = {}; vBoo[0] = patchIn.vBoo_0; vBoo[1] = patchIn.vBoo_1; vBoo[2] = patchIn.vBoo_2; vBoo[3] = patchIn.vBoo_3; spvUnsafeArray _15 = spvUnsafeArray({ patchIn.gl_in[0].vInputs, patchIn.gl_in[1].vInputs, patchIn.gl_in[2].vInputs, patchIn.gl_in[3].vInputs, patchIn.gl_in[4].vInputs, patchIn.gl_in[5].vInputs, patchIn.gl_in[6].vInputs, patchIn.gl_in[7].vInputs, patchIn.gl_in[8].vInputs, patchIn.gl_in[9].vInputs, patchIn.gl_in[10].vInputs, patchIn.gl_in[11].vInputs, patchIn.gl_in[12].vInputs, patchIn.gl_in[13].vInputs, patchIn.gl_in[14].vInputs, patchIn.gl_in[15].vInputs, patchIn.gl_in[16].vInputs, patchIn.gl_in[17].vInputs, patchIn.gl_in[18].vInputs, patchIn.gl_in[19].vInputs, patchIn.gl_in[20].vInputs, patchIn.gl_in[21].vInputs, patchIn.gl_in[22].vInputs, patchIn.gl_in[23].vInputs, patchIn.gl_in[24].vInputs, patchIn.gl_in[25].vInputs, patchIn.gl_in[26].vInputs, patchIn.gl_in[27].vInputs, patchIn.gl_in[28].vInputs, patchIn.gl_in[29].vInputs, patchIn.gl_in[30].vInputs, patchIn.gl_in[31].vInputs }); spvUnsafeArray tmp; tmp = _15; out.gl_Position = (tmp[0] + tmp[1]) + vBoo[patchIn.vIndex]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/tese/quad.domain.tese000066400000000000000000000015121400026215700245730ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_patchIn { float2 gl_TessLevelInner [[attribute(0)]]; float4 gl_TessLevelOuter [[attribute(1)]]; }; [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; gl_TessCoord.y = 1.0 - gl_TessCoord.y; out.gl_Position = float4(((gl_TessCoord.x * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.x) + (((1.0 - gl_TessCoord.x) * patchIn.gl_TessLevelInner.x) * patchIn.gl_TessLevelOuter.z), ((gl_TessCoord.y * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.w) + (((1.0 - gl_TessCoord.y) * patchIn.gl_TessLevelInner.y) * patchIn.gl_TessLevelOuter.y), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/tese/quad.tese000066400000000000000000000020741400026215700233310ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_patchIn { float2 gl_TessLevelInner [[attribute(0)]]; float4 gl_TessLevelOuter [[attribute(1)]]; }; static inline __attribute__((always_inline)) void set_position(thread float4& gl_Position, thread float2& gl_TessCoord, thread float2& gl_TessLevelInner, thread float4& gl_TessLevelOuter) { gl_Position = float4(((gl_TessCoord.x * gl_TessLevelInner.x) * gl_TessLevelOuter.x) + (((1.0 - gl_TessCoord.x) * gl_TessLevelInner.x) * gl_TessLevelOuter.z), ((gl_TessCoord.y * gl_TessLevelInner.y) * gl_TessLevelOuter.y) + (((1.0 - gl_TessCoord.y) * gl_TessLevelInner.y) * gl_TessLevelOuter.w), 0.0, 1.0); } [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; set_position(out.gl_Position, gl_TessCoord, patchIn.gl_TessLevelInner, patchIn.gl_TessLevelOuter); return out; } spirv-cross-2021.01.15/reference/shaders-msl/tese/set-from-function.tese000066400000000000000000000025131400026215700257540ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Block { float4 a; float4 b; }; struct Foo { float4 a; float4 b; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vColor [[attribute(0)]]; float4 Block_a [[attribute(2)]]; float4 Block_b [[attribute(3)]]; }; struct main0_patchIn { float4 vColors [[attribute(1)]]; float4 Foo_a [[attribute(4)]]; float4 Foo_b [[attribute(5)]]; patch_control_point gl_in; }; static inline __attribute__((always_inline)) void set_from_function(thread float4& gl_Position, thread patch_control_point& gl_in, thread float4& vColors, thread Foo& vFoo) { gl_Position = gl_in[0].Block_a; gl_Position += gl_in[0].Block_b; gl_Position += gl_in[1].Block_a; gl_Position += gl_in[1].Block_b; gl_Position += gl_in[0].vColor; gl_Position += gl_in[1].vColor; gl_Position += vColors; gl_Position += vFoo.a; gl_Position += vFoo.b; } [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]]) { main0_out out = {}; Foo vFoo = {}; vFoo.a = patchIn.Foo_a; vFoo.b = patchIn.Foo_b; set_from_function(out.gl_Position, patchIn.gl_in, patchIn.vColors, vFoo); return out; } spirv-cross-2021.01.15/reference/shaders-msl/tese/triangle-tess-level.tese000066400000000000000000000035031400026215700262630ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_patchIn { float4 gl_TessLevel [[attribute(0)]]; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray gl_TessLevelInner = {}; spvUnsafeArray gl_TessLevelOuter = {}; gl_TessLevelInner[0] = patchIn.gl_TessLevel.w; gl_TessLevelOuter[0] = patchIn.gl_TessLevel.x; gl_TessLevelOuter[1] = patchIn.gl_TessLevel.y; gl_TessLevelOuter[2] = patchIn.gl_TessLevel.z; out.gl_Position = float4((gl_TessCoord.x * gl_TessLevelInner[0]) * gl_TessLevelOuter[0], (gl_TessCoord.y * gl_TessLevelInner[0]) * gl_TessLevelOuter[1], (gl_TessCoord.z * gl_TessLevelInner[0]) * gl_TessLevelOuter[2], 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/tese/triangle.tese000066400000000000000000000004061400026215700242010ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; [[ patch(triangle, 0) ]] vertex main0_out main0() { main0_out out = {}; out.gl_Position = float4(1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/tese/water_tess.tese000066400000000000000000000053601400026215700245600ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4x4 uMVP; float4 uScale; float2 uInvScale; float3 uCamPos; float2 uPatchSize; float2 uInvHeightmapSize; }; struct main0_out { float3 vWorld [[user(locn0)]]; float4 vGradNormalTex [[user(locn1)]]; float4 gl_Position [[position]]; }; struct main0_patchIn { float2 vOutPatchPosBase [[attribute(0)]]; float4 vPatchLods [[attribute(1)]]; }; static inline __attribute__((always_inline)) float2 lerp_vertex(thread const float2& tess_coord, thread float2& vOutPatchPosBase, constant UBO& v_31) { return vOutPatchPosBase + (tess_coord * v_31.uPatchSize); } static inline __attribute__((always_inline)) float2 lod_factor(thread const float2& tess_coord, thread float4& vPatchLods) { float2 x = mix(vPatchLods.yx, vPatchLods.zw, float2(tess_coord.x)); float level0 = mix(x.x, x.y, tess_coord.y); float floor_level = floor(level0); float fract_level = level0 - floor_level; return float2(floor_level, fract_level); } static inline __attribute__((always_inline)) float3 sample_height_displacement(thread const float2& uv, thread const float2& off, thread const float2& lod, thread texture2d uHeightmapDisplacement, thread const sampler uHeightmapDisplacementSmplr) { return mix(uHeightmapDisplacement.sample(uHeightmapDisplacementSmplr, (uv + (off * 0.5)), level(lod.x)).xyz, uHeightmapDisplacement.sample(uHeightmapDisplacementSmplr, (uv + (off * 1.0)), level(lod.x + 1.0)).xyz, float3(lod.y)); } [[ patch(quad, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant UBO& v_31 [[buffer(0)]], texture2d uHeightmapDisplacement [[texture(0)]], sampler uHeightmapDisplacementSmplr [[sampler(0)]], float2 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; float2 tess_coord = float3(gl_TessCoord, 0).xy; float2 param = tess_coord; float2 pos = lerp_vertex(param, patchIn.vOutPatchPosBase, v_31); float2 param_1 = tess_coord; float2 lod = lod_factor(param_1, patchIn.vPatchLods); float2 tex = pos * v_31.uInvHeightmapSize; pos *= v_31.uScale.xy; float delta_mod = exp2(lod.x); float2 off = v_31.uInvHeightmapSize * delta_mod; out.vGradNormalTex = float4(tex + (v_31.uInvHeightmapSize * 0.5), tex * v_31.uScale.zw); float2 param_2 = tex; float2 param_3 = off; float2 param_4 = lod; float3 height_displacement = sample_height_displacement(param_2, param_3, param_4, uHeightmapDisplacement, uHeightmapDisplacementSmplr); pos += height_displacement.yz; out.vWorld = float3(pos.x, height_displacement.x, pos.y); out.gl_Position = v_31.uMVP * float4(out.vWorld, 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/000077500000000000000000000000001400026215700215325ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/vert/basic.capture.vert000066400000000000000000000014711400026215700251620ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex void main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]], uint gl_BaseVertex [[base_vertex]], uint gl_InstanceIndex [[instance_id]], uint gl_BaseInstance [[base_instance]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]]) { device main0_out& out = spvOut[(gl_InstanceIndex - gl_BaseInstance) * spvIndirectParams[0] + gl_VertexIndex - gl_BaseVertex]; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; } spirv-cross-2021.01.15/reference/shaders-msl/vert/basic.for-tess.vert000066400000000000000000000013531400026215700252600ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal; float4 gl_Position; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; kernel void main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 spvStageInputSize [[grid_size]], device main0_out* spvOut [[buffer(28)]]) { device main0_out& out = spvOut[gl_GlobalInvocationID.y * spvStageInputSize.x + gl_GlobalInvocationID.x]; if (any(gl_GlobalInvocationID >= spvStageInputSize)) return; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; } spirv-cross-2021.01.15/reference/shaders-msl/vert/basic.vert000066400000000000000000000007661400026215700235260ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _16.uMVP * in.aVertex; out.vNormal = in.aNormal; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/clip-distance-block.no-user-varying.vert000066400000000000000000000007121400026215700313070ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.Position; out.gl_ClipDistance[0] = in.Position.x; out.gl_ClipDistance[1] = in.Position.y; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/clip-distance-block.vert000066400000000000000000000012141400026215700262410ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_ClipDistance [[clip_distance]] [2]; float gl_ClipDistance_0 [[user(clip0)]]; float gl_ClipDistance_1 [[user(clip1)]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = in.Position; out.gl_ClipDistance[0] = in.Position.x; out.gl_ClipDistance[1] = in.Position.y; out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; out.gl_ClipDistance_1 = out.gl_ClipDistance[1]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/copy.flatten.vert000066400000000000000000000020701400026215700250410ustar00rootroot00000000000000#include #include using namespace metal; struct Light { packed_float3 Position; float Radius; float4 Color; }; struct UBO { float4x4 uMVP; Light lights[4]; }; struct Light_1 { float3 Position; float Radius; float4 Color; }; struct main0_out { float4 vColor [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _21 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _21.uMVP * in.aVertex; out.vColor = float4(0.0); Light_1 light; for (int i = 0; i < 4; i++) { light.Position = float3(_21.lights[i].Position); light.Radius = _21.lights[i].Radius; light.Color = _21.lights[i].Color; float3 L = in.aVertex.xyz - light.Position; out.vColor += ((_21.lights[i].Color * fast::clamp(1.0 - (length(L) / light.Radius), 0.0, 1.0)) * dot(in.aNormal, normalize(L))); } return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/dynamic.flatten.vert000066400000000000000000000015361400026215700255210ustar00rootroot00000000000000#include #include using namespace metal; struct Light { packed_float3 Position; float Radius; float4 Color; }; struct UBO { float4x4 uMVP; Light lights[4]; }; struct main0_out { float4 vColor [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _21 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _21.uMVP * in.aVertex; out.vColor = float4(0.0); for (int i = 0; i < 4; i++) { float3 L = in.aVertex.xyz - float3(_21.lights[i].Position); out.vColor += ((_21.lights[i].Color * fast::clamp(1.0 - (length(L) / _21.lights[i].Radius), 0.0, 1.0)) * dot(in.aNormal, normalize(L))); } return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/float-math.invariant-float-math.vert000066400000000000000000000067021400026215700305210ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Matrices { float4x4 vpMatrix; float4x4 wMatrix; float4x3 wMatrix4x3; float3x4 wMatrix3x4; }; struct main0_out { float3 OutNormal [[user(locn0)]]; float4 OutWorldPos_0 [[user(locn1)]]; float4 OutWorldPos_1 [[user(locn2)]]; float4 OutWorldPos_2 [[user(locn3)]]; float4 OutWorldPos_3 [[user(locn4)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 InPos [[attribute(0)]]; float3 InNormal [[attribute(1)]]; }; template T spvFMul(T l, T r) { return fma(l, r, T(0)); } template vec spvFMulVectorMatrix(vec v, matrix m) { vec res = vec(0); for (uint i = Rows; i > 0; --i) { vec tmp(0); for (uint j = 0; j < Cols; ++j) { tmp[j] = m[j][i - 1]; } res = fma(tmp, vec(v[i - 1]), res); } return res; } template vec spvFMulMatrixVector(matrix m, vec v) { vec res = vec(0); for (uint i = Cols; i > 0; --i) { res = fma(m[i - 1], vec(v[i - 1]), res); } return res; } template matrix spvFMulMatrixMatrix(matrix l, matrix r) { matrix res; for (uint i = 0; i < RCols; i++) { vec tmp(0); for (uint j = 0; j < LCols; j++) { tmp = fma(vec(r[i][j]), l[j], tmp); } res[i] = tmp; } return res; } vertex main0_out main0(main0_in in [[stage_in]], constant Matrices& _22 [[buffer(0)]]) { main0_out out = {}; spvUnsafeArray OutWorldPos = {}; out.gl_Position = spvFMulMatrixVector(spvFMulMatrixMatrix(_22.vpMatrix, _22.wMatrix), float4(in.InPos, 1.0)); OutWorldPos[0] = spvFMulMatrixVector(_22.wMatrix, float4(in.InPos, 1.0)); OutWorldPos[1] = spvFMulVectorMatrix(float4(in.InPos, 1.0), _22.wMatrix); OutWorldPos[2] = spvFMulMatrixVector(_22.wMatrix3x4, in.InPos); OutWorldPos[3] = spvFMulVectorMatrix(in.InPos, _22.wMatrix4x3); out.OutNormal = spvFMulMatrixVector(_22.wMatrix, float4(in.InNormal, 0.0)).xyz; out.OutWorldPos_0 = OutWorldPos[0]; out.OutWorldPos_1 = OutWorldPos[1]; out.OutWorldPos_2 = OutWorldPos[2]; out.OutWorldPos_3 = OutWorldPos[3]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/float-math.vert000066400000000000000000000042211400026215700244670ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Matrices { float4x4 vpMatrix; float4x4 wMatrix; float4x3 wMatrix4x3; float3x4 wMatrix3x4; }; struct main0_out { float3 OutNormal [[user(locn0)]]; float4 OutWorldPos_0 [[user(locn1)]]; float4 OutWorldPos_1 [[user(locn2)]]; float4 OutWorldPos_2 [[user(locn3)]]; float4 OutWorldPos_3 [[user(locn4)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 InPos [[attribute(0)]]; float3 InNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant Matrices& _22 [[buffer(0)]]) { main0_out out = {}; spvUnsafeArray OutWorldPos = {}; out.gl_Position = (_22.vpMatrix * _22.wMatrix) * float4(in.InPos, 1.0); OutWorldPos[0] = _22.wMatrix * float4(in.InPos, 1.0); OutWorldPos[1] = float4(in.InPos, 1.0) * _22.wMatrix; OutWorldPos[2] = _22.wMatrix3x4 * in.InPos; OutWorldPos[3] = in.InPos * _22.wMatrix4x3; out.OutNormal = (_22.wMatrix * float4(in.InNormal, 0.0)).xyz; out.OutWorldPos_0 = OutWorldPos[0]; out.OutWorldPos_1 = OutWorldPos[1]; out.OutWorldPos_2 = OutWorldPos[2]; out.OutWorldPos_3 = OutWorldPos[3]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/functions.vert000066400000000000000000000107551400026215700244540ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4x4 uMVP; float3 rotDeg; float3 rotRad; int2 bits; }; struct main0_out { float3 vNormal [[user(locn0)]]; float3 vRotDeg [[user(locn1)]]; float3 vRotRad [[user(locn2)]]; int2 vLSB [[user(locn3)]]; int2 vMSB [[user(locn4)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; // Implementation of the GLSL radians() function template inline T radians(T d) { return d * T(0.01745329251); } // Implementation of the GLSL degrees() function template inline T degrees(T r) { return r * T(57.2957795131); } // Implementation of the GLSL findLSB() function template inline T spvFindLSB(T x) { return select(ctz(x), T(-1), x == T(0)); } // Implementation of the signed GLSL findMSB() function template inline T spvFindSMSB(T x) { T v = select(x, T(-1) - x, x < T(0)); return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0)); } // Returns the determinant of a 2x2 matrix. static inline __attribute__((always_inline)) float spvDet2x2(float a1, float a2, float b1, float b2) { return a1 * b2 - b1 * a2; } // Returns the determinant of a 3x3 matrix. static inline __attribute__((always_inline)) float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) { return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3); } // Returns the inverse of a matrix, by using the algorithm of calculating the classical // adjoint and dividing by the determinant. The contents of the matrix are changed. static inline __attribute__((always_inline)) float4x4 spvInverse4x4(float4x4 m) { float4x4 adj; // The adjoint matrix (inverse after dividing by determinant) // Create the transpose of the cofactors, as the classical adjoint of the matrix. adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]); adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]); adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]); adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]); adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]); adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]); adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]); adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]); adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]); adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]); adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]); adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]); // Calculate the determinant as a combination of the cofactors of the first row. float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] * m[3][0]); // Divide the classical adjoint matrix by the determinant. // If determinant is zero, matrix is not invertable, so leave it unchanged. return (det != 0.0f) ? (adj * (1.0f / det)) : m; } vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = spvInverse4x4(_18.uMVP) * in.aVertex; out.vNormal = in.aNormal; out.vRotDeg = degrees(_18.rotRad); out.vRotRad = radians(_18.rotDeg); out.vLSB = spvFindLSB(_18.bits); out.vMSB = spvFindSMSB(_18.bits); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/in_out_array_mat.vert000066400000000000000000000070401400026215700257710ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct UBO { float4x4 projection; float4x4 model; float lodBias; }; struct main0_out { float3 outPos [[user(locn0)]]; float3 outNormal [[user(locn1)]]; float4 outTransModel_0 [[user(locn2)]]; float4 outTransModel_1 [[user(locn3)]]; float4 outTransModel_2 [[user(locn4)]]; float4 outTransModel_3 [[user(locn5)]]; float outLodBias [[user(locn6)]]; float4 color [[user(locn7)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 inPos [[attribute(0)]]; float4 colors_0 [[attribute(1)]]; float4 colors_1 [[attribute(2)]]; float4 colors_2 [[attribute(3)]]; float3 inNormal [[attribute(4)]]; float4 inViewMat_0 [[attribute(5)]]; float4 inViewMat_1 [[attribute(6)]]; float4 inViewMat_2 [[attribute(7)]]; float4 inViewMat_3 [[attribute(8)]]; }; static inline __attribute__((always_inline)) void write_deeper_in_function(thread float4x4& outTransModel, constant UBO& ubo, thread float4& color, thread spvUnsafeArray (&colors)) { outTransModel[1].y = ubo.lodBias; color = colors[2]; } static inline __attribute__((always_inline)) void write_in_function(thread float4x4& outTransModel, constant UBO& ubo, thread float4& color, thread spvUnsafeArray (&colors), thread float3& inNormal) { outTransModel[2] = float4(inNormal, 1.0); write_deeper_in_function(outTransModel, ubo, color, colors); } vertex main0_out main0(main0_in in [[stage_in]], constant UBO& ubo [[buffer(0)]]) { main0_out out = {}; float4x4 outTransModel = {}; spvUnsafeArray colors = {}; float4x4 inViewMat = {}; colors[0] = in.colors_0; colors[1] = in.colors_1; colors[2] = in.colors_2; inViewMat[0] = in.inViewMat_0; inViewMat[1] = in.inViewMat_1; inViewMat[2] = in.inViewMat_2; inViewMat[3] = in.inViewMat_3; out.gl_Position = (ubo.projection * ubo.model) * float4(in.inPos, 1.0); out.outPos = float3((ubo.model * float4(in.inPos, 1.0)).xyz); out.outNormal = float3x3(float3(float3(ubo.model[0].x, ubo.model[0].y, ubo.model[0].z)), float3(float3(ubo.model[1].x, ubo.model[1].y, ubo.model[1].z)), float3(float3(ubo.model[2].x, ubo.model[2].y, ubo.model[2].z))) * in.inNormal; out.outLodBias = ubo.lodBias; outTransModel = transpose(ubo.model) * inViewMat; write_in_function(outTransModel, ubo, out.color, colors, in.inNormal); out.outTransModel_0 = outTransModel[0]; out.outTransModel_1 = outTransModel[1]; out.outTransModel_2 = outTransModel[2]; out.outTransModel_3 = outTransModel[3]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/interface-block-block-composites.frag000066400000000000000000000043741400026215700307060ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Vert { float3x3 wMatrix; float4 wTmp; spvUnsafeArray arr; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float3 vMatrix_0 [[user(locn0)]]; float3 vMatrix_1 [[user(locn1)]]; float3 vMatrix_2 [[user(locn2)]]; float3 Vert_wMatrix_0 [[user(locn4)]]; float3 Vert_wMatrix_1 [[user(locn5)]]; float3 Vert_wMatrix_2 [[user(locn6)]]; float4 Vert_wTmp [[user(locn7)]]; float Vert_arr_0 [[user(locn8)]]; float Vert_arr_1 [[user(locn9)]]; float Vert_arr_2 [[user(locn10)]]; float Vert_arr_3 [[user(locn11)]]; }; fragment main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; Vert _17 = {}; float3x3 vMatrix = {}; _17.wMatrix[0] = in.Vert_wMatrix_0; _17.wMatrix[1] = in.Vert_wMatrix_1; _17.wMatrix[2] = in.Vert_wMatrix_2; _17.wTmp = in.Vert_wTmp; _17.arr[0] = in.Vert_arr_0; _17.arr[1] = in.Vert_arr_1; _17.arr[2] = in.Vert_arr_2; _17.arr[3] = in.Vert_arr_3; vMatrix[0] = in.vMatrix_0; vMatrix[1] = in.vMatrix_1; vMatrix[2] = in.vMatrix_2; out.FragColor = (_17.wMatrix[0].xxyy + _17.wTmp) + vMatrix[1].yyzz; for (int i = 0; i < 4; i++) { out.FragColor += float4(_17.arr[i]); } return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/interface-block-block-composites.vert000066400000000000000000000047111400026215700307420ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct Vert { spvUnsafeArray arr; float3x3 wMatrix; float4 wTmp; }; struct main0_out { float3 vMatrix_0 [[user(locn0)]]; float3 vMatrix_1 [[user(locn1)]]; float3 vMatrix_2 [[user(locn2)]]; float Vert_arr_0 [[user(locn4)]]; float Vert_arr_1 [[user(locn5)]]; float Vert_arr_2 [[user(locn6)]]; float3 Vert_wMatrix_0 [[user(locn7)]]; float3 Vert_wMatrix_1 [[user(locn8)]]; float3 Vert_wMatrix_2 [[user(locn9)]]; float4 Vert_wTmp [[user(locn10)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 Matrix_0 [[attribute(0)]]; float3 Matrix_1 [[attribute(1)]]; float3 Matrix_2 [[attribute(2)]]; float4 Pos [[attribute(4)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float3x3 vMatrix = {}; Vert _20 = {}; float3x3 Matrix = {}; Matrix[0] = in.Matrix_0; Matrix[1] = in.Matrix_1; Matrix[2] = in.Matrix_2; vMatrix = Matrix; _20.wMatrix = Matrix; _20.arr[0] = 1.0; _20.arr[1] = 2.0; _20.arr[2] = 3.0; _20.wTmp = in.Pos; out.gl_Position = in.Pos; out.vMatrix_0 = vMatrix[0]; out.vMatrix_1 = vMatrix[1]; out.vMatrix_2 = vMatrix[2]; out.Vert_arr_0 = _20.arr[0]; out.Vert_arr_1 = _20.arr[1]; out.Vert_arr_2 = _20.arr[2]; out.Vert_wMatrix_0 = _20.wMatrix[0]; out.Vert_wMatrix_1 = _20.wMatrix[1]; out.Vert_wMatrix_2 = _20.wMatrix[2]; out.Vert_wTmp = _20.wTmp; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/interpolation-qualifiers-block.vert000066400000000000000000000022711400026215700305570ustar00rootroot00000000000000#include #include using namespace metal; struct Output { float2 v0; float2 v1; float3 v2; float4 v3; float v4; float v5; float v6; }; struct main0_out { float2 Output_v0 [[user(locn0)]]; float2 Output_v1 [[user(locn1)]]; float3 Output_v2 [[user(locn2)]]; float4 Output_v3 [[user(locn3)]]; float Output_v4 [[user(locn4)]]; float Output_v5 [[user(locn5)]]; float Output_v6 [[user(locn6)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; Output outp = {}; outp.v0 = in.Position.xy; outp.v1 = in.Position.zw; outp.v2 = float3(in.Position.x, in.Position.z * in.Position.y, in.Position.x); outp.v3 = in.Position.xxyy; outp.v4 = in.Position.w; outp.v5 = in.Position.y; outp.v6 = in.Position.x * in.Position.w; out.gl_Position = in.Position; out.Output_v0 = outp.v0; out.Output_v1 = outp.v1; out.Output_v2 = outp.v2; out.Output_v3 = outp.v3; out.Output_v4 = outp.v4; out.Output_v5 = outp.v5; out.Output_v6 = outp.v6; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/interpolation-qualifiers.vert000066400000000000000000000014461400026215700274720ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float2 v0 [[user(locn0)]]; float2 v1 [[user(locn1)]]; float3 v2 [[user(locn2)]]; float4 v3 [[user(locn3)]]; float v4 [[user(locn4)]]; float v5 [[user(locn5)]]; float v6 [[user(locn6)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.v0 = in.Position.xy; out.v1 = in.Position.zw; out.v2 = float3(in.Position.x, in.Position.z * in.Position.y, in.Position.x); out.v3 = in.Position.xxyy; out.v4 = in.Position.w; out.v5 = in.Position.y; out.v6 = in.Position.x * in.Position.w; out.gl_Position = in.Position; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/invariant.msl21.vert000066400000000000000000000007321400026215700253660ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position, invariant]]; }; struct main0_in { float4 vInput0 [[attribute(0)]]; float4 vInput1 [[attribute(1)]]; float4 vInput2 [[attribute(2)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float4 _20 = in.vInput1 * in.vInput2; float4 _21 = in.vInput0 + _20; out.gl_Position = _21; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/leaf-function.capture.vert000066400000000000000000000021541400026215700266320ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; static inline __attribute__((always_inline)) void set_output(device float4& gl_Position, constant UBO& v_18, thread float4& aVertex, device float3& vNormal, thread float3& aNormal) { gl_Position = v_18.uMVP * aVertex; vNormal = aNormal; } vertex void main0(main0_in in [[stage_in]], constant UBO& v_18 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]], uint gl_BaseVertex [[base_vertex]], uint gl_InstanceIndex [[instance_id]], uint gl_BaseInstance [[base_instance]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]]) { device main0_out& out = spvOut[(gl_InstanceIndex - gl_BaseInstance) * spvIndirectParams[0] + gl_VertexIndex - gl_BaseVertex]; set_output(out.gl_Position, v_18, in.aVertex, out.vNormal, in.aNormal); } spirv-cross-2021.01.15/reference/shaders-msl/vert/leaf-function.for-tess.vert000066400000000000000000000020361400026215700267300ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4x4 uMVP; }; struct main0_out { float3 vNormal; float4 gl_Position; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; static inline __attribute__((always_inline)) void set_output(device float4& gl_Position, constant UBO& v_18, thread float4& aVertex, device float3& vNormal, thread float3& aNormal) { gl_Position = v_18.uMVP * aVertex; vNormal = aNormal; } kernel void main0(main0_in in [[stage_in]], constant UBO& v_18 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 spvStageInputSize [[grid_size]], device main0_out* spvOut [[buffer(28)]]) { device main0_out& out = spvOut[gl_GlobalInvocationID.y * spvStageInputSize.x + gl_GlobalInvocationID.x]; if (any(gl_GlobalInvocationID >= spvStageInputSize)) return; set_output(out.gl_Position, v_18, in.aVertex, out.vNormal, in.aNormal); } spirv-cross-2021.01.15/reference/shaders-msl/vert/no-disable-vertex-out.frag-output.vert000066400000000000000000000011101400026215700310360ustar00rootroot00000000000000#include #include using namespace metal; struct buf { float4x4 MVP; float4 position[36]; float4 attr[36]; }; struct main0_out { float4 texcoord [[user(locn0)]]; float3 frag_pos [[user(locn1)]]; float4 gl_Position [[position]]; }; vertex main0_out main0(constant buf& ubuf [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.texcoord = ubuf.attr[int(gl_VertexIndex)]; out.gl_Position = ubuf.MVP * ubuf.position[int(gl_VertexIndex)]; out.frag_pos = out.gl_Position.xyz; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/no_stage_out.for-tess.vert000066400000000000000000000014141400026215700266630ustar00rootroot00000000000000#include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_10_12 { uint4 _RESERVED_IDENTIFIER_FIXUP_m0[1024]; }; struct main0_in { uint4 _RESERVED_IDENTIFIER_FIXUP_19 [[attribute(0)]]; }; kernel void main0(main0_in in [[stage_in]], device _RESERVED_IDENTIFIER_FIXUP_10_12& _RESERVED_IDENTIFIER_FIXUP_12 [[buffer(0)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]], uint3 spvStageInputSize [[grid_size]], uint3 spvDispatchBase [[grid_origin]]) { if (any(gl_GlobalInvocationID >= spvStageInputSize)) return; uint gl_VertexIndex = gl_GlobalInvocationID.x + spvDispatchBase.x; _RESERVED_IDENTIFIER_FIXUP_12._RESERVED_IDENTIFIER_FIXUP_m0[int(gl_VertexIndex)] = in._RESERVED_IDENTIFIER_FIXUP_19; } spirv-cross-2021.01.15/reference/shaders-msl/vert/no_stage_out.vert000066400000000000000000000010301400026215700251140ustar00rootroot00000000000000#include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_10_12 { uint4 _RESERVED_IDENTIFIER_FIXUP_m0[1024]; }; struct main0_in { uint4 _RESERVED_IDENTIFIER_FIXUP_19 [[attribute(0)]]; }; vertex void main0(main0_in in [[stage_in]], device _RESERVED_IDENTIFIER_FIXUP_10_12& _RESERVED_IDENTIFIER_FIXUP_12 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { _RESERVED_IDENTIFIER_FIXUP_12._RESERVED_IDENTIFIER_FIXUP_m0[int(gl_VertexIndex)] = in._RESERVED_IDENTIFIER_FIXUP_19; } spirv-cross-2021.01.15/reference/shaders-msl/vert/no_stage_out.write_buff.vert000066400000000000000000000020021400026215700272470ustar00rootroot00000000000000#include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_33_35 { uint4 _RESERVED_IDENTIFIER_FIXUP_m0[1024]; }; struct _RESERVED_IDENTIFIER_FIXUP_38_40 { uint4 _RESERVED_IDENTIFIER_FIXUP_m0[1024]; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 _RESERVED_IDENTIFIER_FIXUP_14 [[attribute(0)]]; }; vertex void main0(main0_in in [[stage_in]], device _RESERVED_IDENTIFIER_FIXUP_33_35& _RESERVED_IDENTIFIER_FIXUP_35 [[buffer(0)]], constant _RESERVED_IDENTIFIER_FIXUP_38_40& _RESERVED_IDENTIFIER_FIXUP_40 [[buffer(1)]]) { main0_out out = {}; out.gl_Position = in._RESERVED_IDENTIFIER_FIXUP_14; for (int _RESERVED_IDENTIFIER_FIXUP_19 = 0; _RESERVED_IDENTIFIER_FIXUP_19 < 1024; _RESERVED_IDENTIFIER_FIXUP_19++) { _RESERVED_IDENTIFIER_FIXUP_35._RESERVED_IDENTIFIER_FIXUP_m0[_RESERVED_IDENTIFIER_FIXUP_19] = _RESERVED_IDENTIFIER_FIXUP_40._RESERVED_IDENTIFIER_FIXUP_m0[_RESERVED_IDENTIFIER_FIXUP_19]; } } spirv-cross-2021.01.15/reference/shaders-msl/vert/no_stage_out.write_buff_atomic.vert000066400000000000000000000014471400026215700306170ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_19_21 { uint _RESERVED_IDENTIFIER_FIXUP_m0; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 _RESERVED_IDENTIFIER_FIXUP_14 [[attribute(0)]]; }; vertex void main0(main0_in in [[stage_in]], volatile device _RESERVED_IDENTIFIER_FIXUP_19_21& _RESERVED_IDENTIFIER_FIXUP_21 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = in._RESERVED_IDENTIFIER_FIXUP_14; uint _29 = atomic_fetch_add_explicit((volatile device atomic_uint*)&_RESERVED_IDENTIFIER_FIXUP_21._RESERVED_IDENTIFIER_FIXUP_m0, 1u, memory_order_relaxed); uint _RESERVED_IDENTIFIER_FIXUP_26 = _29; } spirv-cross-2021.01.15/reference/shaders-msl/vert/no_stage_out.write_tex.vert000066400000000000000000000013761400026215700271420ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 _RESERVED_IDENTIFIER_FIXUP_14 [[attribute(0)]]; }; vertex void main0(main0_in in [[stage_in]], texture1d _RESERVED_IDENTIFIER_FIXUP_32 [[texture(0)]], texture1d _RESERVED_IDENTIFIER_FIXUP_35 [[texture(1)]]) { main0_out out = {}; out.gl_Position = in._RESERVED_IDENTIFIER_FIXUP_14; for (int _RESERVED_IDENTIFIER_FIXUP_19 = 0; _RESERVED_IDENTIFIER_FIXUP_19 < 128; _RESERVED_IDENTIFIER_FIXUP_19++) { _RESERVED_IDENTIFIER_FIXUP_32.write(_RESERVED_IDENTIFIER_FIXUP_35.read(uint(_RESERVED_IDENTIFIER_FIXUP_19)), uint(_RESERVED_IDENTIFIER_FIXUP_19)); } } spirv-cross-2021.01.15/reference/shaders-msl/vert/out_block.vert000066400000000000000000000014531400026215700244200ustar00rootroot00000000000000#include #include using namespace metal; struct Transform { float4x4 transform; }; struct VertexOut { float4 color; float4 color2; }; struct main0_out { float4 VertexOut_color [[user(locn2)]]; float4 VertexOut_color2 [[user(locn3)]]; float4 gl_Position [[position]]; }; struct main0_in { float3 position [[attribute(0)]]; float4 color [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant Transform& block [[buffer(0)]]) { main0_out out = {}; VertexOut outputs = {}; out.gl_Position = block.transform * float4(in.position, 1.0); outputs.color = in.color; outputs.color2 = in.color + float4(1.0); out.VertexOut_color = outputs.color; out.VertexOut_color2 = outputs.color2; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/packed-bool-to-uint.vert000066400000000000000000000013261400026215700262130ustar00rootroot00000000000000#include #include using namespace metal; struct Struct { uint flags[1]; }; struct defaultUniformsVS { Struct flags; float4 uquad[4]; float4x4 umatrix; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant defaultUniformsVS& _24 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.gl_Position = _24.umatrix * float4(_24.uquad[int(gl_VertexIndex)].x, _24.uquad[int(gl_VertexIndex)].y, in.a_position.z, in.a_position.w); if (_24.flags.flags[0] != 0u) { out.gl_Position.z = 0.0; } return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/packed-bool2-to-packed_uint2.vert000066400000000000000000000013311400026215700276620ustar00rootroot00000000000000#include #include using namespace metal; struct Struct { uint2 flags[1]; }; struct defaultUniformsVS { Struct flags; float4 uquad[4]; float4x4 umatrix; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant defaultUniformsVS& _25 [[buffer(0)]], uint gl_VertexIndex [[vertex_id]]) { main0_out out = {}; out.gl_Position = _25.umatrix * float4(_25.uquad[int(gl_VertexIndex)].x, _25.uquad[int(gl_VertexIndex)].y, in.a_position.z, in.a_position.w); if (_25.flags.flags[0].x != 0u) { out.gl_Position.z = 0.0; } return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/packed_matrix.vert000066400000000000000000000041741400026215700252550ustar00rootroot00000000000000#include #include using namespace metal; struct _RESERVED_IDENTIFIER_FIXUP_1365_18812 { float3x4 _RESERVED_IDENTIFIER_FIXUP_m0; float3x4 _RESERVED_IDENTIFIER_FIXUP_m1; }; struct _RESERVED_IDENTIFIER_FIXUP_1126_22044 { float4x4 _RESERVED_IDENTIFIER_FIXUP_m0; float4x4 _RESERVED_IDENTIFIER_FIXUP_m1; float _RESERVED_IDENTIFIER_FIXUP_m9; char _m3_pad[12]; packed_float3 _RESERVED_IDENTIFIER_FIXUP_m10; float _RESERVED_IDENTIFIER_FIXUP_m11; packed_float3 _RESERVED_IDENTIFIER_FIXUP_m12; float _RESERVED_IDENTIFIER_FIXUP_m17; float _RESERVED_IDENTIFIER_FIXUP_m18; float _RESERVED_IDENTIFIER_FIXUP_m19; float2 _RESERVED_IDENTIFIER_FIXUP_m20; }; struct main0_out { float3 _RESERVED_IDENTIFIER_FIXUP_3976 [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 _RESERVED_IDENTIFIER_FIXUP_5275 [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant _RESERVED_IDENTIFIER_FIXUP_1365_18812& _RESERVED_IDENTIFIER_FIXUP_18812 [[buffer(0)]], constant _RESERVED_IDENTIFIER_FIXUP_1126_22044& _RESERVED_IDENTIFIER_FIXUP_22044 [[buffer(1)]]) { main0_out out = {}; float3 _RESERVED_IDENTIFIER_FIXUP_2; float3 _RESERVED_IDENTIFIER_FIXUP_23783; for (;;) { _RESERVED_IDENTIFIER_FIXUP_23783 = normalize(float4(in._RESERVED_IDENTIFIER_FIXUP_5275.xyz, 0.0) * _RESERVED_IDENTIFIER_FIXUP_18812._RESERVED_IDENTIFIER_FIXUP_m1); break; } float4 _RESERVED_IDENTIFIER_FIXUP_14995 = _RESERVED_IDENTIFIER_FIXUP_22044._RESERVED_IDENTIFIER_FIXUP_m0 * float4(float3(_RESERVED_IDENTIFIER_FIXUP_22044._RESERVED_IDENTIFIER_FIXUP_m10) + (in._RESERVED_IDENTIFIER_FIXUP_5275.xyz * (_RESERVED_IDENTIFIER_FIXUP_22044._RESERVED_IDENTIFIER_FIXUP_m17 + _RESERVED_IDENTIFIER_FIXUP_22044._RESERVED_IDENTIFIER_FIXUP_m18)), 1.0); out._RESERVED_IDENTIFIER_FIXUP_3976 = _RESERVED_IDENTIFIER_FIXUP_23783; float4 _RESERVED_IDENTIFIER_FIXUP_6282 = _RESERVED_IDENTIFIER_FIXUP_14995; _RESERVED_IDENTIFIER_FIXUP_6282.y = -_RESERVED_IDENTIFIER_FIXUP_14995.y; out.gl_Position = _RESERVED_IDENTIFIER_FIXUP_6282; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/pointsize.vert000066400000000000000000000011201400026215700244520ustar00rootroot00000000000000#include #include using namespace metal; struct params { float4x4 mvp; float psize; }; struct main0_out { float4 color [[user(locn0)]]; float4 gl_Position [[position]]; float gl_PointSize [[point_size]]; }; struct main0_in { float4 position [[attribute(0)]]; float4 color0 [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant params& _19 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _19.mvp * in.position; out.gl_PointSize = _19.psize; out.color = in.color0; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/read-from-row-major-array.vert000066400000000000000000000031571400026215700273450ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct Block { float3x4 var[3][4]; }; struct main0_out { float v_vtxResult [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 a_position [[attribute(0)]]; }; static inline __attribute__((always_inline)) float compare_float(thread const float& a, thread const float& b) { return float(abs(a - b) < 0.0500000007450580596923828125); } static inline __attribute__((always_inline)) float compare_vec3(thread const float3& a, thread const float3& b) { float param = a.x; float param_1 = b.x; float param_2 = a.y; float param_3 = b.y; float param_4 = a.z; float param_5 = b.z; return (compare_float(param, param_1) * compare_float(param_2, param_3)) * compare_float(param_4, param_5); } static inline __attribute__((always_inline)) float compare_mat2x3(thread const float2x3& a, thread const float2x3& b) { float3 param = a[0]; float3 param_1 = b[0]; float3 param_2 = a[1]; float3 param_3 = b[1]; return compare_vec3(param, param_1) * compare_vec3(param_2, param_3); } vertex main0_out main0(main0_in in [[stage_in]], constant Block& _104 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = in.a_position; float result = 1.0; float2x3 param = transpose(float3x2(_104.var[0][0][0].xy, _104.var[0][0][1].xy, _104.var[0][0][2].xy)); float2x3 param_1 = float2x3(float3(2.0, 6.0, -6.0), float3(0.0, 5.0, 5.0)); result *= compare_mat2x3(param, param_1); out.v_vtxResult = result; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/resource-arrays-leaf.ios.vert000066400000000000000000000024561400026215700272670ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct storage_block { uint4 baz; int2 quux; }; struct constant_block { float4 foo; int bar; }; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 3 #endif constant int arraySize = SPIRV_CROSS_CONSTANT_ID_0; static inline __attribute__((always_inline)) void doWork(device storage_block* (&storage)[2], constant constant_block* (&constants)[4], thread const array, 3> images) { storage[0]->baz = uint4(constants[3]->foo); storage[1]->quux = images[2].read(uint2(int2(constants[1]->bar))).xy; } vertex void main0(device storage_block* storage_0 [[buffer(0)]], device storage_block* storage_1 [[buffer(1)]], constant constant_block* constants_0 [[buffer(2)]], constant constant_block* constants_1 [[buffer(3)]], constant constant_block* constants_2 [[buffer(4)]], constant constant_block* constants_3 [[buffer(5)]], array, 3> images [[texture(0)]]) { device storage_block* storage[] = { storage_0, storage_1, }; constant constant_block* constants[] = { constants_0, constants_1, constants_2, constants_3, }; doWork(storage, constants, images); } spirv-cross-2021.01.15/reference/shaders-msl/vert/resource-arrays.ios.vert000066400000000000000000000020221400026215700263470ustar00rootroot00000000000000#include #include using namespace metal; struct storage_block { uint4 baz; int2 quux; }; struct constant_block { float4 foo; int bar; }; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 3 #endif constant int arraySize = SPIRV_CROSS_CONSTANT_ID_0; vertex void main0(device storage_block* storage_0 [[buffer(0)]], device storage_block* storage_1 [[buffer(1)]], constant constant_block* constants_0 [[buffer(2)]], constant constant_block* constants_1 [[buffer(3)]], constant constant_block* constants_2 [[buffer(4)]], constant constant_block* constants_3 [[buffer(5)]], array, 3> images [[texture(0)]]) { device storage_block* storage[] = { storage_0, storage_1, }; constant constant_block* constants[] = { constants_0, constants_1, constants_2, constants_3, }; storage[0]->baz = uint4(constants[3]->foo); storage[1]->quux = images[2].read(uint2(int2(constants[1]->bar))).xy; } spirv-cross-2021.01.15/reference/shaders-msl/vert/return-array.force-native-array.vert000066400000000000000000000064711400026215700305740ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; constant float4 _20[2] = { float4(10.0), float4(20.0) }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vInput0 [[attribute(0)]]; float4 vInput1 [[attribute(1)]]; }; template inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } template inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A]) { for (uint i = 0; i < A; i++) { dst[i] = src[i]; } } static inline __attribute__((always_inline)) void test(thread float4 (&spvReturnValue)[2]) { spvArrayCopyFromConstantToStack1(spvReturnValue, _20); } static inline __attribute__((always_inline)) void test2(thread float4 (&spvReturnValue)[2], thread float4& vInput0, thread float4& vInput1) { float4 foobar[2]; foobar[0] = vInput0; foobar[1] = vInput1; spvArrayCopyFromStackToStack1(spvReturnValue, foobar); } vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; float4 _42[2]; test(_42); float4 _44[2]; test2(_44, in.vInput0, in.vInput1); out.gl_Position = _42[0] + _44[1]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/return-array.vert000066400000000000000000000033601400026215700250710ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; constant spvUnsafeArray _20 = spvUnsafeArray({ float4(10.0), float4(20.0) }); struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 vInput0 [[attribute(0)]]; float4 vInput1 [[attribute(1)]]; }; static inline __attribute__((always_inline)) spvUnsafeArray test() { return _20; } static inline __attribute__((always_inline)) spvUnsafeArray test2(thread float4& vInput0, thread float4& vInput1) { spvUnsafeArray foobar; foobar[0] = vInput0; foobar[1] = vInput1; return foobar; } vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; out.gl_Position = test()[0] + test2(in.vInput0, in.vInput1)[1]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/set_builtin_in_func.vert000066400000000000000000000010371400026215700264570ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; float gl_PointSize [[point_size]]; }; static inline __attribute__((always_inline)) void write_outblock(thread float4& gl_Position, thread float& gl_PointSize) { gl_PointSize = 1.0; gl_Position = float4(gl_PointSize); } vertex main0_out main0() { main0_out out = {}; write_outblock(out.gl_Position, out.gl_PointSize); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/sign-int-types.vert000066400000000000000000000026771400026215700253420ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct UBO { float4x4 uMVP; float4 uFloatVec4; float3 uFloatVec3; float2 uFloatVec2; float uFloat; int4 uIntVec4; int3 uIntVec3; int2 uIntVec2; int uInt; }; struct main0_out { float4 vFloatVec4 [[user(locn0)]]; float3 vFloatVec3 [[user(locn1)]]; float2 vFloatVec2 [[user(locn2)]]; float vFloat [[user(locn3)]]; int4 vIntVec4 [[user(locn4)]]; int3 vIntVec3 [[user(locn5)]]; int2 vIntVec2 [[user(locn6)]]; int vInt [[user(locn7)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; }; // Implementation of the GLSL sign() function for integer types template::value>::type> inline T sign(T x) { return select(select(select(x, T(0), x == T(0)), T(1), x > T(0)), T(-1), x < T(0)); } vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _21 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _21.uMVP * in.aVertex; out.vFloatVec4 = sign(_21.uFloatVec4); out.vFloatVec3 = sign(_21.uFloatVec3); out.vFloatVec2 = sign(_21.uFloatVec2); out.vFloat = sign(_21.uFloat); out.vIntVec4 = sign(_21.uIntVec4); out.vIntVec3 = sign(_21.uIntVec3); out.vIntVec2 = sign(_21.uIntVec2); out.vInt = sign(_21.uInt); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/signedness-mismatch.shader-inputs.vert000066400000000000000000000031471400026215700311730ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { ushort2 a [[attribute(0)]]; uint3 b [[attribute(1)]]; ushort c_0 [[attribute(2)]]; ushort c_1 [[attribute(3)]]; uint4 d_0 [[attribute(4)]]; uint4 d_1 [[attribute(5)]]; }; vertex main0_out main0(main0_in in [[stage_in]]) { main0_out out = {}; spvUnsafeArray c = {}; spvUnsafeArray d = {}; c[0] = in.c_0; c[1] = in.c_1; d[0] = in.d_0; d[1] = in.d_1; out.gl_Position = float4(float(int(in.a.x)), float(in.b.x), float(uint(c[1])), float(d[0].w)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/texture_buffer.texture-buffer-native.msl21.vert000066400000000000000000000005461400026215700326610ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0(texture_buffer uSamp [[texture(0)]], texture_buffer uSampo [[texture(1)]]) { main0_out out = {}; out.gl_Position = uSamp.read(uint(10)) + uSampo.read(uint(100)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/texture_buffer.vert000066400000000000000000000011651400026215700254700ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } vertex main0_out main0(texture2d uSamp [[texture(0)]], texture2d uSampo [[texture(1)]]) { main0_out out = {}; out.gl_Position = uSamp.read(spvTexelBufferCoord(10)) + uSampo.read(spvTexelBufferCoord(100)); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/ubo.alignment.vert000066400000000000000000000013551400026215700252020ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 mvp; float2 targSize; char _m2_pad[8]; packed_float3 color; float opacity; }; struct main0_out { float3 vNormal [[user(locn0)]]; float3 vColor [[user(locn1)]]; float2 vSize [[user(locn2)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _18 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _18.mvp * in.aVertex; out.vNormal = in.aNormal; out.vColor = float3(_18.color) * _18.opacity; out.vSize = _18.targSize * _18.opacity; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vert/ubo.vert000066400000000000000000000007641400026215700232300ustar00rootroot00000000000000#include #include using namespace metal; struct UBO { float4x4 mvp; }; struct main0_out { float3 vNormal [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 aVertex [[attribute(0)]]; float3 aNormal [[attribute(1)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant UBO& _16 [[buffer(0)]]) { main0_out out = {}; out.gl_Position = _16.mvp * in.aVertex; out.vNormal = in.aNormal; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/000077500000000000000000000000001400026215700220525ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/vulkan/frag/000077500000000000000000000000001400026215700227715ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/vulkan/frag/basic.multiview.no-layered.nocompat.vk.frag000066400000000000000000000033331400026215700332350ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex_0 [[user(locn1)]]; float2 vTex_1 [[user(locn2)]]; float2 vTex_2 [[user(locn3)]]; float2 vTex_3 [[user(locn4)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvViewMask [[buffer(24)]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]]) { main0_out out = {}; spvUnsafeArray vTex = {}; vTex[0] = in.vTex_0; vTex[1] = in.vTex_1; vTex[2] = in.vTex_2; vTex[3] = in.vTex_3; const uint gl_ViewIndex = spvViewMask[0]; out.FragColor = in.vColor * uTex.sample(uTexSmplr, vTex[int(gl_ViewIndex)]); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/frag/basic.multiview.nocompat.vk.frag000066400000000000000000000034021400026215700311740ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; float2 vTex_0 [[user(locn1)]]; float2 vTex_1 [[user(locn2)]]; float2 vTex_2 [[user(locn3)]]; float2 vTex_3 [[user(locn4)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant uint* spvViewMask [[buffer(24)]], texture2d uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]], uint gl_ViewIndex [[render_target_array_index]]) { main0_out out = {}; spvUnsafeArray vTex = {}; vTex[0] = in.vTex_0; vTex[1] = in.vTex_1; vTex[2] = in.vTex_2; vTex[3] = in.vTex_3; gl_ViewIndex += spvViewMask[0]; out.FragColor = in.vColor * uTex.sample(uTexSmplr, vTex[int(gl_ViewIndex)]); return out; } demote-to-helper-forwarding.asm.vk.nocompat.msl23.frag000066400000000000000000000005301400026215700350370ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/vulkan/frag#include #include using namespace metal; struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; bool _15 = simd_is_helper_thread(); discard_fragment(); if (!_15) { out.FragColor = float4(1.0, 0.0, 0.0, 1.0); } return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/frag/demote-to-helper.vk.nocompat.msl23.frag000066400000000000000000000002701400026215700322000ustar00rootroot00000000000000#include #include using namespace metal; fragment void main0() { discard_fragment(); bool _9 = simd_is_helper_thread(); bool helper = _9; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/frag/demote-to-helper.vk.nocompat.msl23.ios.frag000066400000000000000000000002701400026215700327710ustar00rootroot00000000000000#include #include using namespace metal; fragment void main0() { discard_fragment(); bool _9 = simd_is_helper_thread(); bool helper = _9; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/frag/push-constant.vk.frag000066400000000000000000000007051400026215700270610ustar00rootroot00000000000000#include #include using namespace metal; struct PushConstants { float4 value0; float4 value1; }; struct main0_out { float4 FragColor [[color(0)]]; }; struct main0_in { float4 vColor [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant PushConstants& push [[buffer(0)]]) { main0_out out = {}; out.FragColor = (in.vColor + push.value0) + push.value1; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/frag/spec-constant.msl11.vk.frag000066400000000000000000000057731400026215700300020ustar00rootroot00000000000000#include #include using namespace metal; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 1.0 #endif constant float a = SPIRV_CROSS_CONSTANT_ID_1; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 2.0 #endif constant float b = SPIRV_CROSS_CONSTANT_ID_2; #ifndef SPIRV_CROSS_CONSTANT_ID_3 #define SPIRV_CROSS_CONSTANT_ID_3 3 #endif constant int c = SPIRV_CROSS_CONSTANT_ID_3; constant uint _18 = (uint(c) + 0u); constant int _21 = (-c); constant int _23 = (~c); #ifndef SPIRV_CROSS_CONSTANT_ID_4 #define SPIRV_CROSS_CONSTANT_ID_4 4 #endif constant int d = SPIRV_CROSS_CONSTANT_ID_4; constant int _26 = (c + d); constant int _28 = (c - d); constant int _30 = (c * d); constant int _32 = (c / d); #ifndef SPIRV_CROSS_CONSTANT_ID_5 #define SPIRV_CROSS_CONSTANT_ID_5 5u #endif constant uint e = SPIRV_CROSS_CONSTANT_ID_5; #ifndef SPIRV_CROSS_CONSTANT_ID_6 #define SPIRV_CROSS_CONSTANT_ID_6 6u #endif constant uint f = SPIRV_CROSS_CONSTANT_ID_6; constant uint _36 = (e / f); constant int _38 = (c % d); constant uint _40 = (e % f); constant int _42 = (c >> d); constant uint _44 = (e >> f); constant int _46 = (c << d); constant int _48 = (c | d); constant int _50 = (c ^ d); constant int _52 = (c & d); #ifndef SPIRV_CROSS_CONSTANT_ID_7 #define SPIRV_CROSS_CONSTANT_ID_7 false #endif constant bool g = SPIRV_CROSS_CONSTANT_ID_7; #ifndef SPIRV_CROSS_CONSTANT_ID_8 #define SPIRV_CROSS_CONSTANT_ID_8 true #endif constant bool h = SPIRV_CROSS_CONSTANT_ID_8; constant bool _58 = (g || h); constant bool _60 = (g && h); constant bool _62 = (!g); constant bool _64 = (g == h); constant bool _66 = (g != h); constant bool _68 = (c == d); constant bool _70 = (c != d); constant bool _72 = (c < d); constant bool _74 = (e < f); constant bool _76 = (c > d); constant bool _78 = (e > f); constant bool _80 = (c <= d); constant bool _82 = (e <= f); constant bool _84 = (c >= d); constant bool _86 = (e >= f); constant int _92 = int(e + 0u); constant bool _94 = (c != int(0u)); constant bool _96 = (e != 0u); constant int _100 = int(g); constant uint _103 = uint(g); struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; float t0 = a; float t1 = b; uint c0 = _18; int c1 = _21; int c2 = _23; int c3 = _26; int c4 = _28; int c5 = _30; int c6 = _32; uint c7 = _36; int c8 = _38; uint c9 = _40; int c10 = _42; uint c11 = _44; int c12 = _46; int c13 = _48; int c14 = _50; int c15 = _52; bool c16 = _58; bool c17 = _60; bool c18 = _62; bool c19 = _64; bool c20 = _66; bool c21 = _68; bool c22 = _70; bool c23 = _72; bool c24 = _74; bool c25 = _76; bool c26 = _78; bool c27 = _80; bool c28 = _82; bool c29 = _84; bool c30 = _86; int c31 = c8 + c3; int c32 = _92; bool c33 = _94; bool c34 = _96; int c35 = _100; uint c36 = _103; float c37 = float(g); out.FragColor = float4(t0 + t1); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/frag/spec-constant.vk.frag000066400000000000000000000056631400026215700270440ustar00rootroot00000000000000#include #include using namespace metal; constant float a_tmp [[function_constant(1)]]; constant float a = is_function_constant_defined(a_tmp) ? a_tmp : 1.0; constant float b_tmp [[function_constant(2)]]; constant float b = is_function_constant_defined(b_tmp) ? b_tmp : 2.0; constant int c_tmp [[function_constant(3)]]; constant int c = is_function_constant_defined(c_tmp) ? c_tmp : 3; constant uint _18 = (uint(c) + 0u); constant int _21 = (-c); constant int _23 = (~c); constant int d_tmp [[function_constant(4)]]; constant int d = is_function_constant_defined(d_tmp) ? d_tmp : 4; constant int _26 = (c + d); constant int _28 = (c - d); constant int _30 = (c * d); constant int _32 = (c / d); constant uint e_tmp [[function_constant(5)]]; constant uint e = is_function_constant_defined(e_tmp) ? e_tmp : 5u; constant uint f_tmp [[function_constant(6)]]; constant uint f = is_function_constant_defined(f_tmp) ? f_tmp : 6u; constant uint _36 = (e / f); constant int _38 = (c % d); constant uint _40 = (e % f); constant int _42 = (c >> d); constant uint _44 = (e >> f); constant int _46 = (c << d); constant int _48 = (c | d); constant int _50 = (c ^ d); constant int _52 = (c & d); constant bool g_tmp [[function_constant(7)]]; constant bool g = is_function_constant_defined(g_tmp) ? g_tmp : false; constant bool h_tmp [[function_constant(8)]]; constant bool h = is_function_constant_defined(h_tmp) ? h_tmp : true; constant bool _58 = (g || h); constant bool _60 = (g && h); constant bool _62 = (!g); constant bool _64 = (g == h); constant bool _66 = (g != h); constant bool _68 = (c == d); constant bool _70 = (c != d); constant bool _72 = (c < d); constant bool _74 = (e < f); constant bool _76 = (c > d); constant bool _78 = (e > f); constant bool _80 = (c <= d); constant bool _82 = (e <= f); constant bool _84 = (c >= d); constant bool _86 = (e >= f); constant int _92 = int(e + 0u); constant bool _94 = (c != int(0u)); constant bool _96 = (e != 0u); constant int _100 = int(g); constant uint _103 = uint(g); struct main0_out { float4 FragColor [[color(0)]]; }; fragment main0_out main0() { main0_out out = {}; float t0 = a; float t1 = b; uint c0 = _18; int c1 = _21; int c2 = _23; int c3 = _26; int c4 = _28; int c5 = _30; int c6 = _32; uint c7 = _36; int c8 = _38; uint c9 = _40; int c10 = _42; uint c11 = _44; int c12 = _46; int c13 = _48; int c14 = _50; int c15 = _52; bool c16 = _58; bool c17 = _60; bool c18 = _62; bool c19 = _64; bool c20 = _66; bool c21 = _68; bool c22 = _70; bool c23 = _72; bool c24 = _74; bool c25 = _76; bool c26 = _78; bool c27 = _80; bool c28 = _82; bool c29 = _84; bool c30 = _86; int c31 = c8 + c3; int c32 = _92; bool c33 = _94; bool c34 = _96; int c35 = _100; uint c36 = _103; float c37 = float(g); out.FragColor = float4(t0 + t1); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/vert/000077500000000000000000000000001400026215700230325ustar00rootroot00000000000000device-group.multiview.viewfromdev.nocompat.vk.vert000066400000000000000000000005461400026215700350710ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/vulkan/vert#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0() { main0_out out = {}; const int gl_DeviceIndex = 0; const uint gl_ViewIndex = 0; out.gl_Position = float4(float(gl_DeviceIndex), float(int(gl_ViewIndex)), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/vert/device-group.nocompat.vk.vert000066400000000000000000000004411400026215700305620ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0() { main0_out out = {}; const int gl_DeviceIndex = 0; out.gl_Position = float4(float(gl_DeviceIndex)); return out; } multiview.multiview.no-layered.nocompat.vk.vert000066400000000000000000000010001400026215700342110ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-msl/vulkan/vert#include #include using namespace metal; struct MVPs { float4x4 MVP[2]; }; struct main0_out { float4 gl_Position [[position]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant uint* spvViewMask [[buffer(24)]], constant MVPs& _19 [[buffer(0)]]) { main0_out out = {}; const uint gl_ViewIndex = spvViewMask[0]; out.gl_Position = _19.MVP[int(gl_ViewIndex)] * in.Position; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/vert/multiview.multiview.nocompat.vk.vert000066400000000000000000000015041400026215700322430ustar00rootroot00000000000000#include #include using namespace metal; struct MVPs { float4x4 MVP[2]; }; struct main0_out { float4 gl_Position [[position]]; uint gl_Layer [[render_target_array_index]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant uint* spvViewMask [[buffer(24)]], constant MVPs& _19 [[buffer(0)]], uint gl_InstanceIndex [[instance_id]], uint gl_BaseInstance [[base_instance]]) { main0_out out = {}; uint gl_ViewIndex = spvViewMask[0] + (gl_InstanceIndex - gl_BaseInstance) % spvViewMask[1]; gl_InstanceIndex = (gl_InstanceIndex - gl_BaseInstance) / spvViewMask[1] + gl_BaseInstance; out.gl_Position = _19.MVP[int(gl_ViewIndex)] * in.Position; out.gl_Layer = gl_ViewIndex - spvViewMask[0]; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/vert/multiview.nocompat.vk.vert000066400000000000000000000011101400026215700302100ustar00rootroot00000000000000#include #include using namespace metal; struct MVPs { float4x4 MVP[2]; }; struct main0_out { float4 gl_Position [[position]]; uint gl_Layer [[render_target_array_index]]; }; struct main0_in { float4 Position [[attribute(0)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant MVPs& _19 [[buffer(0)]], uint gl_InstanceIndex [[instance_id]], uint gl_BaseInstance [[base_instance]]) { main0_out out = {}; const uint gl_ViewIndex = 0; out.gl_Position = _19.MVP[int(gl_ViewIndex)] * in.Position; return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/vert/small-storage.vk.vert000066400000000000000000000020651400026215700271300ustar00rootroot00000000000000#include #include using namespace metal; struct block { short2 a; ushort2 b; char2 c; uchar2 d; half2 e; }; struct storage { short3 f; ushort3 g; char3 h; uchar3 i; half3 j; }; struct main0_out { short4 p [[user(locn0)]]; ushort4 q [[user(locn1)]]; half4 r [[user(locn2)]]; float4 gl_Position [[position]]; }; struct main0_in { short foo [[attribute(0)]]; ushort bar [[attribute(1)]]; half baz [[attribute(2)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant block& _26 [[buffer(0)]], const device storage& _53 [[buffer(1)]]) { main0_out out = {}; out.p = short4((int4(int(in.foo)) + int4(int2(_26.a), int2(_26.c))) - int4(int3(_53.f) / int3(_53.h), 1)); out.q = ushort4((uint4(uint(in.bar)) + uint4(uint2(_26.b), uint2(_26.d))) - uint4(uint3(_53.g) / uint3(_53.i), 1u)); out.r = half4((float4(float(in.baz)) + float4(float2(_26.e), 0.0, 1.0)) - float4(float3(_53.j), 1.0)); out.gl_Position = float4(0.0, 0.0, 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-msl/vulkan/vert/vulkan-vertex.vk.vert000066400000000000000000000005711400026215700271710ustar00rootroot00000000000000#include #include using namespace metal; struct main0_out { float4 gl_Position [[position]]; }; vertex main0_out main0(uint gl_VertexIndex [[vertex_id]], uint gl_InstanceIndex [[instance_id]]) { main0_out out = {}; out.gl_Position = float4(1.0, 2.0, 3.0, 4.0) * float(int(gl_VertexIndex) + int(gl_InstanceIndex)); return out; } spirv-cross-2021.01.15/reference/shaders-no-opt/000077500000000000000000000000001400026215700211735ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/000077500000000000000000000000001400026215700217535ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/000077500000000000000000000000001400026215700227115ustar00rootroot00000000000000access-chain-dominator-in-loop-body-2.asm.comp000066400000000000000000000010101400026215700332410ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { int values[]; } _4; void main() { int _17 = 0; for (;;) { if (_17 < 100) { int _24 = _4.values[_17]; _4.values[_24] = _17; int _26 = _24 + 1; int _18 = _4.values[_26]; _4.values[_17] = _18; _17 = _18; continue; } else { break; } } } access-chain-dominator-in-loop-body.asm.comp000066400000000000000000000006601400026215700331140ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { int values[]; } _4; void main() { int _17 = 0; for (;;) { if (_17 < 100) { int _24 = _4.values[_17]; _4.values[_24] = _17; _17 = _4.values[_24 + 1]; continue; } else { break; } } } access-tracking-function-call-result.asm.comp000066400000000000000000000004561400026215700334070ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 460 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer Output { int myout; } _5; int foo() { return 12; } void main() { int _17 = foo(); while (true) { _5.myout = _17; return; } _5.myout = _17; } aliased-struct-divergent-member-name.asm.comp000066400000000000000000000004771400026215700333750ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct T { float c; }; layout(binding = 0, std430) buffer SSBO1 { T foo[]; } _7; layout(binding = 1, std140) buffer SSBO2 { T bar[]; } _10; void main() { T v = T(40.0); _7.foo[10].c = v.c; _10.bar[30].c = v.c; } arithmetic-conversion-signs.asm.nocompat.vk.comp.vk000066400000000000000000000021471400026215700346070ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 #extension GL_EXT_shader_explicit_arithmetic_types_int16 : require #extension GL_EXT_shader_16bit_storage : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(set = 0, binding = 0, std430) buffer SSBO { int s32; uint u32; int16_t s16; uint16_t u16; float f32; } _4; void main() { int _29 = _4.s32; uint _30 = _4.u32; int16_t _31 = _4.s16; uint16_t _32 = _4.u16; float _33 = _4.f32; _4.s32 = int(_31); _4.u32 = uint(_31); _4.s32 = int(int16_t(_32)); _4.u32 = uint(int16_t(_32)); _4.u32 = uint(uint16_t(_31)); _4.u32 = uint(_32); _4.s16 = int16_t(_29); _4.u16 = uint16_t(_29); _4.s16 = int16_t(_30); _4.u16 = uint16_t(_30); _4.u16 = uint16_t(_29); _4.u16 = uint16_t(_30); _4.f32 = float(_31); _4.f32 = float(int16_t(_32)); _4.f32 = float(_29); _4.f32 = float(int(_30)); _4.f32 = float(uint16_t(_31)); _4.f32 = float(_32); _4.f32 = float(uint(_29)); _4.f32 = float(_30); _4.s16 = int16_t(_33); _4.u16 = uint16_t(int16_t(_33)); _4.u16 = uint16_t(_33); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/atomic-load-store.asm.comp000066400000000000000000000003741400026215700276770ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { uint a; uint b; } _5; void main() { uint _20 = atomicAdd(_5.b, 0u); uint c = _20; atomicExchange(_5.a, c); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/atomic-result-temporary.asm.comp000066400000000000000000000004531400026215700311620ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { uint count; uint data[]; } _5; void main() { uint _24 = atomicAdd(_5.count, 1u); if (_24 < 1024u) { _5.data[_24] = gl_GlobalInvocationID.x; } } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/bitcast-fp16-fp32.asm.vk.comp000066400000000000000000000010061400026215700277370ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_NV_gpu_shader5) #extension GL_NV_gpu_shader5 : require #else #error No extension available for FP16. #endif layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { f16vec2 a; float b; float c; f16vec2 d; } _4; void main() { _4.b = uintBitsToFloat(packFloat2x16(_4.a)); _4.d = unpackFloat2x16(floatBitsToUint(_4.c)); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/bitcast-fp16-fp32.asm.vk.comp.vk000066400000000000000000000011741400026215700303640ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_EXT_shader_explicit_arithmetic_types_float16) #extension GL_EXT_shader_explicit_arithmetic_types_float16 : require #else #error No extension available for FP16. #endif #extension GL_EXT_shader_16bit_storage : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(set = 0, binding = 0, std430) buffer SSBO { f16vec2 a; float b; float c; f16vec2 d; } _4; void main() { _4.b = uintBitsToFloat(packFloat2x16(_4.a)); _4.d = unpackFloat2x16(floatBitsToUint(_4.c)); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/bitfield-signed-operations.asm.comp000066400000000000000000000014111400026215700315570ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { ivec4 ints; uvec4 uints; } _3; void main() { ivec4 _19 = _3.ints; uvec4 _20 = _3.uints; _3.ints = bitCount(_19); _3.uints = uvec4(bitCount(_19)); _3.ints = bitCount(_20); _3.uints = uvec4(bitCount(_20)); _3.ints = bitfieldReverse(_19); _3.uints = bitfieldReverse(_20); _3.ints = bitfieldExtract(_19, 1, int(11u)); _3.uints = uvec4(bitfieldExtract(ivec4(_20), int(11u), 1)); _3.ints = ivec4(bitfieldExtract(uvec4(_19), 1, int(11u))); _3.uints = bitfieldExtract(_20, int(11u), 1); _3.ints = bitfieldInsert(_19, _19.wzyx, 1, int(11u)); _3.uints = bitfieldInsert(_20, _20.wzyx, int(11u), 1); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/bitscan.asm.comp000066400000000000000000000011111400026215700257650ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { uvec4 u; ivec4 i; } _4; void main() { uvec4 _19 = _4.u; ivec4 _20 = _4.i; _4.u = uvec4(findLSB(_19)); _4.i = findLSB(_19); _4.u = uvec4(findLSB(_20)); _4.i = findLSB(_20); _4.u = uvec4(findMSB(_19)); _4.i = findMSB(_19); _4.u = uvec4(findMSB(uvec4(_20))); _4.i = findMSB(uvec4(_20)); _4.u = uvec4(findMSB(ivec4(_19))); _4.i = findMSB(ivec4(_19)); _4.u = uvec4(findMSB(_20)); _4.i = findMSB(_20); } buffer-atomic-nonuniform.vk.nocompat.asm.comp.vk000066400000000000000000000004771400026215700340710ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(set = 0, binding = 0, std430) buffer SSBO { uint v; } ssbos[]; void main() { uint _24 = gl_GlobalInvocationID.z; uint _25 = atomicAdd(ssbos[nonuniformEXT(_24)].v, 1u); } buffer-reference-aliased-block-name.nocompat.vk.asm.comp.vk000066400000000000000000000013641400026215700357650ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 #extension GL_EXT_buffer_reference : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer Alias; layout(buffer_reference) buffer _6; layout(buffer_reference) buffer _7; layout(buffer_reference, std430) readonly buffer Alias { vec4 v[]; }; layout(buffer_reference, std430) restrict buffer _6 { vec4 v[]; }; layout(buffer_reference, std430) coherent writeonly buffer _7 { vec4 v[]; }; layout(push_constant, std430) uniform Registers { Alias ro; _6 rw; _7 wo; } registers; void main() { registers.rw.v[gl_GlobalInvocationID.x] = registers.ro.v[gl_GlobalInvocationID.x]; registers.wo.v[gl_GlobalInvocationID.x] = registers.ro.v[gl_GlobalInvocationID.x]; } buffer-reference-synthesized-pointer-2.asm.nocompat.vk.comp.vk000066400000000000000000000006031400026215700365360ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 #extension GL_ARB_gpu_shader_int64 : require #extension GL_EXT_buffer_reference : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer uintPointer { uint value; }; layout(push_constant, std430) uniform _4_12 { uint64_t _m0; } _12; void main() { uintPointer _3 = uintPointer(_12._m0); _3.value = 20u; } buffer-reference-synthesized-pointer.asm.nocompat.vk.comp.vk000066400000000000000000000006171400026215700364040ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 #extension GL_ARB_gpu_shader_int64 : require #extension GL_EXT_buffer_reference : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer uint0_Pointer { uint value[]; }; layout(push_constant, std430) uniform _6_14 { uint64_t _m0; } _14; void main() { uint0_Pointer _5 = uint0_Pointer(_14._m0); _5.value[10] = 20u; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/constant-composite-undef.asm.comp000066400000000000000000000004371400026215700313040ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer Block { vec4 f; } block; float _15; void main() { block.f = vec4(0.100000001490116119384765625, 0.20000000298023223876953125, 0.300000011920928955078125, 0.0); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/copy-logical.spv14.asm.comp000066400000000000000000000012561400026215700277120ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct B2 { vec4 elem2; }; struct C { vec4 c; B2 b2; B2 b2_array[4]; }; struct B1 { vec4 elem1; }; struct A { vec4 a; B1 b1; B1 b1_array[4]; }; layout(binding = 0, std430) buffer _8_3 { A a_block; C c_block; } _3; void main() { A _27; _27.a = _3.c_block.c; _27.b1.elem1 = _3.c_block.b2.elem2; _27.b1_array[0].elem1 = _3.c_block.b2_array[0].elem2; _27.b1_array[1].elem1 = _3.c_block.b2_array[1].elem2; _27.b1_array[2].elem1 = _3.c_block.b2_array[2].elem2; _27.b1_array[3].elem1 = _3.c_block.b2_array[3].elem2; _3.a_block = _27; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/extended-debug-extinst.invalid.asm.comp000066400000000000000000000004571400026215700323630ustar00rootroot00000000000000#version 430 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _8_9 { float _m0[]; } _9; layout(binding = 1, std430) buffer _8_10 { float _m0[]; } _10; void main() { _10._m0[gl_GlobalInvocationID.x] = -_9._m0[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/glsl-signed-operations.asm.comp000066400000000000000000000027561400026215700307530ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { ivec4 ints; uvec4 uints; } _4; void main() { ivec4 _19 = _4.ints; uvec4 _20 = _4.uints; _4.ints = abs(_19); _4.uints = uvec4(abs(_19)); _4.ints = abs(ivec4(_20)); _4.uints = uvec4(abs(ivec4(_20))); _4.ints = sign(_19); _4.uints = uvec4(sign(_19)); _4.ints = sign(ivec4(_20)); _4.uints = uvec4(sign(ivec4(_20))); _4.ints = findMSB(ivec4(_20)); _4.uints = uvec4(findMSB(ivec4(_20))); _4.ints = findMSB(uvec4(_19)); _4.uints = uvec4(findMSB(uvec4(_19))); _4.ints = min(_19, _19); _4.uints = uvec4(min(_19, ivec4(_20))); _4.ints = min(ivec4(_20), ivec4(_20)); _4.uints = uvec4(min(ivec4(_20), _19)); _4.ints = ivec4(min(uvec4(_19), _20)); _4.uints = min(uvec4(_19), _20); _4.ints = ivec4(min(_20, uvec4(_19))); _4.uints = min(_20, uvec4(_19)); _4.ints = max(_19, _19); _4.uints = uvec4(max(_19, _19)); _4.ints = max(ivec4(_20), _19); _4.uints = uvec4(max(ivec4(_20), _19)); _4.ints = ivec4(max(uvec4(_19), _20)); _4.uints = max(uvec4(_19), uvec4(_19)); _4.ints = ivec4(max(_20, uvec4(_19))); _4.uints = max(_20, uvec4(_19)); _4.ints = clamp(ivec4(_20), ivec4(_20), ivec4(_20)); _4.uints = uvec4(clamp(ivec4(_20), ivec4(_20), ivec4(_20))); _4.ints = ivec4(clamp(uvec4(_19), uvec4(_19), uvec4(_19))); _4.uints = clamp(uvec4(_19), uvec4(_19), uvec4(_19)); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/glsl.std450.frexp-modf-struct.asm.comp000066400000000000000000000007001400026215700317200ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct _8 { float _m0; float _m1; }; struct _15 { float _m0; int _m1; }; layout(binding = 0, std430) buffer _3_4 { float _m0; int _m1; } _4; void main() { _8 _23; _23._m0 = modf(20.0, _23._m1); _15 _24; _24._m0 = frexp(40.0, _24._m1); _4._m0 = _23._m0; _4._m0 = _23._m1; _4._m0 = _24._m0; _4._m1 = _24._m1; } image-atomic-nonuniform.vk.nocompat.asm.comp.vk000066400000000000000000000005311400026215700336710ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(set = 0, binding = 0, r32ui) uniform uimage2D uImage[]; void main() { uint _26 = gl_GlobalInvocationID.z; uint _31 = imageAtomicAdd(uImage[nonuniformEXT(_26)], ivec2(gl_GlobalInvocationID.xy), 1u); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/loop-variable-with-initializer.asm.comp000066400000000000000000000002311400026215700323720ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; void main() { uint i = 0u; for (;;) { break; } } nonuniform-bracket-handling.vk.nocompat.asm.comp.vk000066400000000000000000000063361400026215700345430ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 #extension GL_EXT_buffer_reference : require #extension GL_EXT_nonuniform_qualifier : require #extension GL_KHR_shader_subgroup_ballot : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(set = 0, binding = 0, std430) restrict readonly buffer SSBO_Offsets { uvec2 _m0[]; } _7; layout(push_constant, std430) uniform RootConstants { uint _m0; uint _m1; uint _m2; uint _m3; uint _m4; uint _m5; uint _m6; uint _m7; } registers; layout(set = 1, binding = 0) uniform samplerBuffer _8[]; layout(set = 4, binding = 0, r32f) uniform imageBuffer _9[]; layout(set = 4, binding = 0, r32ui) uniform uimageBuffer _10[]; void main() { uint _60 = registers._m4 + 2u; uint _63 = subgroupBroadcastFirst(_60); uint _70 = subgroupBroadcastFirst(registers._m4); uint _75 = registers._m1 + 1u; uint _78 = subgroupBroadcastFirst(_75); uint _87 = gl_GlobalInvocationID.x + 4u; uint _98 = gl_GlobalInvocationID.x + 1024u; imageStore(_9[registers._m4], int((_98 < _7._m0[_70].y) ? (_98 + _7._m0[_70].x) : 4294967295u), vec4(imageLoad(_9[registers._m4], int((_87 < _7._m0[_70].y) ? (_87 + _7._m0[_70].x) : 4294967295u)))); uint _105 = gl_GlobalInvocationID.x + 2u; uint _116 = gl_GlobalInvocationID.x + 2048u; imageStore(_9[registers._m4], int((_116 < _7._m0[_70].y) ? (_116 + _7._m0[_70].x) : 4294967295u), vec4(texelFetch(_8[_75], int((_105 < _7._m0[_78].y) ? (_105 + _7._m0[_78].x) : 4294967295u)))); uint _129 = imageAtomicAdd(_10[_60], int((gl_GlobalInvocationID.x < _7._m0[_63].y) ? (gl_GlobalInvocationID.x + _7._m0[_63].x) : 4294967295u), 40u); uint _136 = imageAtomicCompSwap(_10[_60], int((gl_GlobalInvocationID.y < _7._m0[_63].y) ? (gl_GlobalInvocationID.y + _7._m0[_63].x) : 4294967295u), 40u, 50u); imageStore(_9[registers._m4], int((0u < _7._m0[_70].y) ? (0u + _7._m0[_70].x) : 4294967295u), vec4(float(_7._m0[_70].y))); imageStore(_9[registers._m4], int((1u < _7._m0[_70].y) ? (1u + _7._m0[_70].x) : 4294967295u), vec4(float(_7._m0[_78].y))); uint _11 = registers._m4 + (gl_GlobalInvocationID.z + 0u); imageStore(_9[nonuniformEXT(_11)], int((_98 < _7._m0[_11].y) ? (_98 + _7._m0[_11].x) : 4294967295u), vec4(imageLoad(_9[nonuniformEXT(_11)], int((_87 < _7._m0[_11].y) ? (_87 + _7._m0[_11].x) : 4294967295u)))); uint _13 = registers._m1 + (gl_GlobalInvocationID.z + 0u); imageStore(_9[nonuniformEXT(_11)], int((_116 < _7._m0[_11].y) ? (_116 + _7._m0[_11].x) : 4294967295u), vec4(texelFetch(_8[nonuniformEXT(_13)], int((_87 < _7._m0[_13].y) ? (_87 + _7._m0[_13].x) : 4294967295u)))); uint _15 = registers._m4 + (gl_GlobalInvocationID.z + 0u); uint _208 = imageAtomicAdd(_10[nonuniformEXT(_15)], int((gl_GlobalInvocationID.y < _7._m0[_15].y) ? (gl_GlobalInvocationID.y + _7._m0[_15].x) : 4294967295u), 40u); uint _215 = imageAtomicCompSwap(_10[nonuniformEXT(_15)], int((gl_GlobalInvocationID.y < _7._m0[_15].y) ? (gl_GlobalInvocationID.y + _7._m0[_15].x) : 4294967295u), 40u, 70u); imageStore(_9[registers._m4], int((2u < _7._m0[_70].y) ? (2u + _7._m0[_70].x) : 4294967295u), vec4(float(_7._m0[_11].y))); imageStore(_9[registers._m4], int((3u < _7._m0[_70].y) ? (3u + _7._m0[_70].x) : 4294967295u), vec4(float(_7._m0[_13].y))); } phi-temporary-copy-loop-variable.asm.invalid.comp000066400000000000000000000007331400026215700342230ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp#version 450 layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in; layout(binding = 1, rgba32f) uniform writeonly image2D outImageTexture; void main() { int _27_copy; int _30; _30 = 7; for (int _27 = 7; _27 >= 0; _27_copy = _27, _27--, _30 = _27_copy) { if (5.0 > float(_27)) { break; } } imageStore(outImageTexture, ivec2(gl_GlobalInvocationID.xy), vec4(float(_30 - 1), float(_30), 1.0, 1.0)); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/spec-constant-op-convert-sign.asm.comp000066400000000000000000000016261400026215700321660ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 1 #endif const int ConstantInt = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 2u #endif const uint ConstantUint = SPIRV_CROSS_CONSTANT_ID_1; const int64_t ConstantInt64_1 = int64_t(ConstantInt); const int64_t ConstantInt64_2 = int64_t(int(ConstantUint)); const uint64_t ConstantUint64_1 = uint64_t(ConstantInt); const uint64_t ConstantUint64_2 = uint64_t(int(ConstantUint)); const int64_t _20 = (ConstantInt64_1 + ConstantInt64_2); const uint64_t _21 = (ConstantUint64_1 + ConstantUint64_2); const int _22 = int(_20); const uint _23 = uint(_21); layout(binding = 0, std430) buffer SSBO { int s64; uint u64; } _4; void main() { _4.s64 = _22; _4.u64 = _23; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/comp/storage-buffer-basic.asm.comp000066400000000000000000000010451400026215700303420ustar00rootroot00000000000000#version 450 #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 1u #endif #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 3u #endif layout(local_size_x = SPIRV_CROSS_CONSTANT_ID_0, local_size_y = 2, local_size_z = SPIRV_CROSS_CONSTANT_ID_2) in; layout(binding = 0, std430) buffer _6_8 { float _m0[]; } _8; layout(binding = 1, std430) buffer _6_9 { float _m0[]; } _9; uvec3 _22 = gl_WorkGroupSize; void main() { _8._m0[gl_WorkGroupID.x] = _9._m0[gl_WorkGroupID.x] + _8._m0[gl_WorkGroupID.x]; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/000077500000000000000000000000001400026215700226725ustar00rootroot00000000000000combined-image-sampler-dxc-min16float.asm.invalid.frag000066400000000000000000000011461400026215700347150ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 310 es precision mediump float; precision highp int; struct PSInput { highp vec4 color; highp vec2 uv; }; uniform mediump sampler2D SPIRV_Cross_CombinedtexSamp; layout(location = 0) in highp vec4 in_var_COLOR; layout(location = 1) in highp vec2 in_var_TEXCOORD0; layout(location = 0) out highp vec4 out_var_SV_TARGET; highp vec4 src_PSMain(PSInput _input) { vec4 a = _input.color * texture(SPIRV_Cross_CombinedtexSamp, _input.uv); return a; } void main() { PSInput param_var_input = PSInput(in_var_COLOR, in_var_TEXCOORD0); out_var_SV_TARGET = src_PSMain(param_var_input); } demote-impure-function-call.vk.nocompat.asm.frag.vk000066400000000000000000000005161400026215700344220ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 #extension GL_EXT_demote_to_helper_invocation : require layout(location = 0) flat in int vA; layout(location = 0) out vec4 FragColor; vec4 foobar(int a) { if (a < 0) { demote; } return vec4(10.0); } void main() { int param = vA; vec4 _25 = foobar(param); FragColor = vec4(10.0); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/discard-impure-function-call.asm.frag000066400000000000000000000004271400026215700317610ustar00rootroot00000000000000#version 450 layout(location = 0) flat in int vA; layout(location = 0) out vec4 FragColor; vec4 foobar(int a) { if (a < 0) { discard; } return vec4(10.0); } void main() { int param = vA; vec4 _25 = foobar(param); FragColor = vec4(10.0); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/do-while-continue-phi.asm.invalid.frag000066400000000000000000000011661400026215700320530ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out highp vec4 _GLF_color; void main() { for (;;) { bool _32; for (;;) { if (gl_FragCoord.x != gl_FragCoord.x) { _32 = true; break; } if (false) { continue; } else { _32 = false; break; } } if (_32) { break; } _GLF_color = vec4(1.0, 0.0, 0.0, 1.0); break; } } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/do-while-loop-inverted-test.asm.frag000066400000000000000000000002201400026215700315560ustar00rootroot00000000000000#version 450 void main() { int j = 0; int i = 0; do { j = ((j + i) + 1) * j; i++; } while (!(i == 20)); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/early-conditional-return-switch.asm.frag000066400000000000000000000036541400026215700325530ustar00rootroot00000000000000#version 450 layout(binding = 0, std140) uniform type_gCBuffarrayIndex { uint gArrayIndex; } gCBuffarrayIndex; uniform sampler2D SPIRV_Cross_Combinedg_textureArray0SPIRV_Cross_DummySampler; uniform sampler2D SPIRV_Cross_Combinedg_textureArray1SPIRV_Cross_DummySampler; uniform sampler2D SPIRV_Cross_Combinedg_textureArray2SPIRV_Cross_DummySampler; uniform sampler2D SPIRV_Cross_Combinedg_textureArray3SPIRV_Cross_DummySampler; layout(location = 0) out vec4 out_var_SV_TARGET; vec4 _32; void main() { vec4 _80; do { vec4 _77; bool _78; switch (gCBuffarrayIndex.gArrayIndex) { case 0u: { _77 = texelFetch(SPIRV_Cross_Combinedg_textureArray0SPIRV_Cross_DummySampler, ivec3(int(gl_FragCoord.x), int(gl_FragCoord.y), 0).xy, 0); _78 = true; break; } case 1u: { _77 = texelFetch(SPIRV_Cross_Combinedg_textureArray1SPIRV_Cross_DummySampler, ivec3(int(gl_FragCoord.x), int(gl_FragCoord.y), 0).xy, 0); _78 = true; break; } case 2u: { _77 = texelFetch(SPIRV_Cross_Combinedg_textureArray2SPIRV_Cross_DummySampler, ivec3(int(gl_FragCoord.x), int(gl_FragCoord.y), 0).xy, 0); _78 = true; break; } case 3u: { _77 = texelFetch(SPIRV_Cross_Combinedg_textureArray3SPIRV_Cross_DummySampler, ivec3(int(gl_FragCoord.x), int(gl_FragCoord.y), 0).xy, 0); _78 = true; break; } default: { _77 = _32; _78 = false; break; } } if (_78) { _80 = _77; break; } _80 = vec4(0.0, 1.0, 0.0, 1.0); break; } while(false); out_var_SV_TARGET = _80; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/empty-struct-in-struct.asm.frag000066400000000000000000000007561400026215700307300ustar00rootroot00000000000000#version 450 struct EmptyStructTest { int empty_struct_member; }; struct EmptyStruct2Test { EmptyStructTest _m0; }; float GetValue(EmptyStruct2Test self) { return 0.0; } float GetValue_1(EmptyStruct2Test self) { return 0.0; } void main() { EmptyStructTest _25 = EmptyStructTest(0); EmptyStruct2Test emptyStruct; float value = GetValue(emptyStruct); value = GetValue_1(EmptyStruct2Test(_25)); value = GetValue_1(EmptyStruct2Test(EmptyStructTest(0))); } for-loop-dedicated-merge-block-inverted.asm.invalid.frag000066400000000000000000000001761400026215700353300ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 void main() { int _13; for (int _12 = 0; !(_12 == 16); _12 = _13) { _13 = _12 + 1; } } for-loop-dedicated-merge-block-non-inverted.asm.invalid.frag000066400000000000000000000001731400026215700361150ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 void main() { int _13; for (int _12 = 0; _12 != 16; _12 = _13) { _13 = _12 + 1; } } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/for-loop-inverted-test.asm.frag000066400000000000000000000001761400026215700306460ustar00rootroot00000000000000#version 450 void main() { int _13; for (int _12 = 0; !(_12 == 16); _12 = _13) { _13 = _12 + 1; } } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/image-fetch-uint-coord.asm.frag000066400000000000000000000005261400026215700305470ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_CombinedTexSPIRV_Cross_DummySampler; layout(location = 0) flat in uvec3 in_var_TEXCOORD0; layout(location = 0) out vec4 out_var_SV_Target0; void main() { out_var_SV_Target0 = texelFetch(SPIRV_Cross_CombinedTexSPIRV_Cross_DummySampler, ivec2(in_var_TEXCOORD0.xy), int(in_var_TEXCOORD0.z)); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/inliner-dominator-inside-loop.asm.frag000066400000000000000000000206331400026215700321700ustar00rootroot00000000000000#version 450 struct VertexOutput { vec4 HPosition; vec4 Uv_EdgeDistance1; vec4 UvStuds_EdgeDistance2; vec4 Color; vec4 LightPosition_Fog; vec4 View_Depth; vec4 Normal_SpecPower; vec3 Tangent; vec4 PosLightSpace_Reflectance; float studIndex; }; struct Surface { vec3 albedo; vec3 normal; float specular; float gloss; float reflectance; float opacity; }; struct SurfaceInput { vec4 Color; vec2 Uv; vec2 UvStuds; }; struct Globals { mat4 ViewProjection; vec4 ViewRight; vec4 ViewUp; vec4 ViewDir; vec3 CameraPosition; vec3 AmbientColor; vec3 Lamp0Color; vec3 Lamp0Dir; vec3 Lamp1Color; vec4 FogParams; vec3 FogColor; vec4 LightBorder; vec4 LightConfig0; vec4 LightConfig1; vec4 LightConfig2; vec4 LightConfig3; vec4 RefractionBias_FadeDistance_GlowFactor; vec4 OutlineBrightness_ShadowInfo; vec4 ShadowMatrix0; vec4 ShadowMatrix1; vec4 ShadowMatrix2; }; struct Params { vec4 LqmatFarTilingFactor; }; layout(binding = 0, std140) uniform CB0 { Globals CB0; } _19; uniform sampler2D SPIRV_Cross_CombinedDiffuseMapTextureDiffuseMapSampler; uniform sampler2D SPIRV_Cross_CombinedNormalMapTextureNormalMapSampler; uniform sampler2D SPIRV_Cross_CombinedNormalDetailMapTextureNormalDetailMapSampler; uniform sampler2D SPIRV_Cross_CombinedStudsMapTextureStudsMapSampler; uniform sampler2D SPIRV_Cross_CombinedSpecularMapTextureSpecularMapSampler; uniform sampler3D SPIRV_Cross_CombinedLightMapTextureLightMapSampler; uniform sampler2D SPIRV_Cross_CombinedShadowMapTextureShadowMapSampler; uniform samplerCube SPIRV_Cross_CombinedEnvironmentMapTextureEnvironmentMapSampler; layout(location = 0) in vec4 IN_Uv_EdgeDistance1; layout(location = 1) in vec4 IN_UvStuds_EdgeDistance2; layout(location = 2) in vec4 IN_Color; layout(location = 3) in vec4 IN_LightPosition_Fog; layout(location = 4) in vec4 IN_View_Depth; layout(location = 5) in vec4 IN_Normal_SpecPower; layout(location = 6) in vec3 IN_Tangent; layout(location = 7) in vec4 IN_PosLightSpace_Reflectance; layout(location = 8) in float IN_studIndex; layout(location = 0) out vec4 _entryPointOutput; VertexOutput _121; SurfaceInput _122; vec2 _123; vec4 _124; Surface _125; vec4 _192; vec4 _219; vec4 _297; void main() { VertexOutput _128 = _121; _128.HPosition = gl_FragCoord; VertexOutput _130 = _128; _130.Uv_EdgeDistance1 = IN_Uv_EdgeDistance1; VertexOutput _132 = _130; _132.UvStuds_EdgeDistance2 = IN_UvStuds_EdgeDistance2; VertexOutput _134 = _132; _134.Color = IN_Color; VertexOutput _136 = _134; _136.LightPosition_Fog = IN_LightPosition_Fog; VertexOutput _138 = _136; _138.View_Depth = IN_View_Depth; VertexOutput _140 = _138; _140.Normal_SpecPower = IN_Normal_SpecPower; VertexOutput _142 = _140; _142.Tangent = IN_Tangent; VertexOutput _144 = _142; _144.PosLightSpace_Reflectance = IN_PosLightSpace_Reflectance; VertexOutput _146 = _144; _146.studIndex = IN_studIndex; SurfaceInput _147 = _122; _147.Color = IN_Color; SurfaceInput _149 = _147; _149.Uv = IN_Uv_EdgeDistance1.xy; SurfaceInput _151 = _149; _151.UvStuds = IN_UvStuds_EdgeDistance2.xy; SurfaceInput _156 = _151; _156.UvStuds.y = (fract(_151.UvStuds.y) + IN_studIndex) * 0.25; float _160 = clamp(1.0 - (_146.View_Depth.w * 0.00333332992158830165863037109375), 0.0, 1.0); float _163 = _146.View_Depth.w * _19.CB0.RefractionBias_FadeDistance_GlowFactor.y; float _165 = clamp(1.0 - _163, 0.0, 1.0); vec2 _166 = IN_Uv_EdgeDistance1.xy * 1.0; bool _173; vec4 _193; for (;;) { _173 = 0.0 == 0.0; if (_173) { _193 = texture(SPIRV_Cross_CombinedDiffuseMapTextureDiffuseMapSampler, _166); break; } else { float _180 = 1.0 / (1.0 - 0.0); _193 = mix(texture(SPIRV_Cross_CombinedDiffuseMapTextureDiffuseMapSampler, _166 * 0.25), texture(SPIRV_Cross_CombinedDiffuseMapTextureDiffuseMapSampler, _166), vec4(clamp((_160 * _180) - (0.0 * _180), 0.0, 1.0))); break; } _193 = _192; break; } vec4 _220; for (;;) { if (_173) { _220 = texture(SPIRV_Cross_CombinedNormalMapTextureNormalMapSampler, _166); break; } else { float _207 = 1.0 / (1.0 - 0.0); _220 = mix(texture(SPIRV_Cross_CombinedNormalMapTextureNormalMapSampler, _166 * 0.25), texture(SPIRV_Cross_CombinedNormalMapTextureNormalMapSampler, _166), vec4(clamp((_165 * _207) - (0.0 * _207), 0.0, 1.0))); break; } _220 = _219; break; } vec2 _223 = vec2(1.0); vec2 _224 = (_220.wy * 2.0) - _223; vec3 _232 = vec3(_224, sqrt(clamp(1.0 + dot(-_224, _224), 0.0, 1.0))); vec4 _237 = texture(SPIRV_Cross_CombinedNormalDetailMapTextureNormalDetailMapSampler, _166 * 0.0); vec2 _240 = (_237.wy * 2.0) - _223; vec2 _252 = _232.xy + (vec3(_240, sqrt(clamp(1.0 + dot(-_240, _240), 0.0, 1.0))).xy * 0.0); vec3 _253 = vec3(_252.x, _252.y, _232.z); vec2 _255 = _253.xy * _165; vec3 _256 = vec3(_255.x, _255.y, _253.z); vec4 _268 = texture(SPIRV_Cross_CombinedStudsMapTextureStudsMapSampler, _156.UvStuds); vec3 _271 = ((IN_Color.xyz * (_193 * 1.0).xyz) * (1.0 + (_256.x * 0.300000011920928955078125))) * (_268.x * 2.0); vec4 _298; for (;;) { if (0.75 == 0.0) { _298 = texture(SPIRV_Cross_CombinedSpecularMapTextureSpecularMapSampler, _166); break; } else { float _285 = 1.0 / (1.0 - 0.75); _298 = mix(texture(SPIRV_Cross_CombinedSpecularMapTextureSpecularMapSampler, _166 * 0.25), texture(SPIRV_Cross_CombinedSpecularMapTextureSpecularMapSampler, _166), vec4(clamp((_165 * _285) - (0.75 * _285), 0.0, 1.0))); break; } _298 = _297; break; } vec2 _303 = mix(vec2(0.800000011920928955078125, 120.0), (_298.xy * vec2(2.0, 256.0)) + vec2(0.0, 0.00999999977648258209228515625), vec2(_165)); Surface _304 = _125; _304.albedo = _271; Surface _305 = _304; _305.normal = _256; float _306 = _303.x; Surface _307 = _305; _307.specular = _306; float _308 = _303.y; Surface _309 = _307; _309.gloss = _308; float _312 = (_298.xy.y * _165) * 0.0; Surface _313 = _309; _313.reflectance = _312; vec4 _318 = vec4(_271, _146.Color.w); vec3 _329 = normalize(((IN_Tangent * _313.normal.x) + (cross(IN_Normal_SpecPower.xyz, IN_Tangent) * _313.normal.y)) + (IN_Normal_SpecPower.xyz * _313.normal.z)); vec3 _332 = -_19.CB0.Lamp0Dir; float _333 = dot(_329, _332); float _357 = clamp(dot(step(_19.CB0.LightConfig3.xyz, abs(IN_LightPosition_Fog.xyz - _19.CB0.LightConfig2.xyz)), vec3(1.0)), 0.0, 1.0); vec4 _368 = mix(texture(SPIRV_Cross_CombinedLightMapTextureLightMapSampler, IN_LightPosition_Fog.xyz.yzx - (IN_LightPosition_Fog.xyz.yzx * _357)), _19.CB0.LightBorder, vec4(_357)); vec2 _376 = texture(SPIRV_Cross_CombinedShadowMapTextureShadowMapSampler, IN_PosLightSpace_Reflectance.xyz.xy).xy; float _392 = (1.0 - (((step(_376.x, IN_PosLightSpace_Reflectance.xyz.z) * clamp(9.0 - (20.0 * abs(IN_PosLightSpace_Reflectance.xyz.z - 0.5)), 0.0, 1.0)) * _376.y) * _19.CB0.OutlineBrightness_ShadowInfo.w)) * _368.w; vec3 _403 = mix(_318.xyz, texture(SPIRV_Cross_CombinedEnvironmentMapTextureEnvironmentMapSampler, reflect(-IN_View_Depth.xyz, _329)).xyz, vec3(_312)); vec4 _404 = vec4(_403.x, _403.y, _403.z, _318.w); vec3 _422 = (((_19.CB0.AmbientColor + (((_19.CB0.Lamp0Color * clamp(_333, 0.0, 1.0)) + (_19.CB0.Lamp1Color * max(-_333, 0.0))) * _392)) + _368.xyz) * _404.xyz) + (_19.CB0.Lamp0Color * (((step(0.0, _333) * _306) * _392) * pow(clamp(dot(_329, normalize(_332 + normalize(IN_View_Depth.xyz))), 0.0, 1.0), _308))); vec4 _425 = vec4(_422.x, _422.y, _422.z, _124.w); _425.w = _404.w; vec2 _435 = min(IN_Uv_EdgeDistance1.wz, IN_UvStuds_EdgeDistance2.wz); float _439 = min(_435.x, _435.y) / _163; vec3 _445 = _425.xyz * clamp((clamp((_163 * _19.CB0.OutlineBrightness_ShadowInfo.x) + _19.CB0.OutlineBrightness_ShadowInfo.y, 0.0, 1.0) * (1.5 - _439)) + _439, 0.0, 1.0); vec4 _446 = vec4(_445.x, _445.y, _445.z, _425.w); vec3 _453 = mix(_19.CB0.FogColor, _446.xyz, vec3(clamp(_146.LightPosition_Fog.w, 0.0, 1.0))); _entryPointOutput = vec4(_453.x, _453.y, _453.z, _446.w); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/ldexp-uint-exponent.asm.frag000066400000000000000000000003071400026215700302410ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out highp vec4 _GLF_color; void main() { _GLF_color = ldexp(vec4(1.0), ivec4(uvec4(bitCount(uvec4(1u))))); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/loop-merge-to-continue.asm.invalid.frag000066400000000000000000000004311400026215700322450ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 v0; void main() { FragColor = vec4(1.0); for (int i = 0; i < 4; i++) { for (int j = 0; j < 4; j++) { FragColor += vec4(v0[(i + j) & 3]); } } } nonuniform-bracket-handling-2.vk.nocompat.asm.frag.vk000066400000000000000000000010151400026215700346310ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(set = 0, binding = 0, std430) readonly buffer SSBO { uint indices[]; } _8; layout(set = 0, binding = 0) uniform sampler2D uSamplers[]; layout(set = 1, binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; void main() { FragColor = textureLod(uSamplers[nonuniformEXT(_8.indices[10])], vUV, 0.0); FragColor += textureLod(uSampler, vUV, float(_8.indices[int(gl_FragCoord.y)])); } nonuniform-qualifier-propagation.vk.nocompat.asm.frag.vk000066400000000000000000000017161400026215700356070ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(set = 0, binding = 2, std140) uniform UBO { vec4 v[64]; } ubos[]; layout(set = 0, binding = 3, std430) readonly buffer SSBO { vec4 v[]; } ssbos[]; layout(set = 0, binding = 0) uniform texture2D uSamplers[]; layout(set = 0, binding = 1) uniform sampler uSamps[]; layout(set = 0, binding = 4) uniform sampler2D uCombinedSamplers[]; layout(location = 0) flat in int vIndex; layout(location = 0) out vec4 FragColor; layout(location = 1) in vec2 vUV; void main() { int i = vIndex; int _59 = i + 10; int _64 = i + 40; FragColor = texture(nonuniformEXT(sampler2D(uSamplers[_59], uSamps[_64])), vUV); int _71 = i + 10; FragColor = texture(uCombinedSamplers[nonuniformEXT(_71)], vUV); int _77 = i + 20; int _80 = i + 40; FragColor += ubos[nonuniformEXT(_77)].v[_80]; int _87 = i + 50; int _90 = i + 60; FragColor += ssbos[nonuniformEXT(_87)].v[_90]; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/only-initializer-frag-depth.asm.frag000066400000000000000000000001261400026215700316320ustar00rootroot00000000000000#version 450 const float _3_init = 0.5; void main() { gl_FragDepth = _3_init; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/opaque-id-literal-alias.preserve.asm.frag000066400000000000000000000005551400026215700325560ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2DMS uSampled; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; void main() { FragColor = vec4(0.0); if (gl_FragCoord.x < 10.0) { FragColor += texelFetch(uSampled, ivec2(vUV), 0); } else { FragColor += texelFetch(uSampled, ivec2(vUV), 1); } } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/out-of-order-struct-id.asm.frag000066400000000000000000000003761400026215700305560ustar00rootroot00000000000000#version 450 struct Foo { vec4 a; }; struct Bar { Foo foo; Foo foo2; }; layout(binding = 0, std140) uniform UBO { Bar bar; } _7; layout(location = 0) out vec4 FragColor; void main() { FragColor = _7.bar.foo.a + _7.bar.foo2.a; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/phi.zero-initialize.asm.frag000066400000000000000000000006461400026215700302150ustar00rootroot00000000000000#version 450 struct Foo { int a; }; layout(location = 0) in vec4 vColor; layout(location = 0) out vec4 FragColor; int uninit_int = 0; ivec4 uninit_vector = ivec4(0); mat4 uninit_matrix = mat4(vec4(0.0), vec4(0.0), vec4(0.0), vec4(0.0)); Foo uninit_foo = Foo(0); void main() { int _39 = 0; if (vColor.x > 10.0) { _39 = 10; } else { _39 = 20; } FragColor = vColor; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/pixel-interlock-callstack.asm.frag000066400000000000000000000012231400026215700313600ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 1, std430) buffer SSBO1 { uint values1[]; } _7; layout(binding = 0, std430) buffer SSBO0 { uint values0[]; } _9; void callee2() { int _31 = int(gl_FragCoord.x); _7.values1[_31]++; } void callee() { int _39 = int(gl_FragCoord.x); _9.values0[_39]++; callee2(); } void spvMainInterlockedBody() { callee(); } void main() { // Interlocks were used in a way not compatible with GLSL, this is very slow. beginInvocationInterlockARB(); spvMainInterlockedBody(); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/pixel-interlock-control-flow.asm.frag000066400000000000000000000014631400026215700320520ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 1, std430) buffer SSBO1 { uint values1[]; } _7; layout(binding = 2, std430) buffer _12_13 { uint _m0[]; } _13; layout(binding = 0, std430) buffer SSBO0 { uint values0[]; } _9; void callee2() { int _44 = int(gl_FragCoord.x); _7.values1[_44]++; } void callee() { int _52 = int(gl_FragCoord.x); _9.values0[_52]++; callee2(); if (true) { } } void _35() { _13._m0[int(gl_FragCoord.x)] = 4u; } void spvMainInterlockedBody() { callee(); _35(); } void main() { // Interlocks were used in a way not compatible with GLSL, this is very slow. beginInvocationInterlockARB(); spvMainInterlockedBody(); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/pixel-interlock-split-functions.asm.frag000066400000000000000000000013111400026215700325560ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 1, std430) buffer SSBO1 { uint values1[]; } _7; layout(binding = 0, std430) buffer SSBO0 { uint values0[]; } _9; void callee2() { int _37 = int(gl_FragCoord.x); _7.values1[_37]++; } void callee() { int _45 = int(gl_FragCoord.x); _9.values0[_45]++; callee2(); } void _29() { } void _31() { } void spvMainInterlockedBody() { callee(); _29(); _31(); } void main() { // Interlocks were used in a way not compatible with GLSL, this is very slow. beginInvocationInterlockARB(); spvMainInterlockedBody(); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/reserved-function-identifier.asm.frag000066400000000000000000000004761400026215700321030ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; float _mat3(float a) { return a + 1.0; } float _RESERVED_IDENTIFIER_FIXUP_gl_Foo(int a) { return float(a) + 1.0; } void main() { float param = 2.0; int param_1 = 4; FragColor = _mat3(param) + _RESERVED_IDENTIFIER_FIXUP_gl_Foo(param_1); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/reserved-identifiers.asm.frag000066400000000000000000000007021400026215700304330ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 _RESERVED_IDENTIFIER_FIXUP_spvFoo; layout(location = 1) out vec4 SPIRV_Cross_blah; layout(location = 2) out vec4 _40Bar; layout(location = 3) out vec4 _m40; layout(location = 4) out vec4 _underscore_foo_bar_meep_; void main() { _RESERVED_IDENTIFIER_FIXUP_spvFoo = vec4(0.0); SPIRV_Cross_blah = vec4(1.0); _40Bar = vec4(2.0); _m40 = vec4(3.0); _underscore_foo_bar_meep_ = vec4(4.0); } selection-merge-to-continue.asm.invalid.frag000066400000000000000000000005241400026215700332050ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 v0; void main() { FragColor = vec4(1.0); for (int i = 0; i < 4; i++) { if (v0.x == 20.0) { FragColor += vec4(v0[i & 3]); } else { FragColor += vec4(v0[i & 1]); } } } sparse-texture-feedback-uint-code.asm.desktop.frag000066400000000000000000000006131400026215700343050ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 #extension GL_ARB_sparse_texture2 : require struct ResType { uint _m0; vec4 _m1; }; layout(binding = 0) uniform sampler2D uSamp; layout(location = 0) in vec2 vUV; void main() { uint _30; vec4 _31; _30 = sparseTextureARB(uSamp, vUV, _31); ResType _26 = ResType(_30, _31); vec4 texel = _26._m1; bool ret = sparseTexelsResidentARB(int(_26._m0)); } subgroup-arithmetic-cast.nocompat.vk.asm.frag.vk000066400000000000000000000014731400026215700340420ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 #extension GL_KHR_shader_subgroup_arithmetic : require #extension GL_KHR_shader_subgroup_clustered : require layout(location = 0) flat in int index; layout(location = 0) out uint FragColor; void main() { uint _17 = uint(index); FragColor = uint(subgroupMin(index)); FragColor = uint(subgroupMax(int(_17))); FragColor = subgroupMin(uint(index)); FragColor = subgroupMax(_17); FragColor = uint(subgroupInclusiveMax(index)); FragColor = uint(subgroupInclusiveMin(int(_17))); FragColor = subgroupExclusiveMax(uint(index)); FragColor = subgroupExclusiveMin(_17); FragColor = uint(subgroupClusteredMin(index, 4u)); FragColor = uint(subgroupClusteredMax(int(_17), 4u)); FragColor = subgroupClusteredMin(uint(index), 4u); FragColor = subgroupClusteredMax(_17, 4u); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/subgroup-ballot-only.vk.asm.frag000066400000000000000000000017101400026215700310300ustar00rootroot00000000000000#version 450 #if defined(GL_KHR_shader_subgroup_ballot) #extension GL_KHR_shader_subgroup_ballot : require #elif defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #elif defined(GL_ARB_shader_ballot) && defined(GL_ARB_shader_int64) #extension GL_ARB_shader_int64 : enable #extension GL_ARB_shader_ballot : require #else #error No extensions available to emulate requested subgroup feature. #endif layout(location = 0) flat in uint INDEX; layout(location = 0) out uvec4 SV_Target; #if defined(GL_KHR_shader_subgroup_ballot) #elif defined(GL_NV_shader_thread_group) uvec4 subgroupBallot(bool v) { return uvec4(ballotThreadNV(v), 0u, 0u, 0u); } #elif defined(GL_ARB_shader_ballot) uvec4 subgroupBallot(bool v) { return uvec4(unpackUint2x32(ballotARB(v)), 0u, 0u); } #endif void main() { uvec4 _21 = subgroupBallot(INDEX < 100u); SV_Target.x = _21.x; SV_Target.y = _21.y; SV_Target.z = _21.z; SV_Target.w = _21.w; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/subgroup-ballot-only.vk.asm.frag.vk000066400000000000000000000004701400026215700314510ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_ballot : require layout(location = 0) flat in uint INDEX; layout(location = 0) out uvec4 SV_Target; void main() { uvec4 _21 = subgroupBallot(INDEX < 100u); SV_Target.x = _21.x; SV_Target.y = _21.y; SV_Target.z = _21.z; SV_Target.w = _21.w; } switch-block-case-fallthrough.asm.invalid.frag000066400000000000000000000017661400026215700335110ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 layout(location = 0) flat in int vIndex; layout(location = 0) out vec4 FragColor; void main() { int i; int j; int _30; int _31; if (vIndex != 0 && vIndex != 1 && vIndex != 11 && vIndex != 2 && vIndex != 3 && vIndex != 4 && vIndex != 5) { _30 = 2; } if (vIndex == 1 || vIndex == 11) { _31 = 1; } switch (vIndex) { case 0: { _30 = 3; } default: { j = _30; _31 = 0; } case 1: case 11: { j = _31; } case 2: { break; } case 3: { if (vIndex > 3) { i = 0; break; } else { break; } } case 4: { } case 5: { i = 0; break; } } FragColor = vec4(float(i)); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/switch-merge-to-continue.asm.invalid.frag000066400000000000000000000007711400026215700326040ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0); for (int i = 0; i < 4; i++) { switch (i) { case 0: { FragColor.x += 1.0; break; } case 1: { FragColor.y += 3.0; break; } default: { FragColor.z += 3.0; break; } } } } switch-single-case-multiple-exit-cfg.asm.frag000066400000000000000000000006521400026215700332640ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 310 es precision mediump float; precision highp int; layout(location = 0) out highp vec4 _GLF_color; vec2 _19; void main() { highp vec2 _30; do { if (gl_FragCoord.x != gl_FragCoord.x) { _30 = _19; break; } highp vec2 _29 = _19; _29.y = _19.y; _30 = _29; break; } while(false); _GLF_color = vec4(_30, 1.0, 1.0); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/unordered-compare.asm.frag000066400000000000000000000016701400026215700277310ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 A; layout(location = 1) in vec4 B; layout(location = 0) out vec4 FragColor; vec4 test_vector() { bvec4 le = not(greaterThanEqual(A, B)); bvec4 leq = not(greaterThan(A, B)); bvec4 ge = not(lessThanEqual(A, B)); bvec4 geq = not(lessThan(A, B)); bvec4 eq = not(notEqual(A, B)); bvec4 neq = not(equal(A, B)); return ((((mix(vec4(0.0), vec4(1.0), le) + mix(vec4(0.0), vec4(1.0), leq)) + mix(vec4(0.0), vec4(1.0), ge)) + mix(vec4(0.0), vec4(1.0), geq)) + mix(vec4(0.0), vec4(1.0), eq)) + mix(vec4(0.0), vec4(1.0), neq); } float test_scalar() { bool le = !(A.x >= B.x); bool leq = !(A.x > B.x); bool ge = !(A.x <= B.x); bool geq = !(A.x < B.x); bool eq = !(A.x != B.x); bool neq = !(A.x == B.x); return ((((float(le) + float(leq)) + float(ge)) + float(geq)) + float(eq)) + float(neq); } void main() { FragColor = test_vector() + vec4(test_scalar()); } vector-extract-dynamic-spec-constant.asm.frag000066400000000000000000000012611400026215700334060ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag#version 450 #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 0 #endif const int omap_r = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 1 #endif const int omap_g = SPIRV_CROSS_CONSTANT_ID_1; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 2 #endif const int omap_b = SPIRV_CROSS_CONSTANT_ID_2; #ifndef SPIRV_CROSS_CONSTANT_ID_3 #define SPIRV_CROSS_CONSTANT_ID_3 3 #endif const int omap_a = SPIRV_CROSS_CONSTANT_ID_3; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; void main() { FragColor = vec4(vColor[omap_r], vColor[omap_g], vColor[omap_b], vColor[omap_a]); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/vector-shuffle-undef-index.asm.frag000066400000000000000000000003351400026215700314530ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vFloat; vec4 undef; void main() { FragColor = vec4(undef.x, vFloat.y, 0.0, vFloat.w) + vec4(vFloat.z, vFloat.y, 0.0, vFloat.w); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/frag/while-loop-inverted-test.asm.frag000066400000000000000000000002141400026215700311610ustar00rootroot00000000000000#version 450 void main() { int i = 0; int j = 0; while (!(i == 20)) { j = ((j + i) + 1) * j; i++; } } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/geom/000077500000000000000000000000001400026215700227025ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/geom/store-uint-layer.invalid.asm.geom000066400000000000000000000014271400026215700312060ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(max_vertices = 3, triangle_strip) out; struct VertexOutput { vec4 pos; }; struct GeometryOutput { vec4 pos; uint layer; }; void _main(VertexOutput _input[3], GeometryOutput stream) { GeometryOutput _output; _output.layer = 1u; for (int v = 0; v < 3; v++) { _output.pos = _input[v].pos; gl_Position = _output.pos; gl_Layer = int(_output.layer); EmitVertex(); } EndPrimitive(); } void main() { VertexOutput _input[3]; _input[0].pos = gl_in[0].gl_Position; _input[1].pos = gl_in[1].gl_Position; _input[2].pos = gl_in[2].gl_Position; VertexOutput param[3] = _input; GeometryOutput param_1; _main(param, param_1); GeometryOutput stream = param_1; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/loop-header-self-continue-break.asm.comp000066400000000000000000000033331400026215700314460ustar00rootroot00000000000000#version 450 #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 1u #endif #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 1u #endif #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 1u #endif layout(local_size_x = SPIRV_CROSS_CONSTANT_ID_0, local_size_y = SPIRV_CROSS_CONSTANT_ID_1, local_size_z = SPIRV_CROSS_CONSTANT_ID_2) in; layout(binding = 0, std430) buffer _4_6 { float _m0[]; } _6; layout(binding = 1, std430) buffer _4_7 { float _m0[]; } _7; uvec3 _28 = gl_WorkGroupSize; void main() { float _44_copy; float _46; uint _47; float _63; uint _65; float _36 = _6._m0[0u]; uint _39 = 0u; float _44; for (;;) { _44 = _36; _46 = _6._m0[35u]; _47 = 0u; for (;;) { uint _48 = _47 + 1u; float _45 = _6._m0[_48]; _6._m0[_47] = ((_46 + _44) + _45) / 3.0; if (!(_47 < 34u)) { break; } else { _44_copy = _44; _44 = _45; _46 = _44_copy; _47 = _48; } } _6._m0[35u] = (_36 + (_44 + _6._m0[35u])) / 3.0; if (!(_39 < 5u)) { _63 = _6._m0[0u]; _65 = 1u; break; } else { _36 = _6._m0[0u]; _39++; continue; } } float _64; for (;;) { _64 = (_63 < _6._m0[_65]) ? _6._m0[_65] : _63; if (!(_65 < 35u)) { break; } else { _63 = _64; _65++; } } _7._m0[gl_GlobalInvocationID.x] = _64; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/temporary.zero-initialize.asm.frag000066400000000000000000000011071400026215700305310ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int vA; layout(location = 1) flat in mediump int vB; void main() { FragColor = vec4(0.0); mediump int _10 = 0; mediump int _15 = 0; for (mediump int _16 = 0, _17 = 0; _16 < vA; _17 = _15, _16 += _10) { if ((vA + _16) == 20) { _15 = 50; } else { _15 = ((vB + _16) == 40) ? 60 : _17; } _10 = _15 + 10; FragColor += vec4(1.0); } } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/tesc/000077500000000000000000000000001400026215700227115ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/tesc/array-of-block-output-initializer.asm.tesc000066400000000000000000000041431400026215700330410ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; out gl_PerVertex { vec4 gl_Position; float gl_PointSize; float gl_ClipDistance[1]; float gl_CullDistance[1]; } gl_out[4]; layout(location = 0) patch out vert { float v0; float v1; } _5; layout(location = 2) patch out vert_patch { float v2; float v3; } patches[2]; layout(location = 6) patch out float v2; layout(location = 7) out float v3[4]; layout(location = 8) out vert2 { float v4; float v5; } verts[4]; const vec4 _3_0_init[4] = vec4[](vec4(0.0), vec4(0.0), vec4(0.0), vec4(0.0)); const float _3_1_init[4] = float[](0.0, 0.0, 0.0, 0.0); const float _3_2_init[4][1] = float[][](float[](0.0), float[](0.0), float[](0.0), float[](0.0)); const float _3_3_init[4][1] = float[][](float[](0.0), float[](0.0), float[](0.0), float[](0.0)); const float _6_0_init[2] = float[](0.0, 0.0); const float _6_1_init[2] = float[](0.0, 0.0); const float _7_init = 0.0; const float _8_init[4] = float[](0.0, 0.0, 0.0, 0.0); const float _9_0_init[4] = float[](0.0, 0.0, 0.0, 0.0); const float _9_1_init[4] = float[](0.0, 0.0, 0.0, 0.0); void main() { gl_out[gl_InvocationID].gl_Position = _3_0_init[gl_InvocationID]; gl_out[gl_InvocationID].gl_PointSize = _3_1_init[gl_InvocationID]; gl_out[gl_InvocationID].gl_ClipDistance = _3_2_init[gl_InvocationID]; gl_out[gl_InvocationID].gl_CullDistance = _3_3_init[gl_InvocationID]; if (gl_InvocationID == 0) { _5.v0 = 0.0; } if (gl_InvocationID == 0) { _5.v1 = 0.0; } if (gl_InvocationID == 0) { patches[0].v2 = _6_0_init[0]; } if (gl_InvocationID == 0) { patches[1].v2 = _6_0_init[1]; } if (gl_InvocationID == 0) { patches[0].v3 = _6_1_init[0]; } if (gl_InvocationID == 0) { patches[1].v3 = _6_1_init[1]; } if (gl_InvocationID == 0) { v2 = _7_init; } v3[gl_InvocationID] = _8_init[gl_InvocationID]; verts[gl_InvocationID].v4 = _9_0_init[gl_InvocationID]; verts[gl_InvocationID].v5 = _9_1_init[gl_InvocationID]; gl_out[gl_InvocationID].gl_Position = vec4(1.0); } tess-fixed-input-array-builtin-array.invalid.asm.tesc000066400000000000000000000033441400026215700350260ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/tesc#version 450 layout(vertices = 3) out; struct VertexOutput { vec4 pos; vec2 uv; }; struct HSOut { vec4 pos; vec2 uv; }; struct HSConstantOut { float EdgeTess[3]; float InsideTess; }; struct VertexOutput_1 { vec2 uv; }; struct HSOut_1 { vec2 uv; }; layout(location = 0) in VertexOutput_1 p[]; layout(location = 0) out HSOut_1 _entryPointOutput[3]; HSOut _hs_main(VertexOutput p_1[3], uint i) { HSOut _output; _output.pos = p_1[i].pos; _output.uv = p_1[i].uv; return _output; } HSConstantOut PatchHS(VertexOutput _patch[3]) { HSConstantOut _output; _output.EdgeTess[0] = (vec2(1.0) + _patch[0].uv).x; _output.EdgeTess[1] = (vec2(1.0) + _patch[0].uv).x; _output.EdgeTess[2] = (vec2(1.0) + _patch[0].uv).x; _output.InsideTess = (vec2(1.0) + _patch[0].uv).x; return _output; } void main() { VertexOutput p_1[3]; p_1[0].pos = gl_in[0].gl_Position; p_1[0].uv = p[0].uv; p_1[1].pos = gl_in[1].gl_Position; p_1[1].uv = p[1].uv; p_1[2].pos = gl_in[2].gl_Position; p_1[2].uv = p[2].uv; uint i = gl_InvocationID; VertexOutput param[3] = p_1; uint param_1 = i; HSOut flattenTemp = _hs_main(param, param_1); gl_out[gl_InvocationID].gl_Position = flattenTemp.pos; _entryPointOutput[gl_InvocationID].uv = flattenTemp.uv; barrier(); if (int(gl_InvocationID) == 0) { VertexOutput param_2[3] = p_1; HSConstantOut _patchConstantResult = PatchHS(param_2); gl_TessLevelOuter[0] = _patchConstantResult.EdgeTess[0]; gl_TessLevelOuter[1] = _patchConstantResult.EdgeTess[1]; gl_TessLevelOuter[2] = _patchConstantResult.EdgeTess[2]; gl_TessLevelInner[0] = _patchConstantResult.InsideTess; } } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/tesc/tess-level-initializer.asm.tesc000066400000000000000000000010561400026215700307560ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; const float _5_init[2] = float[](0.0, 0.0); const float _6_init[4] = float[](0.0, 0.0, 0.0, 0.0); void main() { if (gl_InvocationID == 0) { gl_TessLevelInner = _5_init; } if (gl_InvocationID == 0) { gl_TessLevelOuter = _6_init; } gl_out[gl_InvocationID].gl_Position = vec4(1.0); gl_TessLevelInner[0] = 1.0; gl_TessLevelInner[1] = 2.0; gl_TessLevelOuter[0] = 3.0; gl_TessLevelOuter[1] = 4.0; gl_TessLevelOuter[2] = 5.0; gl_TessLevelOuter[3] = 6.0; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/vert/000077500000000000000000000000001400026215700227335ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/vert/block-struct-initializer.asm.vert000066400000000000000000000004041400026215700313470ustar00rootroot00000000000000#version 450 struct Foo { float c; float d; }; layout(location = 0) out Vert { float a; float b; } _3; layout(location = 2) out Foo foo; const Foo _4_init = Foo(0.0, 0.0); void main() { _3.a = 0.0; _3.b = 0.0; foo = _4_init; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/vert/builtin-output-initializer.asm.vert000066400000000000000000000003661400026215700317460ustar00rootroot00000000000000#version 450 out float gl_ClipDistance[1]; out float gl_CullDistance[1]; void main() { gl_Position = vec4(0.0); gl_PointSize = 0.0; gl_ClipDistance = float[](0.0); gl_CullDistance = float[](0.0); gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/vert/complex-link-by-name.asm.vert000066400000000000000000000011641400026215700303460ustar00rootroot00000000000000#version 450 struct Struct_vec4 { vec4 m0; }; layout(binding = 0, std140) uniform UBO { Struct_vec4 m0; Struct_vec4 m1; } ubo_binding_0; layout(location = 0) out VertexOut { Struct_vec4 m0; Struct_vec4 m1; } output_location_0; layout(location = 2) out Struct_vec4 output_location_2; layout(location = 3) out Struct_vec4 output_location_3; void main() { Struct_vec4 c; c.m0 = ubo_binding_0.m0.m0; Struct_vec4 b; b.m0 = ubo_binding_0.m1.m0; gl_Position = c.m0 + b.m0; output_location_0.m0 = c; output_location_0.m1 = b; output_location_2 = c; output_location_3 = b; } complex-link-by-name.force-flattened-io.legacy.asm.vert000066400000000000000000000010741400026215700352000ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/asm/vert#version 100 struct Struct_vec4 { vec4 m0; }; struct UBO { Struct_vec4 m0; Struct_vec4 m1; }; uniform UBO ubo_binding_0; varying vec4 output_location_0_m0_m0; varying vec4 output_location_0_m1_m0; varying vec4 output_location_2_m0; varying vec4 output_location_3_m0; void main() { Struct_vec4 c; c.m0 = ubo_binding_0.m0.m0; Struct_vec4 b; b.m0 = ubo_binding_0.m1.m0; gl_Position = c.m0 + b.m0; output_location_0_m0_m0 = c.m0; output_location_0_m1_m0 = b.m0; output_location_2_m0 = c.m0; output_location_3_m0 = b.m0; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/vert/empty-struct-composite.asm.vert000066400000000000000000000001701400026215700310720ustar00rootroot00000000000000#version 450 struct Test { int empty_struct_member; }; void main() { Test _14 = Test(0); Test t = _14; } spirv-cross-2021.01.15/reference/shaders-no-opt/asm/vert/semantic-decoration.asm.vert000066400000000000000000000004751400026215700303520ustar00rootroot00000000000000#version 450 struct VOut { vec4 p; vec4 c; }; layout(location = 0) out vec4 _entryPointOutput_c; VOut _main() { VOut v; v.p = vec4(1.0); v.c = vec4(2.0); return v; } void main() { VOut flattenTemp = _main(); gl_Position = flattenTemp.p; _entryPointOutput_c = flattenTemp.c; } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/000077500000000000000000000000001400026215700221315ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/comp/bitcast-16bit-1.invalid.comp000066400000000000000000000016151400026215700271530ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_NV_gpu_shader5) #extension GL_NV_gpu_shader5 : require #else #error No extension available for FP16. #endif #if defined(GL_AMD_gpu_shader_int16) #extension GL_AMD_gpu_shader_int16 : require #else #error No extension available for Int16. #endif layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO0 { i16vec4 inputs[]; } _25; layout(binding = 1, std430) buffer SSBO1 { ivec4 outputs[]; } _39; void main() { uint ident = gl_GlobalInvocationID.x; f16vec2 a = int16BitsToFloat16(_25.inputs[ident].xy); _39.outputs[ident].x = int(packFloat2x16(a + f16vec2(float16_t(1.0)))); _39.outputs[ident].y = packInt2x16(_25.inputs[ident].zw); _39.outputs[ident].z = int(packUint2x16(u16vec2(_25.inputs[ident].xy))); } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/bitcast-16bit-2.invalid.comp000066400000000000000000000020771400026215700271570ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_int16) #extension GL_AMD_gpu_shader_int16 : require #else #error No extension available for Int16. #endif #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_NV_gpu_shader5) #extension GL_NV_gpu_shader5 : require #else #error No extension available for FP16. #endif layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) buffer SSBO1 { i16vec4 outputs[]; } _21; layout(binding = 0, std430) buffer SSBO0 { ivec4 inputs[]; } _29; layout(binding = 2, std140) uniform UBO { f16vec4 const0; } _40; void main() { uint ident = gl_GlobalInvocationID.x; i16vec2 _47 = unpackInt2x16(_29.inputs[ident].x) + float16BitsToInt16(_40.const0.xy); _21.outputs[ident] = i16vec4(_47.x, _47.y, _21.outputs[ident].z, _21.outputs[ident].w); i16vec2 _66 = i16vec2(unpackUint2x16(uint(_29.inputs[ident].y)) - float16BitsToUint16(_40.const0.zw)); _21.outputs[ident] = i16vec4(_21.outputs[ident].x, _21.outputs[ident].y, _66.x, _66.y); } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/bitfield.comp000066400000000000000000000007531400026215700246000ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; void main() { int signed_value = 0; uint unsigned_value = 0u; int s = bitfieldExtract(signed_value, 5, 20); uint u = bitfieldExtract(unsigned_value, 6, 21); s = bitfieldInsert(s, 40, 5, 4); u = bitfieldInsert(u, 60u, 5, 4); u = bitfieldReverse(u); s = bitfieldReverse(s); int v0 = bitCount(u); int v1 = bitCount(s); int v2 = findMSB(u); int v3 = findLSB(s); } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/glsl.std450.comp000066400000000000000000000066561400026215700250110ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct ResType { float _m0; int _m1; }; layout(binding = 0, std430) buffer SSBO { float res; int ires; uint ures; vec4 f32; ivec4 s32; uvec4 u32; mat2 m2; mat3 m3; mat4 m4; } _19; void main() { _19.res = round(_19.f32.x); _19.res = roundEven(_19.f32.x); _19.res = trunc(_19.f32.x); _19.res = abs(_19.f32.x); _19.ires = abs(_19.s32.x); _19.res = sign(_19.f32.x); _19.ires = sign(_19.s32.x); _19.res = floor(_19.f32.x); _19.res = ceil(_19.f32.x); _19.res = fract(_19.f32.x); _19.res = radians(_19.f32.x); _19.res = degrees(_19.f32.x); _19.res = sin(_19.f32.x); _19.res = cos(_19.f32.x); _19.res = tan(_19.f32.x); _19.res = asin(_19.f32.x); _19.res = acos(_19.f32.x); _19.res = atan(_19.f32.x); _19.res = sinh(_19.f32.x); _19.res = cosh(_19.f32.x); _19.res = tanh(_19.f32.x); _19.res = asinh(_19.f32.x); _19.res = acosh(_19.f32.x); _19.res = atanh(_19.f32.x); _19.res = atan(_19.f32.x, _19.f32.y); _19.res = pow(_19.f32.x, _19.f32.y); _19.res = exp(_19.f32.x); _19.res = log(_19.f32.x); _19.res = exp2(_19.f32.x); _19.res = log2(_19.f32.x); _19.res = sqrt(_19.f32.x); _19.res = inversesqrt(_19.f32.x); _19.res = length(_19.f32.x); _19.res = distance(_19.f32.x, _19.f32.y); _19.res = normalize(_19.f32.x); _19.res = faceforward(_19.f32.x, _19.f32.y, _19.f32.z); _19.res = reflect(_19.f32.x, _19.f32.y); _19.res = refract(_19.f32.x, _19.f32.y, _19.f32.z); _19.res = length(_19.f32.xy); _19.res = distance(_19.f32.xy, _19.f32.zw); vec2 v2 = normalize(_19.f32.xy); v2 = faceforward(_19.f32.xy, _19.f32.yz, _19.f32.zw); v2 = reflect(_19.f32.xy, _19.f32.zw); v2 = refract(_19.f32.xy, _19.f32.yz, _19.f32.w); vec3 v3 = cross(_19.f32.xyz, _19.f32.yzw); _19.res = determinant(_19.m2); _19.res = determinant(_19.m3); _19.res = determinant(_19.m4); _19.m2 = inverse(_19.m2); _19.m3 = inverse(_19.m3); _19.m4 = inverse(_19.m4); float tmp; float _287 = modf(_19.f32.x, tmp); _19.res = _287; _19.res = min(_19.f32.x, _19.f32.y); _19.ures = min(_19.u32.x, _19.u32.y); _19.ires = min(_19.s32.x, _19.s32.y); _19.res = max(_19.f32.x, _19.f32.y); _19.ures = max(_19.u32.x, _19.u32.y); _19.ires = max(_19.s32.x, _19.s32.y); _19.res = clamp(_19.f32.x, _19.f32.y, _19.f32.z); _19.ures = clamp(_19.u32.x, _19.u32.y, _19.u32.z); _19.ires = clamp(_19.s32.x, _19.s32.y, _19.s32.z); _19.res = mix(_19.f32.x, _19.f32.y, _19.f32.z); _19.res = step(_19.f32.x, _19.f32.y); _19.res = smoothstep(_19.f32.x, _19.f32.y, _19.f32.z); _19.res = fma(_19.f32.x, _19.f32.y, _19.f32.z); ResType _387; _387._m0 = frexp(_19.f32.x, _387._m1); int itmp = _387._m1; _19.res = _387._m0; _19.res = ldexp(_19.f32.x, itmp); _19.ures = packSnorm4x8(_19.f32); _19.ures = packUnorm4x8(_19.f32); _19.ures = packSnorm2x16(_19.f32.xy); _19.ures = packUnorm2x16(_19.f32.xy); _19.ures = packHalf2x16(_19.f32.xy); v2 = unpackSnorm2x16(_19.u32.x); v2 = unpackUnorm2x16(_19.u32.x); v2 = unpackHalf2x16(_19.u32.x); vec4 v4 = unpackSnorm4x8(_19.u32.x); v4 = unpackUnorm4x8(_19.u32.x); _19.s32 = findLSB(_19.s32); _19.s32 = findLSB(_19.u32); _19.s32 = findMSB(_19.s32); _19.s32 = findMSB(_19.u32); } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/illegal-struct-name.asm.comp000066400000000000000000000004401400026215700274370ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct Foo { float _abs; }; layout(binding = 0, std430) buffer SSBO { Foo foo; Foo foo2; } _7; void main() { Foo f; f._abs = _7.foo._abs; int _abs = 10; _7.foo2._abs = f._abs; } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/inout-struct.invalid.comp000066400000000000000000000024241400026215700271200ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct Foo { vec4 a; vec4 b; vec4 c; vec4 d; }; layout(binding = 1, std430) readonly buffer SSBO2 { vec4 data[]; } indata; layout(binding = 0, std430) writeonly buffer SSBO { vec4 data[]; } outdata; layout(binding = 2, std430) readonly buffer SSBO3 { Foo foos[]; } foobar; void baz(inout Foo foo) { uint ident = gl_GlobalInvocationID.x; foo.a = indata.data[(4u * ident) + 0u]; foo.b = indata.data[(4u * ident) + 1u]; foo.c = indata.data[(4u * ident) + 2u]; foo.d = indata.data[(4u * ident) + 3u]; } void meow(inout Foo foo) { foo.a += vec4(10.0); foo.b += vec4(20.0); foo.c += vec4(30.0); foo.d += vec4(40.0); } vec4 bar(Foo foo) { return ((foo.a + foo.b) + foo.c) + foo.d; } void main() { Foo param; baz(param); Foo foo = param; Foo param_1 = foo; meow(param_1); foo = param_1; Foo param_2 = foo; Foo param_3; param_3.a = foobar.foos[gl_GlobalInvocationID.x].a; param_3.b = foobar.foos[gl_GlobalInvocationID.x].b; param_3.c = foobar.foos[gl_GlobalInvocationID.x].c; param_3.d = foobar.foos[gl_GlobalInvocationID.x].d; outdata.data[gl_GlobalInvocationID.x] = bar(param_2) + bar(param_3); } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/loop.comp000066400000000000000000000025461400026215700237710ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; } _24; void main() { uint ident = gl_GlobalInvocationID.x; vec4 idat = _24.in_data[ident]; int k = 0; uint i = 0u; if (idat.y == 20.0) { do { k *= 2; i++; } while (i < ident); } switch (k) { case 10: { for (;;) { i++; if (i > 10u) { break; } continue; } break; } default: { for (;;) { i += 2u; if (i > 20u) { break; } continue; } break; } } while (k < 10) { idat *= 2.0; k++; } for (uint i_1 = 0u; i_1 < 16u; i_1++, k++) { for (uint j = 0u; j < 30u; j++) { idat = _24.mvp * idat; } } k = 0; for (;;) { k++; if (k > 10) { k += 2; } else { k += 3; continue; } k += 10; continue; } } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/return.comp000066400000000000000000000011161400026215700243270ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _27; void main() { uint ident = gl_GlobalInvocationID.x; if (ident == 2u) { _27.out_data[ident] = vec4(20.0); } else { if (ident == 4u) { _27.out_data[ident] = vec4(10.0); return; } } int i = 0; while (i < 20) { if (i == 10) { break; } return; } _27.out_data[ident] = vec4(10.0); } shader_ballot_nonuniform_invocations.invalid.comp000066400000000000000000000005001400026215700340430ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/comp#version 450 #extension GL_AMD_shader_ballot : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; void main() { float addInvocations = addInvocationsNonUniformAMD(0.0); int minInvocations = minInvocationsNonUniformAMD(1); uint maxInvocations = uint(maxInvocationsNonUniformAMD(4)); } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/specialization-constant-evaluation.comp000066400000000000000000000150201400026215700320210ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 1 #endif const int SONE = SPIRV_CROSS_CONSTANT_ID_2; #ifndef SPIRV_CROSS_CONSTANT_ID_3 #define SPIRV_CROSS_CONSTANT_ID_3 2 #endif const int STWO = SPIRV_CROSS_CONSTANT_ID_3; const int _10 = (SONE + STWO); const uint _13 = (uint(_10) + 0u); #ifndef SPIRV_CROSS_CONSTANT_ID_5 #define SPIRV_CROSS_CONSTANT_ID_5 1u #endif const uint UONE = SPIRV_CROSS_CONSTANT_ID_5; const uint _15 = (_13 + UONE); #ifndef SPIRV_CROSS_CONSTANT_ID_6 #define SPIRV_CROSS_CONSTANT_ID_6 2u #endif const uint UTWO = SPIRV_CROSS_CONSTANT_ID_6; const uint IADD = (_15 + UTWO); const uint _19 = (IADD - 5u); const uint _28 = (uint(SONE) + 0u); const uint ISUB = (UTWO - _28); const uint IMUL = (UTWO * UTWO); const uint _37 = (IMUL - 3u); const uint UDIV = (UTWO / UTWO); #ifndef SPIRV_CROSS_CONSTANT_ID_4 #define SPIRV_CROSS_CONSTANT_ID_4 -2 #endif const int SNEG_TWO = SPIRV_CROSS_CONSTANT_ID_4; const int SDIV = (STWO / SNEG_TWO); const int _52 = (SDIV + 2); #ifndef SPIRV_CROSS_CONSTANT_ID_7 #define SPIRV_CROSS_CONSTANT_ID_7 -3 #endif const int SNEG_THREE = SPIRV_CROSS_CONSTANT_ID_7; const int SMOD = (STWO % SNEG_THREE); const int _66 = (SMOD + 2); const uint UMOD = (IADD % IMUL); const uint _73 = (UMOD - 1u); const uint LSHL = (IADD << ISUB); const uint _81 = (LSHL - 11u); const uint RSHL = (IADD >> ISUB); const uint _89 = (RSHL - 2u); const int _95 = int(IADD + 0u); const int _96 = (-_95); const int _97 = (-SDIV); const int RSHA = (_96 >> _97); const int _100 = (RSHA + 4); const bool IEQ = (IADD == ISUB); const int _109 = IEQ ? 2 : 1; const bool INEQ = (IADD != ISUB); const int _116 = INEQ ? 1 : 2; const bool ULT = (IADD < ISUB); const int _123 = ULT ? 2 : 1; const bool ULE = (IADD <= ISUB); const int _130 = ULE ? 2 : 1; const bool UGT = (IADD > ISUB); const int _137 = UGT ? 1 : 2; const bool UGE = (IADD >= ISUB); const int _144 = UGE ? 1 : 2; const bool SLT = (SMOD < 1); const int _151 = SLT ? 1 : 2; const bool SLE = (SMOD <= 1); const int _158 = SLE ? 1 : 2; const bool SGT = (SMOD > 1); const int _165 = SGT ? 2 : 1; const bool SGE = (SMOD >= 1); const int _172 = SGE ? 2 : 1; const bool LOR = (IEQ || SLT); const int _179 = LOR ? 1 : 2; const bool LAND = (IEQ && SLT); const int _186 = LAND ? 2 : 1; const bool LNOT = (!LOR); const int _193 = LNOT ? 2 : 1; const uint AND = (IADD & IADD); const uint _200 = (AND - 5u); const uint OR = (IADD | ISUB); const uint _208 = (OR - 6u); const uint XOR = (IADD ^ IADD); const uint _215 = (XOR + 1u); const uint NOT = (~XOR); const uint _223 = (NOT - 4294967294u); const bool LEQ = (LAND == LNOT); const int _230 = LEQ ? 1 : 2; const bool LNEQ = (LAND != LNOT); const int _237 = LNEQ ? 2 : 1; const uint SEL = IEQ ? IADD : ISUB; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 true #endif const bool TRUE = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 false #endif const bool FALSE = SPIRV_CROSS_CONSTANT_ID_1; layout(binding = 0, std430) buffer SSBO_IAdd { float val[_19]; float dummy; } IAdd; layout(binding = 1, std430) buffer SSBO_ISub { float val[ISUB]; float dummy; } ISub; layout(binding = 2, std430) buffer SSBO_IMul { float val[_37]; float dummy; } IMul; layout(binding = 3, std430) buffer SSBO_UDiv { float val[UDIV]; float dummy; } UDiv; layout(binding = 4, std430) buffer SSBO_SDiv { float val[_52]; float dummy; } SDiv; layout(binding = 5, std430) buffer SSBO_SRem { float val[1]; float dummy; } SRem; layout(binding = 6, std430) buffer SSBO_SMod { float val[_66]; float dummy; } SMod; layout(binding = 7, std430) buffer SSBO_UMod { float val[_73]; float dummy; } UMod; layout(binding = 8, std430) buffer SSBO_LShl { float val[_81]; float dummy; } LShl; layout(binding = 9, std430) buffer SSBO_RShl { float val[_89]; float dummy; } RShl; layout(binding = 10, std430) buffer SSBO_RSha { float val[_100]; float dummy; } RSha; layout(binding = 11, std430) buffer SSBO_IEq { float val[_109]; float dummy; } IEq; layout(binding = 12, std430) buffer SSBO_INeq { float val[_116]; float dummy; } INeq; layout(binding = 13, std430) buffer SSBO_Ult { float val[_123]; float dummy; } Ult; layout(binding = 14, std430) buffer SSBO_Ule { float val[_130]; float dummy; } Ule; layout(binding = 15, std430) buffer SSBO_Ugt { float val[_137]; float dummy; } Ugt; layout(binding = 16, std430) buffer SSBO_Uge { float val[_144]; float dummy; } Uge; layout(binding = 17, std430) buffer SSBO_Slt { float val[_151]; float dummy; } Slt; layout(binding = 18, std430) buffer SSBO_Sle { float val[_158]; float dummy; } Sle; layout(binding = 19, std430) buffer SSBO_Sgt { float val[_165]; float dummy; } Sgt; layout(binding = 20, std430) buffer SSBO_Sge { float val[_172]; float dummy; } Sge; layout(binding = 21, std430) buffer SSBO_Lor { float val[_179]; float dummy; } Lor; layout(binding = 22, std430) buffer SSBO_Land { float val[_186]; float dummy; } Land; layout(binding = 23, std430) buffer SSBO_Lnot { float val[_193]; float dummy; } Lnot; layout(binding = 24, std430) buffer SSBO_And { float val[_200]; float dummy; } And; layout(binding = 24, std430) buffer SSBO_Or { float val[_208]; float dummy; } Or; layout(binding = 24, std430) buffer SSBO_Xor { float val[_215]; float dummy; } Xor; layout(binding = 25, std430) buffer SSBO_Not { float val[_223]; float dummy; } Not; layout(binding = 26, std430) buffer SSBO_Leq { float val[_230]; float dummy; } Leq; layout(binding = 27, std430) buffer SSBO_Lneq { float val[_237]; float dummy; } Lneq; layout(binding = 28, std430) buffer SSBO_Sel { float val[SEL]; float dummy; } Sel; void main() { IAdd.val[0] = 0.0; ISub.val[0] = 0.0; IMul.val[0] = 0.0; UDiv.val[0] = 0.0; SDiv.val[0] = 0.0; SRem.val[0] = 0.0; SMod.val[0] = 0.0; UMod.val[0] = 0.0; LShl.val[0] = 0.0; RShl.val[0] = 0.0; RSha.val[0] = 0.0; IEq.val[0] = 0.0; INeq.val[0] = 0.0; Ult.val[0] = 0.0; Ule.val[0] = 0.0; Ugt.val[0] = 0.0; Uge.val[0] = 0.0; Slt.val[0] = 0.0; Sle.val[0] = 0.0; Sgt.val[0] = 0.0; Sge.val[0] = 0.0; Lor.val[0] = 0.0; Land.val[0] = 0.0; Lnot.val[0] = 0.0; And.val[0] = 0.0; Or.val[0] = 0.0; Xor.val[0] = 0.0; Not.val[0] = 0.0; Leq.val[0] = 0.0; Lneq.val[0] = 0.0; Sel.val[0] = 0.0; } struct-packing-scalar.nocompat.invalid.vk.comp.vk000066400000000000000000000047071400026215700334450ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/comp#version 310 es #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct S0 { vec2 a[1]; float b; }; struct S1 { vec3 a; float b; }; struct S2 { vec3 a[1]; float b; }; struct S3 { vec2 a; float b; }; struct S4 { vec2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; S4 m3s[8]; }; layout(set = 0, binding = 1, scalar) restrict buffer SSBO1 { Content content; Content content1[2]; Content content2; mat2 m0; mat2 m1; mat2x3 m2[4]; mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_430; layout(set = 0, binding = 0, std140) restrict buffer SSBO0 { Content content; Content content1[2]; Content content2; mat2 m0; mat2 m1; mat2x3 m2[4]; mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_140; void main() { ssbo_430.content.m0s[0].a[0] = ssbo_140.content.m0s[0].a[0]; ssbo_430.content.m0s[0].b = ssbo_140.content.m0s[0].b; ssbo_430.content.m1s[0].a = ssbo_140.content.m1s[0].a; ssbo_430.content.m1s[0].b = ssbo_140.content.m1s[0].b; ssbo_430.content.m2s[0].a[0] = ssbo_140.content.m2s[0].a[0]; ssbo_430.content.m2s[0].b = ssbo_140.content.m2s[0].b; ssbo_430.content.m0.a[0] = ssbo_140.content.m0.a[0]; ssbo_430.content.m0.b = ssbo_140.content.m0.b; ssbo_430.content.m1.a = ssbo_140.content.m1.a; ssbo_430.content.m1.b = ssbo_140.content.m1.b; ssbo_430.content.m2.a[0] = ssbo_140.content.m2.a[0]; ssbo_430.content.m2.b = ssbo_140.content.m2.b; ssbo_430.content.m3.a = ssbo_140.content.m3.a; ssbo_430.content.m3.b = ssbo_140.content.m3.b; ssbo_430.content.m4 = ssbo_140.content.m4; ssbo_430.content.m3s[0].c = ssbo_140.content.m3s[0].c; ssbo_430.content.m3s[1].c = ssbo_140.content.m3s[1].c; ssbo_430.content.m3s[2].c = ssbo_140.content.m3s[2].c; ssbo_430.content.m3s[3].c = ssbo_140.content.m3s[3].c; ssbo_430.content.m3s[4].c = ssbo_140.content.m3s[4].c; ssbo_430.content.m3s[5].c = ssbo_140.content.m3s[5].c; ssbo_430.content.m3s[6].c = ssbo_140.content.m3s[6].c; ssbo_430.content.m3s[7].c = ssbo_140.content.m3s[7].c; } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/subgroups.nocompat.invalid.vk.comp.vk000066400000000000000000000110461400026215700313460ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_shuffle : require #extension GL_KHR_shader_subgroup_shuffle_relative : require #extension GL_KHR_shader_subgroup_vote : require #extension GL_KHR_shader_subgroup_arithmetic : require #extension GL_KHR_shader_subgroup_clustered : require #extension GL_KHR_shader_subgroup_quad : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(set = 0, binding = 0, std430) buffer SSBO { float FragColor; } _9; void main() { _9.FragColor = float(gl_NumSubgroups); _9.FragColor = float(gl_SubgroupID); _9.FragColor = float(gl_SubgroupSize); _9.FragColor = float(gl_SubgroupInvocationID); subgroupMemoryBarrier(); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); _9.FragColor = vec4(gl_SubgroupEqMask).x; _9.FragColor = vec4(gl_SubgroupGeMask).x; _9.FragColor = vec4(gl_SubgroupGtMask).x; _9.FragColor = vec4(gl_SubgroupLeMask).x; _9.FragColor = vec4(gl_SubgroupLtMask).x; vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); uint shuffled = subgroupShuffle(10u, 8u); uint shuffled_xor = subgroupShuffleXor(30u, 8u); uint shuffled_up = subgroupShuffleUp(20u, 4u); uint shuffled_down = subgroupShuffleDown(20u, 4u); bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal = subgroupAllEqual(true); vec4 added = subgroupAdd(vec4(20.0)); ivec4 iadded = subgroupAdd(ivec4(20)); vec4 multiplied = subgroupMul(vec4(20.0)); ivec4 imultiplied = subgroupMul(ivec4(20)); vec4 lo = subgroupMin(vec4(20.0)); vec4 hi = subgroupMax(vec4(20.0)); ivec4 slo = subgroupMin(ivec4(20)); ivec4 shi = subgroupMax(ivec4(20)); uvec4 ulo = subgroupMin(uvec4(20u)); uvec4 uhi = subgroupMax(uvec4(20u)); uvec4 anded = subgroupAnd(ballot_value); uvec4 ored = subgroupOr(ballot_value); uvec4 xored = subgroupXor(ballot_value); added = subgroupInclusiveAdd(added); iadded = subgroupInclusiveAdd(iadded); multiplied = subgroupInclusiveMul(multiplied); imultiplied = subgroupInclusiveMul(imultiplied); lo = subgroupInclusiveMin(lo); hi = subgroupInclusiveMax(hi); slo = subgroupInclusiveMin(slo); shi = subgroupInclusiveMax(shi); ulo = subgroupInclusiveMin(ulo); uhi = subgroupInclusiveMax(uhi); anded = subgroupInclusiveAnd(anded); ored = subgroupInclusiveOr(ored); xored = subgroupInclusiveXor(ored); added = subgroupExclusiveAdd(lo); added = subgroupExclusiveAdd(multiplied); multiplied = subgroupExclusiveMul(multiplied); iadded = subgroupExclusiveAdd(imultiplied); imultiplied = subgroupExclusiveMul(imultiplied); lo = subgroupExclusiveMin(lo); hi = subgroupExclusiveMax(hi); ulo = subgroupExclusiveMin(ulo); uhi = subgroupExclusiveMax(uhi); slo = subgroupExclusiveMin(slo); shi = subgroupExclusiveMax(shi); anded = subgroupExclusiveAnd(anded); ored = subgroupExclusiveOr(ored); xored = subgroupExclusiveXor(ored); added = subgroupClusteredAdd(added, 4u); multiplied = subgroupClusteredMul(multiplied, 4u); iadded = subgroupClusteredAdd(iadded, 4u); imultiplied = subgroupClusteredMul(imultiplied, 4u); lo = subgroupClusteredMin(lo, 4u); hi = subgroupClusteredMax(hi, 4u); ulo = subgroupClusteredMin(ulo, 4u); uhi = subgroupClusteredMax(uhi, 4u); slo = subgroupClusteredMin(slo, 4u); shi = subgroupClusteredMax(shi, 4u); anded = subgroupClusteredAnd(anded, 4u); ored = subgroupClusteredOr(ored, 4u); xored = subgroupClusteredXor(xored, 4u); vec4 swap_horiz = subgroupQuadSwapHorizontal(vec4(20.0)); vec4 swap_vertical = subgroupQuadSwapVertical(vec4(20.0)); vec4 swap_diagonal = subgroupQuadSwapDiagonal(vec4(20.0)); vec4 quad_broadcast = subgroupQuadBroadcast(vec4(20.0), 3u); } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/subgroups_basicvoteballot.vk.comp000066400000000000000000000434071400026215700307260ustar00rootroot00000000000000#version 450 #if defined(GL_KHR_shader_subgroup_ballot) #extension GL_KHR_shader_subgroup_ballot : require #elif defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #elif defined(GL_ARB_shader_ballot) && defined(GL_ARB_shader_int64) #extension GL_ARB_shader_int64 : enable #extension GL_ARB_shader_ballot : require #else #error No extensions available to emulate requested subgroup feature. #endif #if defined(GL_KHR_shader_subgroup_basic) #extension GL_KHR_shader_subgroup_basic : require #elif defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #elif defined(GL_ARB_shader_ballot) && defined(GL_ARB_shader_int64) #extension GL_ARB_shader_int64 : enable #extension GL_ARB_shader_ballot : require #elif defined(GL_AMD_gcn_shader) && (defined(GL_AMD_gpu_shader_int64) || defined(GL_NV_gpu_shader5)) #extension GL_AMD_gpu_shader_int64 : enable #extension GL_NV_gpu_shader5 : enable #extension GL_AMD_gcn_shader : require #else #error No extensions available to emulate requested subgroup feature. #endif #if defined(GL_KHR_shader_subgroup_basic) #extension GL_KHR_shader_subgroup_basic : require #elif defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #elif defined(GL_ARB_shader_ballot) && defined(GL_ARB_shader_int64) #extension GL_ARB_shader_int64 : enable #extension GL_ARB_shader_ballot : require #else #error No extensions available to emulate requested subgroup feature. #endif #if defined(GL_KHR_shader_subgroup_basic) #extension GL_KHR_shader_subgroup_basic : require #elif defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #else #error No extensions available to emulate requested subgroup feature. #endif #if defined(GL_KHR_shader_subgroup_basic) #extension GL_KHR_shader_subgroup_basic : require #elif defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #else #error No extensions available to emulate requested subgroup feature. #endif #if defined(GL_KHR_shader_subgroup_ballot) #extension GL_KHR_shader_subgroup_ballot : require #elif defined(GL_ARB_shader_ballot) && defined(GL_ARB_shader_int64) #extension GL_ARB_shader_int64 : enable #extension GL_ARB_shader_ballot : require #elif defined(GL_NV_shader_thread_shuffle) #extension GL_NV_shader_thread_shuffle : require #else #error No extensions available to emulate requested subgroup feature. #endif #if defined(GL_KHR_shader_subgroup_ballot) #extension GL_KHR_shader_subgroup_ballot : require #elif defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #endif #if defined(GL_KHR_shader_subgroup_vote) #extension GL_KHR_shader_subgroup_vote : require #elif defined(GL_AMD_gcn_shader) && (defined(GL_AMD_gpu_shader_int64) || defined(GL_NV_gpu_shader5)) #extension GL_AMD_gpu_shader_int64 : enable #extension GL_NV_gpu_shader5 : enable #extension GL_AMD_gcn_shader : require #elif defined(GL_NV_gpu_shader_5) #extension GL_NV_gpu_shader_5 : require #elif defined(GL_ARB_shader_group_vote) #extension GL_ARB_shader_group_vote : require #else #error No extensions available to emulate requested subgroup feature. #endif #if defined(GL_KHR_shader_subgroup_basic) #extension GL_KHR_shader_subgroup_basic : require #elif defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #elif defined(GL_ARB_shader_ballot) && defined(GL_ARB_shader_int64) #extension GL_ARB_shader_int64 : enable #extension GL_ARB_shader_ballot : require #elif defined(GL_AMD_gcn_shader) && (defined(GL_AMD_gpu_shader_int64) || defined(GL_NV_gpu_shader5)) #extension GL_AMD_gpu_shader_int64 : enable #extension GL_NV_gpu_shader5 : enable #extension GL_AMD_gcn_shader : require #else #error No extensions available to emulate requested subgroup feature. #endif #if defined(GL_KHR_shader_subgroup_basic) #extension GL_KHR_shader_subgroup_basic : require #endif #if defined(GL_KHR_shader_subgroup_ballot) #extension GL_KHR_shader_subgroup_ballot : require #elif defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #elif defined(GL_ARB_shader_ballot) && defined(GL_ARB_shader_int64) #extension GL_ARB_shader_int64 : enable #extension GL_ARB_shader_ballot : require #else #error No extensions available to emulate requested subgroup feature. #endif #if defined(GL_NV_shader_thread_group) #extension GL_NV_shader_thread_group : require #endif layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { float FragColor; } _9; #if defined(GL_KHR_shader_subgroup_ballot) #elif defined(GL_NV_shader_thread_group) #define gl_SubgroupEqMask uvec4(gl_ThreadEqMaskNV, 0u, 0u, 0u) #define gl_SubgroupGeMask uvec4(gl_ThreadGeMaskNV, 0u, 0u, 0u) #define gl_SubgroupGtMask uvec4(gl_ThreadGtMaskNV, 0u, 0u, 0u) #define gl_SubgroupLeMask uvec4(gl_ThreadLeMaskNV, 0u, 0u, 0u) #define gl_SubgroupLtMask uvec4(gl_ThreadLtMaskNV, 0u, 0u, 0u) #elif defined(GL_ARB_shader_ballot) #define gl_SubgroupEqMask uvec4(unpackUint2x32(gl_SubGroupEqMaskARB), 0u, 0u) #define gl_SubgroupGeMask uvec4(unpackUint2x32(gl_SubGroupGeMaskARB), 0u, 0u) #define gl_SubgroupGtMask uvec4(unpackUint2x32(gl_SubGroupGtMaskARB), 0u, 0u) #define gl_SubgroupLeMask uvec4(unpackUint2x32(gl_SubGroupLeMaskARB), 0u, 0u) #define gl_SubgroupLtMask uvec4(unpackUint2x32(gl_SubGroupLtMaskARB), 0u, 0u) #endif #if defined(GL_KHR_shader_subgroup_basic) #elif defined(GL_NV_shader_thread_group) #define gl_SubgroupSize gl_WarpSizeNV #elif defined(GL_ARB_shader_ballot) #define gl_SubgroupSize gl_SubGroupSizeARB #elif defined(GL_AMD_gcn_shader) #define gl_SubgroupSize uint(gl_SIMDGroupSizeAMD) #endif #if defined(GL_KHR_shader_subgroup_basic) #elif defined(GL_NV_shader_thread_group) #define gl_SubgroupInvocationID gl_ThreadInWarpNV #elif defined(GL_ARB_shader_ballot) #define gl_SubgroupInvocationID gl_SubGroupInvocationARB #endif #if defined(GL_KHR_shader_subgroup_basic) #elif defined(GL_NV_shader_thread_group) #define gl_SubgroupID gl_WarpIDNV #endif #if defined(GL_KHR_shader_subgroup_basic) #elif defined(GL_NV_shader_thread_group) #define gl_NumSubgroups gl_WarpsPerSMNV #endif #if defined(GL_KHR_shader_subgroup_ballot) #elif defined(GL_ARB_shader_ballot) int subgroupBroadcastFirst(int value) { return readFirstInvocationARB(value); } ivec2 subgroupBroadcastFirst(ivec2 value) { return readFirstInvocationARB(value); } ivec3 subgroupBroadcastFirst(ivec3 value) { return readFirstInvocationARB(value); } ivec4 subgroupBroadcastFirst(ivec4 value) { return readFirstInvocationARB(value); } uint subgroupBroadcastFirst(uint value) { return readFirstInvocationARB(value); } uvec2 subgroupBroadcastFirst(uvec2 value) { return readFirstInvocationARB(value); } uvec3 subgroupBroadcastFirst(uvec3 value) { return readFirstInvocationARB(value); } uvec4 subgroupBroadcastFirst(uvec4 value) { return readFirstInvocationARB(value); } float subgroupBroadcastFirst(float value) { return readFirstInvocationARB(value); } vec2 subgroupBroadcastFirst(vec2 value) { return readFirstInvocationARB(value); } vec3 subgroupBroadcastFirst(vec3 value) { return readFirstInvocationARB(value); } vec4 subgroupBroadcastFirst(vec4 value) { return readFirstInvocationARB(value); } double subgroupBroadcastFirst(double value) { return readFirstInvocationARB(value); } dvec2 subgroupBroadcastFirst(dvec2 value) { return readFirstInvocationARB(value); } dvec3 subgroupBroadcastFirst(dvec3 value) { return readFirstInvocationARB(value); } dvec4 subgroupBroadcastFirst(dvec4 value) { return readFirstInvocationARB(value); } int subgroupBroadcast(int value, uint id) { return readInvocationARB(value, id); } ivec2 subgroupBroadcast(ivec2 value, uint id) { return readInvocationARB(value, id); } ivec3 subgroupBroadcast(ivec3 value, uint id) { return readInvocationARB(value, id); } ivec4 subgroupBroadcast(ivec4 value, uint id) { return readInvocationARB(value, id); } uint subgroupBroadcast(uint value, uint id) { return readInvocationARB(value, id); } uvec2 subgroupBroadcast(uvec2 value, uint id) { return readInvocationARB(value, id); } uvec3 subgroupBroadcast(uvec3 value, uint id) { return readInvocationARB(value, id); } uvec4 subgroupBroadcast(uvec4 value, uint id) { return readInvocationARB(value, id); } float subgroupBroadcast(float value, uint id) { return readInvocationARB(value, id); } vec2 subgroupBroadcast(vec2 value, uint id) { return readInvocationARB(value, id); } vec3 subgroupBroadcast(vec3 value, uint id) { return readInvocationARB(value, id); } vec4 subgroupBroadcast(vec4 value, uint id) { return readInvocationARB(value, id); } double subgroupBroadcast(double value, uint id) { return readInvocationARB(value, id); } dvec2 subgroupBroadcast(dvec2 value, uint id) { return readInvocationARB(value, id); } dvec3 subgroupBroadcast(dvec3 value, uint id) { return readInvocationARB(value, id); } dvec4 subgroupBroadcast(dvec4 value, uint id) { return readInvocationARB(value, id); } #elif defined(GL_NV_shader_thread_shuffle) int subgroupBroadcastFirst(int value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } ivec2 subgroupBroadcastFirst(ivec2 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } ivec3 subgroupBroadcastFirst(ivec3 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } ivec4 subgroupBroadcastFirst(ivec4 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } uint subgroupBroadcastFirst(uint value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } uvec2 subgroupBroadcastFirst(uvec2 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } uvec3 subgroupBroadcastFirst(uvec3 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } uvec4 subgroupBroadcastFirst(uvec4 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } float subgroupBroadcastFirst(float value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } vec2 subgroupBroadcastFirst(vec2 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } vec3 subgroupBroadcastFirst(vec3 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } vec4 subgroupBroadcastFirst(vec4 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } double subgroupBroadcastFirst(double value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } dvec2 subgroupBroadcastFirst(dvec2 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } dvec3 subgroupBroadcastFirst(dvec3 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } dvec4 subgroupBroadcastFirst(dvec4 value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); } int subgroupBroadcast(int value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } ivec2 subgroupBroadcast(ivec2 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } ivec3 subgroupBroadcast(ivec3 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } ivec4 subgroupBroadcast(ivec4 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } uint subgroupBroadcast(uint value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } uvec2 subgroupBroadcast(uvec2 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } uvec3 subgroupBroadcast(uvec3 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } uvec4 subgroupBroadcast(uvec4 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } float subgroupBroadcast(float value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } vec2 subgroupBroadcast(vec2 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } vec3 subgroupBroadcast(vec3 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } vec4 subgroupBroadcast(vec4 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } double subgroupBroadcast(double value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } dvec2 subgroupBroadcast(dvec2 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } dvec3 subgroupBroadcast(dvec3 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } dvec4 subgroupBroadcast(dvec4 value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); } #endif #if defined(GL_KHR_shader_subgroup_ballot) #elif defined(GL_NV_shader_thread_group) uint subgroupBallotFindLSB(uvec4 value) { return findLSB(value.x); } uint subgroupBallotFindMSB(uvec4 value) { return findMSB(value.x); } #else uint subgroupBallotFindLSB(uvec4 value) { int firstLive = findLSB(value.x); return uint(firstLive != -1 ? firstLive : (findLSB(value.y) + 32)); } uint subgroupBallotFindMSB(uvec4 value) { int firstLive = findMSB(value.y); return uint(firstLive != -1 ? (firstLive + 32) : findMSB(value.x)); } #endif #if defined(GL_KHR_shader_subgroup_vote) #elif defined(GL_AMD_gcn_shader) bool subgroupAll(bool value) { return ballotAMD(value) == ballotAMD(true); } bool subgroupAny(bool value) { return ballotAMD(value) != 0ull; } bool subgroupAllEqual(bool value) { uint64_t b = ballotAMD(value); return b == 0ull || b == ballotAMD(true); } #elif defined(GL_NV_gpu_shader_5) bool subgroupAll(bool value) { return allThreadsNV(value); } bool subgroupAny(bool value) { return anyThreadNV(value); } bool subgroupAllEqual(bool value) { return allThreadsEqualNV(value); } #elif defined(GL_ARB_shader_group_vote) bool subgroupAll(bool v) { return allInvocationsARB(v); } bool subgroupAny(bool v) { return anyInvocationARB(v); } bool subgroupAllEqual(bool v) { return allInvocationsEqualARB(v); } #endif #ifndef GL_KHR_shader_subgroup_vote #define _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(type) bool subgroupAllEqual(type value) { return subgroupAllEqual(subgroupBroadcastFirst(value) == value); } _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(int) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(ivec2) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(ivec3) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(ivec4) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(uint) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(uvec2) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(uvec3) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(uvec4) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(float) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(vec2) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(vec3) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(vec4) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(double) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(dvec2) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(dvec3) _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(dvec4) #undef _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND #endif #if defined(GL_KHR_shader_subgroup_ballot) #elif defined(GL_NV_shader_thread_group) uvec4 subgroupBallot(bool v) { return uvec4(ballotThreadNV(v), 0u, 0u, 0u); } #elif defined(GL_ARB_shader_ballot) uvec4 subgroupBallot(bool v) { return uvec4(unpackUint2x32(ballotARB(v)), 0u, 0u); } #endif #ifndef GL_KHR_shader_subgroup_basic bool subgroupElect() { uvec4 activeMask = subgroupBallot(true); uint firstLive = subgroupBallotFindLSB(activeMask); return gl_SubgroupInvocationID == firstLive; } #endif #ifndef GL_KHR_shader_subgroup_basic void subgroupBarrier() { memoryBarrierShared(); } #endif #ifndef GL_KHR_shader_subgroup_basic void subgroupMemoryBarrier() { groupMemoryBarrier(); } void subgroupMemoryBarrierBuffer() { groupMemoryBarrier(); } void subgroupMemoryBarrierShared() { memoryBarrierShared(); } void subgroupMemoryBarrierImage() { groupMemoryBarrier(); } #endif #ifndef GL_KHR_shader_subgroup_ballot bool subgroupInverseBallot(uvec4 value) { return any(notEqual(value.xy & gl_SubgroupEqMask.xy, uvec2(0u))); } uint subgroupBallotInclusiveBitCount(uvec4 value) { uvec2 v = value.xy & gl_SubgroupLeMask.xy; ivec2 c = bitCount(v); #ifdef GL_NV_shader_thread_group return uint(c.x); #else return uint(c.x + c.y); #endif } uint subgroupBallotExclusiveBitCount(uvec4 value) { uvec2 v = value.xy & gl_SubgroupLtMask.xy; ivec2 c = bitCount(v); #ifdef GL_NV_shader_thread_group return uint(c.x); #else return uint(c.x + c.y); #endif } #endif #ifndef GL_KHR_shader_subgroup_ballot uint subgroupBallotBitCount(uvec4 value) { ivec2 c = bitCount(value.xy); #ifdef GL_NV_shader_thread_group return uint(c.x); #else return uint(c.x + c.y); #endif } #endif #ifndef GL_KHR_shader_subgroup_ballot bool subgroupBallotBitExtract(uvec4 value, uint index) { #ifdef GL_NV_shader_thread_group uint shifted = value.x >> index; #else uint shifted = value[index >> 5u] >> (index & 0x1fu); #endif return (shifted & 1u) != 0u; } #endif void main() { _9.FragColor = float(gl_NumSubgroups); _9.FragColor = float(gl_SubgroupID); _9.FragColor = float(gl_SubgroupSize); _9.FragColor = float(gl_SubgroupInvocationID); subgroupMemoryBarrier(); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); _9.FragColor = vec4(gl_SubgroupEqMask).x; _9.FragColor = vec4(gl_SubgroupGeMask).x; _9.FragColor = vec4(gl_SubgroupGtMask).x; _9.FragColor = vec4(gl_SubgroupLeMask).x; _9.FragColor = vec4(gl_SubgroupLtMask).x; vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal_bool = subgroupAllEqual(true); bool has_equal_T = subgroupAllEqual(uvec3(5u)); } spirv-cross-2021.01.15/reference/shaders-no-opt/comp/subgroups_basicvoteballot.vk.comp.vk000066400000000000000000000033211400026215700313340ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_vote : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(set = 0, binding = 0, std430) buffer SSBO { float FragColor; } _9; void main() { _9.FragColor = float(gl_NumSubgroups); _9.FragColor = float(gl_SubgroupID); _9.FragColor = float(gl_SubgroupSize); _9.FragColor = float(gl_SubgroupInvocationID); subgroupMemoryBarrier(); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); _9.FragColor = vec4(gl_SubgroupEqMask).x; _9.FragColor = vec4(gl_SubgroupGeMask).x; _9.FragColor = vec4(gl_SubgroupGtMask).x; _9.FragColor = vec4(gl_SubgroupLeMask).x; _9.FragColor = vec4(gl_SubgroupLtMask).x; vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal_bool = subgroupAllEqual(true); bool has_equal_T = subgroupAllEqual(uvec3(5u)); } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/000077500000000000000000000000001400026215700221125ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/frag/16bit-constants.invalid.frag000066400000000000000000000010551400026215700273400ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_NV_gpu_shader5) #extension GL_NV_gpu_shader5 : require #else #error No extension available for FP16. #endif #if defined(GL_AMD_gpu_shader_int16) #extension GL_AMD_gpu_shader_int16 : require #else #error No extension available for Int16. #endif layout(location = 0) out float16_t foo; layout(location = 1) out int16_t bar; layout(location = 2) out uint16_t baz; void main() { foo = float16_t(1.0); bar = 2s; baz = 3us; } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/fp16.invalid.desktop.frag000066400000000000000000000075651400026215700266410ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_NV_gpu_shader5) #extension GL_NV_gpu_shader5 : require #else #error No extension available for FP16. #endif struct ResType { f16vec4 _m0; ivec4 _m1; }; layout(location = 3) in f16vec4 v4; layout(location = 2) in f16vec3 v3; layout(location = 0) in float16_t v1; layout(location = 1) in f16vec2 v2; f16mat2 test_mat2(f16vec2 a, f16vec2 b, f16vec2 c, f16vec2 d) { return f16mat2(f16vec2(a), f16vec2(b)) * f16mat2(f16vec2(c), f16vec2(d)); } f16mat3 test_mat3(f16vec3 a, f16vec3 b, f16vec3 c, f16vec3 d, f16vec3 e, f16vec3 f) { return f16mat3(f16vec3(a), f16vec3(b), f16vec3(c)) * f16mat3(f16vec3(d), f16vec3(e), f16vec3(f)); } void test_constants() { float16_t a = float16_t(1.0); float16_t b = float16_t(1.5); float16_t c = float16_t(-1.5); float16_t d = float16_t(0.0 / 0.0); float16_t e = float16_t(1.0 / 0.0); float16_t f = float16_t(-1.0 / 0.0); float16_t g = float16_t(1014.0); float16_t h = float16_t(9.5367431640625e-07); } float16_t test_result() { return float16_t(1.0); } void test_conversions() { float16_t one = test_result(); int a = int(one); uint b = uint(one); bool c = !(one == float16_t(0.0)); float d = float(one); double e = double(one); float16_t a2 = float16_t(a); float16_t b2 = float16_t(b); float16_t c2 = float16_t(c); float16_t d2 = float16_t(d); float16_t e2 = float16_t(e); } void test_builtins() { f16vec4 res = radians(v4); res = degrees(v4); res = sin(v4); res = cos(v4); res = tan(v4); res = asin(v4); res = atan(v4, v3.xyzz); res = atan(v4); res = sinh(v4); res = cosh(v4); res = tanh(v4); res = asinh(v4); res = acosh(v4); res = atanh(v4); res = pow(v4, v4); res = exp(v4); res = log(v4); res = exp2(v4); res = log2(v4); res = sqrt(v4); res = inversesqrt(v4); res = abs(v4); res = sign(v4); res = floor(v4); res = trunc(v4); res = round(v4); res = roundEven(v4); res = ceil(v4); res = fract(v4); res = mod(v4, v4); f16vec4 tmp; f16vec4 _231 = modf(v4, tmp); res = _231; res = min(v4, v4); res = max(v4, v4); res = clamp(v4, v4, v4); res = mix(v4, v4, v4); res = mix(v4, v4, lessThan(v4, v4)); res = step(v4, v4); res = smoothstep(v4, v4, v4); bvec4 btmp = isnan(v4); btmp = isinf(v4); res = fma(v4, v4, v4); ResType _275; _275._m0 = frexp(v4, _275._m1); ivec4 itmp = _275._m1; res = _275._m0; res = ldexp(res, itmp); uint pack0 = packFloat2x16(v4.xy); uint pack1 = packFloat2x16(v4.zw); res = f16vec4(unpackFloat2x16(pack0), unpackFloat2x16(pack1)); float16_t t0 = length(v4); t0 = distance(v4, v4); t0 = dot(v4, v4); f16vec3 res3 = cross(v3, v3); res = normalize(v4); res = faceforward(v4, v4, v4); res = reflect(v4, v4); res = refract(v4, v4, v1); btmp = lessThan(v4, v4); btmp = lessThanEqual(v4, v4); btmp = greaterThan(v4, v4); btmp = greaterThanEqual(v4, v4); btmp = equal(v4, v4); btmp = not(equal(v4, v4)); res = dFdx(v4); res = dFdy(v4); res = dFdxFine(v4); res = dFdyFine(v4); res = dFdxCoarse(v4); res = dFdyCoarse(v4); res = fwidth(v4); res = fwidthFine(v4); res = fwidthCoarse(v4); } void main() { f16vec2 param = v2; f16vec2 param_1 = v2; f16vec2 param_2 = v3.xy; f16vec2 param_3 = v3.xy; f16mat2 m0 = test_mat2(param, param_1, param_2, param_3); f16vec3 param_4 = v3; f16vec3 param_5 = v3; f16vec3 param_6 = v3; f16vec3 param_7 = v4.xyz; f16vec3 param_8 = v4.xyz; f16vec3 param_9 = v4.yzw; f16mat3 m1 = test_mat3(param_4, param_5, param_6, param_7, param_8, param_9); test_constants(); test_conversions(); test_builtins(); } fragmentMaskFetch_subpassInput.vk.nocompat.invalid.frag.vk000066400000000000000000000003711400026215700353500ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/frag#version 450 #extension GL_AMD_shader_fragment_mask : require layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInputMS t; void main() { vec4 test2 = fragmentFetchAMD(t, 4u); uint testi2 = fragmentMaskFetchAMD(t); } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/fs.invalid.frag000066400000000000000000000006401400026215700250100ustar00rootroot00000000000000#version 450 #extension GL_AMD_shader_fragment_mask : require #extension GL_AMD_shader_explicit_vertex_parameter : require layout(binding = 0) uniform sampler2DMS texture1; layout(location = 0) __explicitInterpAMD in vec4 vary; void main() { uint testi1 = fragmentMaskFetchAMD(texture1, ivec2(0)); vec4 test1 = fragmentFetchAMD(texture1, ivec2(1), 2u); vec4 pos = interpolateAtVertexAMD(vary, 0u); } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/image-gather.frag000066400000000000000000000005561400026215700253130ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSamp; layout(binding = 1) uniform sampler2DShadow uSampShadow; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec3 vUV; void main() { FragColor = textureGather(uSamp, vUV.xy); FragColor += textureGather(uSamp, vUV.xy, 1); FragColor += textureGather(uSampShadow, vUV.xy, vUV.z); } multi-dimensional.desktop.invalid.flatten_dim.frag000066400000000000000000000011731400026215700337120ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/frag#version 450 layout(binding = 0) uniform sampler2D uTextures[2 * 3 * 1]; layout(location = 1) in vec2 vUV; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in int vIndex; void main() { vec4 values3[2 * 3 * 1]; for (int z = 0; z < 2; z++) { for (int y = 0; y < 3; y++) { for (int x = 0; x < 1; x++) { values3[z * 3 * 1 + y * 1 + x] = texture(uTextures[z * 3 * 1 + y * 1 + x], vUV); } } } FragColor = (values3[1 * 3 * 1 + 2 * 1 + 0] + values3[0 * 3 * 1 + 2 * 1 + 0]) + values3[(vIndex + 1) * 3 * 1 + 2 * 1 + vIndex]; } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/nonuniform-constructor.vk.nocompat.frag.vk000066400000000000000000000005761400026215700324150ustar00rootroot00000000000000#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(set = 0, binding = 0) uniform texture2D uTex[]; layout(set = 1, binding = 0) uniform sampler Immut; layout(location = 0) out vec4 FragColor; layout(location = 1) flat in int vIndex; layout(location = 0) in vec2 vUV; void main() { FragColor = texture(nonuniformEXT(sampler2D(uTex[vIndex], Immut)), vUV); } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/pixel-interlock-simple-callstack.frag000066400000000000000000000010051400026215700313060ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 1, std430) buffer SSBO1 { uint values1[]; } _14; layout(binding = 0, std430) buffer SSBO0 { uint values0[]; } _35; void callee2() { int _25 = int(gl_FragCoord.x); _14.values1[_25]++; } void callee() { int _38 = int(gl_FragCoord.x); _35.values0[_38]++; callee2(); } void main() { beginInvocationInterlockARB(); callee(); endInvocationInterlockARB(); } scalar-block-layout-ubo-std430.vk.nocompat.invalid.frag.vk000066400000000000000000000007611400026215700346540ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/frag#version 450 #extension GL_EXT_scalar_block_layout : require layout(set = 0, binding = 0, std430) uniform UBO { float a[1024]; vec3 b[2]; } _17; layout(set = 0, binding = 1, std430) uniform UBOEnhancedLayout { layout(offset = 0) float c[1024]; layout(offset = 4096) vec3 d[2]; layout(offset = 10000) float e; } _30; layout(location = 0) out float FragColor; layout(location = 0) flat in int vIndex; void main() { FragColor = (_17.a[vIndex] + _30.c[vIndex]) + _30.e; } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/sparse-texture-clamp.desktop.frag000066400000000000000000000024121400026215700305070ustar00rootroot00000000000000#version 450 #extension GL_ARB_sparse_texture2 : require #extension GL_ARB_sparse_texture_clamp : require struct ResType { int _m0; vec4 _m1; }; layout(binding = 0) uniform sampler2D uSamp; layout(location = 0) in vec2 vUV; void main() { int _66; vec4 _67; _66 = sparseTextureClampARB(uSamp, vUV, 1.0, _67, 2.0); ResType _25 = ResType(_66, _67); vec4 texel = _25._m1; int code = _25._m0; texel = textureClampARB(uSamp, vUV, 1.0, 2.0); int _68; vec4 _69; _68 = sparseTextureOffsetClampARB(uSamp, vUV, ivec2(1, 2), 1.0, _69, 2.0); ResType _37 = ResType(_68, _69); texel = _37._m1; code = _37._m0; texel = textureOffsetClampARB(uSamp, vUV, ivec2(1, 2), 1.0, 2.0); int _70; vec4 _71; _70 = sparseTextureGradClampARB(uSamp, vUV, vec2(1.0), vec2(2.0), 1.0, _71); ResType _47 = ResType(_70, _71); texel = _47._m1; code = _47._m0; texel = textureGradClampARB(uSamp, vUV, vec2(1.0), vec2(2.0), 1.0); int _72; vec4 _73; _72 = sparseTextureGradOffsetClampARB(uSamp, vUV, vec2(1.0), vec2(2.0), ivec2(-1, -2), 1.0, _73); ResType _58 = ResType(_72, _73); texel = _58._m1; code = _58._m0; texel = textureGradOffsetClampARB(uSamp, vUV, vec2(1.0), vec2(2.0), ivec2(-1, -2), 1.0); } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/sparse-texture-feedback.desktop.frag000066400000000000000000000062461400026215700311500ustar00rootroot00000000000000#version 450 #extension GL_ARB_sparse_texture2 : require #extension GL_ARB_sparse_texture_clamp : require struct ResType { int _m0; vec4 _m1; }; layout(binding = 0) uniform sampler2D uSamp; layout(binding = 1) uniform sampler2DMS uSampMS; layout(binding = 2, rgba8) uniform readonly image2D uImage; layout(binding = 3, rgba8) uniform readonly image2DMS uImageMS; layout(location = 0) in vec2 vUV; void main() { int _144; vec4 _145; _144 = sparseTextureARB(uSamp, vUV, _145); ResType _24 = ResType(_144, _145); vec4 texel = _24._m1; bool ret = sparseTexelsResidentARB(_24._m0); int _146; vec4 _147; _146 = sparseTextureARB(uSamp, vUV, _147, 1.10000002384185791015625); ResType _31 = ResType(_146, _147); texel = _31._m1; ret = sparseTexelsResidentARB(_31._m0); int _148; vec4 _149; _148 = sparseTextureLodARB(uSamp, vUV, 1.0, _149); ResType _38 = ResType(_148, _149); texel = _38._m1; ret = sparseTexelsResidentARB(_38._m0); int _150; vec4 _151; _150 = sparseTextureOffsetARB(uSamp, vUV, ivec2(1), _151); ResType _47 = ResType(_150, _151); texel = _47._m1; ret = sparseTexelsResidentARB(_47._m0); int _152; vec4 _153; _152 = sparseTextureOffsetARB(uSamp, vUV, ivec2(2), _153, 0.5); ResType _56 = ResType(_152, _153); texel = _56._m1; ret = sparseTexelsResidentARB(_56._m0); int _154; vec4 _155; _154 = sparseTexelFetchARB(uSamp, ivec2(vUV), 1, _155); ResType _64 = ResType(_154, _155); texel = _64._m1; ret = sparseTexelsResidentARB(_64._m0); int _156; vec4 _157; _156 = sparseTexelFetchARB(uSampMS, ivec2(vUV), 2, _157); ResType _76 = ResType(_156, _157); texel = _76._m1; ret = sparseTexelsResidentARB(_76._m0); int _158; vec4 _159; _158 = sparseTexelFetchOffsetARB(uSamp, ivec2(vUV), 1, ivec2(2, 3), _159); ResType _86 = ResType(_158, _159); texel = _86._m1; ret = sparseTexelsResidentARB(_86._m0); int _160; vec4 _161; _160 = sparseTextureLodOffsetARB(uSamp, vUV, 1.5, ivec2(2, 3), _161); ResType _93 = ResType(_160, _161); texel = _93._m1; ret = sparseTexelsResidentARB(_93._m0); int _162; vec4 _163; _162 = sparseTextureGradARB(uSamp, vUV, vec2(1.0), vec2(3.0), _163); ResType _102 = ResType(_162, _163); texel = _102._m1; ret = sparseTexelsResidentARB(_102._m0); int _164; vec4 _165; _164 = sparseTextureGradOffsetARB(uSamp, vUV, vec2(1.0), vec2(3.0), ivec2(-2, -3), _165); ResType _111 = ResType(_164, _165); texel = _111._m1; ret = sparseTexelsResidentARB(_111._m0); int _166; vec4 _167; _166 = sparseTextureClampARB(uSamp, vUV, 4.0, _167); ResType _118 = ResType(_166, _167); texel = _118._m1; ret = sparseTexelsResidentARB(_118._m0); int _168; vec4 _169; _168 = sparseImageLoadARB(uImage, ivec2(vUV), _169); ResType _128 = ResType(_168, _169); texel = _128._m1; ret = sparseTexelsResidentARB(_128._m0); int _170; vec4 _171; _170 = sparseImageLoadARB(uImageMS, ivec2(vUV), 1, _171); ResType _138 = ResType(_170, _171); texel = _138._m1; ret = sparseTexelsResidentARB(_138._m0); } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/subpass-input.framebuffer-fetch.nocompat.frag000066400000000000000000000005701400026215700327630ustar00rootroot00000000000000#version 310 es #extension GL_EXT_shader_framebuffer_fetch : require precision mediump float; precision highp int; mediump vec4 uSubpass0; mediump vec4 uSubpass1; layout(location = 0) inout vec3 FragColor; layout(location = 1) inout vec4 FragColor2; void main() { uSubpass0.xyz = FragColor; uSubpass1 = FragColor2; FragColor = uSubpass0.xyz + uSubpass1.xyz; } subpass-input.framebuffer-fetch.nocompat.legacy.frag000066400000000000000000000005301400026215700341430ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/frag#version 100 #extension GL_EXT_shader_framebuffer_fetch : require #extension GL_EXT_draw_buffers : require precision mediump float; precision highp int; mediump vec4 uSubpass0; mediump vec4 uSubpass1; void main() { uSubpass0 = gl_LastFragData[0]; uSubpass1 = gl_LastFragData[1]; gl_FragData[0] = uSubpass0.xyz + uSubpass1.xyz; } spirv-cross-2021.01.15/reference/shaders-no-opt/frag/variables.zero-initialize.frag000066400000000000000000000007251400026215700300440ustar00rootroot00000000000000#version 450 struct Foo { int a; }; layout(location = 0) in vec4 vColor; layout(location = 0) out vec4 FragColor; int uninit_int = 0; ivec4 uninit_vector = ivec4(0); mat4 uninit_matrix = mat4(vec4(0.0), vec4(0.0), vec4(0.0), vec4(0.0)); Foo uninit_foo = Foo(0); void main() { int uninit_function_int = 0; if (vColor.x > 10.0) { uninit_function_int = 10; } else { uninit_function_int = 20; } FragColor = vColor; } spirv-cross-2021.01.15/reference/shaders-no-opt/legacy/000077500000000000000000000000001400026215700224375ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/legacy/frag/000077500000000000000000000000001400026215700233565ustar00rootroot00000000000000switch-single-case-multiple-exit-cfg.legacy.asm.frag000066400000000000000000000006401400026215700352100ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/legacy/frag#version 100 precision mediump float; precision highp int; vec2 _19; void main() { highp vec2 _30; for (int spvDummy15 = 0; spvDummy15 < 1; spvDummy15++) { if (gl_FragCoord.x != gl_FragCoord.x) { _30 = _19; break; } highp vec2 _29 = _19; _29.y = _19.y; _30 = _29; break; } gl_FragData[0] = vec4(_30, 1.0, 1.0); } spirv-cross-2021.01.15/reference/shaders-no-opt/vert/000077500000000000000000000000001400026215700221535ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/vert/io-blocks.force-flattened-io.vert000066400000000000000000000006411400026215700304060ustar00rootroot00000000000000#version 450 struct Foo { vec4 bar[2]; vec4 baz[2]; }; out vec4 _14_foo_bar[2]; out vec4 _14_foo_baz[2]; out vec4 _14_foo2_bar[2]; out vec4 _14_foo2_baz[2]; out vec4 foo3_bar[2]; out vec4 foo3_baz[2]; void main() { _14_foo_bar[0] = vec4(1.0); _14_foo_baz[1] = vec4(2.0); _14_foo2_bar[0] = vec4(3.0); _14_foo2_baz[1] = vec4(4.0); foo3_bar[0] = vec4(5.0); foo3_baz[1] = vec4(6.0); } spirv-cross-2021.01.15/reference/shaders-no-opt/vert/pass-array-by-value.vert000066400000000000000000000012261400026215700266620ustar00rootroot00000000000000#version 310 es layout(location = 0) in int Index1; layout(location = 1) in int Index2; vec4 consume_constant_arrays2(vec4 positions[4], vec4 positions2[4]) { vec4 indexable[4] = positions; vec4 indexable_1[4] = positions2; return indexable[Index1] + indexable_1[Index2]; } vec4 consume_constant_arrays(vec4 positions[4], vec4 positions2[4]) { return consume_constant_arrays2(positions, positions2); } void main() { vec4 LUT2[4]; LUT2[0] = vec4(10.0); LUT2[1] = vec4(11.0); LUT2[2] = vec4(12.0); LUT2[3] = vec4(13.0); gl_Position = consume_constant_arrays(vec4[](vec4(0.0), vec4(1.0), vec4(2.0), vec4(3.0)), LUT2); } spirv-cross-2021.01.15/reference/shaders-no-opt/vulkan/000077500000000000000000000000001400026215700224735ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/vulkan/frag/000077500000000000000000000000001400026215700234125ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/vulkan/frag/spec-constant.vk.frag000066400000000000000000000062571400026215700274650ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 1.0 #endif const float a = SPIRV_CROSS_CONSTANT_ID_1; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 2.0 #endif const float b = SPIRV_CROSS_CONSTANT_ID_2; #ifndef SPIRV_CROSS_CONSTANT_ID_3 #define SPIRV_CROSS_CONSTANT_ID_3 3 #endif const int c = SPIRV_CROSS_CONSTANT_ID_3; const uint _18 = (uint(c) + 0u); const int _21 = (-c); const int _23 = (~c); #ifndef SPIRV_CROSS_CONSTANT_ID_4 #define SPIRV_CROSS_CONSTANT_ID_4 4 #endif const int d = SPIRV_CROSS_CONSTANT_ID_4; const int _26 = (c + d); const int _28 = (c - d); const int _30 = (c * d); const int _32 = (c / d); #ifndef SPIRV_CROSS_CONSTANT_ID_5 #define SPIRV_CROSS_CONSTANT_ID_5 5u #endif const uint e = SPIRV_CROSS_CONSTANT_ID_5; #ifndef SPIRV_CROSS_CONSTANT_ID_6 #define SPIRV_CROSS_CONSTANT_ID_6 6u #endif const uint f = SPIRV_CROSS_CONSTANT_ID_6; const uint _36 = (e / f); const int _38 = (c % d); const uint _40 = (e % f); const int _42 = (c >> d); const uint _44 = (e >> f); const int _46 = (c << d); const int _48 = (c | d); const int _50 = (c ^ d); const int _52 = (c & d); #ifndef SPIRV_CROSS_CONSTANT_ID_7 #define SPIRV_CROSS_CONSTANT_ID_7 false #endif const bool g = SPIRV_CROSS_CONSTANT_ID_7; #ifndef SPIRV_CROSS_CONSTANT_ID_8 #define SPIRV_CROSS_CONSTANT_ID_8 true #endif const bool h = SPIRV_CROSS_CONSTANT_ID_8; const bool _58 = (g || h); const bool _60 = (g && h); const bool _62 = (!g); const bool _64 = (g == h); const bool _66 = (g != h); const bool _68 = (c == d); const bool _70 = (c != d); const bool _72 = (c < d); const bool _74 = (e < f); const bool _76 = (c > d); const bool _78 = (e > f); const bool _80 = (c <= d); const bool _82 = (e <= f); const bool _84 = (c >= d); const bool _86 = (e >= f); const int _92 = int(e + 0u); const bool _94 = (c != int(0u)); const bool _96 = (e != 0u); const int _100 = int(g); const uint _103 = uint(g); const int _118 = (c + 3); const int _127 = (c + 2); const int _135 = (d + 2); struct Foo { float elems[_135]; }; layout(location = 0) out vec4 FragColor; void main() { float t0 = a; float t1 = b; mediump uint c0 = _18; mediump int c1 = _21; mediump int c2 = _23; mediump int c3 = _26; mediump int c4 = _28; mediump int c5 = _30; mediump int c6 = _32; mediump uint c7 = _36; mediump int c8 = _38; mediump uint c9 = _40; mediump int c10 = _42; mediump uint c11 = _44; mediump int c12 = _46; mediump int c13 = _48; mediump int c14 = _50; mediump int c15 = _52; bool c16 = _58; bool c17 = _60; bool c18 = _62; bool c19 = _64; bool c20 = _66; bool c21 = _68; bool c22 = _70; bool c23 = _72; bool c24 = _74; bool c25 = _76; bool c26 = _78; bool c27 = _80; bool c28 = _82; bool c29 = _84; bool c30 = _86; mediump int c31 = c8 + c3; mediump int c32 = _92; bool c33 = _94; bool c34 = _96; mediump int c35 = _100; mediump uint c36 = _103; float c37 = float(g); float vec0[_118][8]; float vec1[_127]; Foo foo; FragColor = ((vec4(t0 + t1) + vec4(vec0[0][0])) + vec4(vec1[0])) + vec4(foo.elems[c]); } spirv-cross-2021.01.15/reference/shaders-no-opt/vulkan/frag/spec-constant.vk.frag.vk000066400000000000000000000051071400026215700300750ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(constant_id = 1) const float a = 1.0; layout(constant_id = 2) const float b = 2.0; layout(constant_id = 3) const int c = 3; const uint _18 = (uint(c) + 0u); const int _21 = (-c); const int _23 = (~c); layout(constant_id = 4) const int d = 4; const int _26 = (c + d); const int _28 = (c - d); const int _30 = (c * d); const int _32 = (c / d); layout(constant_id = 5) const uint e = 5u; layout(constant_id = 6) const uint f = 6u; const uint _36 = (e / f); const int _38 = (c % d); const uint _40 = (e % f); const int _42 = (c >> d); const uint _44 = (e >> f); const int _46 = (c << d); const int _48 = (c | d); const int _50 = (c ^ d); const int _52 = (c & d); layout(constant_id = 7) const bool g = false; layout(constant_id = 8) const bool h = true; const bool _58 = (g || h); const bool _60 = (g && h); const bool _62 = (!g); const bool _64 = (g == h); const bool _66 = (g != h); const bool _68 = (c == d); const bool _70 = (c != d); const bool _72 = (c < d); const bool _74 = (e < f); const bool _76 = (c > d); const bool _78 = (e > f); const bool _80 = (c <= d); const bool _82 = (e <= f); const bool _84 = (c >= d); const bool _86 = (e >= f); const int _92 = int(e + 0u); const bool _94 = (c != int(0u)); const bool _96 = (e != 0u); const int _100 = int(g); const uint _103 = uint(g); const int _118 = (c + 3); const int _127 = (c + 2); const int _135 = (d + 2); struct Foo { float elems[_135]; }; layout(location = 0) out vec4 FragColor; void main() { float t0 = a; float t1 = b; mediump uint c0 = _18; mediump int c1 = _21; mediump int c2 = _23; mediump int c3 = _26; mediump int c4 = _28; mediump int c5 = _30; mediump int c6 = _32; mediump uint c7 = _36; mediump int c8 = _38; mediump uint c9 = _40; mediump int c10 = _42; mediump uint c11 = _44; mediump int c12 = _46; mediump int c13 = _48; mediump int c14 = _50; mediump int c15 = _52; bool c16 = _58; bool c17 = _60; bool c18 = _62; bool c19 = _64; bool c20 = _66; bool c21 = _68; bool c22 = _70; bool c23 = _72; bool c24 = _74; bool c25 = _76; bool c26 = _78; bool c27 = _80; bool c28 = _82; bool c29 = _84; bool c30 = _86; mediump int c31 = c8 + c3; mediump int c32 = _92; bool c33 = _94; bool c34 = _96; mediump int c35 = _100; mediump uint c36 = _103; float c37 = float(g); float vec0[_118][8]; float vec1[_127]; Foo foo; FragColor = ((vec4(t0 + t1) + vec4(vec0[0][0])) + vec4(vec1[0])) + vec4(foo.elems[c]); } ubo-offset-out-of-order.vk.nocompat.frag.vk000066400000000000000000000004221400026215700334400ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-no-opt/vulkan/frag#version 450 layout(set = 0, binding = 0, std140) uniform UBO { layout(offset = 16) mat4 m; layout(offset = 0) vec4 v; } _13; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; void main() { FragColor = (_13.m * vColor) + _13.v; } spirv-cross-2021.01.15/reference/shaders-reflection/000077500000000000000000000000001400026215700221115ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-reflection/asm/000077500000000000000000000000001400026215700226715ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-reflection/asm/aliased-entry-point-names.asm.multi.json000066400000000000000000000023531400026215700324700ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "maim", "mode" : "vert" }, { "name" : "main", "mode" : "vert" }, { "name" : "maim", "mode" : "frag" }, { "name" : "main", "mode" : "frag" } ], "types" : { "_8" : { "name" : "_8", "members" : [ { "name" : "_m0", "type" : "vec4" }, { "name" : "_m1", "type" : "float" }, { "name" : "_m2", "type" : "float", "array" : [ 1 ], "array_size_is_literal" : [ true ] }, { "name" : "_m3", "type" : "float", "array" : [ 1 ], "array_size_is_literal" : [ true ] } ] } } }spirv-cross-2021.01.15/reference/shaders-reflection/asm/comp/000077500000000000000000000000001400026215700236275ustar00rootroot00000000000000pointer-to-array-of-physical-pointer.asm.comp.json000066400000000000000000000030701400026215700352650ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-reflection/asm/comp{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_3" : { "name" : "Params", "members" : [ { "name" : "x", "type" : "float", "offset" : 0 }, { "name" : "y", "type" : "_6", "offset" : 16, "physical_pointer" : true } ] }, "_4" : { "name" : "IntBuf", "members" : [ { "name" : "v", "type" : "int", "offset" : 0 } ] }, "_11" : { "name" : "IntBuf", "type" : "_4", "physical_pointer" : true }, "_6" : { "name" : "IntBuf", "array" : [ 3 ], "array_size_is_literal" : [ true ], "type" : "_11", "array_stride" : 16 } }, "ubos" : [ { "type" : "_3", "name" : "Params", "block_size" : 24, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/asm/op-source-glsl-ssbo-1.asm.comp.json000066400000000000000000000017611400026215700312620ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_5" : { "name" : "SSBO0", "members" : [ { "name" : "a", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] } }, "ssbos" : [ { "type" : "_5", "name" : "SSBO0", "block_size" : 0, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/asm/op-source-glsl-ssbo-2.asm.comp.json000066400000000000000000000031321400026215700312550ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_4" : { "name" : "SSBO0", "members" : [ { "name" : "a", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] }, "_6" : { "name" : "SSBO1", "members" : [ { "name" : "b", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] } }, "ssbos" : [ { "type" : "_4", "name" : "SSBO0", "block_size" : 0, "set" : 0, "binding" : 0 }, { "type" : "_6", "name" : "SSBO1", "block_size" : 0, "set" : 0, "binding" : 1 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/asm/op-source-hlsl-uav-1.asm.comp.json000066400000000000000000000017631400026215700311120ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_4" : { "name" : "UAV0", "members" : [ { "name" : "@data", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] } }, "ssbos" : [ { "type" : "_4", "name" : "UAV0", "block_size" : 0, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/asm/op-source-hlsl-uav-2.asm.comp.json000066400000000000000000000022171400026215700311060ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_4" : { "name" : "UAV0", "members" : [ { "name" : "@data", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] } }, "ssbos" : [ { "type" : "_4", "name" : "UAV0", "block_size" : 0, "set" : 0, "binding" : 0 }, { "type" : "_4", "name" : "UAV1", "block_size" : 0, "set" : 0, "binding" : 1 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/asm/op-source-none-ssbo-1.asm.comp.json000066400000000000000000000017611400026215700312600ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_5" : { "name" : "SSBO0", "members" : [ { "name" : "a", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] } }, "ssbos" : [ { "type" : "_5", "name" : "SSBO0", "block_size" : 0, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/asm/op-source-none-ssbo-2.asm.comp.json000066400000000000000000000031321400026215700312530ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_4" : { "name" : "SSBO0", "members" : [ { "name" : "a", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] }, "_6" : { "name" : "SSBO1", "members" : [ { "name" : "b", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] } }, "ssbos" : [ { "type" : "_4", "name" : "SSBO0", "block_size" : 0, "set" : 0, "binding" : 0 }, { "type" : "_6", "name" : "SSBO1", "block_size" : 0, "set" : 0, "binding" : 1 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/asm/op-source-none-uav-1.asm.comp.json000066400000000000000000000017631400026215700311070ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_4" : { "name" : "UAV0", "members" : [ { "name" : "@data", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] } }, "ssbos" : [ { "type" : "_4", "name" : "UAV0", "block_size" : 0, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/asm/op-source-none-uav-2.asm.comp.json000066400000000000000000000022171400026215700311030ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_4" : { "name" : "UAV0", "members" : [ { "name" : "@data", "type" : "vec4", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 } ] } }, "ssbos" : [ { "type" : "_4", "name" : "UAV0", "block_size" : 0, "set" : 0, "binding" : 0 }, { "type" : "_4", "name" : "UAV1", "block_size" : 0, "set" : 0, "binding" : 1 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/comp/000077500000000000000000000000001400026215700230475ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-reflection/comp/array-of-physical-pointer.comp.json000066400000000000000000000027561400026215700317210ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_11" : { "name" : "Params", "members" : [ { "name" : "x", "type" : "float", "offset" : 0 }, { "name" : "y", "type" : "_7", "array" : [ 3 ], "array_size_is_literal" : [ true ], "offset" : 16, "array_stride" : 16 } ] }, "_13" : { "name" : "IntBuf", "members" : [ { "name" : "v", "type" : "int", "offset" : 0 } ] }, "_7" : { "name" : "IntBuf", "type" : "_13", "physical_pointer" : true } }, "ubos" : [ { "type" : "_11", "name" : "Params", "block_size" : 64, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/comp/function-pointer.invalid.asm.comp.json000066400000000000000000000005341400026215700324100ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ] }spirv-cross-2021.01.15/reference/shaders-reflection/comp/physical-pointer.comp.json000066400000000000000000000023001400026215700301640ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_8" : { "name" : "Params", "members" : [ { "name" : "x", "type" : "float", "offset" : 0 }, { "name" : "y", "type" : "_10", "offset" : 8, "physical_pointer" : true } ] }, "_10" : { "name" : "IntBuf", "members" : [ { "name" : "v", "type" : "int", "offset" : 0 } ] } }, "ubos" : [ { "type" : "_8", "name" : "Params", "block_size" : 16, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/comp/struct-layout.comp.json000066400000000000000000000036751400026215700275510ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_19" : { "name" : "Foo", "members" : [ { "name" : "m", "type" : "mat4", "offset" : 0, "matrix_stride" : 16 } ] }, "_21" : { "name" : "SSBO2", "members" : [ { "name" : "out_data", "type" : "_19", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 64 } ] }, "_28" : { "name" : "SSBO", "members" : [ { "name" : "in_data", "type" : "_19", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 64 } ] } }, "ssbos" : [ { "type" : "_21", "name" : "SSBO2", "writeonly" : true, "block_size" : 0, "set" : 0, "binding" : 1 }, { "type" : "_28", "name" : "SSBO", "readonly" : true, "block_size" : 0, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/comp/struct-packing.comp.json000066400000000000000000000405551400026215700276460ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 1, 1, 1 ], "workgroup_size_is_spec_constant_id" : [ false, false, false ] } ], "types" : { "_11" : { "name" : "S0", "members" : [ { "name" : "a", "type" : "vec2", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 8 }, { "name" : "b", "type" : "float", "offset" : 8 } ] }, "_14" : { "name" : "S1", "members" : [ { "name" : "a", "type" : "vec3", "offset" : 0 }, { "name" : "b", "type" : "float", "offset" : 12 } ] }, "_17" : { "name" : "S2", "members" : [ { "name" : "a", "type" : "vec3", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 }, { "name" : "b", "type" : "float", "offset" : 16 } ] }, "_19" : { "name" : "S3", "members" : [ { "name" : "a", "type" : "vec2", "offset" : 0 }, { "name" : "b", "type" : "float", "offset" : 8 } ] }, "_20" : { "name" : "S4", "members" : [ { "name" : "c", "type" : "vec2", "offset" : 0 } ] }, "_23" : { "name" : "Content", "members" : [ { "name" : "m0s", "type" : "_11", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 }, { "name" : "m1s", "type" : "_14", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 16, "array_stride" : 16 }, { "name" : "m2s", "type" : "_17", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 32, "array_stride" : 32 }, { "name" : "m0", "type" : "_11", "offset" : 64 }, { "name" : "m1", "type" : "_14", "offset" : 80 }, { "name" : "m2", "type" : "_17", "offset" : 96 }, { "name" : "m3", "type" : "_19", "offset" : 128 }, { "name" : "m4", "type" : "float", "offset" : 144 }, { "name" : "m3s", "type" : "_20", "array" : [ 8 ], "array_size_is_literal" : [ true ], "offset" : 152, "array_stride" : 8 } ] }, "_36" : { "name" : "SSBO1", "members" : [ { "name" : "content", "type" : "_23", "offset" : 0 }, { "name" : "content1", "type" : "_23", "array" : [ 2 ], "array_size_is_literal" : [ true ], "offset" : 224, "array_stride" : 224 }, { "name" : "content2", "type" : "_23", "offset" : 672 }, { "name" : "m0", "type" : "mat2", "offset" : 896, "matrix_stride" : 8 }, { "name" : "m1", "type" : "mat2", "offset" : 912, "matrix_stride" : 8 }, { "name" : "m2", "type" : "mat2x3", "array" : [ 4 ], "array_size_is_literal" : [ true ], "offset" : 928, "array_stride" : 32, "matrix_stride" : 16 }, { "name" : "m3", "type" : "mat3x2", "offset" : 1056, "matrix_stride" : 8 }, { "name" : "m4", "type" : "mat2", "offset" : 1080, "matrix_stride" : 8, "row_major" : true }, { "name" : "m5", "type" : "mat2", "array" : [ 9 ], "array_size_is_literal" : [ true ], "offset" : 1096, "array_stride" : 16, "matrix_stride" : 8, "row_major" : true }, { "name" : "m6", "type" : "mat2x3", "array" : [ 2, 4 ], "array_size_is_literal" : [ true, true ], "offset" : 1240, "array_stride" : 48, "matrix_stride" : 8, "row_major" : true }, { "name" : "m7", "type" : "mat3x2", "offset" : 1440, "matrix_stride" : 16, "row_major" : true }, { "name" : "array", "type" : "float", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 1472, "array_stride" : 4 } ] }, "_42" : { "name" : "S0", "members" : [ { "name" : "a", "type" : "vec2", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 }, { "name" : "b", "type" : "float", "offset" : 16 } ] }, "_44" : { "name" : "S1", "members" : [ { "name" : "a", "type" : "vec3", "offset" : 0 }, { "name" : "b", "type" : "float", "offset" : 12 } ] }, "_47" : { "name" : "S2", "members" : [ { "name" : "a", "type" : "vec3", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 }, { "name" : "b", "type" : "float", "offset" : 16 } ] }, "_49" : { "name" : "S3", "members" : [ { "name" : "a", "type" : "vec2", "offset" : 0 }, { "name" : "b", "type" : "float", "offset" : 8 } ] }, "_50" : { "name" : "S4", "members" : [ { "name" : "c", "type" : "vec2", "offset" : 0 } ] }, "_52" : { "name" : "Content", "members" : [ { "name" : "m0s", "type" : "_42", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 32 }, { "name" : "m1s", "type" : "_44", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 32, "array_stride" : 16 }, { "name" : "m2s", "type" : "_47", "array" : [ 1 ], "array_size_is_literal" : [ true ], "offset" : 48, "array_stride" : 32 }, { "name" : "m0", "type" : "_42", "offset" : 80 }, { "name" : "m1", "type" : "_44", "offset" : 112 }, { "name" : "m2", "type" : "_47", "offset" : 128 }, { "name" : "m3", "type" : "_49", "offset" : 160 }, { "name" : "m4", "type" : "float", "offset" : 176 }, { "name" : "m3s", "type" : "_50", "array" : [ 8 ], "array_size_is_literal" : [ true ], "offset" : 192, "array_stride" : 16 } ] }, "_59" : { "name" : "SSBO0", "members" : [ { "name" : "content", "type" : "_52", "offset" : 0 }, { "name" : "content1", "type" : "_52", "array" : [ 2 ], "array_size_is_literal" : [ true ], "offset" : 320, "array_stride" : 320 }, { "name" : "content2", "type" : "_52", "offset" : 960 }, { "name" : "m0", "type" : "mat2", "offset" : 1280, "matrix_stride" : 16 }, { "name" : "m1", "type" : "mat2", "offset" : 1312, "matrix_stride" : 16 }, { "name" : "m2", "type" : "mat2x3", "array" : [ 4 ], "array_size_is_literal" : [ true ], "offset" : 1344, "array_stride" : 32, "matrix_stride" : 16 }, { "name" : "m3", "type" : "mat3x2", "offset" : 1472, "matrix_stride" : 16 }, { "name" : "m4", "type" : "mat2", "offset" : 1520, "matrix_stride" : 16, "row_major" : true }, { "name" : "m5", "type" : "mat2", "array" : [ 9 ], "array_size_is_literal" : [ true ], "offset" : 1552, "array_stride" : 32, "matrix_stride" : 16, "row_major" : true }, { "name" : "m6", "type" : "mat2x3", "array" : [ 2, 4 ], "array_size_is_literal" : [ true, true ], "offset" : 1840, "array_stride" : 96, "matrix_stride" : 16, "row_major" : true }, { "name" : "m7", "type" : "mat3x2", "offset" : 2224, "matrix_stride" : 16, "row_major" : true }, { "name" : "array", "type" : "float", "array" : [ 0 ], "array_size_is_literal" : [ true ], "offset" : 2256, "array_stride" : 16 } ] } }, "ssbos" : [ { "type" : "_36", "name" : "SSBO1", "restrict" : true, "block_size" : 1472, "set" : 0, "binding" : 1 }, { "type" : "_59", "name" : "SSBO0", "restrict" : true, "block_size" : 2256, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/comp/workgroup-size-spec-constant.comp.json000066400000000000000000000024411400026215700324660ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "comp", "workgroup_size" : [ 10, 40, 60 ], "workgroup_size_is_spec_constant_id" : [ true, true, true ] } ], "types" : { "_8" : { "name" : "SSBO", "members" : [ { "name" : "v", "type" : "vec4", "offset" : 0 } ] } }, "ssbos" : [ { "type" : "_8", "name" : "SSBO", "block_size" : 16, "set" : 0, "binding" : 0 } ], "specialization_constants" : [ { "name" : "", "id" : 10, "type" : "uint", "variable_id" : 18, "default_value" : 1 }, { "name" : "", "id" : 40, "type" : "uint", "variable_id" : 19, "default_value" : 1 }, { "name" : "", "id" : 60, "type" : "uint", "variable_id" : 20, "default_value" : 1 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/frag/000077500000000000000000000000001400026215700230305ustar00rootroot00000000000000combined-texture-sampler-shadow.vk.frag.json000066400000000000000000000013141400026215700334020ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-reflection/frag{ "entryPoints" : [ { "name" : "main", "mode" : "frag" } ], "outputs" : [ { "type" : "float", "name" : "FragColor", "location" : 0 } ], "separate_images" : [ { "type" : "texture2D", "name" : "uDepth", "set" : 0, "binding" : 2 } ], "separate_samplers" : [ { "type" : "sampler", "name" : "uSampler", "set" : 0, "binding" : 0 }, { "type" : "sampler", "name" : "uSampler1", "set" : 0, "binding" : 1 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/frag/combined-texture-sampler.vk.frag.json000066400000000000000000000017321400026215700322020ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "frag" } ], "inputs" : [ { "type" : "vec2", "name" : "vTex", "location" : 0 } ], "outputs" : [ { "type" : "vec4", "name" : "FragColor", "location" : 0 } ], "separate_images" : [ { "type" : "texture2D", "name" : "uTexture0", "set" : 0, "binding" : 2 }, { "type" : "texture2D", "name" : "uTexture1", "set" : 0, "binding" : 3 } ], "separate_samplers" : [ { "type" : "sampler", "name" : "uSampler0", "set" : 0, "binding" : 0 }, { "type" : "sampler", "name" : "uSampler1", "set" : 0, "binding" : 1 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/frag/image-load-store-uint-coord.asm.frag.json000066400000000000000000000016511400026215700326350ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "frag" } ], "outputs" : [ { "type" : "vec4", "name" : "@entryPointOutput", "location" : 0 } ], "textures" : [ { "type" : "sampler2D", "name" : "ROIm", "set" : 0, "binding" : 1 } ], "separate_images" : [ { "type" : "samplerBuffer", "name" : "ROBuf", "set" : 0, "binding" : 0 } ], "images" : [ { "type" : "image2D", "name" : "RWIm", "set" : 0, "binding" : 1, "format" : "rgba32f" }, { "type" : "imageBuffer", "name" : "RWBuf", "set" : 0, "binding" : 0, "format" : "rgba32f" } ] }spirv-cross-2021.01.15/reference/shaders-reflection/frag/input-attachment-ms.vk.frag.json000066400000000000000000000012041400026215700311570ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "frag" } ], "subpass_inputs" : [ { "type" : "subpassInputMS", "name" : "uSubpass0", "set" : 0, "binding" : 0, "input_attachment_index" : 0 }, { "type" : "subpassInputMS", "name" : "uSubpass1", "set" : 0, "binding" : 1, "input_attachment_index" : 1 } ], "outputs" : [ { "type" : "vec4", "name" : "FragColor", "location" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/frag/input-attachment.vk.frag.json000066400000000000000000000012001400026215700305360ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "frag" } ], "subpass_inputs" : [ { "type" : "subpassInput", "name" : "uSubpass0", "set" : 0, "binding" : 0, "input_attachment_index" : 0 }, { "type" : "subpassInput", "name" : "uSubpass1", "set" : 0, "binding" : 1, "input_attachment_index" : 1 } ], "outputs" : [ { "type" : "vec4", "name" : "FragColor", "location" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/frag/push-constant.vk.frag.json000066400000000000000000000016531400026215700300730ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "frag" } ], "types" : { "_13" : { "name" : "PushConstants", "members" : [ { "name" : "value0", "type" : "vec4", "offset" : 0 }, { "name" : "value1", "type" : "vec4", "offset" : 16 } ] } }, "inputs" : [ { "type" : "vec4", "name" : "vColor", "location" : 0 } ], "outputs" : [ { "type" : "vec4", "name" : "FragColor", "location" : 0 } ], "push_constants" : [ { "type" : "_13", "name" : "push", "push_constant" : true } ] }spirv-cross-2021.01.15/reference/shaders-reflection/frag/separate-sampler-texture-array.vk.frag.json000066400000000000000000000033621400026215700333430ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "frag" } ], "inputs" : [ { "type" : "vec2", "name" : "vTex", "location" : 0 }, { "type" : "vec3", "name" : "vTex3", "location" : 1 } ], "outputs" : [ { "type" : "vec4", "name" : "FragColor", "location" : 0 } ], "separate_images" : [ { "type" : "texture2D", "name" : "uTexture", "array" : [ 4 ], "array_size_is_literal" : [ true ], "set" : 0, "binding" : 1 }, { "type" : "texture2DArray", "name" : "uTextureArray", "array" : [ 4 ], "array_size_is_literal" : [ true ], "set" : 0, "binding" : 4 }, { "type" : "textureCube", "name" : "uTextureCube", "array" : [ 4 ], "array_size_is_literal" : [ true ], "set" : 0, "binding" : 3 }, { "type" : "texture3D", "name" : "uTexture3D", "array" : [ 4 ], "array_size_is_literal" : [ true ], "set" : 0, "binding" : 2 } ], "separate_samplers" : [ { "type" : "sampler", "name" : "uSampler", "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/frag/spec-constant.vk.frag.json000066400000000000000000000037251400026215700300500ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "frag" } ], "types" : { "_137" : { "name" : "Foo", "members" : [ { "name" : "elems", "type" : "float", "array" : [ 135 ], "array_size_is_literal" : [ false ] } ] } }, "outputs" : [ { "type" : "vec4", "name" : "FragColor", "location" : 0 } ], "specialization_constants" : [ { "name" : "a", "id" : 1, "type" : "float", "variable_id" : 9, "default_value" : 1.5 }, { "name" : "b", "id" : 2, "type" : "float", "variable_id" : 11, "default_value" : 2.5 }, { "name" : "c", "id" : 3, "type" : "int", "variable_id" : 16, "default_value" : 3 }, { "name" : "d", "id" : 4, "type" : "int", "variable_id" : 25, "default_value" : 4 }, { "name" : "e", "id" : 5, "type" : "uint", "variable_id" : 34, "default_value" : 5 }, { "name" : "f", "id" : 6, "type" : "uint", "variable_id" : 35, "default_value" : 6 }, { "name" : "g", "id" : 7, "type" : "bool", "variable_id" : 56, "default_value" : false }, { "name" : "h", "id" : 8, "type" : "bool", "variable_id" : 57, "default_value" : true } ] }spirv-cross-2021.01.15/reference/shaders-reflection/rgen/000077500000000000000000000000001400026215700230445ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-reflection/rgen/acceleration_structure.vk.rgen.json000066400000000000000000000004451400026215700320640ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "rgen" } ], "acceleration_structures" : [ { "type" : "accelerationStructureNV", "name" : "as", "set" : 0, "binding" : 1 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/vert/000077500000000000000000000000001400026215700230715ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-reflection/vert/array-size-reflection.vert.json000066400000000000000000000036051400026215700311650ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "vert" } ], "types" : { "_11" : { "name" : "gl_PerVertex", "members" : [ { "name" : "gl_Position", "type" : "vec4" }, { "name" : "gl_PointSize", "type" : "float" }, { "name" : "gl_ClipDistance", "type" : "float", "array" : [ 1 ], "array_size_is_literal" : [ true ] }, { "name" : "gl_CullDistance", "type" : "float", "array" : [ 1 ], "array_size_is_literal" : [ true ] } ] }, "_18" : { "name" : "u_", "members" : [ { "name" : "u_0", "type" : "vec4", "array" : [ 16 ], "array_size_is_literal" : [ false ], "offset" : 0, "array_stride" : 16 } ] } }, "ubos" : [ { "type" : "_18", "name" : "u_", "block_size" : 16, "set" : 1, "binding" : 0 } ], "specialization_constants" : [ { "name" : "ARR_SIZE", "id" : 0, "type" : "int", "variable_id" : 16, "default_value" : 1 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/vert/read-from-row-major-array.vert.json000066400000000000000000000027741400026215700316600ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "vert" } ], "types" : { "_89" : { "name" : "gl_PerVertex", "members" : [ { "name" : "gl_Position", "type" : "vec4" }, { "name" : "gl_PointSize", "type" : "float" } ] }, "_102" : { "name" : "Block", "members" : [ { "name" : "var", "type" : "mat2x3", "array" : [ 4, 3 ], "array_size_is_literal" : [ true, true ], "offset" : 0, "array_stride" : 192, "matrix_stride" : 16, "row_major" : true } ] } }, "inputs" : [ { "type" : "vec4", "name" : "a_position", "location" : 0 } ], "outputs" : [ { "type" : "float", "name" : "v_vtxResult", "location" : 0 } ], "ubos" : [ { "type" : "_102", "name" : "Block", "block_size" : 576, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/vert/stride-reflection.vert.json000066400000000000000000000050041400026215700303640ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "vert" } ], "types" : { "_11" : { "name" : "gl_PerVertex", "members" : [ { "name" : "gl_Position", "type" : "vec4" }, { "name" : "gl_PointSize", "type" : "float" }, { "name" : "gl_ClipDistance", "type" : "float", "array" : [ 1 ], "array_size_is_literal" : [ true ] }, { "name" : "gl_CullDistance", "type" : "float", "array" : [ 1 ], "array_size_is_literal" : [ true ] } ] }, "_21" : { "name" : "U", "members" : [ { "name" : "v", "type" : "vec4", "array" : [ 4 ], "array_size_is_literal" : [ true ], "offset" : 0, "array_stride" : 16 }, { "name" : "c", "type" : "mat4", "array" : [ 4 ], "array_size_is_literal" : [ true ], "offset" : 64, "array_stride" : 64, "matrix_stride" : 16 }, { "name" : "r", "type" : "mat4", "array" : [ 4 ], "array_size_is_literal" : [ true ], "offset" : 320, "array_stride" : 64, "matrix_stride" : 16, "row_major" : true } ] } }, "ubos" : [ { "type" : "_21", "name" : "U", "block_size" : 576, "set" : 0, "binding" : 0 } ] }spirv-cross-2021.01.15/reference/shaders-reflection/vert/texture_buffer.vert.json000066400000000000000000000014731400026215700300010ustar00rootroot00000000000000{ "entryPoints" : [ { "name" : "main", "mode" : "vert" } ], "types" : { "_8" : { "name" : "gl_PerVertex", "members" : [ { "name" : "gl_Position", "type" : "vec4" }, { "name" : "gl_PointSize", "type" : "float" } ] } }, "textures" : [ { "type" : "samplerBuffer", "name" : "uSamp", "set" : 0, "binding" : 4 } ], "images" : [ { "type" : "imageBuffer", "name" : "uSampo", "set" : 0, "binding" : 5, "format" : "rgba32f" } ] }spirv-cross-2021.01.15/reference/shaders-ue4-no-opt/000077500000000000000000000000001400026215700216665ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4-no-opt/asm/000077500000000000000000000000001400026215700224465ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4-no-opt/asm/frag/000077500000000000000000000000001400026215700233655ustar00rootroot00000000000000accesschain-invalid-expression.asm.invalid.frag000066400000000000000000000444021400026215700344440ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4-no-opt/asm/frag#include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_MobileDirectionalLight { float4 MobileDirectionalLight_DirectionalLightColor; float4 MobileDirectionalLight_DirectionalLightDirectionAndShadowTransition; float4 MobileDirectionalLight_DirectionalLightShadowSize; float4 MobileDirectionalLight_DirectionalLightDistanceFadeMAD; float4 MobileDirectionalLight_DirectionalLightShadowDistances; float4x4 MobileDirectionalLight_DirectionalLightScreenToShadow[4]; }; struct type_Globals { int NumDynamicPointLights; float4 LightPositionAndInvRadius[4]; float4 LightColorAndFalloffExponent[4]; float4 MobileReflectionParams; }; constant float3 _136 = {}; constant float4 _137 = {}; constant float _138 = {}; constant float3 _139 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0)]]; float4 in_var_TEXCOORD7 [[user(locn1)]]; float4 in_var_TEXCOORD8 [[user(locn2)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_MobileDirectionalLight& MobileDirectionalLight [[buffer(1)]], constant type_Globals& _Globals [[buffer(2)]], texture2d MobileDirectionalLight_DirectionalLightShadowTexture [[texture(0)]], texture2d Material_Texture2D_0 [[texture(1)]], texture2d Material_Texture2D_1 [[texture(2)]], texturecube ReflectionCubemap [[texture(3)]], sampler MobileDirectionalLight_DirectionalLightShadowSampler [[sampler(0)]], sampler Material_Texture2D_0Sampler [[sampler(1)]], sampler Material_Texture2D_1Sampler [[sampler(2)]], sampler ReflectionCubemapSampler [[sampler(3)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; float4 _177 = float4((((gl_FragCoord.xy - View.View_ViewRectMin.xy) * View.View_ViewSizeAndInvSize.zw) - float2(0.5)) * float2(2.0, -2.0), _138, 1.0) * float4(gl_FragCoord.w); float3 _179 = in.in_var_TEXCOORD8.xyz - float3(View.View_PreViewTranslation); float3 _181 = normalize(-in.in_var_TEXCOORD8.xyz); float4 _187 = Material_Texture2D_0.sample(Material_Texture2D_0Sampler, (in.in_var_TEXCOORD0 * float2(10.0))); float2 _190 = (_187.xy * float2(2.0)) - float2(1.0); float3 _206 = normalize(float3x3(float3(1.0, 0.0, 0.0), float3(0.0, 1.0, 0.0), float3(0.0, 0.0, 1.0)) * (((float4(_190, sqrt(fast::clamp(1.0 - dot(_190, _190), 0.0, 1.0)), 1.0).xyz * float3(0.300000011920928955078125, 0.300000011920928955078125, 1.0)) * float3(View.View_NormalOverrideParameter.w)) + View.View_NormalOverrideParameter.xyz)); float _208 = dot(_206, _181); float4 _217 = Material_Texture2D_1.sample(Material_Texture2D_1Sampler, (in.in_var_TEXCOORD0 * float2(20.0))); float _219 = mix(0.4000000059604644775390625, 1.0, _217.x); float4 _223 = Material_Texture2D_1.sample(Material_Texture2D_1Sampler, (in.in_var_TEXCOORD0 * float2(5.0))); float _224 = _177.w; float _228 = fast::min(fast::max((_224 - 24.0) * 0.000666666659526526927947998046875, 0.0), 1.0); float _229 = _223.y; float4 _233 = Material_Texture2D_1.sample(Material_Texture2D_1Sampler, (in.in_var_TEXCOORD0 * float2(0.5))); float _235 = _233.y; float _253 = fast::clamp((fast::min(fast::max(mix(0.0, 0.5, _235) + mix(mix(0.699999988079071044921875, 1.0, _229), 1.0, _228), 0.0), 1.0) * View.View_RoughnessOverrideParameter.y) + View.View_RoughnessOverrideParameter.x, 0.119999997317790985107421875, 1.0); float2 _257 = (float2(_253) * float2(-1.0, -0.0274999998509883880615234375)) + float2(1.0, 0.0425000004470348358154296875); float _258 = _257.x; float3 _270 = (fast::clamp(float3(mix(_219, 1.0 - _219, mix(_229, 1.0, _228)) * (mix(0.2949999868869781494140625, 0.660000026226043701171875, mix(_235 + mix(_229, 0.0, _228), 0.5, 0.5)) * 0.5)), float3(0.0), float3(1.0)) * float3(View.View_DiffuseOverrideParameter.w)) + View.View_DiffuseOverrideParameter.xyz; float3 _275 = float3(((fast::min(_258 * _258, exp2((-9.27999973297119140625) * fast::max(_208, 0.0))) * _258) + _257.y) * View.View_SpecularOverrideParameter.w) + View.View_SpecularOverrideParameter.xyz; float _276 = _275.x; float4 _303; int _286 = 0; for (;;) { if (_286 < 2) { if (_224 < MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowDistances[uint(_286)]) { _303 = MobileDirectionalLight.MobileDirectionalLight_DirectionalLightScreenToShadow[_286] * float4(_177.xy, _224, 1.0); break; } _286++; continue; } else { _303 = float4(0.0); break; } } float _423; if (_303.z > 0.0) { float2 _311 = _303.xy * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.xy; float2 _312 = fract(_311); float2 _313 = floor(_311); float3 _320 = _139; _320.x = MobileDirectionalLight_DirectionalLightShadowTexture.sample(MobileDirectionalLight_DirectionalLightShadowSampler, ((_313 + float2(-0.5)) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.zw), level(0.0)).x; float3 _326 = _320; _326.y = MobileDirectionalLight_DirectionalLightShadowTexture.sample(MobileDirectionalLight_DirectionalLightShadowSampler, ((_313 + float2(0.5, -0.5)) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.zw), level(0.0)).x; float3 _332 = _326; _332.z = MobileDirectionalLight_DirectionalLightShadowTexture.sample(MobileDirectionalLight_DirectionalLightShadowSampler, ((_313 + float2(1.5, -0.5)) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.zw), level(0.0)).x; float3 _335 = float3(MobileDirectionalLight.MobileDirectionalLight_DirectionalLightDirectionAndShadowTransition.w); float3 _337 = float3((fast::min(_303.z, 0.999989986419677734375) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightDirectionAndShadowTransition.w) - 1.0); float3 _339 = fast::clamp((_332 * _335) - _337, float3(0.0), float3(1.0)); float3 _345 = _139; _345.x = MobileDirectionalLight_DirectionalLightShadowTexture.sample(MobileDirectionalLight_DirectionalLightShadowSampler, ((_313 + float2(-0.5, 0.5)) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.zw), level(0.0)).x; float3 _351 = _345; _351.y = MobileDirectionalLight_DirectionalLightShadowTexture.sample(MobileDirectionalLight_DirectionalLightShadowSampler, ((_313 + float2(0.5)) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.zw), level(0.0)).x; float3 _357 = _351; _357.z = MobileDirectionalLight_DirectionalLightShadowTexture.sample(MobileDirectionalLight_DirectionalLightShadowSampler, ((_313 + float2(1.5, 0.5)) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.zw), level(0.0)).x; float3 _360 = fast::clamp((_357 * _335) - _337, float3(0.0), float3(1.0)); float3 _366 = _139; _366.x = MobileDirectionalLight_DirectionalLightShadowTexture.sample(MobileDirectionalLight_DirectionalLightShadowSampler, ((_313 + float2(-0.5, 1.5)) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.zw), level(0.0)).x; float3 _372 = _366; _372.y = MobileDirectionalLight_DirectionalLightShadowTexture.sample(MobileDirectionalLight_DirectionalLightShadowSampler, ((_313 + float2(0.5, 1.5)) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.zw), level(0.0)).x; float3 _378 = _372; _378.z = MobileDirectionalLight_DirectionalLightShadowTexture.sample(MobileDirectionalLight_DirectionalLightShadowSampler, ((_313 + float2(1.5)) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightShadowSize.zw), level(0.0)).x; float3 _381 = fast::clamp((_378 * _335) - _337, float3(0.0), float3(1.0)); float _383 = _312.x; float _384 = 1.0 - _383; float3 _399 = _136; _399.x = ((_339.x * _384) + _339.y) + (_339.z * _383); float3 _403 = _399; _403.y = ((_360.x * _384) + _360.y) + (_360.z * _383); float3 _407 = _403; _407.z = ((_381.x * _384) + _381.y) + (_381.z * _383); float _408 = _312.y; float _420 = fast::clamp((_224 * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightDistanceFadeMAD.x) + MobileDirectionalLight.MobileDirectionalLight_DirectionalLightDistanceFadeMAD.y, 0.0, 1.0); _423 = mix(fast::clamp(0.25 * dot(_407, float3(1.0 - _408, 1.0, _408)), 0.0, 1.0), 1.0, _420 * _420); } else { _423 = 1.0; } float3 _429 = normalize(_181 + MobileDirectionalLight.MobileDirectionalLight_DirectionalLightDirectionAndShadowTransition.xyz); float _439 = (_253 * 0.25) + 0.25; float3 _440 = cross(_206, _429); float _442 = _253 * _253; float _443 = fast::max(0.0, dot(_206, _429)) * _442; float _446 = _442 / (dot(_440, _440) + (_443 * _443)); bool _458 = float(_Globals.MobileReflectionParams.w > 0.0) != 0.0; float4 _468 = ReflectionCubemap.sample(ReflectionCubemapSampler, ((-_181) + ((_206 * float3(_208)) * float3(2.0))), level(((_458 ? _Globals.MobileReflectionParams.w : View.View_ReflectionCubemapMaxMip) - 1.0) - (1.0 - (1.2000000476837158203125 * log2(_253))))); float3 _481; if (_458) { _481 = _468.xyz * View.View_SkyLightColor.xyz; } else { float3 _476 = _468.xyz * float3(_468.w * 16.0); _481 = _476 * _476; } float3 _484 = float3(_276); float3 _488; _488 = ((float3(_423 * fast::max(0.0, dot(_206, MobileDirectionalLight.MobileDirectionalLight_DirectionalLightDirectionAndShadowTransition.xyz))) * MobileDirectionalLight.MobileDirectionalLight_DirectionalLightColor.xyz) * (_270 + float3(_276 * (_439 * fast::min(_446 * _446, 65504.0))))) + ((_481 * float3(fast::clamp(1.0, 0.0, 1.0))) * _484); float3 _507; float _509; float _511; float _537; int _491 = 0; for (;;) { if (_491 < _Globals.NumDynamicPointLights) { float3 _501 = _Globals.LightPositionAndInvRadius[_491].xyz - _179; float _502 = dot(_501, _501); float3 _505 = _501 * float3(rsqrt(_502)); _507 = normalize(_181 + _505); _509 = fast::max(0.0, dot(_206, _505)); _511 = fast::max(0.0, dot(_206, _507)); if (_Globals.LightColorAndFalloffExponent[_491].w == 0.0) { float _531 = _502 * (_Globals.LightPositionAndInvRadius[_491].w * _Globals.LightPositionAndInvRadius[_491].w); float _534 = fast::clamp(1.0 - (_531 * _531), 0.0, 1.0); _537 = (1.0 / (_502 + 1.0)) * (_534 * _534); } else { float3 _521 = _501 * float3(_Globals.LightPositionAndInvRadius[_491].w); _537 = pow(1.0 - fast::clamp(dot(_521, _521), 0.0, 1.0), _Globals.LightColorAndFalloffExponent[_491].w); } float3 _544 = cross(_206, _507); float _546 = _511 * _442; float _549 = _442 / (dot(_544, _544) + (_546 * _546)); _488 += fast::min(float3(65000.0), ((float3(_537 * _509) * _Globals.LightColorAndFalloffExponent[_491].xyz) * float3(0.3183098733425140380859375)) * (_270 + float3(_276 * (_439 * fast::min(_549 * _549, 65504.0))))); _491++; continue; } else { break; } } float3 _567 = (mix(_488 + fast::max(float3(0.0), float3(0.0)), _270 + _484, float3(View.View_UnlitViewmodeMask)) * float3(in.in_var_TEXCOORD7.w)) + in.in_var_TEXCOORD7.xyz; float4 _571 = float4(_567.x, _567.y, _567.z, _137.w); _571.w = fast::min(in.in_var_TEXCOORD8.w, 65500.0); out.out_var_SV_Target0 = _571; return out; } spirv-cross-2021.01.15/reference/shaders-ue4-no-opt/asm/frag/array-copy-error.asm.invalid.frag000066400000000000000000000340451400026215700316550ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_PrimitiveDither { float PrimitiveDither_LODFactor; }; struct type_PrimitiveFade { float2 PrimitiveFade_FadeTimeScaleBias; }; struct type_Material { float4 Material_VectorExpressions[9]; float4 Material_ScalarExpressions[3]; }; constant float _98 = {}; constant float _103 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; float gl_FragDepth [[depth(less)]]; }; struct main0_in { float4 in_var_TEXCOORD6 [[user(locn0)]]; float4 in_var_TEXCOORD7 [[user(locn1)]]; float4 in_var_TEXCOORD10_centroid [[user(locn2)]]; float4 in_var_TEXCOORD11_centroid [[user(locn3)]]; float4 in_var_TEXCOORD0_0 [[user(locn4)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_PrimitiveDither& PrimitiveDither [[buffer(1)]], constant type_PrimitiveFade& PrimitiveFade [[buffer(2)]], constant type_Material& Material [[buffer(3)]], texture2d Material_Texture2D_0 [[texture(0)]], texture2d Material_Texture2D_3 [[texture(1)]], sampler Material_Texture2D_0Sampler [[sampler(0)]], sampler Material_Texture2D_3Sampler [[sampler(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; spvUnsafeArray in_var_TEXCOORD0 = {}; in_var_TEXCOORD0[0] = in.in_var_TEXCOORD0_0; float2 _135 = gl_FragCoord.xy - View.View_ViewRectMin.xy; float4 _140 = float4(_103, _103, gl_FragCoord.z, 1.0) * float4(gl_FragCoord.w); float4 _144 = View.View_SVPositionToTranslatedWorld * float4(gl_FragCoord.xyz, 1.0); float3 _148 = _144.xyz / float3(_144.w); float3 _149 = _148 - float3(View.View_PreViewTranslation); float3 _151 = normalize(-_148); float3 _152 = _151 * float3x3(in.in_var_TEXCOORD10_centroid.xyz, cross(in.in_var_TEXCOORD11_centroid.xyz, in.in_var_TEXCOORD10_centroid.xyz) * float3(in.in_var_TEXCOORD11_centroid.w), in.in_var_TEXCOORD11_centroid.xyz); float _170 = mix(Material.Material_ScalarExpressions[0].y, Material.Material_ScalarExpressions[0].z, fast::min(fast::max(abs(dot(_151, in.in_var_TEXCOORD11_centroid.xyz)), 0.0), 1.0)); float _171 = floor(_170); float _172 = 1.0 / _170; float2 _174 = (float2(Material.Material_ScalarExpressions[0].x) * ((_152.xy * float2(-1.0)) / float2(_152.z))) * float2(_172); float2 _175 = dfdx(float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y)); float2 _176 = dfdy(float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y)); float _180_copy; float2 _183; _183 = float2(0.0); float _188; float _211; float2 _212; float _180 = 1.0; int _185 = 0; float _187 = 1.0; float _189 = 1.0; for (;;) { if (float(_185) < (_171 + 2.0)) { _188 = Material_Texture2D_0.sample(Material_Texture2D_0Sampler, (float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y) + _183), gradient2d(_175, _176)).y; if (_180 < _188) { float _201 = _188 - _180; float _203 = _201 / ((_189 - _187) + _201); _211 = (_189 * _203) + (_180 * (1.0 - _203)); _212 = _183 - (float2(_203) * _174); break; } _180_copy = _180; _180 -= _172; _183 += _174; _185++; _187 = _188; _189 = _180_copy; continue; } else { _211 = _98; _212 = _183; break; } } float4 _218 = Material_Texture2D_0.sample(Material_Texture2D_0Sampler, (float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y) + _212.xy), bias(View.View_MaterialTextureMipBias)); float2 _229 = _135 + float2(View.View_TemporalAAParams.x); float _237 = float((uint(_229.x) + (2u * uint(_229.y))) % 5u); float2 _238 = _135 * float2(0.015625); float4 _242 = Material_Texture2D_3.sample(Material_Texture2D_3Sampler, _238, bias(View.View_MaterialTextureMipBias)); float4 _254 = Material_Texture2D_3.sample(Material_Texture2D_3Sampler, _238, bias(View.View_MaterialTextureMipBias)); float3 _272 = float3(_212, (1.0 - _211) * Material.Material_ScalarExpressions[0].x); float2 _275 = dfdx(float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y)); float2 _276 = abs(_275); float3 _279 = dfdx(_149); float2 _283 = dfdy(float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y)); float2 _284 = abs(_283); float3 _287 = dfdy(_149); if (PrimitiveDither.PrimitiveDither_LODFactor != 0.0) { if (abs(PrimitiveDither.PrimitiveDither_LODFactor) > 0.001000000047497451305389404296875) { float _317 = fract(cos(dot(floor(gl_FragCoord.xy), float2(347.834503173828125, 3343.28369140625))) * 1000.0); if ((float((PrimitiveDither.PrimitiveDither_LODFactor < 0.0) ? ((PrimitiveDither.PrimitiveDither_LODFactor + 1.0) > _317) : (PrimitiveDither.PrimitiveDither_LODFactor < _317)) - 0.001000000047497451305389404296875) < 0.0) { discard_fragment(); } } } if ((((_218.z + ((fast::min(fast::max(1.0 - (_218.x * Material.Material_ScalarExpressions[2].y), 0.0), 1.0) + ((_237 + (_242.x * Material.Material_ScalarExpressions[2].z)) * 0.16666667163372039794921875)) + (-0.5))) * ((fast::clamp((View.View_RealTime * PrimitiveFade.PrimitiveFade_FadeTimeScaleBias.x) + PrimitiveFade.PrimitiveFade_FadeTimeScaleBias.y, 0.0, 1.0) + ((_237 + _254.x) * 0.16666667163372039794921875)) + (-0.5))) - 0.33329999446868896484375) < 0.0) { discard_fragment(); } float2 _351 = ((((in.in_var_TEXCOORD6.xy / float2(in.in_var_TEXCOORD6.w)) - View.View_TemporalAAJitter.xy) - ((in.in_var_TEXCOORD7.xy / float2(in.in_var_TEXCOORD7.w)) - View.View_TemporalAAJitter.zw)) * float2(0.2495000064373016357421875)) + float2(0.49999237060546875); out.gl_FragDepth = fast::min(_140.z / (_140.w + (sqrt(dot(_272, _272)) / (fast::max(sqrt(dot(_276, _276)) / sqrt(dot(_279, _279)), sqrt(dot(_284, _284)) / sqrt(dot(_287, _287))) / abs(dot(float3x3(View.View_ViewToTranslatedWorld[0].xyz, View.View_ViewToTranslatedWorld[1].xyz, View.View_ViewToTranslatedWorld[2].xyz) * float3(0.0, 0.0, 1.0), _151))))), gl_FragCoord.z); out.out_var_SV_Target0 = float4(_351.x, _351.y, float2(0.0).x, float2(0.0).y); return out; } phi-variable-declaration.asm.invalid.frag000066400000000000000000000340451400026215700332070ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4-no-opt/asm/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_PrimitiveDither { float PrimitiveDither_LODFactor; }; struct type_PrimitiveFade { float2 PrimitiveFade_FadeTimeScaleBias; }; struct type_Material { float4 Material_VectorExpressions[9]; float4 Material_ScalarExpressions[3]; }; constant float _98 = {}; constant float _103 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; float gl_FragDepth [[depth(less)]]; }; struct main0_in { float4 in_var_TEXCOORD6 [[user(locn0)]]; float4 in_var_TEXCOORD7 [[user(locn1)]]; float4 in_var_TEXCOORD10_centroid [[user(locn2)]]; float4 in_var_TEXCOORD11_centroid [[user(locn3)]]; float4 in_var_TEXCOORD0_0 [[user(locn4)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_PrimitiveDither& PrimitiveDither [[buffer(1)]], constant type_PrimitiveFade& PrimitiveFade [[buffer(2)]], constant type_Material& Material [[buffer(3)]], texture2d Material_Texture2D_0 [[texture(0)]], texture2d Material_Texture2D_3 [[texture(1)]], sampler Material_Texture2D_0Sampler [[sampler(0)]], sampler Material_Texture2D_3Sampler [[sampler(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; spvUnsafeArray in_var_TEXCOORD0 = {}; in_var_TEXCOORD0[0] = in.in_var_TEXCOORD0_0; float2 _135 = gl_FragCoord.xy - View.View_ViewRectMin.xy; float4 _140 = float4(_103, _103, gl_FragCoord.z, 1.0) * float4(gl_FragCoord.w); float4 _144 = View.View_SVPositionToTranslatedWorld * float4(gl_FragCoord.xyz, 1.0); float3 _148 = _144.xyz / float3(_144.w); float3 _149 = _148 - float3(View.View_PreViewTranslation); float3 _151 = normalize(-_148); float3 _152 = _151 * float3x3(in.in_var_TEXCOORD10_centroid.xyz, cross(in.in_var_TEXCOORD11_centroid.xyz, in.in_var_TEXCOORD10_centroid.xyz) * float3(in.in_var_TEXCOORD11_centroid.w), in.in_var_TEXCOORD11_centroid.xyz); float _170 = mix(Material.Material_ScalarExpressions[0].y, Material.Material_ScalarExpressions[0].z, fast::min(fast::max(abs(dot(_151, in.in_var_TEXCOORD11_centroid.xyz)), 0.0), 1.0)); float _171 = floor(_170); float _172 = 1.0 / _170; float2 _174 = (float2(Material.Material_ScalarExpressions[0].x) * ((_152.xy * float2(-1.0)) / float2(_152.z))) * float2(_172); float2 _175 = dfdx(float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y)); float2 _176 = dfdy(float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y)); float _180_copy; float2 _183; _183 = float2(0.0); float _188; float _211; float2 _212; float _180 = 1.0; int _185 = 0; float _187 = 1.0; float _189 = 1.0; for (;;) { if (float(_185) < (_171 + 2.0)) { _188 = Material_Texture2D_0.sample(Material_Texture2D_0Sampler, (float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y) + _183), gradient2d(_175, _176)).y; if (_180 < _188) { float _201 = _188 - _180; float _203 = _201 / ((_189 - _187) + _201); _211 = (_189 * _203) + (_180 * (1.0 - _203)); _212 = _183 - (float2(_203) * _174); break; } _180_copy = _180; _180 -= _172; _183 += _174; _185++; _187 = _188; _189 = _180_copy; continue; } else { _211 = _98; _212 = _183; break; } } float4 _218 = Material_Texture2D_0.sample(Material_Texture2D_0Sampler, (float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y) + _212.xy), bias(View.View_MaterialTextureMipBias)); float2 _229 = _135 + float2(View.View_TemporalAAParams.x); float _237 = float((uint(_229.x) + (2u * uint(_229.y))) % 5u); float2 _238 = _135 * float2(0.015625); float4 _242 = Material_Texture2D_3.sample(Material_Texture2D_3Sampler, _238, bias(View.View_MaterialTextureMipBias)); float4 _254 = Material_Texture2D_3.sample(Material_Texture2D_3Sampler, _238, bias(View.View_MaterialTextureMipBias)); float3 _272 = float3(_212, (1.0 - _211) * Material.Material_ScalarExpressions[0].x); float2 _275 = dfdx(float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y)); float2 _276 = abs(_275); float3 _279 = dfdx(_149); float2 _283 = dfdy(float2(in_var_TEXCOORD0[0].x, in_var_TEXCOORD0[0].y)); float2 _284 = abs(_283); float3 _287 = dfdy(_149); if (PrimitiveDither.PrimitiveDither_LODFactor != 0.0) { if (abs(PrimitiveDither.PrimitiveDither_LODFactor) > 0.001000000047497451305389404296875) { float _317 = fract(cos(dot(floor(gl_FragCoord.xy), float2(347.834503173828125, 3343.28369140625))) * 1000.0); if ((float((PrimitiveDither.PrimitiveDither_LODFactor < 0.0) ? ((PrimitiveDither.PrimitiveDither_LODFactor + 1.0) > _317) : (PrimitiveDither.PrimitiveDither_LODFactor < _317)) - 0.001000000047497451305389404296875) < 0.0) { discard_fragment(); } } } if ((((_218.z + ((fast::min(fast::max(1.0 - (_218.x * Material.Material_ScalarExpressions[2].y), 0.0), 1.0) + ((_237 + (_242.x * Material.Material_ScalarExpressions[2].z)) * 0.16666667163372039794921875)) + (-0.5))) * ((fast::clamp((View.View_RealTime * PrimitiveFade.PrimitiveFade_FadeTimeScaleBias.x) + PrimitiveFade.PrimitiveFade_FadeTimeScaleBias.y, 0.0, 1.0) + ((_237 + _254.x) * 0.16666667163372039794921875)) + (-0.5))) - 0.33329999446868896484375) < 0.0) { discard_fragment(); } float2 _351 = ((((in.in_var_TEXCOORD6.xy / float2(in.in_var_TEXCOORD6.w)) - View.View_TemporalAAJitter.xy) - ((in.in_var_TEXCOORD7.xy / float2(in.in_var_TEXCOORD7.w)) - View.View_TemporalAAJitter.zw)) * float2(0.2495000064373016357421875)) + float2(0.49999237060546875); out.gl_FragDepth = fast::min(_140.z / (_140.w + (sqrt(dot(_272, _272)) / (fast::max(sqrt(dot(_276, _276)) / sqrt(dot(_279, _279)), sqrt(dot(_284, _284)) / sqrt(dot(_287, _287))) / abs(dot(float3x3(View.View_ViewToTranslatedWorld[0].xyz, View.View_ViewToTranslatedWorld[1].xyz, View.View_ViewToTranslatedWorld[2].xyz) * float3(0.0, 0.0, 1.0), _151))))), gl_FragCoord.z); out.out_var_SV_Target0 = float4(_351.x, _351.y, float2(0.0).x, float2(0.0).y); return out; } spirv-cross-2021.01.15/reference/shaders-ue4-no-opt/asm/vert/000077500000000000000000000000001400026215700234265ustar00rootroot00000000000000loop-accesschain-writethrough.asm.invalid.vert000066400000000000000000000067501400026215700344310ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4-no-opt/asm/vert#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_Globals { float4 ViewportSize; float ScatteringScaling; float CocRadiusToCircumscribedRadius; }; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; struct main0_out { float2 out_var_TEXCOORD0 [[user(locn0)]]; float4 out_var_TEXCOORD1 [[user(locn1)]]; float4 out_var_TEXCOORD2 [[user(locn2)]]; float4 out_var_TEXCOORD3 [[user(locn3)]]; float4 out_var_TEXCOORD4 [[user(locn4)]]; float4 out_var_TEXCOORD5 [[user(locn5)]]; float4 out_var_TEXCOORD6 [[user(locn6)]]; float4 gl_Position [[position]]; }; vertex main0_out main0(constant type_Globals& _Globals [[buffer(0)]], const device type_StructuredBuffer_v4float& ScatterDrawList [[buffer(1)]], uint gl_VertexIndex [[vertex_id]], uint gl_InstanceIndex [[instance_id]]) { main0_out out = {}; uint _66 = gl_VertexIndex / 4u; uint _68 = gl_VertexIndex - (_66 * 4u); uint _70 = (16u * gl_InstanceIndex) + _66; float _72; _72 = 0.0; spvUnsafeArray _61; spvUnsafeArray _62; spvUnsafeArray _63; float _73; uint _75 = 0u; for (;;) { if (_75 < 4u) { uint _82 = ((5u * _70) + _75) + 1u; _61[_75] = float4(ScatterDrawList._m0[_82].xyz, 0.0); _62[_75] = ScatterDrawList._m0[_82].w; if (_75 == 0u) { _73 = _62[_75]; } else { _73 = fast::max(_72, _62[_75]); } _63[_75].x = (-0.5) / _62[_75]; _63[_75].y = (0.5 * _62[_75]) + 0.5; _72 = _73; _75++; continue; } else { break; } } float2 _144 = float2(_Globals.ScatteringScaling) * ScatterDrawList._m0[5u * _70].xy; float2 _173 = (((float2((_72 * _Globals.CocRadiusToCircumscribedRadius) + 1.0) * ((float2(float(_68 % 2u), float(_68 / 2u)) * float2(2.0)) - float2(1.0))) + _144) + float2(0.5)) * _Globals.ViewportSize.zw; out.out_var_TEXCOORD0 = _144; out.out_var_TEXCOORD1 = float4(_61[0].xyz, _62[0]); out.out_var_TEXCOORD2 = float4(_61[1].xyz, _62[1]); out.out_var_TEXCOORD3 = float4(_61[2].xyz, _62[2]); out.out_var_TEXCOORD4 = float4(_61[3].xyz, _62[3]); out.out_var_TEXCOORD5 = float4(_63[0].x, _63[0].y, _63[1].x, _63[1].y); out.out_var_TEXCOORD6 = float4(_63[2].x, _63[2].y, _63[3].x, _63[3].y); out.gl_Position = float4((_173.x * 2.0) - 1.0, 1.0 - (_173.y * 2.0), 0.0, 1.0); return out; } spirv-cross-2021.01.15/reference/shaders-ue4/000077500000000000000000000000001400026215700204545ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4/asm/000077500000000000000000000000001400026215700212345ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag/000077500000000000000000000000001400026215700221535ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag/depth-compare.asm.frag000066400000000000000000000354511400026215700263330ustar00rootroot00000000000000#include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Globals { float3 SoftTransitionScale; float4x4 ShadowViewProjectionMatrices[6]; float InvShadowmapResolution; float ShadowFadeFraction; float ShadowSharpen; float4 LightPositionAndInvRadius; float2 ProjectionDepthBiasParameters; float4 PointLightDepthBiasAndProjParameters; }; constant float4 _107 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; fragment main0_out main0(constant type_View& View [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d SceneTexturesStruct_SceneDepthTexture [[texture(0)]], texture2d SceneTexturesStruct_GBufferATexture [[texture(1)]], texture2d SceneTexturesStruct_GBufferBTexture [[texture(2)]], texture2d SceneTexturesStruct_GBufferDTexture [[texture(3)]], depthcube ShadowDepthCubeTexture [[texture(4)]], texture2d SSProfilesTexture [[texture(5)]], sampler SceneTexturesStruct_SceneDepthTextureSampler [[sampler(0)]], sampler SceneTexturesStruct_GBufferATextureSampler [[sampler(1)]], sampler SceneTexturesStruct_GBufferBTextureSampler [[sampler(2)]], sampler SceneTexturesStruct_GBufferDTextureSampler [[sampler(3)]], sampler ShadowDepthTextureSampler [[sampler(4)]], sampler ShadowDepthCubeTextureSampler [[sampler(5)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; float2 _114 = gl_FragCoord.xy * View.View_BufferSizeAndInvSize.zw; float4 _118 = SceneTexturesStruct_SceneDepthTexture.sample(SceneTexturesStruct_SceneDepthTextureSampler, _114, level(0.0)); float _119 = _118.x; float _133 = ((_119 * View.View_InvDeviceZToWorldZTransform.x) + View.View_InvDeviceZToWorldZTransform.y) + (1.0 / ((_119 * View.View_InvDeviceZToWorldZTransform.z) - View.View_InvDeviceZToWorldZTransform.w)); float4 _147 = View.View_ScreenToWorld * float4(((_114 - View.View_ScreenPositionScaleBias.wz) / View.View_ScreenPositionScaleBias.xy) * float2(_133), _133, 1.0); float3 _148 = _147.xyz; float3 _152 = _Globals.LightPositionAndInvRadius.xyz - _148; float _158 = length(_152); bool _160 = (_158 * _Globals.LightPositionAndInvRadius.w) < 1.0; float _207; if (_160) { float3 _165 = abs(_152); float _166 = _165.x; float _167 = _165.y; float _168 = _165.z; float _170 = fast::max(_166, fast::max(_167, _168)); int _189; if (_170 == _166) { _189 = (_166 == _152.x) ? 0 : 1; } else { int _185; if (_170 == _167) { _185 = (_167 == _152.y) ? 2 : 3; } else { _185 = (_168 == _152.z) ? 4 : 5; } _189 = _185; } float4 _196 = _Globals.ShadowViewProjectionMatrices[_189] * float4(_147.xyz, 1.0); float _198 = _196.w; _207 = ShadowDepthCubeTexture.sample_compare(ShadowDepthCubeTextureSampler, (_152 / float3(_158)), (_196.z / _198) + ((-_Globals.PointLightDepthBiasAndProjParameters.x) / _198), level(0.0)); } else { _207 = 1.0; } float _213 = fast::clamp(((_207 - 0.5) * _Globals.ShadowSharpen) + 0.5, 0.0, 1.0); float _218 = sqrt(mix(1.0, _213 * _213, _Globals.ShadowFadeFraction)); float4 _219 = _107; _219.z = _218; float3 _236 = normalize((SceneTexturesStruct_GBufferATexture.sample(SceneTexturesStruct_GBufferATextureSampler, _114, level(0.0)).xyz * float3(2.0)) - float3(1.0)); uint _240 = uint(round(SceneTexturesStruct_GBufferBTexture.sample(SceneTexturesStruct_GBufferBTextureSampler, _114, level(0.0)).w * 255.0)); bool _248 = (_240 & 15u) == 5u; float _448; if (_248) { float4 _260 = SSProfilesTexture.read(uint2(int3(1, int(uint((select(float4(0.0), SceneTexturesStruct_GBufferDTexture.sample(SceneTexturesStruct_GBufferDTextureSampler, _114, level(0.0)), bool4(!(((_240 & 4294967280u) & 16u) != 0u))).x * 255.0) + 0.5)), 0).xy), 0); float _263 = _260.y * 0.5; float _274 = pow(fast::clamp(dot(-(_152 * float3(rsqrt(dot(_152, _152)))), _236), 0.0, 1.0), 1.0); float _445; if (_160) { float3 _278 = _152 / float3(_158); float3 _280 = normalize(cross(_278, float3(0.0, 0.0, 1.0))); float3 _284 = float3(_Globals.InvShadowmapResolution); float3 _285 = _280 * _284; float3 _286 = cross(_280, _278) * _284; float3 _287 = abs(_278); float _288 = _287.x; float _289 = _287.y; float _290 = _287.z; float _292 = fast::max(_288, fast::max(_289, _290)); int _311; if (_292 == _288) { _311 = (_288 == _278.x) ? 0 : 1; } else { int _307; if (_292 == _289) { _307 = (_289 == _278.y) ? 2 : 3; } else { _307 = (_290 == _278.z) ? 4 : 5; } _311 = _307; } float4 _318 = _Globals.ShadowViewProjectionMatrices[_311] * float4(_148 - (_236 * float3(_263)), 1.0); float _323 = _260.x * (10.0 / _Globals.LightPositionAndInvRadius.w); float _329 = (1.0 / (((_318.z / _318.w) * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w; float _342 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, (_278 + (_286 * float3(2.5))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; float _364 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, ((_278 + (_285 * float3(2.3776409626007080078125))) + (_286 * float3(0.77254199981689453125))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; float _387 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, ((_278 + (_285 * float3(1.46946299076080322265625))) + (_286 * float3(-2.0225429534912109375))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; float _410 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, ((_278 + (_285 * float3(-1.46946299076080322265625))) + (_286 * float3(-2.02254199981689453125))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; float _433 = (_329 - ((1.0 / ((float4(ShadowDepthCubeTexture.sample(ShadowDepthTextureSampler, ((_278 + (_285 * float3(-2.3776409626007080078125))) + (_286 * float3(0.772543013095855712890625))), level(0.0))).x * _Globals.PointLightDepthBiasAndProjParameters.z) - _Globals.PointLightDepthBiasAndProjParameters.w)) * _Globals.LightPositionAndInvRadius.w)) * _323; _445 = (((((fast::clamp(abs((_342 > 0.0) ? (_342 + _263) : fast::max(0.0, (_342 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25) + (fast::clamp(abs((_364 > 0.0) ? (_364 + _263) : fast::max(0.0, (_364 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25)) + (fast::clamp(abs((_387 > 0.0) ? (_387 + _263) : fast::max(0.0, (_387 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25)) + (fast::clamp(abs((_410 > 0.0) ? (_410 + _263) : fast::max(0.0, (_410 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25)) + (fast::clamp(abs((_433 > 0.0) ? (_433 + _263) : fast::max(0.0, (_433 * _274) + _263)), 0.1500000059604644775390625, 5.0) + 0.25)) * 0.20000000298023223876953125; } else { _445 = 1.0; } _448 = 1.0 - (_445 * 0.20000000298023223876953125); } else { _448 = 1.0; } float4 _451 = float4(float3(1.0).x, float3(1.0).y, _219.z, float3(1.0).z); _451.w = _248 ? sqrt(_448) : _218; out.out_var_SV_Target0 = _451; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag/global-constant-arrays.asm.frag000066400000000000000000002305531400026215700301710ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_Globals { float4 MappingPolynomial; float3 InverseGamma; float4 ColorMatrixR_ColorCurveCd1; float4 ColorMatrixG_ColorCurveCd3Cm3; float4 ColorMatrixB_ColorCurveCm2; float4 ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3; float4 ColorCurve_Ch1_Ch2; float4 ColorShadow_Luma; float4 ColorShadow_Tint1; float4 ColorShadow_Tint2; float FilmSlope; float FilmToe; float FilmShoulder; float FilmBlackClip; float FilmWhiteClip; packed_float3 ColorScale; float4 OverlayColor; float WhiteTemp; float WhiteTint; float4 ColorSaturation; float4 ColorContrast; float4 ColorGamma; float4 ColorGain; float4 ColorOffset; float4 ColorSaturationShadows; float4 ColorContrastShadows; float4 ColorGammaShadows; float4 ColorGainShadows; float4 ColorOffsetShadows; float4 ColorSaturationMidtones; float4 ColorContrastMidtones; float4 ColorGammaMidtones; float4 ColorGainMidtones; float4 ColorOffsetMidtones; float4 ColorSaturationHighlights; float4 ColorContrastHighlights; float4 ColorGammaHighlights; float4 ColorGainHighlights; float4 ColorOffsetHighlights; float ColorCorrectionShadowsMax; float ColorCorrectionHighlightsMin; uint OutputDevice; uint OutputGamut; float BlueCorrection; float ExpandGamut; }; constant spvUnsafeArray _475 = spvUnsafeArray({ -4.0, -4.0, -3.1573765277862548828125, -0.485249996185302734375, 1.84773242473602294921875, 1.84773242473602294921875 }); constant spvUnsafeArray _476 = spvUnsafeArray({ -0.718548238277435302734375, 2.0810306072235107421875, 3.66812419891357421875, 4.0, 4.0, 4.0 }); constant spvUnsafeArray _479 = spvUnsafeArray({ -4.97062206268310546875, -3.0293781757354736328125, -2.1261999607086181640625, -1.5104999542236328125, -1.0578000545501708984375, -0.4668000042438507080078125, 0.11937999725341796875, 0.7088134288787841796875, 1.2911865711212158203125, 1.2911865711212158203125 }); constant spvUnsafeArray _480 = spvUnsafeArray({ 0.80891323089599609375, 1.19108676910400390625, 1.5683000087738037109375, 1.94830000400543212890625, 2.308300018310546875, 2.63840007781982421875, 2.85949993133544921875, 2.9872608184814453125, 3.0127391815185546875, 3.0127391815185546875 }); constant spvUnsafeArray _482 = spvUnsafeArray({ -2.3010299205780029296875, -2.3010299205780029296875, -1.9312000274658203125, -1.5204999446868896484375, -1.0578000545501708984375, -0.4668000042438507080078125, 0.11937999725341796875, 0.7088134288787841796875, 1.2911865711212158203125, 1.2911865711212158203125 }); constant spvUnsafeArray _483 = spvUnsafeArray({ 0.801995217800140380859375, 1.19800484180450439453125, 1.5943000316619873046875, 1.99730002880096435546875, 2.3782999515533447265625, 2.7683999538421630859375, 3.0515000820159912109375, 3.2746293544769287109375, 3.32743072509765625, 3.32743072509765625 }); constant float3 _391 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0), center_no_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant type_Globals& _Globals [[buffer(0)]], uint gl_Layer [[render_target_array_index]]) { main0_out out = {}; float3x3 _546 = float3x3(float3(0.41245639324188232421875, 0.3575761020183563232421875, 0.180437505245208740234375), float3(0.21267290413379669189453125, 0.715152204036712646484375, 0.072175003588199615478515625), float3(0.01933390088379383087158203125, 0.119191996753215789794921875, 0.950304090976715087890625)) * float3x3(float3(1.01303005218505859375, 0.0061053098179399967193603515625, -0.014971000142395496368408203125), float3(0.0076982299797236919403076171875, 0.99816501140594482421875, -0.005032029934227466583251953125), float3(-0.0028413101099431514739990234375, 0.0046851597726345062255859375, 0.92450702190399169921875)); float3x3 _547 = _546 * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)); float3x3 _548 = float3x3(float3(0.662454187870025634765625, 0.1340042054653167724609375, 0.1561876833438873291015625), float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625), float3(-0.0055746496655046939849853515625, 0.0040607335977256298065185546875, 1.01033914089202880859375)) * float3x3(float3(0.98722398281097412109375, -0.0061132698319852352142333984375, 0.01595330052077770233154296875), float3(-0.007598360069096088409423828125, 1.00186002254486083984375, 0.0053300200961530208587646484375), float3(0.003072570078074932098388671875, -0.0050959498621523380279541015625, 1.0816800594329833984375)); float3x3 _549 = _548 * float3x3(float3(3.2409698963165283203125, -1.53738319873809814453125, -0.4986107647418975830078125), float3(-0.96924364566802978515625, 1.875967502593994140625, 0.0415550582110881805419921875), float3(0.055630080401897430419921875, -0.2039769589900970458984375, 1.05697154998779296875)); float3x3 _550 = float3x3(float3(0.952552378177642822265625, 0.0, 9.25), float3(0.3439664542675018310546875, 0.728166103363037109375, -0.07213254272937774658203125), float3(0.0, 0.0, 1.00882518291473388671875)) * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)); float3x3 _551 = float3x3(float3(0.662454187870025634765625, 0.1340042054653167724609375, 0.1561876833438873291015625), float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625), float3(-0.0055746496655046939849853515625, 0.0040607335977256298065185546875, 1.01033914089202880859375)) * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625)); float3x3 _576; for (;;) { if (_Globals.OutputGamut == 1u) { _576 = _548 * float3x3(float3(2.493396282196044921875, -0.931345880031585693359375, -0.4026944935321807861328125), float3(-0.829486787319183349609375, 1.76265966892242431640625, 0.02362460084259510040283203125), float3(0.0358506999909877777099609375, -0.076182700693607330322265625, 0.957014024257659912109375)); break; } else { if (_Globals.OutputGamut == 2u) { _576 = _548 * float3x3(float3(1.71660840511322021484375, -0.3556621074676513671875, -0.253360092639923095703125), float3(-0.666682898998260498046875, 1.61647760868072509765625, 0.01576850004494190216064453125), float3(0.017642199993133544921875, -0.04277630150318145751953125, 0.94222867488861083984375)); break; } else { if (_Globals.OutputGamut == 3u) { _576 = float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625)); break; } else { if (_Globals.OutputGamut == 4u) { _576 = float3x3(float3(1.0, 0.0, 0.0), float3(0.0, 1.0, 0.0), float3(0.0, 0.0, 1.0)); break; } else { _576 = _549; break; } } } } } float3 _577 = float4((in.in_var_TEXCOORD0 - float2(0.015625)) * float2(1.03225803375244140625), float(gl_Layer) * 0.0322580635547637939453125, 0.0).xyz; float3 _599; if (_Globals.OutputDevice >= 3u) { float3 _591 = pow(_577, float3(0.0126833133399486541748046875)); _599 = pow(fast::max(float3(0.0), _591 - float3(0.8359375)) / (float3(18.8515625) - (float3(18.6875) * _591)), float3(6.277394771575927734375)) * float3(10000.0); } else { _599 = (exp2((_577 - float3(0.434017598628997802734375)) * float3(14.0)) * float3(0.180000007152557373046875)) - (exp2(float3(-6.0762462615966796875)) * float3(0.180000007152557373046875)); } float _602 = _Globals.WhiteTemp * 1.00055634975433349609375; float _616 = (_602 <= 7000.0) ? (0.24406300485134124755859375 + ((99.1100006103515625 + ((2967800.0 - (4604438528.0 / _Globals.WhiteTemp)) / _602)) / _602)) : (0.23703999817371368408203125 + ((247.4799957275390625 + ((1901800.0 - (2005284352.0 / _Globals.WhiteTemp)) / _602)) / _602)); float _633 = ((0.860117733478546142578125 + (0.00015411825734190642833709716796875 * _Globals.WhiteTemp)) + ((1.2864121856637211749330163002014e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)) / ((1.0 + (0.0008424202096648514270782470703125 * _Globals.WhiteTemp)) + ((7.0814513719597016461193561553955e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)); float _644 = ((0.317398726940155029296875 + (4.25 * _Globals.WhiteTemp)) + ((4.2048167614439080352894961833954e-08 * _Globals.WhiteTemp) * _Globals.WhiteTemp)) / ((1.0 - (2.8974181986995972692966461181641e-05 * _Globals.WhiteTemp)) + ((1.6145605741257895715534687042236e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)); float _649 = ((2.0 * _633) - (8.0 * _644)) + 4.0; float2 _653 = float2((3.0 * _633) / _649, (2.0 * _644) / _649); float2 _660 = normalize(float2(_633, _644)); float _665 = _633 + (((-_660.y) * _Globals.WhiteTint) * 0.0500000007450580596923828125); float _669 = _644 + ((_660.x * _Globals.WhiteTint) * 0.0500000007450580596923828125); float _674 = ((2.0 * _665) - (8.0 * _669)) + 4.0; float2 _680 = select(float2(_616, ((((-3.0) * _616) * _616) + (2.86999988555908203125 * _616)) - 0.2750000059604644775390625), _653, bool2(_Globals.WhiteTemp < 4000.0)) + (float2((3.0 * _665) / _674, (2.0 * _669) / _674) - _653); float _681 = _680.x; float _682 = _680.y; float _683 = fast::max(_682, 1.0000000133514319600180897396058e-10); float3 _685 = _391; _685.x = _681 / _683; float3 _686 = _685; _686.y = 1.0; float3 _690 = _686; _690.z = ((1.0 - _681) - _682) / _683; float _691 = fast::max(0.328999996185302734375, 1.0000000133514319600180897396058e-10); float3 _693 = _391; _693.x = 0.3127000033855438232421875 / _691; float3 _694 = _693; _694.y = 1.0; float3 _696 = _694; _696.z = 0.3582999706268310546875 / _691; float3 _697 = _690 * float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)); float3 _698 = _696 * float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)); float3 _717 = (_599 * ((float3x3(float3(0.41245639324188232421875, 0.3575761020183563232421875, 0.180437505245208740234375), float3(0.21267290413379669189453125, 0.715152204036712646484375, 0.072175003588199615478515625), float3(0.01933390088379383087158203125, 0.119191996753215789794921875, 0.950304090976715087890625)) * ((float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)) * float3x3(float3(_698.x / _697.x, 0.0, 0.0), float3(0.0, _698.y / _697.y, 0.0), float3(0.0, 0.0, _698.z / _697.z))) * float3x3(float3(0.986992895603179931640625, -0.14705429971218109130859375, 0.15996269881725311279296875), float3(0.4323053061962127685546875, 0.518360316753387451171875, 0.049291200935840606689453125), float3(-0.00852870009839534759521484375, 0.0400427989661693572998046875, 0.968486726284027099609375)))) * float3x3(float3(3.2409698963165283203125, -1.53738319873809814453125, -0.4986107647418975830078125), float3(-0.96924364566802978515625, 1.875967502593994140625, 0.0415550582110881805419921875), float3(0.055630080401897430419921875, -0.2039769589900970458984375, 1.05697154998779296875)))) * _547; float3 _745; if (_Globals.ColorShadow_Tint2.w != 0.0) { float _724 = dot(_717, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625)); float3 _727 = (_717 / float3(_724)) - float3(1.0); _745 = mix(_717, _717 * (_549 * (float3x3(float3(0.544169127941131591796875, 0.23959259688854217529296875, 0.16669429838657379150390625), float3(0.23946559429168701171875, 0.702153027057647705078125, 0.058381401002407073974609375), float3(-0.0023439000360667705535888671875, 0.0361833982169628143310546875, 1.05521833896636962890625)) * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)))), float3((1.0 - exp2((-4.0) * dot(_727, _727))) * (1.0 - exp2((((-4.0) * _Globals.ExpandGamut) * _724) * _724)))); } else { _745 = _717; } float _746 = dot(_745, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625)); float4 _751 = _Globals.ColorSaturationShadows * _Globals.ColorSaturation; float4 _756 = _Globals.ColorContrastShadows * _Globals.ColorContrast; float4 _761 = _Globals.ColorGammaShadows * _Globals.ColorGamma; float4 _766 = _Globals.ColorGainShadows * _Globals.ColorGain; float4 _771 = _Globals.ColorOffsetShadows + _Globals.ColorOffset; float3 _772 = float3(_746); float _804 = smoothstep(0.0, _Globals.ColorCorrectionShadowsMax, _746); float4 _808 = _Globals.ColorSaturationHighlights * _Globals.ColorSaturation; float4 _811 = _Globals.ColorContrastHighlights * _Globals.ColorContrast; float4 _814 = _Globals.ColorGammaHighlights * _Globals.ColorGamma; float4 _817 = _Globals.ColorGainHighlights * _Globals.ColorGain; float4 _820 = _Globals.ColorOffsetHighlights + _Globals.ColorOffset; float _852 = smoothstep(_Globals.ColorCorrectionHighlightsMin, 1.0, _746); float4 _855 = _Globals.ColorSaturationMidtones * _Globals.ColorSaturation; float4 _858 = _Globals.ColorContrastMidtones * _Globals.ColorContrast; float4 _861 = _Globals.ColorGammaMidtones * _Globals.ColorGamma; float4 _864 = _Globals.ColorGainMidtones * _Globals.ColorGain; float4 _867 = _Globals.ColorOffsetMidtones + _Globals.ColorOffset; float3 _905 = ((((pow(pow(fast::max(float3(0.0), mix(_772, _745, _751.xyz * float3(_751.w))) * float3(5.5555553436279296875), _756.xyz * float3(_756.w)) * float3(0.180000007152557373046875), float3(1.0) / (_761.xyz * float3(_761.w))) * (_766.xyz * float3(_766.w))) + (_771.xyz + float3(_771.w))) * float3(1.0 - _804)) + (((pow(pow(fast::max(float3(0.0), mix(_772, _745, _855.xyz * float3(_855.w))) * float3(5.5555553436279296875), _858.xyz * float3(_858.w)) * float3(0.180000007152557373046875), float3(1.0) / (_861.xyz * float3(_861.w))) * (_864.xyz * float3(_864.w))) + (_867.xyz + float3(_867.w))) * float3(_804 - _852))) + (((pow(pow(fast::max(float3(0.0), mix(_772, _745, _808.xyz * float3(_808.w))) * float3(5.5555553436279296875), _811.xyz * float3(_811.w)) * float3(0.180000007152557373046875), float3(1.0) / (_814.xyz * float3(_814.w))) * (_817.xyz * float3(_817.w))) + (_820.xyz + float3(_820.w))) * float3(_852)); float3 _906 = _905 * _549; float3 _914 = float3(_Globals.BlueCorrection); float3 _916 = mix(_905, _905 * ((_551 * float3x3(float3(0.940437257289886474609375, -0.01830687932670116424560546875, 0.07786960899829864501953125), float3(0.008378696627914905548095703125, 0.82866001129150390625, 0.162961304187774658203125), float3(0.0005471261101774871349334716796875, -0.00088337459601461887359619140625, 1.00033628940582275390625))) * _550), _914) * _551; float _917 = _916.x; float _918 = _916.y; float _920 = _916.z; float _923 = fast::max(fast::max(_917, _918), _920); float _928 = (fast::max(_923, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_917, _918), _920), 1.0000000133514319600180897396058e-10)) / fast::max(_923, 0.00999999977648258209228515625); float _941 = ((_920 + _918) + _917) + (1.75 * sqrt(((_920 * (_920 - _918)) + (_918 * (_918 - _917))) + (_917 * (_917 - _920)))); float _942 = _941 * 0.3333333432674407958984375; float _943 = _928 - 0.4000000059604644775390625; float _948 = fast::max(1.0 - abs(_943 * 2.5), 0.0); float _956 = (1.0 + (float(int(sign(_943 * 5.0))) * (1.0 - (_948 * _948)))) * 0.02500000037252902984619140625; float _969; if (_942 <= 0.053333334624767303466796875) { _969 = _956; } else { float _968; if (_942 >= 0.1599999964237213134765625) { _968 = 0.0; } else { _968 = _956 * ((0.23999999463558197021484375 / _941) - 0.5); } _969 = _968; } float3 _972 = _916 * float3(1.0 + _969); float _973 = _972.x; float _974 = _972.y; float _976 = _972.z; float _990; if ((_973 == _974) && (_974 == _976)) { _990 = 0.0; } else { _990 = 57.2957763671875 * atan2(sqrt(3.0) * (_974 - _976), ((2.0 * _973) - _974) - _976); } float _995; if (_990 < 0.0) { _995 = _990 + 360.0; } else { _995 = _990; } float _996 = fast::clamp(_995, 0.0, 360.0); float _1001; if (_996 > 180.0) { _1001 = _996 - 360.0; } else { _1001 = _996; } float _1005 = smoothstep(0.0, 1.0, 1.0 - abs(_1001 * 0.01481481455266475677490234375)); float3 _1012 = _972; _1012.x = _973 + ((((_1005 * _1005) * _928) * (0.02999999932944774627685546875 - _973)) * 0.180000007152557373046875); float3 _1014 = fast::max(float3(0.0), _1012 * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375))); float _1023 = (1.0 + _Globals.FilmBlackClip) - _Globals.FilmToe; float _1026 = 1.0 + _Globals.FilmWhiteClip; float _1029 = _1026 - _Globals.FilmShoulder; float _1056; if (_Globals.FilmToe > 0.800000011920928955078125) { _1056 = ((0.819999992847442626953125 - _Globals.FilmToe) / _Globals.FilmSlope) + (log(0.180000007152557373046875) / log(10.0)); } else { float _1035 = (0.180000007152557373046875 + _Globals.FilmBlackClip) / _1023; _1056 = (log(0.180000007152557373046875) / log(10.0)) - ((0.5 * log(_1035 / (2.0 - _1035))) * (_1023 / _Globals.FilmSlope)); } float _1061 = ((1.0 - _Globals.FilmToe) / _Globals.FilmSlope) - _1056; float _1063 = (_Globals.FilmShoulder / _Globals.FilmSlope) - _1061; float _1065 = log(10.0); float3 _1067 = log(mix(float3(dot(_1014, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1014, float3(0.959999978542327880859375))) / float3(_1065); float3 _1071 = float3(_Globals.FilmSlope) * (_1067 + float3(_1061)); float3 _1079 = float3(_1056); float3 _1080 = _1067 - _1079; float3 _1092 = float3(_1063); float3 _1106 = fast::clamp(_1080 / float3(_1063 - _1056), float3(0.0), float3(1.0)); float3 _1110 = select(_1106, float3(1.0) - _1106, bool3(_1063 < _1056)); float3 _1115 = mix(select(_1071, float3(-_Globals.FilmBlackClip) + (float3(2.0 * _1023) / (float3(1.0) + exp(float3(((-2.0) * _Globals.FilmSlope) / _1023) * _1080))), _1067 < _1079), select(_1071, float3(_1026) - (float3(2.0 * _1029) / (float3(1.0) + exp(float3((2.0 * _Globals.FilmSlope) / _1029) * (_1067 - _1092)))), _1067 > _1092), ((float3(3.0) - (float3(2.0) * _1110)) * _1110) * _1110); float3 _1119 = fast::max(float3(0.0), mix(float3(dot(_1115, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1115, float3(0.930000007152557373046875))); float3 _1189; if (_Globals.ColorShadow_Tint2.w == 0.0) { float3 _1131 = _391; _1131.x = dot(_906, _Globals.ColorMatrixR_ColorCurveCd1.xyz); float3 _1136 = _1131; _1136.y = dot(_906, _Globals.ColorMatrixG_ColorCurveCd3Cm3.xyz); float3 _1141 = _1136; _1141.z = dot(_906, _Globals.ColorMatrixB_ColorCurveCm2.xyz); float3 _1157 = fast::max(float3(0.0), _1141 * (_Globals.ColorShadow_Tint1.xyz + (_Globals.ColorShadow_Tint2.xyz * float3(1.0 / (dot(_906, _Globals.ColorShadow_Luma.xyz) + 1.0))))); float3 _1162 = fast::max(float3(0.0), _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.xxx - _1157); float3 _1164 = fast::max(_1157, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.zzz); _1189 = ((((_1164 * _Globals.ColorCurve_Ch1_Ch2.xxx) + _Globals.ColorCurve_Ch1_Ch2.yyy) * (float3(1.0) / (_1164 + _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.www))) + ((fast::clamp(_1157, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.xxx, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.zzz) * _Globals.ColorMatrixB_ColorCurveCm2.www) + (((_1162 * _Globals.ColorMatrixR_ColorCurveCd1.www) * (float3(1.0) / (_1162 + _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.yyy))) + _Globals.ColorMatrixG_ColorCurveCd3Cm3.www))) - float3(0.00200000009499490261077880859375); } else { _1189 = fast::max(float3(0.0), mix(_1119, _1119 * ((_551 * float3x3(float3(1.06317996978759765625, 0.02339559979736804962158203125, -0.08657260239124298095703125), float3(-0.010633699595928192138671875, 1.2063200473785400390625, -0.1956900060176849365234375), float3(-0.0005908869788981974124908447265625, 0.00105247995816171169281005859375, 0.999538004398345947265625))) * _550), _914) * _549); } float3 _1218 = pow(fast::max(float3(0.0), mix((((float3(_Globals.MappingPolynomial.x) * (_1189 * _1189)) + (float3(_Globals.MappingPolynomial.y) * _1189)) + float3(_Globals.MappingPolynomial.z)) * float3(_Globals.ColorScale), _Globals.OverlayColor.xyz, float3(_Globals.OverlayColor.w))), float3(_Globals.InverseGamma.y)); float3 _3001; if (_Globals.OutputDevice == 0u) { float _2961 = _1218.x; float _2973; for (;;) { if (_2961 < 0.00313066993840038776397705078125) { _2973 = _2961 * 12.9200000762939453125; break; } _2973 = (pow(_2961, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _2974 = _1218.y; float _2986; for (;;) { if (_2974 < 0.00313066993840038776397705078125) { _2986 = _2974 * 12.9200000762939453125; break; } _2986 = (pow(_2974, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _2987 = _1218.z; float _2999; for (;;) { if (_2987 < 0.00313066993840038776397705078125) { _2999 = _2987 * 12.9200000762939453125; break; } _2999 = (pow(_2987, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } _3001 = float3(_2973, _2986, _2999); } else { float3 _2960; if (_Globals.OutputDevice == 1u) { float3 _2953 = fast::max(float3(6.1035199905745685100555419921875e-05), (_1218 * _547) * _576); _2960 = fast::min(_2953 * float3(4.5), (pow(fast::max(_2953, float3(0.017999999225139617919921875)), float3(0.449999988079071044921875)) * float3(1.09899997711181640625)) - float3(0.098999999463558197021484375)); } else { float3 _2950; if ((_Globals.OutputDevice == 3u) || (_Globals.OutputDevice == 5u)) { float3 _2100 = (_906 * float3(1.5)) * (_546 * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625))); float _2101 = _2100.x; float _2102 = _2100.y; float _2104 = _2100.z; float _2107 = fast::max(fast::max(_2101, _2102), _2104); float _2112 = (fast::max(_2107, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_2101, _2102), _2104), 1.0000000133514319600180897396058e-10)) / fast::max(_2107, 0.00999999977648258209228515625); float _2125 = ((_2104 + _2102) + _2101) + (1.75 * sqrt(((_2104 * (_2104 - _2102)) + (_2102 * (_2102 - _2101))) + (_2101 * (_2101 - _2104)))); float _2126 = _2125 * 0.3333333432674407958984375; float _2127 = _2112 - 0.4000000059604644775390625; float _2132 = fast::max(1.0 - abs(_2127 * 2.5), 0.0); float _2140 = (1.0 + (float(int(sign(_2127 * 5.0))) * (1.0 - (_2132 * _2132)))) * 0.02500000037252902984619140625; float _2153; if (_2126 <= 0.053333334624767303466796875) { _2153 = _2140; } else { float _2152; if (_2126 >= 0.1599999964237213134765625) { _2152 = 0.0; } else { _2152 = _2140 * ((0.23999999463558197021484375 / _2125) - 0.5); } _2153 = _2152; } float3 _2156 = _2100 * float3(1.0 + _2153); float _2157 = _2156.x; float _2158 = _2156.y; float _2160 = _2156.z; float _2174; if ((_2157 == _2158) && (_2158 == _2160)) { _2174 = 0.0; } else { _2174 = 57.2957763671875 * atan2(sqrt(3.0) * (_2158 - _2160), ((2.0 * _2157) - _2158) - _2160); } float _2179; if (_2174 < 0.0) { _2179 = _2174 + 360.0; } else { _2179 = _2174; } float _2180 = fast::clamp(_2179, 0.0, 360.0); float _2185; if (_2180 > 180.0) { _2185 = _2180 - 360.0; } else { _2185 = _2180; } float _2235; if ((_2185 > (-67.5)) && (_2185 < 67.5)) { float _2192 = (_2185 - (-67.5)) * 0.0296296291053295135498046875; int _2193 = int(_2192); float _2195 = _2192 - float(_2193); float _2196 = _2195 * _2195; float _2197 = _2196 * _2195; float _2234; if (_2193 == 3) { _2234 = (((_2197 * (-0.16666667163372039794921875)) + (_2196 * 0.5)) + (_2195 * (-0.5))) + 0.16666667163372039794921875; } else { float _2227; if (_2193 == 2) { _2227 = ((_2197 * 0.5) + (_2196 * (-1.0))) + 0.666666686534881591796875; } else { float _2222; if (_2193 == 1) { _2222 = (((_2197 * (-0.5)) + (_2196 * 0.5)) + (_2195 * 0.5)) + 0.16666667163372039794921875; } else { float _2215; if (_2193 == 0) { _2215 = _2197 * 0.16666667163372039794921875; } else { _2215 = 0.0; } _2222 = _2215; } _2227 = _2222; } _2234 = _2227; } _2235 = _2234; } else { _2235 = 0.0; } float3 _2242 = _2156; _2242.x = _2157 + ((((_2235 * 1.5) * _2112) * (0.02999999932944774627685546875 - _2157)) * 0.180000007152557373046875); float3 _2245 = fast::clamp(fast::clamp(_2242, float3(0.0), float3(65535.0)) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)), float3(0.0), float3(65535.0)); float3 _2248 = mix(float3(dot(_2245, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _2245, float3(0.959999978542327880859375)); float _2249 = _2248.x; float _2253 = 0.17999999225139617919921875 * exp2(18.0); float _2255 = exp2(-14.0); float _2258 = log((_2249 <= 0.0) ? _2255 : _2249) / _1065; float _2260 = log(0.17999999225139617919921875 * exp2(-15.0)) / _1065; float _2327; if (_2258 <= _2260) { _2327 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _2267 = log(0.180000007152557373046875) / _1065; float _2324; if ((_2258 > _2260) && (_2258 < _2267)) { float _2307 = (3.0 * (_2258 - _2260)) / (_2267 - _2260); int _2308 = int(_2307); float _2310 = _2307 - float(_2308); _2324 = dot(float3(_2310 * _2310, _2310, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_2308], _475[_2308 + 1], _475[_2308 + 2])); } else { float _2275 = log(_2253) / _1065; float _2303; if ((_2258 >= _2267) && (_2258 < _2275)) { float _2286 = (3.0 * (_2258 - _2267)) / (_2275 - _2267); int _2287 = int(_2286); float _2289 = _2286 - float(_2287); _2303 = dot(float3(_2289 * _2289, _2289, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_2287], _476[_2287 + 1], _476[_2287 + 2])); } else { _2303 = log(10000.0) / _1065; } _2324 = _2303; } _2327 = _2324; } float3 _2329 = _391; _2329.x = pow(10.0, _2327); float _2330 = _2248.y; float _2334 = log((_2330 <= 0.0) ? _2255 : _2330) / _1065; float _2401; if (_2334 <= _2260) { _2401 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _2341 = log(0.180000007152557373046875) / _1065; float _2398; if ((_2334 > _2260) && (_2334 < _2341)) { float _2381 = (3.0 * (_2334 - _2260)) / (_2341 - _2260); int _2382 = int(_2381); float _2384 = _2381 - float(_2382); _2398 = dot(float3(_2384 * _2384, _2384, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_2382], _475[_2382 + 1], _475[_2382 + 2])); } else { float _2349 = log(_2253) / _1065; float _2377; if ((_2334 >= _2341) && (_2334 < _2349)) { float _2360 = (3.0 * (_2334 - _2341)) / (_2349 - _2341); int _2361 = int(_2360); float _2363 = _2360 - float(_2361); _2377 = dot(float3(_2363 * _2363, _2363, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_2361], _476[_2361 + 1], _476[_2361 + 2])); } else { _2377 = log(10000.0) / _1065; } _2398 = _2377; } _2401 = _2398; } float3 _2403 = _2329; _2403.y = pow(10.0, _2401); float _2404 = _2248.z; float _2408 = log((_2404 <= 0.0) ? _2255 : _2404) / _1065; float _2475; if (_2408 <= _2260) { _2475 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _2415 = log(0.180000007152557373046875) / _1065; float _2472; if ((_2408 > _2260) && (_2408 < _2415)) { float _2455 = (3.0 * (_2408 - _2260)) / (_2415 - _2260); int _2456 = int(_2455); float _2458 = _2455 - float(_2456); _2472 = dot(float3(_2458 * _2458, _2458, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_2456], _475[_2456 + 1], _475[_2456 + 2])); } else { float _2423 = log(_2253) / _1065; float _2451; if ((_2408 >= _2415) && (_2408 < _2423)) { float _2434 = (3.0 * (_2408 - _2415)) / (_2423 - _2415); int _2435 = int(_2434); float _2437 = _2434 - float(_2435); _2451 = dot(float3(_2437 * _2437, _2437, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_2435], _476[_2435 + 1], _476[_2435 + 2])); } else { _2451 = log(10000.0) / _1065; } _2472 = _2451; } _2475 = _2472; } float3 _2477 = _2403; _2477.z = pow(10.0, _2475); float3 _2479 = (_2477 * float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625))) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)); float _2481 = 0.17999999225139617919921875 * pow(2.0, -12.0); float _2485 = log((_2481 <= 0.0) ? _2255 : _2481) / _1065; float _2552; if (_2485 <= _2260) { _2552 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _2492 = log(0.180000007152557373046875) / _1065; float _2549; if ((_2485 > _2260) && (_2485 < _2492)) { float _2532 = (3.0 * (_2485 - _2260)) / (_2492 - _2260); int _2533 = int(_2532); float _2535 = _2532 - float(_2533); _2549 = dot(float3(_2535 * _2535, _2535, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_2533], _475[_2533 + 1], _475[_2533 + 2])); } else { float _2500 = log(_2253) / _1065; float _2528; if ((_2485 >= _2492) && (_2485 < _2500)) { float _2511 = (3.0 * (_2485 - _2492)) / (_2500 - _2492); int _2512 = int(_2511); float _2514 = _2511 - float(_2512); _2528 = dot(float3(_2514 * _2514, _2514, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_2512], _476[_2512 + 1], _476[_2512 + 2])); } else { _2528 = log(10000.0) / _1065; } _2549 = _2528; } _2552 = _2549; } float _2555 = log(0.180000007152557373046875) / _1065; float _2611; if (_2555 <= _2260) { _2611 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _2608; if ((_2555 > _2260) && (_2555 < _2555)) { _2608 = (float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[3], _475[4], _475[5])).z; } else { float _2568 = log(_2253) / _1065; float _2596; if ((_2555 >= _2555) && (_2555 < _2568)) { float _2579 = (3.0 * (_2555 - _2555)) / (_2568 - _2555); int _2580 = int(_2579); float _2582 = _2579 - float(_2580); _2596 = dot(float3(_2582 * _2582, _2582, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_2580], _476[_2580 + 1], _476[_2580 + 2])); } else { _2596 = log(10000.0) / _1065; } _2608 = _2596; } _2611 = _2608; } float _2612 = pow(10.0, _2611); float _2614 = 0.17999999225139617919921875 * pow(2.0, 10.0); float _2618 = log((_2614 <= 0.0) ? _2255 : _2614) / _1065; float _2683; if (_2618 <= _2260) { _2683 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _2680; if ((_2618 > _2260) && (_2618 < _2555)) { float _2663 = (3.0 * (_2618 - _2260)) / (_2555 - _2260); int _2664 = int(_2663); float _2666 = _2663 - float(_2664); _2680 = dot(float3(_2666 * _2666, _2666, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_2664], _475[_2664 + 1], _475[_2664 + 2])); } else { float _2631 = log(_2253) / _1065; float _2659; if ((_2618 >= _2555) && (_2618 < _2631)) { float _2642 = (3.0 * (_2618 - _2555)) / (_2631 - _2555); int _2643 = int(_2642); float _2645 = _2642 - float(_2643); _2659 = dot(float3(_2645 * _2645, _2645, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_2643], _476[_2643 + 1], _476[_2643 + 2])); } else { _2659 = log(10000.0) / _1065; } _2680 = _2659; } _2683 = _2680; } float _2684 = pow(10.0, _2683); float _2685 = _2479.x; float _2689 = log((_2685 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2685) / _1065; float _2690 = log(pow(10.0, _2552)); float _2691 = _2690 / _1065; float _2768; if (_2689 <= _2691) { _2768 = (_2689 * 3.0) + ((log(9.9999997473787516355514526367188e-05) / _1065) - ((3.0 * _2690) / _1065)); } else { float _2698 = log(_2612) / _1065; float _2760; if ((_2689 > _2691) && (_2689 < _2698)) { float _2743 = (7.0 * (_2689 - _2691)) / (_2698 - _2691); int _2744 = int(_2743); float _2746 = _2743 - float(_2744); _2760 = dot(float3(_2746 * _2746, _2746, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_479[_2744], _479[_2744 + 1], _479[_2744 + 2])); } else { float _2705 = log(_2684); float _2706 = _2705 / _1065; float _2739; if ((_2689 >= _2698) && (_2689 < _2706)) { float _2722 = (7.0 * (_2689 - _2698)) / (_2706 - _2698); int _2723 = int(_2722); float _2725 = _2722 - float(_2723); _2739 = dot(float3(_2725 * _2725, _2725, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_480[_2723], _480[_2723 + 1], _480[_2723 + 2])); } else { _2739 = (_2689 * 0.0599999986588954925537109375) + ((log(1000.0) / _1065) - ((0.0599999986588954925537109375 * _2705) / _1065)); } _2760 = _2739; } _2768 = _2760; } float3 _2770 = _391; _2770.x = pow(10.0, _2768); float _2771 = _2479.y; float _2775 = log((_2771 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2771) / _1065; float _2852; if (_2775 <= _2691) { _2852 = (_2775 * 3.0) + ((log(9.9999997473787516355514526367188e-05) / _1065) - ((3.0 * _2690) / _1065)); } else { float _2782 = log(_2612) / _1065; float _2844; if ((_2775 > _2691) && (_2775 < _2782)) { float _2827 = (7.0 * (_2775 - _2691)) / (_2782 - _2691); int _2828 = int(_2827); float _2830 = _2827 - float(_2828); _2844 = dot(float3(_2830 * _2830, _2830, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_479[_2828], _479[_2828 + 1], _479[_2828 + 2])); } else { float _2789 = log(_2684); float _2790 = _2789 / _1065; float _2823; if ((_2775 >= _2782) && (_2775 < _2790)) { float _2806 = (7.0 * (_2775 - _2782)) / (_2790 - _2782); int _2807 = int(_2806); float _2809 = _2806 - float(_2807); _2823 = dot(float3(_2809 * _2809, _2809, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_480[_2807], _480[_2807 + 1], _480[_2807 + 2])); } else { _2823 = (_2775 * 0.0599999986588954925537109375) + ((log(1000.0) / _1065) - ((0.0599999986588954925537109375 * _2789) / _1065)); } _2844 = _2823; } _2852 = _2844; } float3 _2854 = _2770; _2854.y = pow(10.0, _2852); float _2855 = _2479.z; float _2859 = log((_2855 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2855) / _1065; float _2936; if (_2859 <= _2691) { _2936 = (_2859 * 3.0) + ((log(9.9999997473787516355514526367188e-05) / _1065) - ((3.0 * _2690) / _1065)); } else { float _2866 = log(_2612) / _1065; float _2928; if ((_2859 > _2691) && (_2859 < _2866)) { float _2911 = (7.0 * (_2859 - _2691)) / (_2866 - _2691); int _2912 = int(_2911); float _2914 = _2911 - float(_2912); _2928 = dot(float3(_2914 * _2914, _2914, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_479[_2912], _479[_2912 + 1], _479[_2912 + 2])); } else { float _2873 = log(_2684); float _2874 = _2873 / _1065; float _2907; if ((_2859 >= _2866) && (_2859 < _2874)) { float _2890 = (7.0 * (_2859 - _2866)) / (_2874 - _2866); int _2891 = int(_2890); float _2893 = _2890 - float(_2891); _2907 = dot(float3(_2893 * _2893, _2893, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_480[_2891], _480[_2891 + 1], _480[_2891 + 2])); } else { _2907 = (_2859 * 0.0599999986588954925537109375) + ((log(1000.0) / _1065) - ((0.0599999986588954925537109375 * _2873) / _1065)); } _2928 = _2907; } _2936 = _2928; } float3 _2938 = _2854; _2938.z = pow(10.0, _2936); float3 _2942 = pow(((_2938 - float3(3.5073844628641381859779357910156e-05)) * _576) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _2950 = pow((float3(0.8359375) + (float3(18.8515625) * _2942)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _2942))), float3(78.84375)); } else { float3 _2097; if ((_Globals.OutputDevice == 4u) || (_Globals.OutputDevice == 6u)) { float3 _1263 = (_906 * float3(1.5)) * (_546 * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625))); float _1264 = _1263.x; float _1265 = _1263.y; float _1267 = _1263.z; float _1270 = fast::max(fast::max(_1264, _1265), _1267); float _1275 = (fast::max(_1270, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_1264, _1265), _1267), 1.0000000133514319600180897396058e-10)) / fast::max(_1270, 0.00999999977648258209228515625); float _1288 = ((_1267 + _1265) + _1264) + (1.75 * sqrt(((_1267 * (_1267 - _1265)) + (_1265 * (_1265 - _1264))) + (_1264 * (_1264 - _1267)))); float _1289 = _1288 * 0.3333333432674407958984375; float _1290 = _1275 - 0.4000000059604644775390625; float _1295 = fast::max(1.0 - abs(_1290 * 2.5), 0.0); float _1303 = (1.0 + (float(int(sign(_1290 * 5.0))) * (1.0 - (_1295 * _1295)))) * 0.02500000037252902984619140625; float _1316; if (_1289 <= 0.053333334624767303466796875) { _1316 = _1303; } else { float _1315; if (_1289 >= 0.1599999964237213134765625) { _1315 = 0.0; } else { _1315 = _1303 * ((0.23999999463558197021484375 / _1288) - 0.5); } _1316 = _1315; } float3 _1319 = _1263 * float3(1.0 + _1316); float _1320 = _1319.x; float _1321 = _1319.y; float _1323 = _1319.z; float _1337; if ((_1320 == _1321) && (_1321 == _1323)) { _1337 = 0.0; } else { _1337 = 57.2957763671875 * atan2(sqrt(3.0) * (_1321 - _1323), ((2.0 * _1320) - _1321) - _1323); } float _1342; if (_1337 < 0.0) { _1342 = _1337 + 360.0; } else { _1342 = _1337; } float _1343 = fast::clamp(_1342, 0.0, 360.0); float _1348; if (_1343 > 180.0) { _1348 = _1343 - 360.0; } else { _1348 = _1343; } float _1398; if ((_1348 > (-67.5)) && (_1348 < 67.5)) { float _1355 = (_1348 - (-67.5)) * 0.0296296291053295135498046875; int _1356 = int(_1355); float _1358 = _1355 - float(_1356); float _1359 = _1358 * _1358; float _1360 = _1359 * _1358; float _1397; if (_1356 == 3) { _1397 = (((_1360 * (-0.16666667163372039794921875)) + (_1359 * 0.5)) + (_1358 * (-0.5))) + 0.16666667163372039794921875; } else { float _1390; if (_1356 == 2) { _1390 = ((_1360 * 0.5) + (_1359 * (-1.0))) + 0.666666686534881591796875; } else { float _1385; if (_1356 == 1) { _1385 = (((_1360 * (-0.5)) + (_1359 * 0.5)) + (_1358 * 0.5)) + 0.16666667163372039794921875; } else { float _1378; if (_1356 == 0) { _1378 = _1360 * 0.16666667163372039794921875; } else { _1378 = 0.0; } _1385 = _1378; } _1390 = _1385; } _1397 = _1390; } _1398 = _1397; } else { _1398 = 0.0; } float3 _1405 = _1319; _1405.x = _1320 + ((((_1398 * 1.5) * _1275) * (0.02999999932944774627685546875 - _1320)) * 0.180000007152557373046875); float3 _1408 = fast::clamp(fast::clamp(_1405, float3(0.0), float3(65535.0)) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)), float3(0.0), float3(65535.0)); float3 _1411 = mix(float3(dot(_1408, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1408, float3(0.959999978542327880859375)); float _1412 = _1411.x; float _1416 = 0.17999999225139617919921875 * exp2(18.0); float _1418 = exp2(-14.0); float _1421 = log((_1412 <= 0.0) ? _1418 : _1412) / _1065; float _1423 = log(0.17999999225139617919921875 * exp2(-15.0)) / _1065; float _1490; if (_1421 <= _1423) { _1490 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _1430 = log(0.180000007152557373046875) / _1065; float _1487; if ((_1421 > _1423) && (_1421 < _1430)) { float _1470 = (3.0 * (_1421 - _1423)) / (_1430 - _1423); int _1471 = int(_1470); float _1473 = _1470 - float(_1471); _1487 = dot(float3(_1473 * _1473, _1473, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_1471], _475[_1471 + 1], _475[_1471 + 2])); } else { float _1438 = log(_1416) / _1065; float _1466; if ((_1421 >= _1430) && (_1421 < _1438)) { float _1449 = (3.0 * (_1421 - _1430)) / (_1438 - _1430); int _1450 = int(_1449); float _1452 = _1449 - float(_1450); _1466 = dot(float3(_1452 * _1452, _1452, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_1450], _476[_1450 + 1], _476[_1450 + 2])); } else { _1466 = log(10000.0) / _1065; } _1487 = _1466; } _1490 = _1487; } float3 _1492 = _391; _1492.x = pow(10.0, _1490); float _1493 = _1411.y; float _1497 = log((_1493 <= 0.0) ? _1418 : _1493) / _1065; float _1564; if (_1497 <= _1423) { _1564 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _1504 = log(0.180000007152557373046875) / _1065; float _1561; if ((_1497 > _1423) && (_1497 < _1504)) { float _1544 = (3.0 * (_1497 - _1423)) / (_1504 - _1423); int _1545 = int(_1544); float _1547 = _1544 - float(_1545); _1561 = dot(float3(_1547 * _1547, _1547, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_1545], _475[_1545 + 1], _475[_1545 + 2])); } else { float _1512 = log(_1416) / _1065; float _1540; if ((_1497 >= _1504) && (_1497 < _1512)) { float _1523 = (3.0 * (_1497 - _1504)) / (_1512 - _1504); int _1524 = int(_1523); float _1526 = _1523 - float(_1524); _1540 = dot(float3(_1526 * _1526, _1526, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_1524], _476[_1524 + 1], _476[_1524 + 2])); } else { _1540 = log(10000.0) / _1065; } _1561 = _1540; } _1564 = _1561; } float3 _1566 = _1492; _1566.y = pow(10.0, _1564); float _1567 = _1411.z; float _1571 = log((_1567 <= 0.0) ? _1418 : _1567) / _1065; float _1638; if (_1571 <= _1423) { _1638 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _1578 = log(0.180000007152557373046875) / _1065; float _1635; if ((_1571 > _1423) && (_1571 < _1578)) { float _1618 = (3.0 * (_1571 - _1423)) / (_1578 - _1423); int _1619 = int(_1618); float _1621 = _1618 - float(_1619); _1635 = dot(float3(_1621 * _1621, _1621, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_1619], _475[_1619 + 1], _475[_1619 + 2])); } else { float _1586 = log(_1416) / _1065; float _1614; if ((_1571 >= _1578) && (_1571 < _1586)) { float _1597 = (3.0 * (_1571 - _1578)) / (_1586 - _1578); int _1598 = int(_1597); float _1600 = _1597 - float(_1598); _1614 = dot(float3(_1600 * _1600, _1600, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_1598], _476[_1598 + 1], _476[_1598 + 2])); } else { _1614 = log(10000.0) / _1065; } _1635 = _1614; } _1638 = _1635; } float3 _1640 = _1566; _1640.z = pow(10.0, _1638); float3 _1642 = (_1640 * float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625))) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)); float _1644 = 0.17999999225139617919921875 * pow(2.0, -12.0); float _1648 = log((_1644 <= 0.0) ? _1418 : _1644) / _1065; float _1715; if (_1648 <= _1423) { _1715 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _1655 = log(0.180000007152557373046875) / _1065; float _1712; if ((_1648 > _1423) && (_1648 < _1655)) { float _1695 = (3.0 * (_1648 - _1423)) / (_1655 - _1423); int _1696 = int(_1695); float _1698 = _1695 - float(_1696); _1712 = dot(float3(_1698 * _1698, _1698, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_1696], _475[_1696 + 1], _475[_1696 + 2])); } else { float _1663 = log(_1416) / _1065; float _1691; if ((_1648 >= _1655) && (_1648 < _1663)) { float _1674 = (3.0 * (_1648 - _1655)) / (_1663 - _1655); int _1675 = int(_1674); float _1677 = _1674 - float(_1675); _1691 = dot(float3(_1677 * _1677, _1677, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_1675], _476[_1675 + 1], _476[_1675 + 2])); } else { _1691 = log(10000.0) / _1065; } _1712 = _1691; } _1715 = _1712; } float _1718 = log(0.180000007152557373046875) / _1065; float _1774; if (_1718 <= _1423) { _1774 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _1771; if ((_1718 > _1423) && (_1718 < _1718)) { _1771 = (float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[3], _475[4], _475[5])).z; } else { float _1731 = log(_1416) / _1065; float _1759; if ((_1718 >= _1718) && (_1718 < _1731)) { float _1742 = (3.0 * (_1718 - _1718)) / (_1731 - _1718); int _1743 = int(_1742); float _1745 = _1742 - float(_1743); _1759 = dot(float3(_1745 * _1745, _1745, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_1743], _476[_1743 + 1], _476[_1743 + 2])); } else { _1759 = log(10000.0) / _1065; } _1771 = _1759; } _1774 = _1771; } float _1775 = pow(10.0, _1774); float _1777 = 0.17999999225139617919921875 * pow(2.0, 11.0); float _1781 = log((_1777 <= 0.0) ? _1418 : _1777) / _1065; float _1846; if (_1781 <= _1423) { _1846 = log(9.9999997473787516355514526367188e-05) / _1065; } else { float _1843; if ((_1781 > _1423) && (_1781 < _1718)) { float _1826 = (3.0 * (_1781 - _1423)) / (_1718 - _1423); int _1827 = int(_1826); float _1829 = _1826 - float(_1827); _1843 = dot(float3(_1829 * _1829, _1829, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_475[_1827], _475[_1827 + 1], _475[_1827 + 2])); } else { float _1794 = log(_1416) / _1065; float _1822; if ((_1781 >= _1718) && (_1781 < _1794)) { float _1805 = (3.0 * (_1781 - _1718)) / (_1794 - _1718); int _1806 = int(_1805); float _1808 = _1805 - float(_1806); _1822 = dot(float3(_1808 * _1808, _1808, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_476[_1806], _476[_1806 + 1], _476[_1806 + 2])); } else { _1822 = log(10000.0) / _1065; } _1843 = _1822; } _1846 = _1843; } float _1847 = pow(10.0, _1846); float _1848 = _1642.x; float _1852 = log((_1848 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _1848) / _1065; float _1854 = log(pow(10.0, _1715)) / _1065; float _1926; if (_1852 <= _1854) { _1926 = log(0.004999999888241291046142578125) / _1065; } else { float _1861 = log(_1775) / _1065; float _1923; if ((_1852 > _1854) && (_1852 < _1861)) { float _1906 = (7.0 * (_1852 - _1854)) / (_1861 - _1854); int _1907 = int(_1906); float _1909 = _1906 - float(_1907); _1923 = dot(float3(_1909 * _1909, _1909, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_482[_1907], _482[_1907 + 1], _482[_1907 + 2])); } else { float _1868 = log(_1847); float _1869 = _1868 / _1065; float _1902; if ((_1852 >= _1861) && (_1852 < _1869)) { float _1885 = (7.0 * (_1852 - _1861)) / (_1869 - _1861); int _1886 = int(_1885); float _1888 = _1885 - float(_1886); _1902 = dot(float3(_1888 * _1888, _1888, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_483[_1886], _483[_1886 + 1], _483[_1886 + 2])); } else { _1902 = (_1852 * 0.119999997317790985107421875) + ((log(2000.0) / _1065) - ((0.119999997317790985107421875 * _1868) / _1065)); } _1923 = _1902; } _1926 = _1923; } float3 _1928 = _391; _1928.x = pow(10.0, _1926); float _1929 = _1642.y; float _1933 = log((_1929 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _1929) / _1065; float _2005; if (_1933 <= _1854) { _2005 = log(0.004999999888241291046142578125) / _1065; } else { float _1940 = log(_1775) / _1065; float _2002; if ((_1933 > _1854) && (_1933 < _1940)) { float _1985 = (7.0 * (_1933 - _1854)) / (_1940 - _1854); int _1986 = int(_1985); float _1988 = _1985 - float(_1986); _2002 = dot(float3(_1988 * _1988, _1988, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_482[_1986], _482[_1986 + 1], _482[_1986 + 2])); } else { float _1947 = log(_1847); float _1948 = _1947 / _1065; float _1981; if ((_1933 >= _1940) && (_1933 < _1948)) { float _1964 = (7.0 * (_1933 - _1940)) / (_1948 - _1940); int _1965 = int(_1964); float _1967 = _1964 - float(_1965); _1981 = dot(float3(_1967 * _1967, _1967, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_483[_1965], _483[_1965 + 1], _483[_1965 + 2])); } else { _1981 = (_1933 * 0.119999997317790985107421875) + ((log(2000.0) / _1065) - ((0.119999997317790985107421875 * _1947) / _1065)); } _2002 = _1981; } _2005 = _2002; } float3 _2007 = _1928; _2007.y = pow(10.0, _2005); float _2008 = _1642.z; float _2012 = log((_2008 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2008) / _1065; float _2084; if (_2012 <= _1854) { _2084 = log(0.004999999888241291046142578125) / _1065; } else { float _2019 = log(_1775) / _1065; float _2081; if ((_2012 > _1854) && (_2012 < _2019)) { float _2064 = (7.0 * (_2012 - _1854)) / (_2019 - _1854); int _2065 = int(_2064); float _2067 = _2064 - float(_2065); _2081 = dot(float3(_2067 * _2067, _2067, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_482[_2065], _482[_2065 + 1], _482[_2065 + 2])); } else { float _2026 = log(_1847); float _2027 = _2026 / _1065; float _2060; if ((_2012 >= _2019) && (_2012 < _2027)) { float _2043 = (7.0 * (_2012 - _2019)) / (_2027 - _2019); int _2044 = int(_2043); float _2046 = _2043 - float(_2044); _2060 = dot(float3(_2046 * _2046, _2046, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_483[_2044], _483[_2044 + 1], _483[_2044 + 2])); } else { _2060 = (_2012 * 0.119999997317790985107421875) + ((log(2000.0) / _1065) - ((0.119999997317790985107421875 * _2026) / _1065)); } _2081 = _2060; } _2084 = _2081; } float3 _2086 = _2007; _2086.z = pow(10.0, _2084); float3 _2089 = pow((_2086 * _576) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _2097 = pow((float3(0.8359375) + (float3(18.8515625) * _2089)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _2089))), float3(78.84375)); } else { float3 _1260; if (_Globals.OutputDevice == 7u) { float3 _1252 = pow(((_906 * _547) * _576) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _1260 = pow((float3(0.8359375) + (float3(18.8515625) * _1252)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _1252))), float3(78.84375)); } else { _1260 = pow((_1218 * _547) * _576, float3(_Globals.InverseGamma.z)); } _2097 = _1260; } _2950 = _2097; } _2960 = _2950; } _3001 = _2960; } float3 _3002 = _3001 * float3(0.95238101482391357421875); float4 _3004 = float4(_3002.x, _3002.y, _3002.z, float4(0.0).w); _3004.w = 0.0; out.out_var_SV_Target0 = _3004; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag/padded-float-array-member-defef.asm.frag000066400000000000000000002346701400026215700315630ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_Globals { float4 MappingPolynomial; float3 InverseGamma; float4 ColorMatrixR_ColorCurveCd1; float4 ColorMatrixG_ColorCurveCd3Cm3; float4 ColorMatrixB_ColorCurveCm2; float4 ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3; float4 ColorCurve_Ch1_Ch2; float4 ColorShadow_Luma; float4 ColorShadow_Tint1; float4 ColorShadow_Tint2; float FilmSlope; float FilmToe; float FilmShoulder; float FilmBlackClip; float FilmWhiteClip; float4 LUTWeights[5]; float3 ColorScale; float4 OverlayColor; float WhiteTemp; float WhiteTint; float4 ColorSaturation; float4 ColorContrast; float4 ColorGamma; float4 ColorGain; float4 ColorOffset; float4 ColorSaturationShadows; float4 ColorContrastShadows; float4 ColorGammaShadows; float4 ColorGainShadows; float4 ColorOffsetShadows; float4 ColorSaturationMidtones; float4 ColorContrastMidtones; float4 ColorGammaMidtones; float4 ColorGainMidtones; float4 ColorOffsetMidtones; float4 ColorSaturationHighlights; float4 ColorContrastHighlights; float4 ColorGammaHighlights; float4 ColorGainHighlights; float4 ColorOffsetHighlights; float ColorCorrectionShadowsMax; float ColorCorrectionHighlightsMin; uint OutputDevice; uint OutputGamut; float BlueCorrection; float ExpandGamut; }; constant spvUnsafeArray _499 = spvUnsafeArray({ -4.0, -4.0, -3.1573765277862548828125, -0.485249996185302734375, 1.84773242473602294921875, 1.84773242473602294921875 }); constant spvUnsafeArray _500 = spvUnsafeArray({ -0.718548238277435302734375, 2.0810306072235107421875, 3.66812419891357421875, 4.0, 4.0, 4.0 }); constant spvUnsafeArray _503 = spvUnsafeArray({ -4.97062206268310546875, -3.0293781757354736328125, -2.1261999607086181640625, -1.5104999542236328125, -1.0578000545501708984375, -0.4668000042438507080078125, 0.11937999725341796875, 0.7088134288787841796875, 1.2911865711212158203125, 1.2911865711212158203125 }); constant spvUnsafeArray _504 = spvUnsafeArray({ 0.80891323089599609375, 1.19108676910400390625, 1.5683000087738037109375, 1.94830000400543212890625, 2.308300018310546875, 2.63840007781982421875, 2.85949993133544921875, 2.9872608184814453125, 3.0127391815185546875, 3.0127391815185546875 }); constant spvUnsafeArray _506 = spvUnsafeArray({ -2.3010299205780029296875, -2.3010299205780029296875, -1.9312000274658203125, -1.5204999446868896484375, -1.0578000545501708984375, -0.4668000042438507080078125, 0.11937999725341796875, 0.7088134288787841796875, 1.2911865711212158203125, 1.2911865711212158203125 }); constant spvUnsafeArray _507 = spvUnsafeArray({ 0.801995217800140380859375, 1.19800484180450439453125, 1.5943000316619873046875, 1.99730002880096435546875, 2.3782999515533447265625, 2.7683999538421630859375, 3.0515000820159912109375, 3.2746293544769287109375, 3.32743072509765625, 3.32743072509765625 }); constant float3 _523 = {}; constant float3 _525 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { float2 in_var_TEXCOORD0 [[user(locn0), center_no_perspective]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant type_Globals& _Globals [[buffer(0)]], texture2d Texture1 [[texture(0)]], sampler Texture1Sampler [[sampler(0)]], uint gl_Layer [[render_target_array_index]]) { main0_out out = {}; float3x3 _572 = float3x3(float3(0.41245639324188232421875, 0.3575761020183563232421875, 0.180437505245208740234375), float3(0.21267290413379669189453125, 0.715152204036712646484375, 0.072175003588199615478515625), float3(0.01933390088379383087158203125, 0.119191996753215789794921875, 0.950304090976715087890625)) * float3x3(float3(1.01303005218505859375, 0.0061053098179399967193603515625, -0.014971000142395496368408203125), float3(0.0076982299797236919403076171875, 0.99816501140594482421875, -0.005032029934227466583251953125), float3(-0.0028413101099431514739990234375, 0.0046851597726345062255859375, 0.92450702190399169921875)); float3x3 _573 = _572 * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)); float3x3 _574 = float3x3(float3(0.662454187870025634765625, 0.1340042054653167724609375, 0.1561876833438873291015625), float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625), float3(-0.0055746496655046939849853515625, 0.0040607335977256298065185546875, 1.01033914089202880859375)) * float3x3(float3(0.98722398281097412109375, -0.0061132698319852352142333984375, 0.01595330052077770233154296875), float3(-0.007598360069096088409423828125, 1.00186002254486083984375, 0.0053300200961530208587646484375), float3(0.003072570078074932098388671875, -0.0050959498621523380279541015625, 1.0816800594329833984375)); float3x3 _575 = _574 * float3x3(float3(3.2409698963165283203125, -1.53738319873809814453125, -0.4986107647418975830078125), float3(-0.96924364566802978515625, 1.875967502593994140625, 0.0415550582110881805419921875), float3(0.055630080401897430419921875, -0.2039769589900970458984375, 1.05697154998779296875)); float3x3 _576 = float3x3(float3(0.952552378177642822265625, 0.0, 9.25), float3(0.3439664542675018310546875, 0.728166103363037109375, -0.07213254272937774658203125), float3(0.0, 0.0, 1.00882518291473388671875)) * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)); float3x3 _577 = float3x3(float3(0.662454187870025634765625, 0.1340042054653167724609375, 0.1561876833438873291015625), float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625), float3(-0.0055746496655046939849853515625, 0.0040607335977256298065185546875, 1.01033914089202880859375)) * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625)); float3x3 _602; for (;;) { if (_Globals.OutputGamut == 1u) { _602 = _574 * float3x3(float3(2.493396282196044921875, -0.931345880031585693359375, -0.4026944935321807861328125), float3(-0.829486787319183349609375, 1.76265966892242431640625, 0.02362460084259510040283203125), float3(0.0358506999909877777099609375, -0.076182700693607330322265625, 0.957014024257659912109375)); break; } else { if (_Globals.OutputGamut == 2u) { _602 = _574 * float3x3(float3(1.71660840511322021484375, -0.3556621074676513671875, -0.253360092639923095703125), float3(-0.666682898998260498046875, 1.61647760868072509765625, 0.01576850004494190216064453125), float3(0.017642199993133544921875, -0.04277630150318145751953125, 0.94222867488861083984375)); break; } else { if (_Globals.OutputGamut == 3u) { _602 = float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625)); break; } else { if (_Globals.OutputGamut == 4u) { _602 = float3x3(float3(1.0, 0.0, 0.0), float3(0.0, 1.0, 0.0), float3(0.0, 0.0, 1.0)); break; } else { _602 = _575; break; } } } } } float3 _603 = float4((in.in_var_TEXCOORD0 - float2(0.015625)) * float2(1.03225803375244140625), float(gl_Layer) * 0.0322580635547637939453125, 0.0).xyz; float3 _625; if (_Globals.OutputDevice >= 3u) { float3 _617 = pow(_603, float3(0.0126833133399486541748046875)); _625 = pow(fast::max(float3(0.0), _617 - float3(0.8359375)) / (float3(18.8515625) - (float3(18.6875) * _617)), float3(6.277394771575927734375)) * float3(10000.0); } else { _625 = (exp2((_603 - float3(0.434017598628997802734375)) * float3(14.0)) * float3(0.180000007152557373046875)) - (exp2(float3(-6.0762462615966796875)) * float3(0.180000007152557373046875)); } float _628 = _Globals.WhiteTemp * 1.00055634975433349609375; float _642 = (_628 <= 7000.0) ? (0.24406300485134124755859375 + ((99.1100006103515625 + ((2967800.0 - (4604438528.0 / _Globals.WhiteTemp)) / _628)) / _628)) : (0.23703999817371368408203125 + ((247.4799957275390625 + ((1901800.0 - (2005284352.0 / _Globals.WhiteTemp)) / _628)) / _628)); float _659 = ((0.860117733478546142578125 + (0.00015411825734190642833709716796875 * _Globals.WhiteTemp)) + ((1.2864121856637211749330163002014e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)) / ((1.0 + (0.0008424202096648514270782470703125 * _Globals.WhiteTemp)) + ((7.0814513719597016461193561553955e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)); float _670 = ((0.317398726940155029296875 + (4.25 * _Globals.WhiteTemp)) + ((4.2048167614439080352894961833954e-08 * _Globals.WhiteTemp) * _Globals.WhiteTemp)) / ((1.0 - (2.8974181986995972692966461181641e-05 * _Globals.WhiteTemp)) + ((1.6145605741257895715534687042236e-07 * _Globals.WhiteTemp) * _Globals.WhiteTemp)); float _675 = ((2.0 * _659) - (8.0 * _670)) + 4.0; float2 _679 = float2((3.0 * _659) / _675, (2.0 * _670) / _675); float2 _686 = normalize(float2(_659, _670)); float _691 = _659 + (((-_686.y) * _Globals.WhiteTint) * 0.0500000007450580596923828125); float _695 = _670 + ((_686.x * _Globals.WhiteTint) * 0.0500000007450580596923828125); float _700 = ((2.0 * _691) - (8.0 * _695)) + 4.0; float2 _706 = select(float2(_642, ((((-3.0) * _642) * _642) + (2.86999988555908203125 * _642)) - 0.2750000059604644775390625), _679, bool2(_Globals.WhiteTemp < 4000.0)) + (float2((3.0 * _691) / _700, (2.0 * _695) / _700) - _679); float _707 = _706.x; float _708 = _706.y; float _709 = fast::max(_708, 1.0000000133514319600180897396058e-10); float3 _711 = _523; _711.x = _707 / _709; float3 _712 = _711; _712.y = 1.0; float3 _716 = _712; _716.z = ((1.0 - _707) - _708) / _709; float _717 = fast::max(0.328999996185302734375, 1.0000000133514319600180897396058e-10); float3 _719 = _523; _719.x = 0.3127000033855438232421875 / _717; float3 _720 = _719; _720.y = 1.0; float3 _722 = _720; _722.z = 0.3582999706268310546875 / _717; float3 _723 = _716 * float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)); float3 _724 = _722 * float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)); float3 _743 = (_625 * ((float3x3(float3(0.41245639324188232421875, 0.3575761020183563232421875, 0.180437505245208740234375), float3(0.21267290413379669189453125, 0.715152204036712646484375, 0.072175003588199615478515625), float3(0.01933390088379383087158203125, 0.119191996753215789794921875, 0.950304090976715087890625)) * ((float3x3(float3(0.89509999752044677734375, 0.2664000093936920166015625, -0.16140000522136688232421875), float3(-0.750199973583221435546875, 1.71350002288818359375, 0.0366999991238117218017578125), float3(0.0388999991118907928466796875, -0.06849999725818634033203125, 1.02960002422332763671875)) * float3x3(float3(_724.x / _723.x, 0.0, 0.0), float3(0.0, _724.y / _723.y, 0.0), float3(0.0, 0.0, _724.z / _723.z))) * float3x3(float3(0.986992895603179931640625, -0.14705429971218109130859375, 0.15996269881725311279296875), float3(0.4323053061962127685546875, 0.518360316753387451171875, 0.049291200935840606689453125), float3(-0.00852870009839534759521484375, 0.0400427989661693572998046875, 0.968486726284027099609375)))) * float3x3(float3(3.2409698963165283203125, -1.53738319873809814453125, -0.4986107647418975830078125), float3(-0.96924364566802978515625, 1.875967502593994140625, 0.0415550582110881805419921875), float3(0.055630080401897430419921875, -0.2039769589900970458984375, 1.05697154998779296875)))) * _573; float3 _771; if (_Globals.ColorShadow_Tint2.w != 0.0) { float _750 = dot(_743, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625)); float3 _753 = (_743 / float3(_750)) - float3(1.0); _771 = mix(_743, _743 * (_575 * (float3x3(float3(0.544169127941131591796875, 0.23959259688854217529296875, 0.16669429838657379150390625), float3(0.23946559429168701171875, 0.702153027057647705078125, 0.058381401002407073974609375), float3(-0.0023439000360667705535888671875, 0.0361833982169628143310546875, 1.05521833896636962890625)) * float3x3(float3(1.6410233974456787109375, -0.324803292751312255859375, -0.23642469942569732666015625), float3(-0.663662850856781005859375, 1.6153316497802734375, 0.016756348311901092529296875), float3(0.01172189414501190185546875, -0.008284442126750946044921875, 0.98839485645294189453125)))), float3((1.0 - exp2((-4.0) * dot(_753, _753))) * (1.0 - exp2((((-4.0) * _Globals.ExpandGamut) * _750) * _750)))); } else { _771 = _743; } float _772 = dot(_771, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625)); float4 _777 = _Globals.ColorSaturationShadows * _Globals.ColorSaturation; float4 _782 = _Globals.ColorContrastShadows * _Globals.ColorContrast; float4 _787 = _Globals.ColorGammaShadows * _Globals.ColorGamma; float4 _792 = _Globals.ColorGainShadows * _Globals.ColorGain; float4 _797 = _Globals.ColorOffsetShadows + _Globals.ColorOffset; float3 _798 = float3(_772); float _830 = smoothstep(0.0, _Globals.ColorCorrectionShadowsMax, _772); float4 _834 = _Globals.ColorSaturationHighlights * _Globals.ColorSaturation; float4 _837 = _Globals.ColorContrastHighlights * _Globals.ColorContrast; float4 _840 = _Globals.ColorGammaHighlights * _Globals.ColorGamma; float4 _843 = _Globals.ColorGainHighlights * _Globals.ColorGain; float4 _846 = _Globals.ColorOffsetHighlights + _Globals.ColorOffset; float _878 = smoothstep(_Globals.ColorCorrectionHighlightsMin, 1.0, _772); float4 _881 = _Globals.ColorSaturationMidtones * _Globals.ColorSaturation; float4 _884 = _Globals.ColorContrastMidtones * _Globals.ColorContrast; float4 _887 = _Globals.ColorGammaMidtones * _Globals.ColorGamma; float4 _890 = _Globals.ColorGainMidtones * _Globals.ColorGain; float4 _893 = _Globals.ColorOffsetMidtones + _Globals.ColorOffset; float3 _931 = ((((pow(pow(fast::max(float3(0.0), mix(_798, _771, _777.xyz * float3(_777.w))) * float3(5.5555553436279296875), _782.xyz * float3(_782.w)) * float3(0.180000007152557373046875), float3(1.0) / (_787.xyz * float3(_787.w))) * (_792.xyz * float3(_792.w))) + (_797.xyz + float3(_797.w))) * float3(1.0 - _830)) + (((pow(pow(fast::max(float3(0.0), mix(_798, _771, _881.xyz * float3(_881.w))) * float3(5.5555553436279296875), _884.xyz * float3(_884.w)) * float3(0.180000007152557373046875), float3(1.0) / (_887.xyz * float3(_887.w))) * (_890.xyz * float3(_890.w))) + (_893.xyz + float3(_893.w))) * float3(_830 - _878))) + (((pow(pow(fast::max(float3(0.0), mix(_798, _771, _834.xyz * float3(_834.w))) * float3(5.5555553436279296875), _837.xyz * float3(_837.w)) * float3(0.180000007152557373046875), float3(1.0) / (_840.xyz * float3(_840.w))) * (_843.xyz * float3(_843.w))) + (_846.xyz + float3(_846.w))) * float3(_878)); float3 _932 = _931 * _575; float3 _940 = float3(_Globals.BlueCorrection); float3 _942 = mix(_931, _931 * ((_577 * float3x3(float3(0.940437257289886474609375, -0.01830687932670116424560546875, 0.07786960899829864501953125), float3(0.008378696627914905548095703125, 0.82866001129150390625, 0.162961304187774658203125), float3(0.0005471261101774871349334716796875, -0.00088337459601461887359619140625, 1.00033628940582275390625))) * _576), _940) * _577; float _943 = _942.x; float _944 = _942.y; float _946 = _942.z; float _949 = fast::max(fast::max(_943, _944), _946); float _954 = (fast::max(_949, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_943, _944), _946), 1.0000000133514319600180897396058e-10)) / fast::max(_949, 0.00999999977648258209228515625); float _967 = ((_946 + _944) + _943) + (1.75 * sqrt(((_946 * (_946 - _944)) + (_944 * (_944 - _943))) + (_943 * (_943 - _946)))); float _968 = _967 * 0.3333333432674407958984375; float _969 = _954 - 0.4000000059604644775390625; float _974 = fast::max(1.0 - abs(_969 * 2.5), 0.0); float _982 = (1.0 + (float(int(sign(_969 * 5.0))) * (1.0 - (_974 * _974)))) * 0.02500000037252902984619140625; float _995; if (_968 <= 0.053333334624767303466796875) { _995 = _982; } else { float _994; if (_968 >= 0.1599999964237213134765625) { _994 = 0.0; } else { _994 = _982 * ((0.23999999463558197021484375 / _967) - 0.5); } _995 = _994; } float3 _998 = _942 * float3(1.0 + _995); float _999 = _998.x; float _1000 = _998.y; float _1002 = _998.z; float _1016; if ((_999 == _1000) && (_1000 == _1002)) { _1016 = 0.0; } else { _1016 = 57.2957763671875 * atan2(sqrt(3.0) * (_1000 - _1002), ((2.0 * _999) - _1000) - _1002); } float _1021; if (_1016 < 0.0) { _1021 = _1016 + 360.0; } else { _1021 = _1016; } float _1022 = fast::clamp(_1021, 0.0, 360.0); float _1027; if (_1022 > 180.0) { _1027 = _1022 - 360.0; } else { _1027 = _1022; } float _1031 = smoothstep(0.0, 1.0, 1.0 - abs(_1027 * 0.01481481455266475677490234375)); float3 _1038 = _998; _1038.x = _999 + ((((_1031 * _1031) * _954) * (0.02999999932944774627685546875 - _999)) * 0.180000007152557373046875); float3 _1040 = fast::max(float3(0.0), _1038 * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375))); float _1049 = (1.0 + _Globals.FilmBlackClip) - _Globals.FilmToe; float _1052 = 1.0 + _Globals.FilmWhiteClip; float _1055 = _1052 - _Globals.FilmShoulder; float _1082; if (_Globals.FilmToe > 0.800000011920928955078125) { _1082 = ((0.819999992847442626953125 - _Globals.FilmToe) / _Globals.FilmSlope) + (log(0.180000007152557373046875) / log(10.0)); } else { float _1061 = (0.180000007152557373046875 + _Globals.FilmBlackClip) / _1049; _1082 = (log(0.180000007152557373046875) / log(10.0)) - ((0.5 * log(_1061 / (2.0 - _1061))) * (_1049 / _Globals.FilmSlope)); } float _1087 = ((1.0 - _Globals.FilmToe) / _Globals.FilmSlope) - _1082; float _1089 = (_Globals.FilmShoulder / _Globals.FilmSlope) - _1087; float _1091 = log(10.0); float3 _1093 = log(mix(float3(dot(_1040, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1040, float3(0.959999978542327880859375))) / float3(_1091); float3 _1097 = float3(_Globals.FilmSlope) * (_1093 + float3(_1087)); float3 _1105 = float3(_1082); float3 _1106 = _1093 - _1105; float3 _1118 = float3(_1089); float3 _1132 = fast::clamp(_1106 / float3(_1089 - _1082), float3(0.0), float3(1.0)); float3 _1136 = select(_1132, float3(1.0) - _1132, bool3(_1089 < _1082)); float3 _1141 = mix(select(_1097, float3(-_Globals.FilmBlackClip) + (float3(2.0 * _1049) / (float3(1.0) + exp(float3(((-2.0) * _Globals.FilmSlope) / _1049) * _1106))), _1093 < _1105), select(_1097, float3(_1052) - (float3(2.0 * _1055) / (float3(1.0) + exp(float3((2.0 * _Globals.FilmSlope) / _1055) * (_1093 - _1118)))), _1093 > _1118), ((float3(3.0) - (float3(2.0) * _1136)) * _1136) * _1136); float3 _1145 = fast::max(float3(0.0), mix(float3(dot(_1141, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1141, float3(0.930000007152557373046875))); float3 _1215; if (_Globals.ColorShadow_Tint2.w == 0.0) { float3 _1157 = _525; _1157.x = dot(_932, _Globals.ColorMatrixR_ColorCurveCd1.xyz); float3 _1162 = _1157; _1162.y = dot(_932, _Globals.ColorMatrixG_ColorCurveCd3Cm3.xyz); float3 _1167 = _1162; _1167.z = dot(_932, _Globals.ColorMatrixB_ColorCurveCm2.xyz); float3 _1183 = fast::max(float3(0.0), _1167 * (_Globals.ColorShadow_Tint1.xyz + (_Globals.ColorShadow_Tint2.xyz * float3(1.0 / (dot(_932, _Globals.ColorShadow_Luma.xyz) + 1.0))))); float3 _1188 = fast::max(float3(0.0), _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.xxx - _1183); float3 _1190 = fast::max(_1183, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.zzz); _1215 = ((((_1190 * _Globals.ColorCurve_Ch1_Ch2.xxx) + _Globals.ColorCurve_Ch1_Ch2.yyy) * (float3(1.0) / (_1190 + _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.www))) + ((fast::clamp(_1183, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.xxx, _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.zzz) * _Globals.ColorMatrixB_ColorCurveCm2.www) + (((_1188 * _Globals.ColorMatrixR_ColorCurveCd1.www) * (float3(1.0) / (_1188 + _Globals.ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3.yyy))) + _Globals.ColorMatrixG_ColorCurveCd3Cm3.www))) - float3(0.00200000009499490261077880859375); } else { _1215 = fast::max(float3(0.0), mix(_1145, _1145 * ((_577 * float3x3(float3(1.06317996978759765625, 0.02339559979736804962158203125, -0.08657260239124298095703125), float3(-0.010633699595928192138671875, 1.2063200473785400390625, -0.1956900060176849365234375), float3(-0.0005908869788981974124908447265625, 0.00105247995816171169281005859375, 0.999538004398345947265625))) * _576), _940) * _575); } float3 _1216 = fast::clamp(_1215, float3(0.0), float3(1.0)); float _1217 = _1216.x; float _1229; for (;;) { if (_1217 < 0.00313066993840038776397705078125) { _1229 = _1217 * 12.9200000762939453125; break; } _1229 = (pow(_1217, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _1230 = _1216.y; float _1242; for (;;) { if (_1230 < 0.00313066993840038776397705078125) { _1242 = _1230 * 12.9200000762939453125; break; } _1242 = (pow(_1230, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _1243 = _1216.z; float _1255; for (;;) { if (_1243 < 0.00313066993840038776397705078125) { _1255 = _1243 * 12.9200000762939453125; break; } _1255 = (pow(_1243, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float3 _1256 = float3(_1229, _1242, _1255); float3 _1258 = (_1256 * float3(0.9375)) + float3(0.03125); float _1270 = (_1258.z * 16.0) - 0.5; float _1271 = floor(_1270); float _1275 = (_1258.x + _1271) * 0.0625; float _1276 = _1258.y; float4 _1279 = Texture1.sample(Texture1Sampler, float2(_1275, _1276)); float4 _1283 = Texture1.sample(Texture1Sampler, float2(_1275 + 0.0625, _1276)); float3 _1289 = fast::max(float3(6.1035199905745685100555419921875e-05), (float3(_Globals.LUTWeights[0].x) * _1256) + (float3(_Globals.LUTWeights[1].x) * mix(_1279, _1283, float4(_1270 - _1271)).xyz)); float3 _1295 = select(_1289 * float3(0.077399380505084991455078125), pow((_1289 * float3(0.94786727428436279296875)) + float3(0.0521326996386051177978515625), float3(2.400000095367431640625)), _1289 > float3(0.040449999272823333740234375)); float3 _1324 = pow(fast::max(float3(0.0), mix((((float3(_Globals.MappingPolynomial.x) * (_1295 * _1295)) + (float3(_Globals.MappingPolynomial.y) * _1295)) + float3(_Globals.MappingPolynomial.z)) * _Globals.ColorScale, _Globals.OverlayColor.xyz, float3(_Globals.OverlayColor.w))), float3(_Globals.InverseGamma.y)); float3 _3103; if (_Globals.OutputDevice == 0u) { float _3063 = _1324.x; float _3075; for (;;) { if (_3063 < 0.00313066993840038776397705078125) { _3075 = _3063 * 12.9200000762939453125; break; } _3075 = (pow(_3063, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _3076 = _1324.y; float _3088; for (;;) { if (_3076 < 0.00313066993840038776397705078125) { _3088 = _3076 * 12.9200000762939453125; break; } _3088 = (pow(_3076, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } float _3089 = _1324.z; float _3101; for (;;) { if (_3089 < 0.00313066993840038776397705078125) { _3101 = _3089 * 12.9200000762939453125; break; } _3101 = (pow(_3089, 0.4166666567325592041015625) * 1.05499994754791259765625) - 0.054999999701976776123046875; break; } _3103 = float3(_3075, _3088, _3101); } else { float3 _3062; if (_Globals.OutputDevice == 1u) { float3 _3055 = fast::max(float3(6.1035199905745685100555419921875e-05), (_1324 * _573) * _602); _3062 = fast::min(_3055 * float3(4.5), (pow(fast::max(_3055, float3(0.017999999225139617919921875)), float3(0.449999988079071044921875)) * float3(1.09899997711181640625)) - float3(0.098999999463558197021484375)); } else { float3 _3052; if ((_Globals.OutputDevice == 3u) || (_Globals.OutputDevice == 5u)) { float3 _2204 = (_932 * float3(1.5)) * (_572 * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625))); float _2205 = _2204.x; float _2206 = _2204.y; float _2208 = _2204.z; float _2211 = fast::max(fast::max(_2205, _2206), _2208); float _2216 = (fast::max(_2211, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_2205, _2206), _2208), 1.0000000133514319600180897396058e-10)) / fast::max(_2211, 0.00999999977648258209228515625); float _2229 = ((_2208 + _2206) + _2205) + (1.75 * sqrt(((_2208 * (_2208 - _2206)) + (_2206 * (_2206 - _2205))) + (_2205 * (_2205 - _2208)))); float _2230 = _2229 * 0.3333333432674407958984375; float _2231 = _2216 - 0.4000000059604644775390625; float _2236 = fast::max(1.0 - abs(_2231 * 2.5), 0.0); float _2244 = (1.0 + (float(int(sign(_2231 * 5.0))) * (1.0 - (_2236 * _2236)))) * 0.02500000037252902984619140625; float _2257; if (_2230 <= 0.053333334624767303466796875) { _2257 = _2244; } else { float _2256; if (_2230 >= 0.1599999964237213134765625) { _2256 = 0.0; } else { _2256 = _2244 * ((0.23999999463558197021484375 / _2229) - 0.5); } _2257 = _2256; } float3 _2260 = _2204 * float3(1.0 + _2257); float _2261 = _2260.x; float _2262 = _2260.y; float _2264 = _2260.z; float _2278; if ((_2261 == _2262) && (_2262 == _2264)) { _2278 = 0.0; } else { _2278 = 57.2957763671875 * atan2(sqrt(3.0) * (_2262 - _2264), ((2.0 * _2261) - _2262) - _2264); } float _2283; if (_2278 < 0.0) { _2283 = _2278 + 360.0; } else { _2283 = _2278; } float _2284 = fast::clamp(_2283, 0.0, 360.0); float _2289; if (_2284 > 180.0) { _2289 = _2284 - 360.0; } else { _2289 = _2284; } float _2339; if ((_2289 > (-67.5)) && (_2289 < 67.5)) { float _2296 = (_2289 - (-67.5)) * 0.0296296291053295135498046875; int _2297 = int(_2296); float _2299 = _2296 - float(_2297); float _2300 = _2299 * _2299; float _2301 = _2300 * _2299; float _2338; if (_2297 == 3) { _2338 = (((_2301 * (-0.16666667163372039794921875)) + (_2300 * 0.5)) + (_2299 * (-0.5))) + 0.16666667163372039794921875; } else { float _2331; if (_2297 == 2) { _2331 = ((_2301 * 0.5) + (_2300 * (-1.0))) + 0.666666686534881591796875; } else { float _2326; if (_2297 == 1) { _2326 = (((_2301 * (-0.5)) + (_2300 * 0.5)) + (_2299 * 0.5)) + 0.16666667163372039794921875; } else { float _2319; if (_2297 == 0) { _2319 = _2301 * 0.16666667163372039794921875; } else { _2319 = 0.0; } _2326 = _2319; } _2331 = _2326; } _2338 = _2331; } _2339 = _2338; } else { _2339 = 0.0; } float3 _2346 = _2260; _2346.x = _2261 + ((((_2339 * 1.5) * _2216) * (0.02999999932944774627685546875 - _2261)) * 0.180000007152557373046875); float3 _2349 = fast::clamp(fast::clamp(_2346, float3(0.0), float3(65535.0)) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)), float3(0.0), float3(65535.0)); float3 _2352 = mix(float3(dot(_2349, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _2349, float3(0.959999978542327880859375)); float _2353 = _2352.x; float _2357 = 0.17999999225139617919921875 * exp2(18.0); float _2359 = exp2(-14.0); float _2362 = log((_2353 <= 0.0) ? _2359 : _2353) / _1091; float _2364 = log(0.17999999225139617919921875 * exp2(-15.0)) / _1091; float _2431; if (_2362 <= _2364) { _2431 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _2371 = log(0.180000007152557373046875) / _1091; float _2428; if ((_2362 > _2364) && (_2362 < _2371)) { float _2411 = (3.0 * (_2362 - _2364)) / (_2371 - _2364); int _2412 = int(_2411); float _2414 = _2411 - float(_2412); _2428 = dot(float3(_2414 * _2414, _2414, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_2412], _499[_2412 + 1], _499[_2412 + 2])); } else { float _2379 = log(_2357) / _1091; float _2407; if ((_2362 >= _2371) && (_2362 < _2379)) { float _2390 = (3.0 * (_2362 - _2371)) / (_2379 - _2371); int _2391 = int(_2390); float _2393 = _2390 - float(_2391); _2407 = dot(float3(_2393 * _2393, _2393, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_2391], _500[_2391 + 1], _500[_2391 + 2])); } else { _2407 = log(10000.0) / _1091; } _2428 = _2407; } _2431 = _2428; } float3 _2433 = _523; _2433.x = pow(10.0, _2431); float _2434 = _2352.y; float _2438 = log((_2434 <= 0.0) ? _2359 : _2434) / _1091; float _2505; if (_2438 <= _2364) { _2505 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _2445 = log(0.180000007152557373046875) / _1091; float _2502; if ((_2438 > _2364) && (_2438 < _2445)) { float _2485 = (3.0 * (_2438 - _2364)) / (_2445 - _2364); int _2486 = int(_2485); float _2488 = _2485 - float(_2486); _2502 = dot(float3(_2488 * _2488, _2488, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_2486], _499[_2486 + 1], _499[_2486 + 2])); } else { float _2453 = log(_2357) / _1091; float _2481; if ((_2438 >= _2445) && (_2438 < _2453)) { float _2464 = (3.0 * (_2438 - _2445)) / (_2453 - _2445); int _2465 = int(_2464); float _2467 = _2464 - float(_2465); _2481 = dot(float3(_2467 * _2467, _2467, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_2465], _500[_2465 + 1], _500[_2465 + 2])); } else { _2481 = log(10000.0) / _1091; } _2502 = _2481; } _2505 = _2502; } float3 _2507 = _2433; _2507.y = pow(10.0, _2505); float _2508 = _2352.z; float _2512 = log((_2508 <= 0.0) ? _2359 : _2508) / _1091; float _2579; if (_2512 <= _2364) { _2579 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _2519 = log(0.180000007152557373046875) / _1091; float _2576; if ((_2512 > _2364) && (_2512 < _2519)) { float _2559 = (3.0 * (_2512 - _2364)) / (_2519 - _2364); int _2560 = int(_2559); float _2562 = _2559 - float(_2560); _2576 = dot(float3(_2562 * _2562, _2562, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_2560], _499[_2560 + 1], _499[_2560 + 2])); } else { float _2527 = log(_2357) / _1091; float _2555; if ((_2512 >= _2519) && (_2512 < _2527)) { float _2538 = (3.0 * (_2512 - _2519)) / (_2527 - _2519); int _2539 = int(_2538); float _2541 = _2538 - float(_2539); _2555 = dot(float3(_2541 * _2541, _2541, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_2539], _500[_2539 + 1], _500[_2539 + 2])); } else { _2555 = log(10000.0) / _1091; } _2576 = _2555; } _2579 = _2576; } float3 _2581 = _2507; _2581.z = pow(10.0, _2579); float3 _2583 = (_2581 * float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625))) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)); float _2585 = 0.17999999225139617919921875 * pow(2.0, -12.0); float _2589 = log((_2585 <= 0.0) ? _2359 : _2585) / _1091; float _2656; if (_2589 <= _2364) { _2656 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _2596 = log(0.180000007152557373046875) / _1091; float _2653; if ((_2589 > _2364) && (_2589 < _2596)) { float _2636 = (3.0 * (_2589 - _2364)) / (_2596 - _2364); int _2637 = int(_2636); float _2639 = _2636 - float(_2637); _2653 = dot(float3(_2639 * _2639, _2639, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_2637], _499[_2637 + 1], _499[_2637 + 2])); } else { float _2604 = log(_2357) / _1091; float _2632; if ((_2589 >= _2596) && (_2589 < _2604)) { float _2615 = (3.0 * (_2589 - _2596)) / (_2604 - _2596); int _2616 = int(_2615); float _2618 = _2615 - float(_2616); _2632 = dot(float3(_2618 * _2618, _2618, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_2616], _500[_2616 + 1], _500[_2616 + 2])); } else { _2632 = log(10000.0) / _1091; } _2653 = _2632; } _2656 = _2653; } float _2659 = log(0.180000007152557373046875) / _1091; float _2713; if (_2659 <= _2364) { _2713 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _2710; if ((_2659 > _2364) && (_2659 < _2659)) { _2710 = (float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[3], _499[4], _499[5])).z; } else { float _2672 = log(_2357) / _1091; float _2700; if ((_2659 >= _2659) && (_2659 < _2672)) { float _2683 = (3.0 * (_2659 - _2659)) / (_2672 - _2659); int _2684 = int(_2683); float _2686 = _2683 - float(_2684); _2700 = dot(float3(_2686 * _2686, _2686, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_2684], _500[_2684 + 1], _500[_2684 + 2])); } else { _2700 = log(10000.0) / _1091; } _2710 = _2700; } _2713 = _2710; } float _2714 = pow(10.0, _2713); float _2716 = 0.17999999225139617919921875 * pow(2.0, 10.0); float _2720 = log((_2716 <= 0.0) ? _2359 : _2716) / _1091; float _2785; if (_2720 <= _2364) { _2785 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _2782; if ((_2720 > _2364) && (_2720 < _2659)) { float _2765 = (3.0 * (_2720 - _2364)) / (_2659 - _2364); int _2766 = int(_2765); float _2768 = _2765 - float(_2766); _2782 = dot(float3(_2768 * _2768, _2768, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_2766], _499[_2766 + 1], _499[_2766 + 2])); } else { float _2733 = log(_2357) / _1091; float _2761; if ((_2720 >= _2659) && (_2720 < _2733)) { float _2744 = (3.0 * (_2720 - _2659)) / (_2733 - _2659); int _2745 = int(_2744); float _2747 = _2744 - float(_2745); _2761 = dot(float3(_2747 * _2747, _2747, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_2745], _500[_2745 + 1], _500[_2745 + 2])); } else { _2761 = log(10000.0) / _1091; } _2782 = _2761; } _2785 = _2782; } float _2786 = pow(10.0, _2785); float _2787 = _2583.x; float _2791 = log((_2787 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2787) / _1091; float _2792 = log(pow(10.0, _2656)); float _2793 = _2792 / _1091; float _2870; if (_2791 <= _2793) { _2870 = (_2791 * 3.0) + ((log(9.9999997473787516355514526367188e-05) / _1091) - ((3.0 * _2792) / _1091)); } else { float _2800 = log(_2714) / _1091; float _2862; if ((_2791 > _2793) && (_2791 < _2800)) { float _2845 = (7.0 * (_2791 - _2793)) / (_2800 - _2793); int _2846 = int(_2845); float _2848 = _2845 - float(_2846); _2862 = dot(float3(_2848 * _2848, _2848, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_503[_2846], _503[_2846 + 1], _503[_2846 + 2])); } else { float _2807 = log(_2786); float _2808 = _2807 / _1091; float _2841; if ((_2791 >= _2800) && (_2791 < _2808)) { float _2824 = (7.0 * (_2791 - _2800)) / (_2808 - _2800); int _2825 = int(_2824); float _2827 = _2824 - float(_2825); _2841 = dot(float3(_2827 * _2827, _2827, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_504[_2825], _504[_2825 + 1], _504[_2825 + 2])); } else { _2841 = (_2791 * 0.0599999986588954925537109375) + ((log(1000.0) / _1091) - ((0.0599999986588954925537109375 * _2807) / _1091)); } _2862 = _2841; } _2870 = _2862; } float3 _2872 = _523; _2872.x = pow(10.0, _2870); float _2873 = _2583.y; float _2877 = log((_2873 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2873) / _1091; float _2954; if (_2877 <= _2793) { _2954 = (_2877 * 3.0) + ((log(9.9999997473787516355514526367188e-05) / _1091) - ((3.0 * _2792) / _1091)); } else { float _2884 = log(_2714) / _1091; float _2946; if ((_2877 > _2793) && (_2877 < _2884)) { float _2929 = (7.0 * (_2877 - _2793)) / (_2884 - _2793); int _2930 = int(_2929); float _2932 = _2929 - float(_2930); _2946 = dot(float3(_2932 * _2932, _2932, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_503[_2930], _503[_2930 + 1], _503[_2930 + 2])); } else { float _2891 = log(_2786); float _2892 = _2891 / _1091; float _2925; if ((_2877 >= _2884) && (_2877 < _2892)) { float _2908 = (7.0 * (_2877 - _2884)) / (_2892 - _2884); int _2909 = int(_2908); float _2911 = _2908 - float(_2909); _2925 = dot(float3(_2911 * _2911, _2911, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_504[_2909], _504[_2909 + 1], _504[_2909 + 2])); } else { _2925 = (_2877 * 0.0599999986588954925537109375) + ((log(1000.0) / _1091) - ((0.0599999986588954925537109375 * _2891) / _1091)); } _2946 = _2925; } _2954 = _2946; } float3 _2956 = _2872; _2956.y = pow(10.0, _2954); float _2957 = _2583.z; float _2961 = log((_2957 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2957) / _1091; float _3038; if (_2961 <= _2793) { _3038 = (_2961 * 3.0) + ((log(9.9999997473787516355514526367188e-05) / _1091) - ((3.0 * _2792) / _1091)); } else { float _2968 = log(_2714) / _1091; float _3030; if ((_2961 > _2793) && (_2961 < _2968)) { float _3013 = (7.0 * (_2961 - _2793)) / (_2968 - _2793); int _3014 = int(_3013); float _3016 = _3013 - float(_3014); _3030 = dot(float3(_3016 * _3016, _3016, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_503[_3014], _503[_3014 + 1], _503[_3014 + 2])); } else { float _2975 = log(_2786); float _2976 = _2975 / _1091; float _3009; if ((_2961 >= _2968) && (_2961 < _2976)) { float _2992 = (7.0 * (_2961 - _2968)) / (_2976 - _2968); int _2993 = int(_2992); float _2995 = _2992 - float(_2993); _3009 = dot(float3(_2995 * _2995, _2995, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_504[_2993], _504[_2993 + 1], _504[_2993 + 2])); } else { _3009 = (_2961 * 0.0599999986588954925537109375) + ((log(1000.0) / _1091) - ((0.0599999986588954925537109375 * _2975) / _1091)); } _3030 = _3009; } _3038 = _3030; } float3 _3040 = _2956; _3040.z = pow(10.0, _3038); float3 _3044 = pow(((_3040 - float3(3.5073844628641381859779357910156e-05)) * _602) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _3052 = pow((float3(0.8359375) + (float3(18.8515625) * _3044)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _3044))), float3(78.84375)); } else { float3 _2201; if ((_Globals.OutputDevice == 4u) || (_Globals.OutputDevice == 6u)) { float3 _1369 = (_932 * float3(1.5)) * (_572 * float3x3(float3(1.04981100559234619140625, 0.0, -9.74845024757087230682373046875e-05), float3(-0.49590301513671875, 1.37331306934356689453125, 0.09824003279209136962890625), float3(0.0, 0.0, 0.991252005100250244140625))); float _1370 = _1369.x; float _1371 = _1369.y; float _1373 = _1369.z; float _1376 = fast::max(fast::max(_1370, _1371), _1373); float _1381 = (fast::max(_1376, 1.0000000133514319600180897396058e-10) - fast::max(fast::min(fast::min(_1370, _1371), _1373), 1.0000000133514319600180897396058e-10)) / fast::max(_1376, 0.00999999977648258209228515625); float _1394 = ((_1373 + _1371) + _1370) + (1.75 * sqrt(((_1373 * (_1373 - _1371)) + (_1371 * (_1371 - _1370))) + (_1370 * (_1370 - _1373)))); float _1395 = _1394 * 0.3333333432674407958984375; float _1396 = _1381 - 0.4000000059604644775390625; float _1401 = fast::max(1.0 - abs(_1396 * 2.5), 0.0); float _1409 = (1.0 + (float(int(sign(_1396 * 5.0))) * (1.0 - (_1401 * _1401)))) * 0.02500000037252902984619140625; float _1422; if (_1395 <= 0.053333334624767303466796875) { _1422 = _1409; } else { float _1421; if (_1395 >= 0.1599999964237213134765625) { _1421 = 0.0; } else { _1421 = _1409 * ((0.23999999463558197021484375 / _1394) - 0.5); } _1422 = _1421; } float3 _1425 = _1369 * float3(1.0 + _1422); float _1426 = _1425.x; float _1427 = _1425.y; float _1429 = _1425.z; float _1443; if ((_1426 == _1427) && (_1427 == _1429)) { _1443 = 0.0; } else { _1443 = 57.2957763671875 * atan2(sqrt(3.0) * (_1427 - _1429), ((2.0 * _1426) - _1427) - _1429); } float _1448; if (_1443 < 0.0) { _1448 = _1443 + 360.0; } else { _1448 = _1443; } float _1449 = fast::clamp(_1448, 0.0, 360.0); float _1454; if (_1449 > 180.0) { _1454 = _1449 - 360.0; } else { _1454 = _1449; } float _1504; if ((_1454 > (-67.5)) && (_1454 < 67.5)) { float _1461 = (_1454 - (-67.5)) * 0.0296296291053295135498046875; int _1462 = int(_1461); float _1464 = _1461 - float(_1462); float _1465 = _1464 * _1464; float _1466 = _1465 * _1464; float _1503; if (_1462 == 3) { _1503 = (((_1466 * (-0.16666667163372039794921875)) + (_1465 * 0.5)) + (_1464 * (-0.5))) + 0.16666667163372039794921875; } else { float _1496; if (_1462 == 2) { _1496 = ((_1466 * 0.5) + (_1465 * (-1.0))) + 0.666666686534881591796875; } else { float _1491; if (_1462 == 1) { _1491 = (((_1466 * (-0.5)) + (_1465 * 0.5)) + (_1464 * 0.5)) + 0.16666667163372039794921875; } else { float _1484; if (_1462 == 0) { _1484 = _1466 * 0.16666667163372039794921875; } else { _1484 = 0.0; } _1491 = _1484; } _1496 = _1491; } _1503 = _1496; } _1504 = _1503; } else { _1504 = 0.0; } float3 _1511 = _1425; _1511.x = _1426 + ((((_1504 * 1.5) * _1381) * (0.02999999932944774627685546875 - _1426)) * 0.180000007152557373046875); float3 _1514 = fast::clamp(fast::clamp(_1511, float3(0.0), float3(65535.0)) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)), float3(0.0), float3(65535.0)); float3 _1517 = mix(float3(dot(_1514, float3(0.272228717803955078125, 0.674081742763519287109375, 0.053689517080783843994140625))), _1514, float3(0.959999978542327880859375)); float _1518 = _1517.x; float _1522 = 0.17999999225139617919921875 * exp2(18.0); float _1524 = exp2(-14.0); float _1527 = log((_1518 <= 0.0) ? _1524 : _1518) / _1091; float _1529 = log(0.17999999225139617919921875 * exp2(-15.0)) / _1091; float _1596; if (_1527 <= _1529) { _1596 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _1536 = log(0.180000007152557373046875) / _1091; float _1593; if ((_1527 > _1529) && (_1527 < _1536)) { float _1576 = (3.0 * (_1527 - _1529)) / (_1536 - _1529); int _1577 = int(_1576); float _1579 = _1576 - float(_1577); _1593 = dot(float3(_1579 * _1579, _1579, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_1577], _499[_1577 + 1], _499[_1577 + 2])); } else { float _1544 = log(_1522) / _1091; float _1572; if ((_1527 >= _1536) && (_1527 < _1544)) { float _1555 = (3.0 * (_1527 - _1536)) / (_1544 - _1536); int _1556 = int(_1555); float _1558 = _1555 - float(_1556); _1572 = dot(float3(_1558 * _1558, _1558, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_1556], _500[_1556 + 1], _500[_1556 + 2])); } else { _1572 = log(10000.0) / _1091; } _1593 = _1572; } _1596 = _1593; } float3 _1598 = _523; _1598.x = pow(10.0, _1596); float _1599 = _1517.y; float _1603 = log((_1599 <= 0.0) ? _1524 : _1599) / _1091; float _1670; if (_1603 <= _1529) { _1670 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _1610 = log(0.180000007152557373046875) / _1091; float _1667; if ((_1603 > _1529) && (_1603 < _1610)) { float _1650 = (3.0 * (_1603 - _1529)) / (_1610 - _1529); int _1651 = int(_1650); float _1653 = _1650 - float(_1651); _1667 = dot(float3(_1653 * _1653, _1653, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_1651], _499[_1651 + 1], _499[_1651 + 2])); } else { float _1618 = log(_1522) / _1091; float _1646; if ((_1603 >= _1610) && (_1603 < _1618)) { float _1629 = (3.0 * (_1603 - _1610)) / (_1618 - _1610); int _1630 = int(_1629); float _1632 = _1629 - float(_1630); _1646 = dot(float3(_1632 * _1632, _1632, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_1630], _500[_1630 + 1], _500[_1630 + 2])); } else { _1646 = log(10000.0) / _1091; } _1667 = _1646; } _1670 = _1667; } float3 _1672 = _1598; _1672.y = pow(10.0, _1670); float _1673 = _1517.z; float _1677 = log((_1673 <= 0.0) ? _1524 : _1673) / _1091; float _1744; if (_1677 <= _1529) { _1744 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _1684 = log(0.180000007152557373046875) / _1091; float _1741; if ((_1677 > _1529) && (_1677 < _1684)) { float _1724 = (3.0 * (_1677 - _1529)) / (_1684 - _1529); int _1725 = int(_1724); float _1727 = _1724 - float(_1725); _1741 = dot(float3(_1727 * _1727, _1727, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_1725], _499[_1725 + 1], _499[_1725 + 2])); } else { float _1692 = log(_1522) / _1091; float _1720; if ((_1677 >= _1684) && (_1677 < _1692)) { float _1703 = (3.0 * (_1677 - _1684)) / (_1692 - _1684); int _1704 = int(_1703); float _1706 = _1703 - float(_1704); _1720 = dot(float3(_1706 * _1706, _1706, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_1704], _500[_1704 + 1], _500[_1704 + 2])); } else { _1720 = log(10000.0) / _1091; } _1741 = _1720; } _1744 = _1741; } float3 _1746 = _1672; _1746.z = pow(10.0, _1744); float3 _1748 = (_1746 * float3x3(float3(0.695452213287353515625, 0.140678703784942626953125, 0.16386906802654266357421875), float3(0.0447945632040500640869140625, 0.859671115875244140625, 0.095534317195415496826171875), float3(-0.0055258828215301036834716796875, 0.0040252101607620716094970703125, 1.00150072574615478515625))) * float3x3(float3(1.45143926143646240234375, -0.236510753631591796875, -0.214928567409515380859375), float3(-0.07655377686023712158203125, 1.1762297153472900390625, -0.0996759235858917236328125), float3(0.0083161480724811553955078125, -0.0060324496589601039886474609375, 0.99771630764007568359375)); float _1750 = 0.17999999225139617919921875 * pow(2.0, -12.0); float _1754 = log((_1750 <= 0.0) ? _1524 : _1750) / _1091; float _1821; if (_1754 <= _1529) { _1821 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _1761 = log(0.180000007152557373046875) / _1091; float _1818; if ((_1754 > _1529) && (_1754 < _1761)) { float _1801 = (3.0 * (_1754 - _1529)) / (_1761 - _1529); int _1802 = int(_1801); float _1804 = _1801 - float(_1802); _1818 = dot(float3(_1804 * _1804, _1804, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_1802], _499[_1802 + 1], _499[_1802 + 2])); } else { float _1769 = log(_1522) / _1091; float _1797; if ((_1754 >= _1761) && (_1754 < _1769)) { float _1780 = (3.0 * (_1754 - _1761)) / (_1769 - _1761); int _1781 = int(_1780); float _1783 = _1780 - float(_1781); _1797 = dot(float3(_1783 * _1783, _1783, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_1781], _500[_1781 + 1], _500[_1781 + 2])); } else { _1797 = log(10000.0) / _1091; } _1818 = _1797; } _1821 = _1818; } float _1824 = log(0.180000007152557373046875) / _1091; float _1878; if (_1824 <= _1529) { _1878 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _1875; if ((_1824 > _1529) && (_1824 < _1824)) { _1875 = (float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[3], _499[4], _499[5])).z; } else { float _1837 = log(_1522) / _1091; float _1865; if ((_1824 >= _1824) && (_1824 < _1837)) { float _1848 = (3.0 * (_1824 - _1824)) / (_1837 - _1824); int _1849 = int(_1848); float _1851 = _1848 - float(_1849); _1865 = dot(float3(_1851 * _1851, _1851, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_1849], _500[_1849 + 1], _500[_1849 + 2])); } else { _1865 = log(10000.0) / _1091; } _1875 = _1865; } _1878 = _1875; } float _1879 = pow(10.0, _1878); float _1881 = 0.17999999225139617919921875 * pow(2.0, 11.0); float _1885 = log((_1881 <= 0.0) ? _1524 : _1881) / _1091; float _1950; if (_1885 <= _1529) { _1950 = log(9.9999997473787516355514526367188e-05) / _1091; } else { float _1947; if ((_1885 > _1529) && (_1885 < _1824)) { float _1930 = (3.0 * (_1885 - _1529)) / (_1824 - _1529); int _1931 = int(_1930); float _1933 = _1930 - float(_1931); _1947 = dot(float3(_1933 * _1933, _1933, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_499[_1931], _499[_1931 + 1], _499[_1931 + 2])); } else { float _1898 = log(_1522) / _1091; float _1926; if ((_1885 >= _1824) && (_1885 < _1898)) { float _1909 = (3.0 * (_1885 - _1824)) / (_1898 - _1824); int _1910 = int(_1909); float _1912 = _1909 - float(_1910); _1926 = dot(float3(_1912 * _1912, _1912, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_500[_1910], _500[_1910 + 1], _500[_1910 + 2])); } else { _1926 = log(10000.0) / _1091; } _1947 = _1926; } _1950 = _1947; } float _1951 = pow(10.0, _1950); float _1952 = _1748.x; float _1956 = log((_1952 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _1952) / _1091; float _1958 = log(pow(10.0, _1821)) / _1091; float _2030; if (_1956 <= _1958) { _2030 = log(0.004999999888241291046142578125) / _1091; } else { float _1965 = log(_1879) / _1091; float _2027; if ((_1956 > _1958) && (_1956 < _1965)) { float _2010 = (7.0 * (_1956 - _1958)) / (_1965 - _1958); int _2011 = int(_2010); float _2013 = _2010 - float(_2011); _2027 = dot(float3(_2013 * _2013, _2013, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_506[_2011], _506[_2011 + 1], _506[_2011 + 2])); } else { float _1972 = log(_1951); float _1973 = _1972 / _1091; float _2006; if ((_1956 >= _1965) && (_1956 < _1973)) { float _1989 = (7.0 * (_1956 - _1965)) / (_1973 - _1965); int _1990 = int(_1989); float _1992 = _1989 - float(_1990); _2006 = dot(float3(_1992 * _1992, _1992, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_507[_1990], _507[_1990 + 1], _507[_1990 + 2])); } else { _2006 = (_1956 * 0.119999997317790985107421875) + ((log(2000.0) / _1091) - ((0.119999997317790985107421875 * _1972) / _1091)); } _2027 = _2006; } _2030 = _2027; } float3 _2032 = _523; _2032.x = pow(10.0, _2030); float _2033 = _1748.y; float _2037 = log((_2033 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2033) / _1091; float _2109; if (_2037 <= _1958) { _2109 = log(0.004999999888241291046142578125) / _1091; } else { float _2044 = log(_1879) / _1091; float _2106; if ((_2037 > _1958) && (_2037 < _2044)) { float _2089 = (7.0 * (_2037 - _1958)) / (_2044 - _1958); int _2090 = int(_2089); float _2092 = _2089 - float(_2090); _2106 = dot(float3(_2092 * _2092, _2092, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_506[_2090], _506[_2090 + 1], _506[_2090 + 2])); } else { float _2051 = log(_1951); float _2052 = _2051 / _1091; float _2085; if ((_2037 >= _2044) && (_2037 < _2052)) { float _2068 = (7.0 * (_2037 - _2044)) / (_2052 - _2044); int _2069 = int(_2068); float _2071 = _2068 - float(_2069); _2085 = dot(float3(_2071 * _2071, _2071, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_507[_2069], _507[_2069 + 1], _507[_2069 + 2])); } else { _2085 = (_2037 * 0.119999997317790985107421875) + ((log(2000.0) / _1091) - ((0.119999997317790985107421875 * _2051) / _1091)); } _2106 = _2085; } _2109 = _2106; } float3 _2111 = _2032; _2111.y = pow(10.0, _2109); float _2112 = _1748.z; float _2116 = log((_2112 <= 0.0) ? 9.9999997473787516355514526367188e-05 : _2112) / _1091; float _2188; if (_2116 <= _1958) { _2188 = log(0.004999999888241291046142578125) / _1091; } else { float _2123 = log(_1879) / _1091; float _2185; if ((_2116 > _1958) && (_2116 < _2123)) { float _2168 = (7.0 * (_2116 - _1958)) / (_2123 - _1958); int _2169 = int(_2168); float _2171 = _2168 - float(_2169); _2185 = dot(float3(_2171 * _2171, _2171, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_506[_2169], _506[_2169 + 1], _506[_2169 + 2])); } else { float _2130 = log(_1951); float _2131 = _2130 / _1091; float _2164; if ((_2116 >= _2123) && (_2116 < _2131)) { float _2147 = (7.0 * (_2116 - _2123)) / (_2131 - _2123); int _2148 = int(_2147); float _2150 = _2147 - float(_2148); _2164 = dot(float3(_2150 * _2150, _2150, 1.0), float3x3(float3(0.5, -1.0, 0.5), float3(-1.0, 1.0, 0.5), float3(0.5, 0.0, 0.0)) * float3(_507[_2148], _507[_2148 + 1], _507[_2148 + 2])); } else { _2164 = (_2116 * 0.119999997317790985107421875) + ((log(2000.0) / _1091) - ((0.119999997317790985107421875 * _2130) / _1091)); } _2185 = _2164; } _2188 = _2185; } float3 _2190 = _2111; _2190.z = pow(10.0, _2188); float3 _2193 = pow((_2190 * _602) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _2201 = pow((float3(0.8359375) + (float3(18.8515625) * _2193)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _2193))), float3(78.84375)); } else { float3 _1366; if (_Globals.OutputDevice == 7u) { float3 _1358 = pow(((_932 * _573) * _602) * float3(9.9999997473787516355514526367188e-05), float3(0.1593017578125)); _1366 = pow((float3(0.8359375) + (float3(18.8515625) * _1358)) * (float3(1.0) / (float3(1.0) + (float3(18.6875) * _1358))), float3(78.84375)); } else { _1366 = pow((_1324 * _573) * _602, float3(_Globals.InverseGamma.z)); } _2201 = _1366; } _3052 = _2201; } _3062 = _3052; } _3103 = _3062; } float3 _3104 = _3103 * float3(0.95238101482391357421875); float4 _3106 = float4(_3104.x, _3104.y, _3104.z, float4(0.0).w); _3106.w = 0.0; out.out_var_SV_Target0 = _3106; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag/sample-mask-not-array.asm.frag000066400000000000000000000601611400026215700277230ustar00rootroot00000000000000#include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; struct type_TranslucentBasePass { uint TranslucentBasePass_Shared_Forward_NumLocalLights; uint TranslucentBasePass_Shared_Forward_NumReflectionCaptures; uint TranslucentBasePass_Shared_Forward_HasDirectionalLight; uint TranslucentBasePass_Shared_Forward_NumGridCells; packed_int3 TranslucentBasePass_Shared_Forward_CulledGridSize; uint TranslucentBasePass_Shared_Forward_MaxCulledLightsPerCell; uint TranslucentBasePass_Shared_Forward_LightGridPixelSizeShift; uint PrePadding_TranslucentBasePass_Shared_Forward_36; uint PrePadding_TranslucentBasePass_Shared_Forward_40; uint PrePadding_TranslucentBasePass_Shared_Forward_44; packed_float3 TranslucentBasePass_Shared_Forward_LightGridZParams; float PrePadding_TranslucentBasePass_Shared_Forward_60; packed_float3 TranslucentBasePass_Shared_Forward_DirectionalLightDirection; float PrePadding_TranslucentBasePass_Shared_Forward_76; packed_float3 TranslucentBasePass_Shared_Forward_DirectionalLightColor; float TranslucentBasePass_Shared_Forward_DirectionalLightVolumetricScatteringIntensity; uint TranslucentBasePass_Shared_Forward_DirectionalLightShadowMapChannelMask; uint PrePadding_TranslucentBasePass_Shared_Forward_100; float2 TranslucentBasePass_Shared_Forward_DirectionalLightDistanceFadeMAD; uint TranslucentBasePass_Shared_Forward_NumDirectionalLightCascades; uint PrePadding_TranslucentBasePass_Shared_Forward_116; uint PrePadding_TranslucentBasePass_Shared_Forward_120; uint PrePadding_TranslucentBasePass_Shared_Forward_124; float4 TranslucentBasePass_Shared_Forward_CascadeEndDepths; float4x4 TranslucentBasePass_Shared_Forward_DirectionalLightWorldToShadowMatrix[4]; float4 TranslucentBasePass_Shared_Forward_DirectionalLightShadowmapMinMax[4]; float4 TranslucentBasePass_Shared_Forward_DirectionalLightShadowmapAtlasBufferSize; float TranslucentBasePass_Shared_Forward_DirectionalLightDepthBias; uint TranslucentBasePass_Shared_Forward_DirectionalLightUseStaticShadowing; uint PrePadding_TranslucentBasePass_Shared_Forward_488; uint PrePadding_TranslucentBasePass_Shared_Forward_492; float4 TranslucentBasePass_Shared_Forward_DirectionalLightStaticShadowBufferSize; float4x4 TranslucentBasePass_Shared_Forward_DirectionalLightWorldToStaticShadow; float PrePadding_TranslucentBasePass_Shared_ForwardISR_576; float PrePadding_TranslucentBasePass_Shared_ForwardISR_580; float PrePadding_TranslucentBasePass_Shared_ForwardISR_584; float PrePadding_TranslucentBasePass_Shared_ForwardISR_588; float PrePadding_TranslucentBasePass_Shared_ForwardISR_592; float PrePadding_TranslucentBasePass_Shared_ForwardISR_596; float PrePadding_TranslucentBasePass_Shared_ForwardISR_600; float PrePadding_TranslucentBasePass_Shared_ForwardISR_604; float PrePadding_TranslucentBasePass_Shared_ForwardISR_608; float PrePadding_TranslucentBasePass_Shared_ForwardISR_612; float PrePadding_TranslucentBasePass_Shared_ForwardISR_616; float PrePadding_TranslucentBasePass_Shared_ForwardISR_620; float PrePadding_TranslucentBasePass_Shared_ForwardISR_624; float PrePadding_TranslucentBasePass_Shared_ForwardISR_628; float PrePadding_TranslucentBasePass_Shared_ForwardISR_632; float PrePadding_TranslucentBasePass_Shared_ForwardISR_636; uint TranslucentBasePass_Shared_ForwardISR_NumLocalLights; uint TranslucentBasePass_Shared_ForwardISR_NumReflectionCaptures; uint TranslucentBasePass_Shared_ForwardISR_HasDirectionalLight; uint TranslucentBasePass_Shared_ForwardISR_NumGridCells; packed_int3 TranslucentBasePass_Shared_ForwardISR_CulledGridSize; uint TranslucentBasePass_Shared_ForwardISR_MaxCulledLightsPerCell; uint TranslucentBasePass_Shared_ForwardISR_LightGridPixelSizeShift; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_676; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_680; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_684; packed_float3 TranslucentBasePass_Shared_ForwardISR_LightGridZParams; float PrePadding_TranslucentBasePass_Shared_ForwardISR_700; packed_float3 TranslucentBasePass_Shared_ForwardISR_DirectionalLightDirection; float PrePadding_TranslucentBasePass_Shared_ForwardISR_716; packed_float3 TranslucentBasePass_Shared_ForwardISR_DirectionalLightColor; float TranslucentBasePass_Shared_ForwardISR_DirectionalLightVolumetricScatteringIntensity; uint TranslucentBasePass_Shared_ForwardISR_DirectionalLightShadowMapChannelMask; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_740; float2 TranslucentBasePass_Shared_ForwardISR_DirectionalLightDistanceFadeMAD; uint TranslucentBasePass_Shared_ForwardISR_NumDirectionalLightCascades; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_756; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_760; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_764; float4 TranslucentBasePass_Shared_ForwardISR_CascadeEndDepths; float4x4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightWorldToShadowMatrix[4]; float4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightShadowmapMinMax[4]; float4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightShadowmapAtlasBufferSize; float TranslucentBasePass_Shared_ForwardISR_DirectionalLightDepthBias; uint TranslucentBasePass_Shared_ForwardISR_DirectionalLightUseStaticShadowing; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_1128; uint PrePadding_TranslucentBasePass_Shared_ForwardISR_1132; float4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightStaticShadowBufferSize; float4x4 TranslucentBasePass_Shared_ForwardISR_DirectionalLightWorldToStaticShadow; float PrePadding_TranslucentBasePass_Shared_Reflection_1216; float PrePadding_TranslucentBasePass_Shared_Reflection_1220; float PrePadding_TranslucentBasePass_Shared_Reflection_1224; float PrePadding_TranslucentBasePass_Shared_Reflection_1228; float PrePadding_TranslucentBasePass_Shared_Reflection_1232; float PrePadding_TranslucentBasePass_Shared_Reflection_1236; float PrePadding_TranslucentBasePass_Shared_Reflection_1240; float PrePadding_TranslucentBasePass_Shared_Reflection_1244; float PrePadding_TranslucentBasePass_Shared_Reflection_1248; float PrePadding_TranslucentBasePass_Shared_Reflection_1252; float PrePadding_TranslucentBasePass_Shared_Reflection_1256; float PrePadding_TranslucentBasePass_Shared_Reflection_1260; float PrePadding_TranslucentBasePass_Shared_Reflection_1264; float PrePadding_TranslucentBasePass_Shared_Reflection_1268; float PrePadding_TranslucentBasePass_Shared_Reflection_1272; float PrePadding_TranslucentBasePass_Shared_Reflection_1276; float4 TranslucentBasePass_Shared_Reflection_SkyLightParameters; float TranslucentBasePass_Shared_Reflection_SkyLightCubemapBrightness; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1300; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1304; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1308; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1312; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1316; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1320; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1324; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1328; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1332; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1336; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1340; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1344; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1348; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1352; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1356; float4 TranslucentBasePass_Shared_PlanarReflection_ReflectionPlane; float4 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionOrigin; float4 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionXAxis; float4 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionYAxis; float3x4 TranslucentBasePass_Shared_PlanarReflection_InverseTransposeMirrorMatrix; packed_float3 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionParameters; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1484; float2 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionParameters2; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1496; float PrePadding_TranslucentBasePass_Shared_PlanarReflection_1500; float4x4 TranslucentBasePass_Shared_PlanarReflection_ProjectionWithExtraFOV[2]; float4 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionScreenScaleBias[2]; float2 TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionScreenBound; uint TranslucentBasePass_Shared_PlanarReflection_bIsStereo; float PrePadding_TranslucentBasePass_Shared_Fog_1676; float PrePadding_TranslucentBasePass_Shared_Fog_1680; float PrePadding_TranslucentBasePass_Shared_Fog_1684; float PrePadding_TranslucentBasePass_Shared_Fog_1688; float PrePadding_TranslucentBasePass_Shared_Fog_1692; float4 TranslucentBasePass_Shared_Fog_ExponentialFogParameters; float4 TranslucentBasePass_Shared_Fog_ExponentialFogParameters2; float4 TranslucentBasePass_Shared_Fog_ExponentialFogColorParameter; float4 TranslucentBasePass_Shared_Fog_ExponentialFogParameters3; float4 TranslucentBasePass_Shared_Fog_InscatteringLightDirection; float4 TranslucentBasePass_Shared_Fog_DirectionalInscatteringColor; float2 TranslucentBasePass_Shared_Fog_SinCosInscatteringColorCubemapRotation; float PrePadding_TranslucentBasePass_Shared_Fog_1800; float PrePadding_TranslucentBasePass_Shared_Fog_1804; packed_float3 TranslucentBasePass_Shared_Fog_FogInscatteringTextureParameters; float TranslucentBasePass_Shared_Fog_ApplyVolumetricFog; float PrePadding_TranslucentBasePass_1824; float PrePadding_TranslucentBasePass_1828; float PrePadding_TranslucentBasePass_1832; float PrePadding_TranslucentBasePass_1836; float PrePadding_TranslucentBasePass_1840; float PrePadding_TranslucentBasePass_1844; float PrePadding_TranslucentBasePass_1848; float PrePadding_TranslucentBasePass_1852; float PrePadding_TranslucentBasePass_1856; float PrePadding_TranslucentBasePass_1860; float PrePadding_TranslucentBasePass_1864; float PrePadding_TranslucentBasePass_1868; float PrePadding_TranslucentBasePass_1872; float PrePadding_TranslucentBasePass_1876; float PrePadding_TranslucentBasePass_1880; float PrePadding_TranslucentBasePass_1884; float PrePadding_TranslucentBasePass_1888; float PrePadding_TranslucentBasePass_1892; float PrePadding_TranslucentBasePass_1896; float PrePadding_TranslucentBasePass_1900; float PrePadding_TranslucentBasePass_1904; float PrePadding_TranslucentBasePass_1908; float PrePadding_TranslucentBasePass_1912; float PrePadding_TranslucentBasePass_1916; float PrePadding_TranslucentBasePass_1920; float PrePadding_TranslucentBasePass_1924; float PrePadding_TranslucentBasePass_1928; float PrePadding_TranslucentBasePass_1932; float PrePadding_TranslucentBasePass_1936; float PrePadding_TranslucentBasePass_1940; float PrePadding_TranslucentBasePass_1944; float PrePadding_TranslucentBasePass_1948; float PrePadding_TranslucentBasePass_1952; float PrePadding_TranslucentBasePass_1956; float PrePadding_TranslucentBasePass_1960; float PrePadding_TranslucentBasePass_1964; float PrePadding_TranslucentBasePass_1968; float PrePadding_TranslucentBasePass_1972; float PrePadding_TranslucentBasePass_1976; float PrePadding_TranslucentBasePass_1980; float PrePadding_TranslucentBasePass_1984; float PrePadding_TranslucentBasePass_1988; float PrePadding_TranslucentBasePass_1992; float PrePadding_TranslucentBasePass_1996; float PrePadding_TranslucentBasePass_2000; float PrePadding_TranslucentBasePass_2004; float PrePadding_TranslucentBasePass_2008; float PrePadding_TranslucentBasePass_2012; float PrePadding_TranslucentBasePass_2016; float PrePadding_TranslucentBasePass_2020; float PrePadding_TranslucentBasePass_2024; float PrePadding_TranslucentBasePass_2028; float PrePadding_TranslucentBasePass_2032; float PrePadding_TranslucentBasePass_2036; float PrePadding_TranslucentBasePass_2040; float PrePadding_TranslucentBasePass_2044; float PrePadding_TranslucentBasePass_2048; float PrePadding_TranslucentBasePass_2052; float PrePadding_TranslucentBasePass_2056; float PrePadding_TranslucentBasePass_2060; float PrePadding_TranslucentBasePass_2064; float PrePadding_TranslucentBasePass_2068; float PrePadding_TranslucentBasePass_2072; float PrePadding_TranslucentBasePass_2076; float PrePadding_TranslucentBasePass_2080; float PrePadding_TranslucentBasePass_2084; float PrePadding_TranslucentBasePass_2088; float PrePadding_TranslucentBasePass_2092; float PrePadding_TranslucentBasePass_2096; float PrePadding_TranslucentBasePass_2100; float PrePadding_TranslucentBasePass_2104; float PrePadding_TranslucentBasePass_2108; float PrePadding_TranslucentBasePass_2112; float PrePadding_TranslucentBasePass_2116; float PrePadding_TranslucentBasePass_2120; float PrePadding_TranslucentBasePass_2124; float PrePadding_TranslucentBasePass_2128; float PrePadding_TranslucentBasePass_2132; float PrePadding_TranslucentBasePass_2136; float PrePadding_TranslucentBasePass_2140; float4 TranslucentBasePass_HZBUvFactorAndInvFactor; float4 TranslucentBasePass_PrevScreenPositionScaleBias; float TranslucentBasePass_PrevSceneColorPreExposureInv; }; struct type_Material { float4 Material_VectorExpressions[2]; float4 Material_ScalarExpressions[1]; }; constant float _108 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; uint gl_SampleMask [[sample_mask]]; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[user(locn0)]]; float4 in_var_TEXCOORD11_centroid [[user(locn1)]]; uint in_var_PRIMITIVE_ID [[user(locn2)]]; float4 in_var_TEXCOORD7 [[user(locn3)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], const device type_StructuredBuffer_v4float& View_PrimitiveSceneData [[buffer(1)]], constant type_TranslucentBasePass& TranslucentBasePass [[buffer(2)]], constant type_Material& Material [[buffer(3)]], texture3d TranslucentBasePass_Shared_Fog_IntegratedLightScattering [[texture(0)]], sampler View_SharedBilinearClampedSampler [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleMaskIn [[sample_mask]]) { main0_out out = {}; float4 _137 = View.View_SVPositionToTranslatedWorld * float4(gl_FragCoord.xyz, 1.0); float3 _142 = (_137.xyz / float3(_137.w)) - float3(View.View_PreViewTranslation); bool _165 = TranslucentBasePass.TranslucentBasePass_Shared_Fog_ApplyVolumetricFog > 0.0; float4 _215; if (_165) { float4 _172 = View.View_WorldToClip * float4(_142, 1.0); float _173 = _172.w; float4 _202; if (_165) { _202 = TranslucentBasePass_Shared_Fog_IntegratedLightScattering.sample(View_SharedBilinearClampedSampler, float3(((_172.xy / float2(_173)).xy * float2(0.5, -0.5)) + float2(0.5), (log2((_173 * View.View_VolumetricFogGridZParams[0]) + View.View_VolumetricFogGridZParams[1]) * View.View_VolumetricFogGridZParams[2]) * View.View_VolumetricFogInvGridSize[2]), level(0.0)); } else { _202 = float4(0.0, 0.0, 0.0, 1.0); } _215 = float4(_202.xyz + (in.in_var_TEXCOORD7.xyz * float3(_202.w)), _202.w * in.in_var_TEXCOORD7.w); } else { _215 = in.in_var_TEXCOORD7; } float3 _216 = fast::max(Material.Material_VectorExpressions[1].xyz * float3(((1.0 + dot(float3(-1.0, -1.5, 3.0) / float3(sqrt(12.25)), normalize(float3x3(in.in_var_TEXCOORD10_centroid.xyz, cross(in.in_var_TEXCOORD11_centroid.xyz, in.in_var_TEXCOORD10_centroid.xyz) * float3(in.in_var_TEXCOORD11_centroid.w), in.in_var_TEXCOORD11_centroid.xyz) * normalize((float3(0.0, 0.0, 1.0) * float3(View.View_NormalOverrideParameter.w)) + View.View_NormalOverrideParameter.xyz)))) * 0.5) + 0.20000000298023223876953125), float3(0.0)); float3 _246; if (View.View_OutOfBoundsMask > 0.0) { uint _222 = in.in_var_PRIMITIVE_ID * 26u; float3 _245; if (any(abs(_142 - View_PrimitiveSceneData._m0[_222 + 5u].xyz) > (View_PrimitiveSceneData._m0[_222 + 19u].xyz + float3(1.0)))) { _245 = mix(float3(1.0, 1.0, 0.0), float3(0.0, 1.0, 1.0), select(float3(0.0), float3(1.0), float3(fract(dot(_142, float3(0.57700002193450927734375)) * 0.00200000009499490261077880859375)) > float3(0.5))); } else { _245 = _216; } _246 = _245; } else { _246 = _216; } float4 _256 = float4((_246 * float3(_215.w)) + _215.xyz, _108); _256.w = 1.0; float4 _268; uint _269; if (View.View_NumSceneColorMSAASamples > 1) { _268 = _256 * float4(float(View.View_NumSceneColorMSAASamples) * 0.25); _269 = gl_SampleMaskIn & 15u; } else { _268 = _256; _269 = gl_SampleMaskIn; } out.out_var_SV_Target0 = _268; out.gl_SampleMask = _269; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag/subpass-input.ios.framebuffer-fetch.asm.frag000066400000000000000000000207101400026215700325530ustar00rootroot00000000000000#include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Globals { float3 SoftTransitionScale; float4 ShadowBufferSize; float ShadowFadeFraction; float ShadowSharpen; float4 LightPositionAndInvRadius; float4x4 ScreenToShadowMatrix; float2 ProjectionDepthBiasParameters; float4 ModulatedShadowColor; float4 ShadowTileOffsetAndSize; }; constant float4 _58 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; fragment main0_out main0(constant type_View& View [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], float4 _RESERVED_IDENTIFIER_FIXUP_gl_LastFragData [[color(0)]], texture2d ShadowDepthTexture [[texture(0)]], sampler ShadowDepthTextureSampler [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float4 _67 = _RESERVED_IDENTIFIER_FIXUP_gl_LastFragData; float _68 = _67.w; float4 _82 = _Globals.ScreenToShadowMatrix * float4((((gl_FragCoord.xy * View.View_BufferSizeAndInvSize.zw) - View.View_ScreenPositionScaleBias.wz) / View.View_ScreenPositionScaleBias.xy) * float2(_68), _68, 1.0); float _118 = fast::clamp(((fast::clamp((ShadowDepthTexture.sample(ShadowDepthTextureSampler, (((_82.xyz / float3(_82.w)).xy * _Globals.ShadowTileOffsetAndSize.zw).xy + _Globals.ShadowTileOffsetAndSize.xy).xy, level(0.0)).xxx * float3(_Globals.SoftTransitionScale.z)) - float3((fast::min(_82.z, 0.999989986419677734375) * _Globals.SoftTransitionScale.z) - 1.0), float3(0.0), float3(1.0)).x - 0.5) * _Globals.ShadowSharpen) + 0.5, 0.0, 1.0); float3 _127 = mix(_Globals.ModulatedShadowColor.xyz, float3(1.0), float3(mix(1.0, _118 * _118, _Globals.ShadowFadeFraction))); float4 _129 = float4(_127.x, _127.y, _127.z, _58.w); _129.w = 0.0; out.out_var_SV_Target0 = _129; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag/subpass-input.msl23.framebuffer-fetch.asm.frag000066400000000000000000000207101400026215700327210ustar00rootroot00000000000000#include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Globals { float3 SoftTransitionScale; float4 ShadowBufferSize; float ShadowFadeFraction; float ShadowSharpen; float4 LightPositionAndInvRadius; float4x4 ScreenToShadowMatrix; float2 ProjectionDepthBiasParameters; float4 ModulatedShadowColor; float4 ShadowTileOffsetAndSize; }; constant float4 _58 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; fragment main0_out main0(constant type_View& View [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], float4 _RESERVED_IDENTIFIER_FIXUP_gl_LastFragData [[color(0)]], texture2d ShadowDepthTexture [[texture(0)]], sampler ShadowDepthTextureSampler [[sampler(0)]], float4 gl_FragCoord [[position]], uint gl_SampleID [[sample_id]]) { main0_out out = {}; gl_FragCoord.xy += get_sample_position(gl_SampleID) - 0.5; float4 _67 = _RESERVED_IDENTIFIER_FIXUP_gl_LastFragData; float _68 = _67.w; float4 _82 = _Globals.ScreenToShadowMatrix * float4((((gl_FragCoord.xy * View.View_BufferSizeAndInvSize.zw) - View.View_ScreenPositionScaleBias.wz) / View.View_ScreenPositionScaleBias.xy) * float2(_68), _68, 1.0); float _118 = fast::clamp(((fast::clamp((ShadowDepthTexture.sample(ShadowDepthTextureSampler, (((_82.xyz / float3(_82.w)).xy * _Globals.ShadowTileOffsetAndSize.zw).xy + _Globals.ShadowTileOffsetAndSize.xy).xy, level(0.0)).xxx * float3(_Globals.SoftTransitionScale.z)) - float3((fast::min(_82.z, 0.999989986419677734375) * _Globals.SoftTransitionScale.z) - 1.0), float3(0.0), float3(1.0)).x - 0.5) * _Globals.ShadowSharpen) + 0.5, 0.0, 1.0); float3 _127 = mix(_Globals.ModulatedShadowColor.xyz, float3(1.0), float3(mix(1.0, _118 * _118, _Globals.ShadowFadeFraction))); float4 _129 = float4(_127.x, _127.y, _127.z, _58.w); _129.w = 0.0; out.out_var_SV_Target0 = _129; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag/texture-atomics.asm.argument.msl2.frag000066400000000000000000000101411400026215700314220ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; struct spvDescriptorSetBuffer0 { const device type_StructuredBuffer_v4float* CulledObjectBoxBounds [[id(0)]]; constant type_Globals* _Globals [[id(1)]]; texture2d RWShadowTileNumCulledObjects [[id(2)]]; device atomic_uint* RWShadowTileNumCulledObjects_atomic [[id(3)]]; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], constant spvDescriptorSetBuffer0& spvDescriptorSet0 [[buffer(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float(((*spvDescriptorSet0._Globals).ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2((*spvDescriptorSet0._Globals).ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _107 = _103 + 1u; if (all((*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_107].xy > _96.xy) && all((*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103].xyz < _102)) { float3 _121 = float3(0.5) * ((*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103].xyz + (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_107].xyz); float _122 = _96.x; float _123 = _96.y; spvUnsafeArray _73; _73[0] = float3(_122, _123, -1000.0); float _126 = _100.x; _73[1] = float3(_126, _123, -1000.0); float _129 = _100.y; _73[2] = float3(_122, _129, -1000.0); _73[3] = float3(_126, _129, -1000.0); _73[4] = float3(_122, _123, 1.0); _73[5] = float3(_126, _123, 1.0); _73[6] = float3(_122, _129, 1.0); _73[7] = float3(_126, _129, 1.0); float3 _155; float3 _158; _155 = float3(-500000.0); _158 = float3(500000.0); for (int _160 = 0; _160 < 8; ) { float3 _166 = _73[_160] - _121; float3 _170 = float3(dot(_166, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 2u].xyz), dot(_166, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 3u].xyz), dot(_166, (*spvDescriptorSet0.CulledObjectBoxBounds)._m0[_103 + 4u].xyz)); _155 = fast::max(_155, _170); _158 = fast::min(_158, _170); _160++; continue; } if (all(_158 < float3(1.0)) && all(_155 > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&spvDescriptorSet0.RWShadowTileNumCulledObjects_atomic[(_78 * (*spvDescriptorSet0._Globals).ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag/texture-atomics.asm.frag000066400000000000000000000074261400026215700267410ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device type_StructuredBuffer_v4float& CulledObjectBoxBounds [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d RWShadowTileNumCulledObjects [[texture(0)]], device atomic_uint* RWShadowTileNumCulledObjects_atomic [[buffer(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float((_Globals.ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2(_Globals.ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _107 = _103 + 1u; if (all(CulledObjectBoxBounds._m0[_107].xy > _96.xy) && all(CulledObjectBoxBounds._m0[_103].xyz < _102)) { float3 _121 = float3(0.5) * (CulledObjectBoxBounds._m0[_103].xyz + CulledObjectBoxBounds._m0[_107].xyz); float _122 = _96.x; float _123 = _96.y; spvUnsafeArray _73; _73[0] = float3(_122, _123, -1000.0); float _126 = _100.x; _73[1] = float3(_126, _123, -1000.0); float _129 = _100.y; _73[2] = float3(_122, _129, -1000.0); _73[3] = float3(_126, _129, -1000.0); _73[4] = float3(_122, _123, 1.0); _73[5] = float3(_126, _123, 1.0); _73[6] = float3(_122, _129, 1.0); _73[7] = float3(_126, _129, 1.0); float3 _155; float3 _158; _155 = float3(-500000.0); _158 = float3(500000.0); for (int _160 = 0; _160 < 8; ) { float3 _166 = _73[_160] - _121; float3 _170 = float3(dot(_166, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); _155 = fast::max(_155, _170); _158 = fast::min(_158, _170); _160++; continue; } if (all(_158 < float3(1.0)) && all(_155 > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&RWShadowTileNumCulledObjects_atomic[(_78 * _Globals.ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } texture-atomics.asm.graphics-robust-access.frag000066400000000000000000000074261400026215700332340ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4/asm/frag#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #pragma clang diagnostic ignored "-Wunused-variable" #include #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; struct type_Globals { uint2 ShadowTileListGroupSize; }; constant float3 _70 = {}; struct main0_out { float4 out_var_SV_Target0 [[color(0)]]; }; struct main0_in { uint in_var_TEXCOORD0 [[user(locn0)]]; }; fragment main0_out main0(main0_in in [[stage_in]], const device type_StructuredBuffer_v4float& CulledObjectBoxBounds [[buffer(0)]], constant type_Globals& _Globals [[buffer(1)]], texture2d RWShadowTileNumCulledObjects [[texture(0)]], device atomic_uint* RWShadowTileNumCulledObjects_atomic [[buffer(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; uint2 _77 = uint2(gl_FragCoord.xy); uint _78 = _77.y; uint _83 = _77.x; float2 _91 = float2(float(_83), float((_Globals.ShadowTileListGroupSize.y - 1u) - _78)); float2 _93 = float2(_Globals.ShadowTileListGroupSize); float2 _96 = ((_91 / _93) * float2(2.0)) - float2(1.0); float2 _100 = (((_91 + float2(1.0)) / _93) * float2(2.0)) - float2(1.0); float3 _102 = float3(_100.x, _100.y, _70.z); _102.z = 1.0; uint _103 = in.in_var_TEXCOORD0 * 5u; uint _107 = _103 + 1u; if (all(CulledObjectBoxBounds._m0[_107].xy > _96.xy) && all(CulledObjectBoxBounds._m0[_103].xyz < _102)) { float3 _121 = float3(0.5) * (CulledObjectBoxBounds._m0[_103].xyz + CulledObjectBoxBounds._m0[_107].xyz); float _122 = _96.x; float _123 = _96.y; spvUnsafeArray _73; _73[0] = float3(_122, _123, -1000.0); float _126 = _100.x; _73[1] = float3(_126, _123, -1000.0); float _129 = _100.y; _73[2] = float3(_122, _129, -1000.0); _73[3] = float3(_126, _129, -1000.0); _73[4] = float3(_122, _123, 1.0); _73[5] = float3(_126, _123, 1.0); _73[6] = float3(_122, _129, 1.0); _73[7] = float3(_126, _129, 1.0); float3 _155; float3 _158; _155 = float3(-500000.0); _158 = float3(500000.0); for (int _160 = 0; _160 < 8; ) { float3 _166 = _73[_160] - _121; float3 _170 = float3(dot(_166, CulledObjectBoxBounds._m0[_103 + 2u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 3u].xyz), dot(_166, CulledObjectBoxBounds._m0[_103 + 4u].xyz)); _155 = fast::max(_155, _170); _158 = fast::min(_158, _170); _160++; continue; } if (all(_158 < float3(1.0)) && all(_155 > float3(-1.0))) { uint _179 = atomic_fetch_add_explicit((device atomic_uint*)&RWShadowTileNumCulledObjects_atomic[(_78 * _Globals.ShadowTileListGroupSize.x) + _83], 1u, memory_order_relaxed); } } out.out_var_SV_Target0 = float4(0.0); return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/tesc/000077500000000000000000000000001400026215700221725ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4/asm/tesc/hs-incorrect-base-type.asm.tesc000066400000000000000000000612631400026215700301300ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct FVertexFactoryInterpolantsVSToPS { float4 TangentToWorld0; float4 TangentToWorld2; float4 Color; spvUnsafeArray TexCoords; float4 LightMapCoordinate; uint PrimitiveId; uint LightmapDataIndex; }; struct FVertexFactoryInterpolantsVSToDS { FVertexFactoryInterpolantsVSToPS InterpolantsVSToPS; }; struct FSharedBasePassInterpolants { }; struct FBasePassInterpolantsVSToDS { FSharedBasePassInterpolants _m0; }; struct FBasePassVSToDS { FVertexFactoryInterpolantsVSToDS FactoryInterpolants; FBasePassInterpolantsVSToDS BasePassInterpolants; float4 Position; }; struct FPNTessellationHSToDS { FBasePassVSToDS PassSpecificData; spvUnsafeArray WorldPosition; float3 DisplacementScale; float TessellationMultiplier; float WorldDisplacementMultiplier; }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_StructuredBuffer_v4float { float4 _m0[1]; }; constant float4 _142 = {}; struct main0_out { float4 out_var_COLOR0; uint out_var_LIGHTMAP_ID; float3 out_var_PN_DisplacementScales; spvUnsafeArray out_var_PN_POSITION; float out_var_PN_TessellationMultiplier; float out_var_PN_WorldDisplacementMultiplier; uint out_var_PRIMITIVE_ID; spvUnsafeArray out_var_TEXCOORD0; float4 out_var_TEXCOORD10_centroid; float4 out_var_TEXCOORD11_centroid; float4 out_var_TEXCOORD4; float4 out_var_VS_To_DS_Position; }; struct main0_patchOut { float4 out_var_PN_POSITION9; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[attribute(0)]]; float4 in_var_TEXCOORD11_centroid [[attribute(1)]]; float4 in_var_COLOR0 [[attribute(2)]]; float4 in_var_TEXCOORD0_0 [[attribute(3)]]; float4 in_var_TEXCOORD4 [[attribute(4)]]; uint in_var_PRIMITIVE_ID [[attribute(5)]]; uint in_var_LIGHTMAP_ID [[attribute(6)]]; float4 in_var_VS_To_DS_Position [[attribute(7)]]; }; kernel void main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], const device type_StructuredBuffer_v4float& View_PrimitiveSceneData [[buffer(1)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { threadgroup FPNTessellationHSToDS temp_var_hullMainRetVal[3]; device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 3) return; spvUnsafeArray _144 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD10_centroid, gl_in[1].in_var_TEXCOORD10_centroid, gl_in[2].in_var_TEXCOORD10_centroid, gl_in[3].in_var_TEXCOORD10_centroid, gl_in[4].in_var_TEXCOORD10_centroid, gl_in[5].in_var_TEXCOORD10_centroid, gl_in[6].in_var_TEXCOORD10_centroid, gl_in[7].in_var_TEXCOORD10_centroid, gl_in[8].in_var_TEXCOORD10_centroid, gl_in[9].in_var_TEXCOORD10_centroid, gl_in[10].in_var_TEXCOORD10_centroid, gl_in[11].in_var_TEXCOORD10_centroid }); spvUnsafeArray _145 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD11_centroid, gl_in[1].in_var_TEXCOORD11_centroid, gl_in[2].in_var_TEXCOORD11_centroid, gl_in[3].in_var_TEXCOORD11_centroid, gl_in[4].in_var_TEXCOORD11_centroid, gl_in[5].in_var_TEXCOORD11_centroid, gl_in[6].in_var_TEXCOORD11_centroid, gl_in[7].in_var_TEXCOORD11_centroid, gl_in[8].in_var_TEXCOORD11_centroid, gl_in[9].in_var_TEXCOORD11_centroid, gl_in[10].in_var_TEXCOORD11_centroid, gl_in[11].in_var_TEXCOORD11_centroid }); spvUnsafeArray _146 = spvUnsafeArray({ gl_in[0].in_var_COLOR0, gl_in[1].in_var_COLOR0, gl_in[2].in_var_COLOR0, gl_in[3].in_var_COLOR0, gl_in[4].in_var_COLOR0, gl_in[5].in_var_COLOR0, gl_in[6].in_var_COLOR0, gl_in[7].in_var_COLOR0, gl_in[8].in_var_COLOR0, gl_in[9].in_var_COLOR0, gl_in[10].in_var_COLOR0, gl_in[11].in_var_COLOR0 }); spvUnsafeArray, 12> _147 = spvUnsafeArray, 12>({ spvUnsafeArray({ gl_in[0].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[1].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[2].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[3].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[4].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[5].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[6].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[7].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[8].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[9].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[10].in_var_TEXCOORD0_0 }), spvUnsafeArray({ gl_in[11].in_var_TEXCOORD0_0 }) }); spvUnsafeArray _148 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD4, gl_in[1].in_var_TEXCOORD4, gl_in[2].in_var_TEXCOORD4, gl_in[3].in_var_TEXCOORD4, gl_in[4].in_var_TEXCOORD4, gl_in[5].in_var_TEXCOORD4, gl_in[6].in_var_TEXCOORD4, gl_in[7].in_var_TEXCOORD4, gl_in[8].in_var_TEXCOORD4, gl_in[9].in_var_TEXCOORD4, gl_in[10].in_var_TEXCOORD4, gl_in[11].in_var_TEXCOORD4 }); spvUnsafeArray _149 = spvUnsafeArray({ gl_in[0].in_var_PRIMITIVE_ID, gl_in[1].in_var_PRIMITIVE_ID, gl_in[2].in_var_PRIMITIVE_ID, gl_in[3].in_var_PRIMITIVE_ID, gl_in[4].in_var_PRIMITIVE_ID, gl_in[5].in_var_PRIMITIVE_ID, gl_in[6].in_var_PRIMITIVE_ID, gl_in[7].in_var_PRIMITIVE_ID, gl_in[8].in_var_PRIMITIVE_ID, gl_in[9].in_var_PRIMITIVE_ID, gl_in[10].in_var_PRIMITIVE_ID, gl_in[11].in_var_PRIMITIVE_ID }); spvUnsafeArray _150 = spvUnsafeArray({ gl_in[0].in_var_LIGHTMAP_ID, gl_in[1].in_var_LIGHTMAP_ID, gl_in[2].in_var_LIGHTMAP_ID, gl_in[3].in_var_LIGHTMAP_ID, gl_in[4].in_var_LIGHTMAP_ID, gl_in[5].in_var_LIGHTMAP_ID, gl_in[6].in_var_LIGHTMAP_ID, gl_in[7].in_var_LIGHTMAP_ID, gl_in[8].in_var_LIGHTMAP_ID, gl_in[9].in_var_LIGHTMAP_ID, gl_in[10].in_var_LIGHTMAP_ID, gl_in[11].in_var_LIGHTMAP_ID }); spvUnsafeArray _259 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_Position, gl_in[1].in_var_VS_To_DS_Position, gl_in[2].in_var_VS_To_DS_Position, gl_in[3].in_var_VS_To_DS_Position, gl_in[4].in_var_VS_To_DS_Position, gl_in[5].in_var_VS_To_DS_Position, gl_in[6].in_var_VS_To_DS_Position, gl_in[7].in_var_VS_To_DS_Position, gl_in[8].in_var_VS_To_DS_Position, gl_in[9].in_var_VS_To_DS_Position, gl_in[10].in_var_VS_To_DS_Position, gl_in[11].in_var_VS_To_DS_Position }); spvUnsafeArray _284 = spvUnsafeArray({ FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[0], _145[0], _146[0], _147[0], _148[0], _149[0], _150[0] } }, FBasePassInterpolantsVSToDS{ { } }, _259[0] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[1], _145[1], _146[1], _147[1], _148[1], _149[1], _150[1] } }, FBasePassInterpolantsVSToDS{ { } }, _259[1] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[2], _145[2], _146[2], _147[2], _148[2], _149[2], _150[2] } }, FBasePassInterpolantsVSToDS{ { } }, _259[2] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[3], _145[3], _146[3], _147[3], _148[3], _149[3], _150[3] } }, FBasePassInterpolantsVSToDS{ { } }, _259[3] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[4], _145[4], _146[4], _147[4], _148[4], _149[4], _150[4] } }, FBasePassInterpolantsVSToDS{ { } }, _259[4] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[5], _145[5], _146[5], _147[5], _148[5], _149[5], _150[5] } }, FBasePassInterpolantsVSToDS{ { } }, _259[5] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[6], _145[6], _146[6], _147[6], _148[6], _149[6], _150[6] } }, FBasePassInterpolantsVSToDS{ { } }, _259[6] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[7], _145[7], _146[7], _147[7], _148[7], _149[7], _150[7] } }, FBasePassInterpolantsVSToDS{ { } }, _259[7] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[8], _145[8], _146[8], _147[8], _148[8], _149[8], _150[8] } }, FBasePassInterpolantsVSToDS{ { } }, _259[8] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[9], _145[9], _146[9], _147[9], _148[9], _149[9], _150[9] } }, FBasePassInterpolantsVSToDS{ { } }, _259[9] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[10], _145[10], _146[10], _147[10], _148[10], _149[10], _150[10] } }, FBasePassInterpolantsVSToDS{ { } }, _259[10] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _144[11], _145[11], _146[11], _147[11], _148[11], _149[11], _150[11] } }, FBasePassInterpolantsVSToDS{ { } }, _259[11] } }); spvUnsafeArray param_var_I; param_var_I = _284; float4 _301 = float4(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float3 _310 = View_PrimitiveSceneData._m0[(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.PrimitiveId * 26u) + 22u].xyz * float3x3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz, cross(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz) * float3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.w), param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz); uint _313 = (gl_InvocationID < 2u) ? (gl_InvocationID + 1u) : 0u; uint _314 = 2u * gl_InvocationID; uint _315 = 3u + _314; uint _316 = _314 + 4u; float4 _328 = float4(param_var_I[_313].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _336 = float4(param_var_I[_315].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _344 = float4(param_var_I[_316].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); spvUnsafeArray _392 = spvUnsafeArray({ param_var_I[gl_InvocationID].Position, (((((float4(2.0) * param_var_I[gl_InvocationID].Position) + param_var_I[_313].Position) - (float4(dot(param_var_I[_313].Position - param_var_I[gl_InvocationID].Position, _301)) * _301)) * float4(0.3333333432674407958984375)) + ((((float4(2.0) * param_var_I[_315].Position) + param_var_I[_316].Position) - (float4(dot(param_var_I[_316].Position - param_var_I[_315].Position, _336)) * _336)) * float4(0.3333333432674407958984375))) * float4(0.5), (((((float4(2.0) * param_var_I[_313].Position) + param_var_I[gl_InvocationID].Position) - (float4(dot(param_var_I[gl_InvocationID].Position - param_var_I[_313].Position, _328)) * _328)) * float4(0.3333333432674407958984375)) + ((((float4(2.0) * param_var_I[_316].Position) + param_var_I[_315].Position) - (float4(dot(param_var_I[_315].Position - param_var_I[_316].Position, _344)) * _344)) * float4(0.3333333432674407958984375))) * float4(0.5) }); gl_out[gl_InvocationID].out_var_TEXCOORD10_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; gl_out[gl_InvocationID].out_var_TEXCOORD11_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; gl_out[gl_InvocationID].out_var_COLOR0 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.Color; gl_out[gl_InvocationID].out_var_TEXCOORD0 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TexCoords; gl_out[gl_InvocationID].out_var_TEXCOORD4 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.LightMapCoordinate; gl_out[gl_InvocationID].out_var_PRIMITIVE_ID = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.PrimitiveId; gl_out[gl_InvocationID].out_var_LIGHTMAP_ID = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.LightmapDataIndex; gl_out[gl_InvocationID].out_var_VS_To_DS_Position = param_var_I[gl_InvocationID].Position; gl_out[gl_InvocationID].out_var_PN_POSITION = _392; gl_out[gl_InvocationID].out_var_PN_DisplacementScales = _310; gl_out[gl_InvocationID].out_var_PN_TessellationMultiplier = 1.0; gl_out[gl_InvocationID].out_var_PN_WorldDisplacementMultiplier = 1.0; temp_var_hullMainRetVal[gl_InvocationID] = FPNTessellationHSToDS{ param_var_I[gl_InvocationID], _392, _310, 1.0, 1.0 }; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0u) { float4 _450 = (((((temp_var_hullMainRetVal[0u].WorldPosition[1] + temp_var_hullMainRetVal[0u].WorldPosition[2]) + temp_var_hullMainRetVal[1u].WorldPosition[1]) + temp_var_hullMainRetVal[1u].WorldPosition[2]) + temp_var_hullMainRetVal[2u].WorldPosition[1]) + temp_var_hullMainRetVal[2u].WorldPosition[2]) * float4(0.16666667163372039794921875); float4 _463 = _142; _463.x = 0.5 * (temp_var_hullMainRetVal[1u].TessellationMultiplier + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _469 = _463; _469.y = 0.5 * (temp_var_hullMainRetVal[2u].TessellationMultiplier + temp_var_hullMainRetVal[0u].TessellationMultiplier); float4 _474 = _469; _474.z = 0.5 * (temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier); float4 _481 = _474; _481.w = 0.333000004291534423828125 * ((temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier) + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _589; for (;;) { float4 _489 = View.View_ViewToClip * float4(0.0); float4 _494 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[0u].WorldPosition[0].xyz, 1.0); float3 _495 = _494.xyz; float3 _496 = _489.xyz; float _498 = _494.w; float _499 = _489.w; float4 _516 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[1u].WorldPosition[0].xyz, 1.0); float3 _517 = _516.xyz; float _519 = _516.w; float4 _537 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[2u].WorldPosition[0].xyz, 1.0); float3 _538 = _537.xyz; float _540 = _537.w; if (any((((select(int3(0), int3(1), (_495 - _496) < float3(_498 + _499)) + (int3(2) * select(int3(0), int3(1), (_495 + _496) > float3((-_498) - _499)))) | (select(int3(0), int3(1), (_517 - _496) < float3(_519 + _499)) + (int3(2) * select(int3(0), int3(1), (_517 + _496) > float3((-_519) - _499))))) | (select(int3(0), int3(1), (_538 - _496) < float3(_540 + _499)) + (int3(2) * select(int3(0), int3(1), (_538 + _496) > float3((-_540) - _499))))) != int3(3))) { _589 = float4(0.0); break; } float3 _558 = temp_var_hullMainRetVal[0u].WorldPosition[0].xyz - temp_var_hullMainRetVal[1u].WorldPosition[0].xyz; float3 _559 = temp_var_hullMainRetVal[1u].WorldPosition[0].xyz - temp_var_hullMainRetVal[2u].WorldPosition[0].xyz; float3 _560 = temp_var_hullMainRetVal[2u].WorldPosition[0].xyz - temp_var_hullMainRetVal[0u].WorldPosition[0].xyz; float3 _563 = (float3(0.5) * (temp_var_hullMainRetVal[0u].WorldPosition[0].xyz + temp_var_hullMainRetVal[1u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _566 = (float3(0.5) * (temp_var_hullMainRetVal[1u].WorldPosition[0].xyz + temp_var_hullMainRetVal[2u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _569 = (float3(0.5) * (temp_var_hullMainRetVal[2u].WorldPosition[0].xyz + temp_var_hullMainRetVal[0u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float _573 = sqrt(dot(_559, _559) / dot(_566, _566)); float _577 = sqrt(dot(_560, _560) / dot(_569, _569)); float _581 = sqrt(dot(_558, _558) / dot(_563, _563)); float4 _586 = float4(_573, _577, _581, 1.0); _586.w = 0.333000004291534423828125 * ((_573 + _577) + _581); _589 = float4(View.View_AdaptiveTessellationFactor) * _586; break; } float4 _591 = fast::clamp(_481 * _589, float4(1.0), float4(15.0)); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0u] = half(_591.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1u] = half(_591.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2u] = half(_591.z); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_591.w); patchOut.out_var_PN_POSITION9 = _450 + ((_450 - (((temp_var_hullMainRetVal[2u].WorldPosition[0] + temp_var_hullMainRetVal[1u].WorldPosition[0]) + temp_var_hullMainRetVal[0u].WorldPosition[0]) * float4(0.3333333432674407958984375))) * float4(0.5)); } } spirv-cross-2021.01.15/reference/shaders-ue4/asm/tesc/hs-input-array-access.asm.tesc000066400000000000000000000620331400026215700277570ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct FVertexFactoryInterpolantsVSToPS { float4 TangentToWorld0; float4 TangentToWorld2; }; struct FVertexFactoryInterpolantsVSToDS { FVertexFactoryInterpolantsVSToPS InterpolantsVSToPS; }; struct FHitProxyVSToDS { FVertexFactoryInterpolantsVSToDS FactoryInterpolants; float4 Position; uint VertexID; }; struct FHullShaderConstantDominantVertexData { float2 UV; float4 Normal; float3 Tangent; }; struct FHullShaderConstantDominantEdgeData { float2 UV0; float2 UV1; float4 Normal0; float4 Normal1; float3 Tangent0; float3 Tangent1; }; struct FPNTessellationHSToDS { FHitProxyVSToDS PassSpecificData; spvUnsafeArray WorldPosition; float3 DisplacementScale; float TessellationMultiplier; float WorldDisplacementMultiplier; FHullShaderConstantDominantVertexData DominantVertex; FHullShaderConstantDominantEdgeData DominantEdge; }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_DrawsVelocity; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; uint Primitive_LightingChannelMask; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightmapDataIndex; packed_float3 Primitive_PreSkinnedLocalBounds; int Primitive_SingleCaptureIndex; uint Primitive_OutputVelocity; uint PrePadding_Primitive_420; uint PrePadding_Primitive_424; uint PrePadding_Primitive_428; float4 Primitive_CustomPrimitiveData[4]; }; constant float4 _140 = {}; struct main0_out { float3 out_var_PN_DisplacementScales; float2 out_var_PN_DominantEdge; float2 out_var_PN_DominantEdge1; float4 out_var_PN_DominantEdge2; float4 out_var_PN_DominantEdge3; float3 out_var_PN_DominantEdge4; float3 out_var_PN_DominantEdge5; float2 out_var_PN_DominantVertex; float4 out_var_PN_DominantVertex1; float3 out_var_PN_DominantVertex2; spvUnsafeArray out_var_PN_POSITION; float out_var_PN_TessellationMultiplier; float out_var_PN_WorldDisplacementMultiplier; float4 out_var_TEXCOORD10_centroid; float4 out_var_TEXCOORD11_centroid; float4 out_var_VS_To_DS_Position; uint out_var_VS_To_DS_VertexID; }; struct main0_patchOut { float4 out_var_PN_POSITION9; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[attribute(0)]]; float4 in_var_TEXCOORD11_centroid [[attribute(1)]]; float4 in_var_VS_To_DS_Position [[attribute(2)]]; uint in_var_VS_To_DS_VertexID [[attribute(3)]]; }; kernel void main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_Primitive& Primitive [[buffer(1)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { threadgroup FPNTessellationHSToDS temp_var_hullMainRetVal[3]; device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 3) return; spvUnsafeArray _142 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD10_centroid, gl_in[1].in_var_TEXCOORD10_centroid, gl_in[2].in_var_TEXCOORD10_centroid, gl_in[3].in_var_TEXCOORD10_centroid, gl_in[4].in_var_TEXCOORD10_centroid, gl_in[5].in_var_TEXCOORD10_centroid, gl_in[6].in_var_TEXCOORD10_centroid, gl_in[7].in_var_TEXCOORD10_centroid, gl_in[8].in_var_TEXCOORD10_centroid, gl_in[9].in_var_TEXCOORD10_centroid, gl_in[10].in_var_TEXCOORD10_centroid, gl_in[11].in_var_TEXCOORD10_centroid }); spvUnsafeArray _143 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD11_centroid, gl_in[1].in_var_TEXCOORD11_centroid, gl_in[2].in_var_TEXCOORD11_centroid, gl_in[3].in_var_TEXCOORD11_centroid, gl_in[4].in_var_TEXCOORD11_centroid, gl_in[5].in_var_TEXCOORD11_centroid, gl_in[6].in_var_TEXCOORD11_centroid, gl_in[7].in_var_TEXCOORD11_centroid, gl_in[8].in_var_TEXCOORD11_centroid, gl_in[9].in_var_TEXCOORD11_centroid, gl_in[10].in_var_TEXCOORD11_centroid, gl_in[11].in_var_TEXCOORD11_centroid }); spvUnsafeArray _192 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_Position, gl_in[1].in_var_VS_To_DS_Position, gl_in[2].in_var_VS_To_DS_Position, gl_in[3].in_var_VS_To_DS_Position, gl_in[4].in_var_VS_To_DS_Position, gl_in[5].in_var_VS_To_DS_Position, gl_in[6].in_var_VS_To_DS_Position, gl_in[7].in_var_VS_To_DS_Position, gl_in[8].in_var_VS_To_DS_Position, gl_in[9].in_var_VS_To_DS_Position, gl_in[10].in_var_VS_To_DS_Position, gl_in[11].in_var_VS_To_DS_Position }); spvUnsafeArray _193 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_VertexID, gl_in[1].in_var_VS_To_DS_VertexID, gl_in[2].in_var_VS_To_DS_VertexID, gl_in[3].in_var_VS_To_DS_VertexID, gl_in[4].in_var_VS_To_DS_VertexID, gl_in[5].in_var_VS_To_DS_VertexID, gl_in[6].in_var_VS_To_DS_VertexID, gl_in[7].in_var_VS_To_DS_VertexID, gl_in[8].in_var_VS_To_DS_VertexID, gl_in[9].in_var_VS_To_DS_VertexID, gl_in[10].in_var_VS_To_DS_VertexID, gl_in[11].in_var_VS_To_DS_VertexID }); spvUnsafeArray _230 = spvUnsafeArray({ FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[0], _143[0] } }, _192[0], _193[0] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[1], _143[1] } }, _192[1], _193[1] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[2], _143[2] } }, _192[2], _193[2] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[3], _143[3] } }, _192[3], _193[3] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[4], _143[4] } }, _192[4], _193[4] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[5], _143[5] } }, _192[5], _193[5] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[6], _143[6] } }, _192[6], _193[6] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[7], _143[7] } }, _192[7], _193[7] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[8], _143[8] } }, _192[8], _193[8] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[9], _143[9] } }, _192[9], _193[9] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[10], _143[10] } }, _192[10], _193[10] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _142[11], _143[11] } }, _192[11], _193[11] } }); spvUnsafeArray param_var_I; param_var_I = _230; float4 _247 = float4(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float3 _251 = Primitive.Primitive_NonUniformScale.xyz * float3x3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz, cross(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz) * float3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.w), param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz); uint _254 = (gl_InvocationID < 2u) ? (gl_InvocationID + 1u) : 0u; uint _255 = 2u * gl_InvocationID; uint _256 = 3u + _255; uint _257 = _255 + 4u; uint _264 = (_254 < 2u) ? (_254 + 1u) : 0u; uint _265 = 2u * _254; uint _266 = 3u + _265; uint _267 = _265 + 4u; float4 _279 = float4(param_var_I[9u + gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _315; float4 _316; float4 _317; float4 _318; if ((param_var_I[_266].VertexID < param_var_I[_254].VertexID) || ((param_var_I[_266].VertexID == param_var_I[_254].VertexID) && (param_var_I[_267].VertexID < param_var_I[_264].VertexID))) { _315 = param_var_I[_267].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; _316 = param_var_I[_267].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; _317 = param_var_I[_266].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; _318 = param_var_I[_266].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; } else { _315 = param_var_I[_264].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; _316 = param_var_I[_264].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; _317 = param_var_I[_254].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; _318 = param_var_I[_254].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; } float4 _324 = float4(_318.xyz, 0.0); float4 _328 = float4(_316.xyz, 0.0); float4 _336 = float4(param_var_I[_254].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _344 = float4(param_var_I[_256].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _352 = float4(param_var_I[_257].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); spvUnsafeArray _402 = spvUnsafeArray({ param_var_I[gl_InvocationID].Position, (((((float4(2.0) * param_var_I[gl_InvocationID].Position) + param_var_I[_254].Position) - (float4(dot(param_var_I[_254].Position - param_var_I[gl_InvocationID].Position, _247)) * _247)) * float4(0.3333333432674407958984375)) + ((((float4(2.0) * param_var_I[_256].Position) + param_var_I[_257].Position) - (float4(dot(param_var_I[_257].Position - param_var_I[_256].Position, _344)) * _344)) * float4(0.3333333432674407958984375))) * float4(0.5), (((((float4(2.0) * param_var_I[_254].Position) + param_var_I[gl_InvocationID].Position) - (float4(dot(param_var_I[gl_InvocationID].Position - param_var_I[_254].Position, _336)) * _336)) * float4(0.3333333432674407958984375)) + ((((float4(2.0) * param_var_I[_257].Position) + param_var_I[_256].Position) - (float4(dot(param_var_I[_256].Position - param_var_I[_257].Position, _352)) * _352)) * float4(0.3333333432674407958984375))) * float4(0.5) }); gl_out[gl_InvocationID].out_var_TEXCOORD10_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; gl_out[gl_InvocationID].out_var_TEXCOORD11_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; gl_out[gl_InvocationID].out_var_VS_To_DS_Position = param_var_I[gl_InvocationID].Position; gl_out[gl_InvocationID].out_var_VS_To_DS_VertexID = param_var_I[gl_InvocationID].VertexID; gl_out[gl_InvocationID].out_var_PN_POSITION = _402; gl_out[gl_InvocationID].out_var_PN_DisplacementScales = _251; gl_out[gl_InvocationID].out_var_PN_TessellationMultiplier = 1.0; gl_out[gl_InvocationID].out_var_PN_WorldDisplacementMultiplier = 1.0; gl_out[gl_InvocationID].out_var_PN_DominantVertex = float2(0.0); gl_out[gl_InvocationID].out_var_PN_DominantVertex1 = _279; gl_out[gl_InvocationID].out_var_PN_DominantVertex2 = param_var_I[9u + gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz; gl_out[gl_InvocationID].out_var_PN_DominantEdge = float2(0.0); gl_out[gl_InvocationID].out_var_PN_DominantEdge1 = float2(0.0); gl_out[gl_InvocationID].out_var_PN_DominantEdge2 = _324; gl_out[gl_InvocationID].out_var_PN_DominantEdge3 = _328; gl_out[gl_InvocationID].out_var_PN_DominantEdge4 = _317.xyz; gl_out[gl_InvocationID].out_var_PN_DominantEdge5 = _315.xyz; temp_var_hullMainRetVal[gl_InvocationID] = FPNTessellationHSToDS{ param_var_I[gl_InvocationID], _402, _251, 1.0, 1.0, FHullShaderConstantDominantVertexData{ float2(0.0), _279, param_var_I[9u + gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz }, FHullShaderConstantDominantEdgeData{ float2(0.0), float2(0.0), _324, _328, _317.xyz, _315.xyz } }; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0u) { float4 _461 = (((((temp_var_hullMainRetVal[0u].WorldPosition[1] + temp_var_hullMainRetVal[0u].WorldPosition[2]) + temp_var_hullMainRetVal[1u].WorldPosition[1]) + temp_var_hullMainRetVal[1u].WorldPosition[2]) + temp_var_hullMainRetVal[2u].WorldPosition[1]) + temp_var_hullMainRetVal[2u].WorldPosition[2]) * float4(0.16666667163372039794921875); float4 _474 = _140; _474.x = 0.5 * (temp_var_hullMainRetVal[1u].TessellationMultiplier + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _480 = _474; _480.y = 0.5 * (temp_var_hullMainRetVal[2u].TessellationMultiplier + temp_var_hullMainRetVal[0u].TessellationMultiplier); float4 _485 = _480; _485.z = 0.5 * (temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier); float4 _492 = _485; _492.w = 0.333000004291534423828125 * ((temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier) + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _600; for (;;) { float4 _500 = View.View_ViewToClip * float4(0.0); float4 _505 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[0u].WorldPosition[0].xyz, 1.0); float3 _506 = _505.xyz; float3 _507 = _500.xyz; float _509 = _505.w; float _510 = _500.w; float4 _527 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[1u].WorldPosition[0].xyz, 1.0); float3 _528 = _527.xyz; float _530 = _527.w; float4 _548 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[2u].WorldPosition[0].xyz, 1.0); float3 _549 = _548.xyz; float _551 = _548.w; if (any((((select(int3(0), int3(1), (_506 - _507) < float3(_509 + _510)) + (int3(2) * select(int3(0), int3(1), (_506 + _507) > float3((-_509) - _510)))) | (select(int3(0), int3(1), (_528 - _507) < float3(_530 + _510)) + (int3(2) * select(int3(0), int3(1), (_528 + _507) > float3((-_530) - _510))))) | (select(int3(0), int3(1), (_549 - _507) < float3(_551 + _510)) + (int3(2) * select(int3(0), int3(1), (_549 + _507) > float3((-_551) - _510))))) != int3(3))) { _600 = float4(0.0); break; } float3 _569 = temp_var_hullMainRetVal[0u].WorldPosition[0].xyz - temp_var_hullMainRetVal[1u].WorldPosition[0].xyz; float3 _570 = temp_var_hullMainRetVal[1u].WorldPosition[0].xyz - temp_var_hullMainRetVal[2u].WorldPosition[0].xyz; float3 _571 = temp_var_hullMainRetVal[2u].WorldPosition[0].xyz - temp_var_hullMainRetVal[0u].WorldPosition[0].xyz; float3 _574 = (float3(0.5) * (temp_var_hullMainRetVal[0u].WorldPosition[0].xyz + temp_var_hullMainRetVal[1u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _577 = (float3(0.5) * (temp_var_hullMainRetVal[1u].WorldPosition[0].xyz + temp_var_hullMainRetVal[2u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _580 = (float3(0.5) * (temp_var_hullMainRetVal[2u].WorldPosition[0].xyz + temp_var_hullMainRetVal[0u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float _584 = sqrt(dot(_570, _570) / dot(_577, _577)); float _588 = sqrt(dot(_571, _571) / dot(_580, _580)); float _592 = sqrt(dot(_569, _569) / dot(_574, _574)); float4 _597 = float4(_584, _588, _592, 1.0); _597.w = 0.333000004291534423828125 * ((_584 + _588) + _592); _600 = float4(View.View_AdaptiveTessellationFactor) * _597; break; } float4 _602 = fast::clamp(_492 * _600, float4(1.0), float4(15.0)); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0u] = half(_602.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1u] = half(_602.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2u] = half(_602.z); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_602.w); patchOut.out_var_PN_POSITION9 = _461 + ((_461 - (((temp_var_hullMainRetVal[2u].WorldPosition[0] + temp_var_hullMainRetVal[1u].WorldPosition[0]) + temp_var_hullMainRetVal[0u].WorldPosition[0]) * float4(0.3333333432674407958984375))) * float4(0.5)); } } spirv-cross-2021.01.15/reference/shaders-ue4/asm/tesc/hs-texcoord-array.asm.tesc000066400000000000000000000571011400026215700272100ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct FVertexFactoryInterpolantsVSToPS { float4 TangentToWorld0; float4 TangentToWorld2; float4 Color; spvUnsafeArray TexCoords; }; struct FVertexFactoryInterpolantsVSToDS { FVertexFactoryInterpolantsVSToPS InterpolantsVSToPS; }; struct FHitProxyVSToDS { FVertexFactoryInterpolantsVSToDS FactoryInterpolants; float4 Position; }; struct FPNTessellationHSToDS { FHitProxyVSToDS PassSpecificData; spvUnsafeArray WorldPosition; float3 DisplacementScale; float TessellationMultiplier; float WorldDisplacementMultiplier; }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_DrawsVelocity; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; uint Primitive_LightingChannelMask; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightmapDataIndex; packed_float3 Primitive_PreSkinnedLocalBounds; int Primitive_SingleCaptureIndex; uint Primitive_OutputVelocity; uint PrePadding_Primitive_420; uint PrePadding_Primitive_424; uint PrePadding_Primitive_428; float4 Primitive_CustomPrimitiveData[4]; }; constant float4 _127 = {}; struct main0_out { float4 out_var_COLOR0; float3 out_var_PN_DisplacementScales; spvUnsafeArray out_var_PN_POSITION; float out_var_PN_TessellationMultiplier; float out_var_PN_WorldDisplacementMultiplier; spvUnsafeArray out_var_TEXCOORD0; float4 out_var_TEXCOORD10_centroid; float4 out_var_TEXCOORD11_centroid; float4 out_var_VS_To_DS_Position; }; struct main0_patchOut { float4 out_var_PN_POSITION9; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[attribute(0)]]; float4 in_var_TEXCOORD11_centroid [[attribute(1)]]; float4 in_var_COLOR0 [[attribute(2)]]; float2 in_var_TEXCOORD0_0 [[attribute(3)]]; float2 in_var_TEXCOORD0_1 [[attribute(4)]]; float4 in_var_VS_To_DS_Position [[attribute(5)]]; }; kernel void main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_Primitive& Primitive [[buffer(1)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { threadgroup FPNTessellationHSToDS temp_var_hullMainRetVal[3]; device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3]; device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 3) return; spvUnsafeArray _129 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD10_centroid, gl_in[1].in_var_TEXCOORD10_centroid, gl_in[2].in_var_TEXCOORD10_centroid, gl_in[3].in_var_TEXCOORD10_centroid, gl_in[4].in_var_TEXCOORD10_centroid, gl_in[5].in_var_TEXCOORD10_centroid, gl_in[6].in_var_TEXCOORD10_centroid, gl_in[7].in_var_TEXCOORD10_centroid, gl_in[8].in_var_TEXCOORD10_centroid, gl_in[9].in_var_TEXCOORD10_centroid, gl_in[10].in_var_TEXCOORD10_centroid, gl_in[11].in_var_TEXCOORD10_centroid }); spvUnsafeArray _130 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD11_centroid, gl_in[1].in_var_TEXCOORD11_centroid, gl_in[2].in_var_TEXCOORD11_centroid, gl_in[3].in_var_TEXCOORD11_centroid, gl_in[4].in_var_TEXCOORD11_centroid, gl_in[5].in_var_TEXCOORD11_centroid, gl_in[6].in_var_TEXCOORD11_centroid, gl_in[7].in_var_TEXCOORD11_centroid, gl_in[8].in_var_TEXCOORD11_centroid, gl_in[9].in_var_TEXCOORD11_centroid, gl_in[10].in_var_TEXCOORD11_centroid, gl_in[11].in_var_TEXCOORD11_centroid }); spvUnsafeArray _131 = spvUnsafeArray({ gl_in[0].in_var_COLOR0, gl_in[1].in_var_COLOR0, gl_in[2].in_var_COLOR0, gl_in[3].in_var_COLOR0, gl_in[4].in_var_COLOR0, gl_in[5].in_var_COLOR0, gl_in[6].in_var_COLOR0, gl_in[7].in_var_COLOR0, gl_in[8].in_var_COLOR0, gl_in[9].in_var_COLOR0, gl_in[10].in_var_COLOR0, gl_in[11].in_var_COLOR0 }); spvUnsafeArray, 12> _132 = spvUnsafeArray, 12>({ spvUnsafeArray({ gl_in[0].in_var_TEXCOORD0_0, gl_in[0].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[1].in_var_TEXCOORD0_0, gl_in[1].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[2].in_var_TEXCOORD0_0, gl_in[2].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[3].in_var_TEXCOORD0_0, gl_in[3].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[4].in_var_TEXCOORD0_0, gl_in[4].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[5].in_var_TEXCOORD0_0, gl_in[5].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[6].in_var_TEXCOORD0_0, gl_in[6].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[7].in_var_TEXCOORD0_0, gl_in[7].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[8].in_var_TEXCOORD0_0, gl_in[8].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[9].in_var_TEXCOORD0_0, gl_in[9].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[10].in_var_TEXCOORD0_0, gl_in[10].in_var_TEXCOORD0_1 }), spvUnsafeArray({ gl_in[11].in_var_TEXCOORD0_0, gl_in[11].in_var_TEXCOORD0_1 }) }); spvUnsafeArray _205 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_Position, gl_in[1].in_var_VS_To_DS_Position, gl_in[2].in_var_VS_To_DS_Position, gl_in[3].in_var_VS_To_DS_Position, gl_in[4].in_var_VS_To_DS_Position, gl_in[5].in_var_VS_To_DS_Position, gl_in[6].in_var_VS_To_DS_Position, gl_in[7].in_var_VS_To_DS_Position, gl_in[8].in_var_VS_To_DS_Position, gl_in[9].in_var_VS_To_DS_Position, gl_in[10].in_var_VS_To_DS_Position, gl_in[11].in_var_VS_To_DS_Position }); spvUnsafeArray _230 = spvUnsafeArray({ FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[0], _130[0], _131[0], _132[0] } }, _205[0] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[1], _130[1], _131[1], _132[1] } }, _205[1] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[2], _130[2], _131[2], _132[2] } }, _205[2] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[3], _130[3], _131[3], _132[3] } }, _205[3] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[4], _130[4], _131[4], _132[4] } }, _205[4] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[5], _130[5], _131[5], _132[5] } }, _205[5] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[6], _130[6], _131[6], _132[6] } }, _205[6] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[7], _130[7], _131[7], _132[7] } }, _205[7] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[8], _130[8], _131[8], _132[8] } }, _205[8] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[9], _130[9], _131[9], _132[9] } }, _205[9] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[10], _130[10], _131[10], _132[10] } }, _205[10] }, FHitProxyVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _129[11], _130[11], _131[11], _132[11] } }, _205[11] } }); spvUnsafeArray param_var_I; param_var_I = _230; float4 _247 = float4(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float3 _251 = Primitive.Primitive_NonUniformScale.xyz * float3x3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz, cross(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz) * float3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.w), param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz); uint _254 = (gl_InvocationID < 2u) ? (gl_InvocationID + 1u) : 0u; uint _255 = 2u * gl_InvocationID; uint _256 = 3u + _255; uint _257 = _255 + 4u; float4 _269 = float4(param_var_I[_254].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _277 = float4(param_var_I[_256].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); float4 _285 = float4(param_var_I[_257].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, 0.0); spvUnsafeArray _333 = spvUnsafeArray({ param_var_I[gl_InvocationID].Position, (((((float4(2.0) * param_var_I[gl_InvocationID].Position) + param_var_I[_254].Position) - (float4(dot(param_var_I[_254].Position - param_var_I[gl_InvocationID].Position, _247)) * _247)) * float4(0.3333333432674407958984375)) + ((((float4(2.0) * param_var_I[_256].Position) + param_var_I[_257].Position) - (float4(dot(param_var_I[_257].Position - param_var_I[_256].Position, _277)) * _277)) * float4(0.3333333432674407958984375))) * float4(0.5), (((((float4(2.0) * param_var_I[_254].Position) + param_var_I[gl_InvocationID].Position) - (float4(dot(param_var_I[gl_InvocationID].Position - param_var_I[_254].Position, _269)) * _269)) * float4(0.3333333432674407958984375)) + ((((float4(2.0) * param_var_I[_257].Position) + param_var_I[_256].Position) - (float4(dot(param_var_I[_256].Position - param_var_I[_257].Position, _285)) * _285)) * float4(0.3333333432674407958984375))) * float4(0.5) }); gl_out[gl_InvocationID].out_var_TEXCOORD10_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; gl_out[gl_InvocationID].out_var_TEXCOORD11_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; gl_out[gl_InvocationID].out_var_COLOR0 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.Color; gl_out[gl_InvocationID].out_var_TEXCOORD0 = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TexCoords; gl_out[gl_InvocationID].out_var_VS_To_DS_Position = param_var_I[gl_InvocationID].Position; gl_out[gl_InvocationID].out_var_PN_POSITION = _333; gl_out[gl_InvocationID].out_var_PN_DisplacementScales = _251; gl_out[gl_InvocationID].out_var_PN_TessellationMultiplier = 1.0; gl_out[gl_InvocationID].out_var_PN_WorldDisplacementMultiplier = 1.0; temp_var_hullMainRetVal[gl_InvocationID] = FPNTessellationHSToDS{ param_var_I[gl_InvocationID], _333, _251, 1.0, 1.0 }; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0u) { float4 _385 = (((((temp_var_hullMainRetVal[0u].WorldPosition[1] + temp_var_hullMainRetVal[0u].WorldPosition[2]) + temp_var_hullMainRetVal[1u].WorldPosition[1]) + temp_var_hullMainRetVal[1u].WorldPosition[2]) + temp_var_hullMainRetVal[2u].WorldPosition[1]) + temp_var_hullMainRetVal[2u].WorldPosition[2]) * float4(0.16666667163372039794921875); float4 _398 = _127; _398.x = 0.5 * (temp_var_hullMainRetVal[1u].TessellationMultiplier + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _404 = _398; _404.y = 0.5 * (temp_var_hullMainRetVal[2u].TessellationMultiplier + temp_var_hullMainRetVal[0u].TessellationMultiplier); float4 _409 = _404; _409.z = 0.5 * (temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier); float4 _416 = _409; _416.w = 0.333000004291534423828125 * ((temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier) + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _524; for (;;) { float4 _424 = View.View_ViewToClip * float4(0.0); float4 _429 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[0u].WorldPosition[0].xyz, 1.0); float3 _430 = _429.xyz; float3 _431 = _424.xyz; float _433 = _429.w; float _434 = _424.w; float4 _451 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[1u].WorldPosition[0].xyz, 1.0); float3 _452 = _451.xyz; float _454 = _451.w; float4 _472 = View.View_TranslatedWorldToClip * float4(temp_var_hullMainRetVal[2u].WorldPosition[0].xyz, 1.0); float3 _473 = _472.xyz; float _475 = _472.w; if (any((((select(int3(0), int3(1), (_430 - _431) < float3(_433 + _434)) + (int3(2) * select(int3(0), int3(1), (_430 + _431) > float3((-_433) - _434)))) | (select(int3(0), int3(1), (_452 - _431) < float3(_454 + _434)) + (int3(2) * select(int3(0), int3(1), (_452 + _431) > float3((-_454) - _434))))) | (select(int3(0), int3(1), (_473 - _431) < float3(_475 + _434)) + (int3(2) * select(int3(0), int3(1), (_473 + _431) > float3((-_475) - _434))))) != int3(3))) { _524 = float4(0.0); break; } float3 _493 = temp_var_hullMainRetVal[0u].WorldPosition[0].xyz - temp_var_hullMainRetVal[1u].WorldPosition[0].xyz; float3 _494 = temp_var_hullMainRetVal[1u].WorldPosition[0].xyz - temp_var_hullMainRetVal[2u].WorldPosition[0].xyz; float3 _495 = temp_var_hullMainRetVal[2u].WorldPosition[0].xyz - temp_var_hullMainRetVal[0u].WorldPosition[0].xyz; float3 _498 = (float3(0.5) * (temp_var_hullMainRetVal[0u].WorldPosition[0].xyz + temp_var_hullMainRetVal[1u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _501 = (float3(0.5) * (temp_var_hullMainRetVal[1u].WorldPosition[0].xyz + temp_var_hullMainRetVal[2u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float3 _504 = (float3(0.5) * (temp_var_hullMainRetVal[2u].WorldPosition[0].xyz + temp_var_hullMainRetVal[0u].WorldPosition[0].xyz)) - float3(View.View_TranslatedWorldCameraOrigin); float _508 = sqrt(dot(_494, _494) / dot(_501, _501)); float _512 = sqrt(dot(_495, _495) / dot(_504, _504)); float _516 = sqrt(dot(_493, _493) / dot(_498, _498)); float4 _521 = float4(_508, _512, _516, 1.0); _521.w = 0.333000004291534423828125 * ((_508 + _512) + _516); _524 = float4(View.View_AdaptiveTessellationFactor) * _521; break; } float4 _526 = fast::clamp(_416 * _524, float4(1.0), float4(15.0)); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0u] = half(_526.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1u] = half(_526.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2u] = half(_526.z); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_526.w); patchOut.out_var_PN_POSITION9 = _385 + ((_385 - (((temp_var_hullMainRetVal[2u].WorldPosition[0] + temp_var_hullMainRetVal[1u].WorldPosition[0]) + temp_var_hullMainRetVal[0u].WorldPosition[0]) * float4(0.3333333432674407958984375))) * float4(0.5)); } } spirv-cross-2021.01.15/reference/shaders-ue4/asm/tesc/tess-factor-must-be-threadgroup.asm.tesc000066400000000000000000000174311400026215700317650ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct FVertexFactoryInterpolantsVSToPS { float4 TangentToWorld0; float4 TangentToWorld2; }; struct FVertexFactoryInterpolantsVSToDS { FVertexFactoryInterpolantsVSToPS InterpolantsVSToPS; }; struct FSharedBasePassInterpolants { }; struct FBasePassInterpolantsVSToDS { FSharedBasePassInterpolants _m0; }; struct FBasePassVSToDS { FVertexFactoryInterpolantsVSToDS FactoryInterpolants; FBasePassInterpolantsVSToDS BasePassInterpolants; float4 Position; }; struct FFlatTessellationHSToDS { FBasePassVSToDS PassSpecificData; float3 DisplacementScale; float TessellationMultiplier; float WorldDisplacementMultiplier; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_DrawsVelocity; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; uint Primitive_LightingChannelMask; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightmapDataIndex; packed_float3 Primitive_PreSkinnedLocalBounds; int Primitive_SingleCaptureIndex; uint Primitive_OutputVelocity; uint PrePadding_Primitive_420; uint PrePadding_Primitive_424; uint PrePadding_Primitive_428; float4 Primitive_CustomPrimitiveData[4]; }; struct type_Material { float4 Material_VectorExpressions[3]; float4 Material_ScalarExpressions[1]; }; constant float4 _88 = {}; struct main0_out { float3 out_var_Flat_DisplacementScales; float out_var_Flat_TessellationMultiplier; float out_var_Flat_WorldDisplacementMultiplier; float4 out_var_TEXCOORD10_centroid; float4 out_var_TEXCOORD11_centroid; float4 out_var_VS_To_DS_Position; }; struct main0_in { float4 in_var_TEXCOORD10_centroid [[attribute(0)]]; float4 in_var_TEXCOORD11_centroid [[attribute(1)]]; float4 in_var_VS_To_DS_Position [[attribute(2)]]; }; kernel void main0(main0_in in [[stage_in]], constant type_Primitive& Primitive [[buffer(0)]], constant type_Material& Material [[buffer(1)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], constant uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]]) { threadgroup FFlatTessellationHSToDS temp_var_hullMainRetVal[3]; device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3]; if (gl_InvocationID < spvIndirectParams[0]) gl_in[gl_InvocationID] = in; threadgroup_barrier(mem_flags::mem_threadgroup); if (gl_InvocationID >= 3) return; spvUnsafeArray _90 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD10_centroid, gl_in[1].in_var_TEXCOORD10_centroid, gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _91 = spvUnsafeArray({ gl_in[0].in_var_TEXCOORD11_centroid, gl_in[1].in_var_TEXCOORD11_centroid, gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray _104 = spvUnsafeArray({ gl_in[0].in_var_VS_To_DS_Position, gl_in[1].in_var_VS_To_DS_Position, gl_in[2].in_var_VS_To_DS_Position }); spvUnsafeArray _111 = spvUnsafeArray({ FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _90[0], _91[0] } }, FBasePassInterpolantsVSToDS{ { } }, _104[0] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _90[1], _91[1] } }, FBasePassInterpolantsVSToDS{ { } }, _104[1] }, FBasePassVSToDS{ FVertexFactoryInterpolantsVSToDS{ FVertexFactoryInterpolantsVSToPS{ _90[2], _91[2] } }, FBasePassInterpolantsVSToDS{ { } }, _104[2] } }); spvUnsafeArray param_var_I; param_var_I = _111; float3 _128 = Primitive.Primitive_NonUniformScale.xyz * float3x3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz, cross(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz, param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0.xyz) * float3(param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.w), param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2.xyz); gl_out[gl_InvocationID].out_var_TEXCOORD10_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld0; gl_out[gl_InvocationID].out_var_TEXCOORD11_centroid = param_var_I[gl_InvocationID].FactoryInterpolants.InterpolantsVSToPS.TangentToWorld2; gl_out[gl_InvocationID].out_var_VS_To_DS_Position = param_var_I[gl_InvocationID].Position; gl_out[gl_InvocationID].out_var_Flat_DisplacementScales = _128; gl_out[gl_InvocationID].out_var_Flat_TessellationMultiplier = Material.Material_ScalarExpressions[0].x; gl_out[gl_InvocationID].out_var_Flat_WorldDisplacementMultiplier = 1.0; temp_var_hullMainRetVal[gl_InvocationID] = FFlatTessellationHSToDS{ param_var_I[gl_InvocationID], _128, Material.Material_ScalarExpressions[0].x, 1.0 }; threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); if (gl_InvocationID == 0u) { float4 _154 = _88; _154.x = 0.5 * (temp_var_hullMainRetVal[1u].TessellationMultiplier + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _160 = _154; _160.y = 0.5 * (temp_var_hullMainRetVal[2u].TessellationMultiplier + temp_var_hullMainRetVal[0u].TessellationMultiplier); float4 _165 = _160; _165.z = 0.5 * (temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier); float4 _172 = _165; _172.w = 0.333000004291534423828125 * ((temp_var_hullMainRetVal[0u].TessellationMultiplier + temp_var_hullMainRetVal[1u].TessellationMultiplier) + temp_var_hullMainRetVal[2u].TessellationMultiplier); float4 _173 = fast::clamp(_172, float4(1.0), float4(15.0)); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0u] = half(_173.x); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1u] = half(_173.y); spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2u] = half(_173.z); spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_173.w); } } spirv-cross-2021.01.15/reference/shaders-ue4/asm/tese/000077500000000000000000000000001400026215700221745ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4/asm/tese/ds-double-gl-in-deref.asm.tese000066400000000000000000000445751400026215700276210ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_ShadowDepthPass { float PrePadding_ShadowDepthPass_LPV_0; float PrePadding_ShadowDepthPass_LPV_4; float PrePadding_ShadowDepthPass_LPV_8; float PrePadding_ShadowDepthPass_LPV_12; float PrePadding_ShadowDepthPass_LPV_16; float PrePadding_ShadowDepthPass_LPV_20; float PrePadding_ShadowDepthPass_LPV_24; float PrePadding_ShadowDepthPass_LPV_28; float PrePadding_ShadowDepthPass_LPV_32; float PrePadding_ShadowDepthPass_LPV_36; float PrePadding_ShadowDepthPass_LPV_40; float PrePadding_ShadowDepthPass_LPV_44; float PrePadding_ShadowDepthPass_LPV_48; float PrePadding_ShadowDepthPass_LPV_52; float PrePadding_ShadowDepthPass_LPV_56; float PrePadding_ShadowDepthPass_LPV_60; float PrePadding_ShadowDepthPass_LPV_64; float PrePadding_ShadowDepthPass_LPV_68; float PrePadding_ShadowDepthPass_LPV_72; float PrePadding_ShadowDepthPass_LPV_76; float PrePadding_ShadowDepthPass_LPV_80; float PrePadding_ShadowDepthPass_LPV_84; float PrePadding_ShadowDepthPass_LPV_88; float PrePadding_ShadowDepthPass_LPV_92; float PrePadding_ShadowDepthPass_LPV_96; float PrePadding_ShadowDepthPass_LPV_100; float PrePadding_ShadowDepthPass_LPV_104; float PrePadding_ShadowDepthPass_LPV_108; float PrePadding_ShadowDepthPass_LPV_112; float PrePadding_ShadowDepthPass_LPV_116; float PrePadding_ShadowDepthPass_LPV_120; float PrePadding_ShadowDepthPass_LPV_124; float PrePadding_ShadowDepthPass_LPV_128; float PrePadding_ShadowDepthPass_LPV_132; float PrePadding_ShadowDepthPass_LPV_136; float PrePadding_ShadowDepthPass_LPV_140; float PrePadding_ShadowDepthPass_LPV_144; float PrePadding_ShadowDepthPass_LPV_148; float PrePadding_ShadowDepthPass_LPV_152; float PrePadding_ShadowDepthPass_LPV_156; float PrePadding_ShadowDepthPass_LPV_160; float PrePadding_ShadowDepthPass_LPV_164; float PrePadding_ShadowDepthPass_LPV_168; float PrePadding_ShadowDepthPass_LPV_172; float PrePadding_ShadowDepthPass_LPV_176; float PrePadding_ShadowDepthPass_LPV_180; float PrePadding_ShadowDepthPass_LPV_184; float PrePadding_ShadowDepthPass_LPV_188; float PrePadding_ShadowDepthPass_LPV_192; float PrePadding_ShadowDepthPass_LPV_196; float PrePadding_ShadowDepthPass_LPV_200; float PrePadding_ShadowDepthPass_LPV_204; float PrePadding_ShadowDepthPass_LPV_208; float PrePadding_ShadowDepthPass_LPV_212; float PrePadding_ShadowDepthPass_LPV_216; float PrePadding_ShadowDepthPass_LPV_220; float PrePadding_ShadowDepthPass_LPV_224; float PrePadding_ShadowDepthPass_LPV_228; float PrePadding_ShadowDepthPass_LPV_232; float PrePadding_ShadowDepthPass_LPV_236; float PrePadding_ShadowDepthPass_LPV_240; float PrePadding_ShadowDepthPass_LPV_244; float PrePadding_ShadowDepthPass_LPV_248; float PrePadding_ShadowDepthPass_LPV_252; float PrePadding_ShadowDepthPass_LPV_256; float PrePadding_ShadowDepthPass_LPV_260; float PrePadding_ShadowDepthPass_LPV_264; float PrePadding_ShadowDepthPass_LPV_268; float4x4 ShadowDepthPass_LPV_mRsmToWorld; float4 ShadowDepthPass_LPV_mLightColour; float4 ShadowDepthPass_LPV_GeometryVolumeCaptureLightDirection; float4 ShadowDepthPass_LPV_mEyePos; packed_int3 ShadowDepthPass_LPV_mOldGridOffset; int PrePadding_ShadowDepthPass_LPV_396; packed_int3 ShadowDepthPass_LPV_mLpvGridOffset; float ShadowDepthPass_LPV_ClearMultiplier; float ShadowDepthPass_LPV_LpvScale; float ShadowDepthPass_LPV_OneOverLpvScale; float ShadowDepthPass_LPV_DirectionalOcclusionIntensity; float ShadowDepthPass_LPV_DirectionalOcclusionRadius; float ShadowDepthPass_LPV_RsmAreaIntensityMultiplier; float ShadowDepthPass_LPV_RsmPixelToTexcoordMultiplier; float ShadowDepthPass_LPV_SecondaryOcclusionStrength; float ShadowDepthPass_LPV_SecondaryBounceStrength; float ShadowDepthPass_LPV_VplInjectionBias; float ShadowDepthPass_LPV_GeometryVolumeInjectionBias; float ShadowDepthPass_LPV_EmissiveInjectionMultiplier; int ShadowDepthPass_LPV_PropagationIndex; float4x4 ShadowDepthPass_ProjectionMatrix; float4x4 ShadowDepthPass_ViewMatrix; float4 ShadowDepthPass_ShadowParams; float ShadowDepthPass_bClampToNearPlane; float PrePadding_ShadowDepthPass_612; float PrePadding_ShadowDepthPass_616; float PrePadding_ShadowDepthPass_620; float4x4 ShadowDepthPass_ShadowViewProjectionMatrices[6]; float4x4 ShadowDepthPass_ShadowViewMatrices[6]; }; constant float4 _113 = {}; struct main0_out { float4 out_var_TEXCOORD10_centroid [[user(locn0)]]; float4 out_var_TEXCOORD11_centroid [[user(locn1)]]; float4 out_var_COLOR0 [[user(locn2)]]; float4 out_var_TEXCOORD0_0 [[user(locn3)]]; uint out_var_PRIMITIVE_ID [[user(locn4)]]; float out_var_TEXCOORD6 [[user(locn5)]]; float out_var_TEXCOORD8 [[user(locn6)]]; float3 out_var_TEXCOORD7 [[user(locn7)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_COLOR0 [[attribute(0)]]; float4 in_var_PN_POSITION_0 [[attribute(2)]]; float4 in_var_PN_POSITION_1 [[attribute(3)]]; float4 in_var_PN_POSITION_2 [[attribute(4)]]; float in_var_PN_WorldDisplacementMultiplier [[attribute(7)]]; uint in_var_PRIMITIVE_ID [[attribute(8)]]; float4 in_var_TEXCOORD0_0 [[attribute(9)]]; float4 in_var_TEXCOORD10_centroid [[attribute(10)]]; float4 in_var_TEXCOORD11_centroid [[attribute(11)]]; }; struct main0_patchIn { float4 in_var_PN_POSITION9 [[attribute(5)]]; patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant type_View& View [[buffer(0)]], constant type_ShadowDepthPass& ShadowDepthPass [[buffer(1)]], texture2d Material_Texture2D_3 [[texture(0)]], sampler Material_Texture2D_3Sampler [[sampler(0)]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray out_var_TEXCOORD0 = {}; spvUnsafeArray _117 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD10_centroid, patchIn.gl_in[1].in_var_TEXCOORD10_centroid, patchIn.gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _118 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD11_centroid, patchIn.gl_in[1].in_var_TEXCOORD11_centroid, patchIn.gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray _119 = spvUnsafeArray({ patchIn.gl_in[0].in_var_COLOR0, patchIn.gl_in[1].in_var_COLOR0, patchIn.gl_in[2].in_var_COLOR0 }); spvUnsafeArray, 3> _120 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD0_0 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_TEXCOORD0_0 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_TEXCOORD0_0 }) }); spvUnsafeArray, 3> _135 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_POSITION_0, patchIn.gl_in[0].in_var_PN_POSITION_1, patchIn.gl_in[0].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_PN_POSITION_0, patchIn.gl_in[1].in_var_PN_POSITION_1, patchIn.gl_in[1].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_PN_POSITION_0, patchIn.gl_in[2].in_var_PN_POSITION_1, patchIn.gl_in[2].in_var_PN_POSITION_2 }) }); spvUnsafeArray _136 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_WorldDisplacementMultiplier, patchIn.gl_in[1].in_var_PN_WorldDisplacementMultiplier, patchIn.gl_in[2].in_var_PN_WorldDisplacementMultiplier }); float _157 = gl_TessCoord.x * gl_TessCoord.x; float _158 = gl_TessCoord.y * gl_TessCoord.y; float _159 = gl_TessCoord.z * gl_TessCoord.z; float4 _165 = float4(gl_TessCoord.x); float4 _169 = float4(gl_TessCoord.y); float4 _174 = float4(gl_TessCoord.z); float4 _177 = float4(_157 * 3.0); float4 _181 = float4(_158 * 3.0); float4 _188 = float4(_159 * 3.0); float4 _202 = ((((((((((_135[0][0] * float4(_157)) * _165) + ((_135[1][0] * float4(_158)) * _169)) + ((_135[2][0] * float4(_159)) * _174)) + ((_135[0][1] * _177) * _169)) + ((_135[0][2] * _181) * _165)) + ((_135[1][1] * _181) * _174)) + ((_135[1][2] * _188) * _169)) + ((_135[2][1] * _188) * _165)) + ((_135[2][2] * _177) * _174)) + ((((patchIn.in_var_PN_POSITION9 * float4(6.0)) * _174) * _165) * _169); float3 _226 = ((_117[0].xyz * float3(gl_TessCoord.x)) + (_117[1].xyz * float3(gl_TessCoord.y))).xyz + (_117[2].xyz * float3(gl_TessCoord.z)); float4 _229 = ((_118[0] * _165) + (_118[1] * _169)) + (_118[2] * _174); float4 _231 = ((_119[0] * _165) + (_119[1] * _169)) + (_119[2] * _174); float4 _233 = ((_120[0][0] * _165) + (_120[1][0] * _169)) + (_120[2][0] * _174); spvUnsafeArray _234 = spvUnsafeArray({ _233 }); float3 _236 = _229.xyz; float3 _264 = _202.xyz + (((float3((Material_Texture2D_3.sample(Material_Texture2D_3Sampler, (float2(View.View_GameTime * 0.20000000298023223876953125, View.View_GameTime * (-0.699999988079071044921875)) + (_233.zw * float2(1.0, 2.0))), level(-1.0)).x * 10.0) * (1.0 - _231.x)) * _236) * float3(0.5)) * float3(((_136[0] * gl_TessCoord.x) + (_136[1] * gl_TessCoord.y)) + (_136[2] * gl_TessCoord.z))); float4x4 _116 = ShadowDepthPass.ShadowDepthPass_ViewMatrix; float4 _270 = ShadowDepthPass.ShadowDepthPass_ProjectionMatrix * float4(_264.x, _264.y, _264.z, _202.w); float4 _281; if ((ShadowDepthPass.ShadowDepthPass_bClampToNearPlane > 0.0) && (_270.z < 0.0)) { float4 _279 = _270; _279.z = 9.9999999747524270787835121154785e-07; float4 _280 = _279; _280.w = 1.0; _281 = _280; } else { _281 = _270; } float _290 = abs(dot(float3(_116[0u].z, _116[1u].z, _116[2u].z), _236)); out.out_var_TEXCOORD10_centroid = float4(_226.x, _226.y, _226.z, _113.w); out.out_var_TEXCOORD11_centroid = _229; out.out_var_COLOR0 = _231; out_var_TEXCOORD0 = _234; out.out_var_PRIMITIVE_ID = patchIn.gl_in[0u].in_var_PRIMITIVE_ID; out.out_var_TEXCOORD6 = _281.z; out.out_var_TEXCOORD8 = (ShadowDepthPass.ShadowDepthPass_ShadowParams.y * fast::clamp((abs(_290) > 0.0) ? (sqrt(fast::clamp(1.0 - (_290 * _290), 0.0, 1.0)) / _290) : ShadowDepthPass.ShadowDepthPass_ShadowParams.z, 0.0, ShadowDepthPass.ShadowDepthPass_ShadowParams.z)) + ShadowDepthPass.ShadowDepthPass_ShadowParams.x; out.out_var_TEXCOORD7 = _264.xyz; out.gl_Position = _281; out.out_var_TEXCOORD0_0 = out_var_TEXCOORD0[0]; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/tese/ds-patch-input-fixes.asm.tese000066400000000000000000000476211400026215700276230ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; float PrePadding_View_3048; float PrePadding_View_3052; float4x4 View_WorldToVirtualTexture; float4 View_VirtualTextureParams; float4 View_XRPassthroughCameraUVs[2]; }; struct type_Material { float4 Material_VectorExpressions[5]; float4 Material_ScalarExpressions[2]; }; constant float4 _118 = {}; struct main0_out { float4 out_var_TEXCOORD6 [[user(locn0)]]; float4 out_var_TEXCOORD7 [[user(locn1)]]; float4 out_var_TEXCOORD10_centroid [[user(locn2)]]; float4 out_var_TEXCOORD11_centroid [[user(locn3)]]; float gl_ClipDistance [[clip_distance]] [1]; float gl_ClipDistance_0 [[user(clip0)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_PN_DominantEdge2 [[attribute(3)]]; float4 in_var_PN_DominantEdge3 [[attribute(4)]]; float3 in_var_PN_DominantEdge4 [[attribute(5)]]; float3 in_var_PN_DominantEdge5 [[attribute(6)]]; float4 in_var_PN_DominantVertex1 [[attribute(8)]]; float3 in_var_PN_DominantVertex2 [[attribute(9)]]; float4 in_var_PN_POSITION_0 [[attribute(10)]]; float4 in_var_PN_POSITION_1 [[attribute(11)]]; float4 in_var_PN_POSITION_2 [[attribute(12)]]; float in_var_PN_WorldDisplacementMultiplier [[attribute(15)]]; float4 in_var_TEXCOORD10_centroid [[attribute(16)]]; float4 in_var_TEXCOORD11_centroid [[attribute(17)]]; float4 in_var_TEXCOORD6 [[attribute(18)]]; float4 in_var_TEXCOORD8 [[attribute(19)]]; }; struct main0_patchIn { float4 in_var_PN_POSITION9 [[attribute(13)]]; patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant type_View& View [[buffer(0)]], constant type_Material& Material [[buffer(1)]], texture3d View_GlobalDistanceFieldTexture0 [[texture(0)]], texture3d View_GlobalDistanceFieldTexture1 [[texture(1)]], texture3d View_GlobalDistanceFieldTexture2 [[texture(2)]], texture3d View_GlobalDistanceFieldTexture3 [[texture(3)]], sampler View_GlobalDistanceFieldSampler0 [[sampler(0)]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray _120 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD6, patchIn.gl_in[1].in_var_TEXCOORD6, patchIn.gl_in[2].in_var_TEXCOORD6 }); spvUnsafeArray _121 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD8, patchIn.gl_in[1].in_var_TEXCOORD8, patchIn.gl_in[2].in_var_TEXCOORD8 }); spvUnsafeArray _128 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD10_centroid, patchIn.gl_in[1].in_var_TEXCOORD10_centroid, patchIn.gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _129 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD11_centroid, patchIn.gl_in[1].in_var_TEXCOORD11_centroid, patchIn.gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray, 3> _136 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_POSITION_0, patchIn.gl_in[0].in_var_PN_POSITION_1, patchIn.gl_in[0].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_PN_POSITION_0, patchIn.gl_in[1].in_var_PN_POSITION_1, patchIn.gl_in[1].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_PN_POSITION_0, patchIn.gl_in[2].in_var_PN_POSITION_1, patchIn.gl_in[2].in_var_PN_POSITION_2 }) }); spvUnsafeArray _137 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_WorldDisplacementMultiplier, patchIn.gl_in[1].in_var_PN_WorldDisplacementMultiplier, patchIn.gl_in[2].in_var_PN_WorldDisplacementMultiplier }); spvUnsafeArray _138 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantVertex1, patchIn.gl_in[1].in_var_PN_DominantVertex1, patchIn.gl_in[2].in_var_PN_DominantVertex1 }); spvUnsafeArray _139 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantVertex2, patchIn.gl_in[1].in_var_PN_DominantVertex2, patchIn.gl_in[2].in_var_PN_DominantVertex2 }); spvUnsafeArray _146 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantEdge2, patchIn.gl_in[1].in_var_PN_DominantEdge2, patchIn.gl_in[2].in_var_PN_DominantEdge2 }); spvUnsafeArray _147 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantEdge3, patchIn.gl_in[1].in_var_PN_DominantEdge3, patchIn.gl_in[2].in_var_PN_DominantEdge3 }); spvUnsafeArray _148 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantEdge4, patchIn.gl_in[1].in_var_PN_DominantEdge4, patchIn.gl_in[2].in_var_PN_DominantEdge4 }); spvUnsafeArray _149 = spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_DominantEdge5, patchIn.gl_in[1].in_var_PN_DominantEdge5, patchIn.gl_in[2].in_var_PN_DominantEdge5 }); float _190 = gl_TessCoord.x * gl_TessCoord.x; float _191 = gl_TessCoord.y * gl_TessCoord.y; float _192 = gl_TessCoord.z * gl_TessCoord.z; float4 _198 = float4(gl_TessCoord.x); float4 _202 = float4(gl_TessCoord.y); float4 _207 = float4(gl_TessCoord.z); float4 _210 = float4(_190 * 3.0); float4 _214 = float4(_191 * 3.0); float4 _221 = float4(_192 * 3.0); float4 _235 = ((((((((((_136[0][0] * float4(_190)) * _198) + ((_136[1][0] * float4(_191)) * _202)) + ((_136[2][0] * float4(_192)) * _207)) + ((_136[0][1] * _210) * _202)) + ((_136[0][2] * _214) * _198)) + ((_136[1][1] * _214) * _207)) + ((_136[1][2] * _221) * _202)) + ((_136[2][1] * _221) * _198)) + ((_136[2][2] * _210) * _207)) + ((((patchIn.in_var_PN_POSITION9 * float4(6.0)) * _207) * _198) * _202); float3 _237 = float3(gl_TessCoord.x); float3 _240 = float3(gl_TessCoord.y); float3 _254 = float3(gl_TessCoord.z); float3 _256 = ((_128[0].xyz * _237) + (_128[1].xyz * _240)).xyz + (_128[2].xyz * _254); float4 _259 = ((_129[0] * _198) + (_129[1] * _202)) + (_129[2] * _207); float3 _264 = _235.xyz; float3 _265 = _256.xyz; float3 _266 = _259.xyz; float3 _272 = _264 + float3(View.View_WorldCameraOrigin); float _279 = float(int(gl_TessCoord.x == 0.0)); float _282 = float(int(gl_TessCoord.y == 0.0)); float _285 = float(int(gl_TessCoord.z == 0.0)); float _286 = _279 + _282; float _287 = _286 + _285; float4 _387; float3 _388; if (float(int(_287 == 2.0)) == 1.0) { float _363 = float(int((_282 + _285) == 2.0)); float _367 = float(int((_285 + _279) == 2.0)); float _370 = float(int(_286 == 2.0)); _387 = ((float4(_363) * _138[0]) + (float4(_367) * _138[1])) + (float4(_370) * _138[2]); _388 = ((float3(_363) * _139[0]) + (float3(_367) * _139[1])) + (float3(_370) * _139[2]); } else { float4 _358; float3 _359; if (float(int(_287 == 1.0)) != 0.0) { float4 _304 = float4(_279); float4 _306 = float4(_282); float4 _309 = float4(_285); float4 _311 = ((_304 * _146[0]) + (_306 * _146[1])) + (_309 * _146[2]); float4 _316 = ((_304 * _147[0]) + (_306 * _147[1])) + (_309 * _147[2]); float3 _331 = float3(_279); float3 _333 = float3(_282); float3 _336 = float3(_285); float3 _338 = ((_331 * _148[0]) + (_333 * _148[1])) + (_336 * _148[2]); float3 _343 = ((_331 * _149[0]) + (_333 * _149[1])) + (_336 * _149[2]); _358 = ((_304 * ((_202 * _311) + (_207 * _316))) + (_306 * ((_207 * _311) + (_198 * _316)))) + (_309 * ((_198 * _311) + (_202 * _316))); _359 = ((_331 * ((_240 * _338) + (_254 * _343))) + (_333 * ((_254 * _338) + (_237 * _343)))) + (_336 * ((_237 * _338) + (_240 * _343))); } else { _358 = float4(_259.xyz, 0.0); _359 = _265; } _387 = _358; _388 = _359; } float3x3 _398; if (float(int(_287 == 0.0)) == 0.0) { _398 = float3x3(_388, cross(_387.xyz, _388) * float3(_387.w), _387.xyz); } else { _398 = float3x3(_265, cross(_266, _265) * float3(_259.w), _266); } float3 _411 = fast::min(fast::max((_272 - View.View_GlobalVolumeCenterAndExtent[0].xyz) + View.View_GlobalVolumeCenterAndExtent[0].www, float3(0.0)), fast::max((View.View_GlobalVolumeCenterAndExtent[0].xyz + View.View_GlobalVolumeCenterAndExtent[0].www) - _272, float3(0.0))); float _547; if (fast::min(_411.x, fast::min(_411.y, _411.z)) > (View.View_GlobalVolumeCenterAndExtent[0].w * View.View_GlobalVolumeTexelSize)) { _547 = View_GlobalDistanceFieldTexture0.sample(View_GlobalDistanceFieldSampler0, ((_272 * View.View_GlobalVolumeWorldToUVAddAndMul[0u].www) + View.View_GlobalVolumeWorldToUVAddAndMul[0u].xyz), level(0.0)).x; } else { float3 _436 = fast::min(fast::max((_272 - View.View_GlobalVolumeCenterAndExtent[1].xyz) + View.View_GlobalVolumeCenterAndExtent[1].www, float3(0.0)), fast::max((View.View_GlobalVolumeCenterAndExtent[1].xyz + View.View_GlobalVolumeCenterAndExtent[1].www) - _272, float3(0.0))); float _535; if (fast::min(_436.x, fast::min(_436.y, _436.z)) > (View.View_GlobalVolumeCenterAndExtent[1].w * View.View_GlobalVolumeTexelSize)) { _535 = View_GlobalDistanceFieldTexture1.sample(View_GlobalDistanceFieldSampler0, ((_272 * View.View_GlobalVolumeWorldToUVAddAndMul[1u].www) + View.View_GlobalVolumeWorldToUVAddAndMul[1u].xyz), level(0.0)).x; } else { float3 _459 = fast::min(fast::max((_272 - View.View_GlobalVolumeCenterAndExtent[2].xyz) + View.View_GlobalVolumeCenterAndExtent[2].www, float3(0.0)), fast::max((View.View_GlobalVolumeCenterAndExtent[2].xyz + View.View_GlobalVolumeCenterAndExtent[2].www) - _272, float3(0.0))); float3 _475 = fast::min(fast::max((_272 - View.View_GlobalVolumeCenterAndExtent[3].xyz) + View.View_GlobalVolumeCenterAndExtent[3].www, float3(0.0)), fast::max((View.View_GlobalVolumeCenterAndExtent[3].xyz + View.View_GlobalVolumeCenterAndExtent[3].www) - _272, float3(0.0))); float _480 = fast::min(_475.x, fast::min(_475.y, _475.z)); float _523; if (fast::min(_459.x, fast::min(_459.y, _459.z)) > (View.View_GlobalVolumeCenterAndExtent[2].w * View.View_GlobalVolumeTexelSize)) { _523 = View_GlobalDistanceFieldTexture2.sample(View_GlobalDistanceFieldSampler0, ((_272 * View.View_GlobalVolumeWorldToUVAddAndMul[2u].www) + View.View_GlobalVolumeWorldToUVAddAndMul[2u].xyz), level(0.0)).x; } else { float _511; if (_480 > (View.View_GlobalVolumeCenterAndExtent[3].w * View.View_GlobalVolumeTexelSize)) { _511 = mix(View.View_MaxGlobalDistance, View_GlobalDistanceFieldTexture3.sample(View_GlobalDistanceFieldSampler0, ((_272 * View.View_GlobalVolumeWorldToUVAddAndMul[3u].www) + View.View_GlobalVolumeWorldToUVAddAndMul[3u].xyz), level(0.0)).x, fast::clamp((_480 * 10.0) * View.View_GlobalVolumeWorldToUVAddAndMul[3].w, 0.0, 1.0)); } else { _511 = View.View_MaxGlobalDistance; } _523 = _511; } _535 = _523; } _547 = _535; } float3 _565 = _264 + ((_398[2] * float3(fast::min(_547 + Material.Material_ScalarExpressions[0].z, 0.0) * Material.Material_ScalarExpressions[0].w)) * float3(((_137[0] * gl_TessCoord.x) + (_137[1] * gl_TessCoord.y)) + (_137[2] * gl_TessCoord.z))); float4 _574 = View.View_TranslatedWorldToClip * float4(_565.x, _565.y, _565.z, _235.w); float4 _579 = _574; _579.z = _574.z + (0.001000000047497451305389404296875 * _574.w); out.gl_Position = _579; out.out_var_TEXCOORD6 = ((_120[0] * _198) + (_120[1] * _202)) + (_120[2] * _207); out.out_var_TEXCOORD7 = ((_121[0] * _198) + (_121[1] * _202)) + (_121[2] * _207); out.out_var_TEXCOORD10_centroid = float4(_256.x, _256.y, _256.z, _118.w); out.out_var_TEXCOORD11_centroid = _259; out.gl_ClipDistance[0u] = dot(View.View_GlobalClippingPlane, float4(_565.xyz - float3(View.View_PreViewTranslation), 1.0)); out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/tese/ds-patch-inputs.asm.tese000066400000000000000000000227411400026215700266660ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_ShadowDepthPass { float PrePadding_ShadowDepthPass_LPV_0; float PrePadding_ShadowDepthPass_LPV_4; float PrePadding_ShadowDepthPass_LPV_8; float PrePadding_ShadowDepthPass_LPV_12; float PrePadding_ShadowDepthPass_LPV_16; float PrePadding_ShadowDepthPass_LPV_20; float PrePadding_ShadowDepthPass_LPV_24; float PrePadding_ShadowDepthPass_LPV_28; float PrePadding_ShadowDepthPass_LPV_32; float PrePadding_ShadowDepthPass_LPV_36; float PrePadding_ShadowDepthPass_LPV_40; float PrePadding_ShadowDepthPass_LPV_44; float PrePadding_ShadowDepthPass_LPV_48; float PrePadding_ShadowDepthPass_LPV_52; float PrePadding_ShadowDepthPass_LPV_56; float PrePadding_ShadowDepthPass_LPV_60; float PrePadding_ShadowDepthPass_LPV_64; float PrePadding_ShadowDepthPass_LPV_68; float PrePadding_ShadowDepthPass_LPV_72; float PrePadding_ShadowDepthPass_LPV_76; float PrePadding_ShadowDepthPass_LPV_80; float PrePadding_ShadowDepthPass_LPV_84; float PrePadding_ShadowDepthPass_LPV_88; float PrePadding_ShadowDepthPass_LPV_92; float PrePadding_ShadowDepthPass_LPV_96; float PrePadding_ShadowDepthPass_LPV_100; float PrePadding_ShadowDepthPass_LPV_104; float PrePadding_ShadowDepthPass_LPV_108; float PrePadding_ShadowDepthPass_LPV_112; float PrePadding_ShadowDepthPass_LPV_116; float PrePadding_ShadowDepthPass_LPV_120; float PrePadding_ShadowDepthPass_LPV_124; float PrePadding_ShadowDepthPass_LPV_128; float PrePadding_ShadowDepthPass_LPV_132; float PrePadding_ShadowDepthPass_LPV_136; float PrePadding_ShadowDepthPass_LPV_140; float PrePadding_ShadowDepthPass_LPV_144; float PrePadding_ShadowDepthPass_LPV_148; float PrePadding_ShadowDepthPass_LPV_152; float PrePadding_ShadowDepthPass_LPV_156; float PrePadding_ShadowDepthPass_LPV_160; float PrePadding_ShadowDepthPass_LPV_164; float PrePadding_ShadowDepthPass_LPV_168; float PrePadding_ShadowDepthPass_LPV_172; float PrePadding_ShadowDepthPass_LPV_176; float PrePadding_ShadowDepthPass_LPV_180; float PrePadding_ShadowDepthPass_LPV_184; float PrePadding_ShadowDepthPass_LPV_188; float PrePadding_ShadowDepthPass_LPV_192; float PrePadding_ShadowDepthPass_LPV_196; float PrePadding_ShadowDepthPass_LPV_200; float PrePadding_ShadowDepthPass_LPV_204; float PrePadding_ShadowDepthPass_LPV_208; float PrePadding_ShadowDepthPass_LPV_212; float PrePadding_ShadowDepthPass_LPV_216; float PrePadding_ShadowDepthPass_LPV_220; float PrePadding_ShadowDepthPass_LPV_224; float PrePadding_ShadowDepthPass_LPV_228; float PrePadding_ShadowDepthPass_LPV_232; float PrePadding_ShadowDepthPass_LPV_236; float PrePadding_ShadowDepthPass_LPV_240; float PrePadding_ShadowDepthPass_LPV_244; float PrePadding_ShadowDepthPass_LPV_248; float PrePadding_ShadowDepthPass_LPV_252; float PrePadding_ShadowDepthPass_LPV_256; float PrePadding_ShadowDepthPass_LPV_260; float PrePadding_ShadowDepthPass_LPV_264; float PrePadding_ShadowDepthPass_LPV_268; float4x4 ShadowDepthPass_LPV_mRsmToWorld; float4 ShadowDepthPass_LPV_mLightColour; float4 ShadowDepthPass_LPV_GeometryVolumeCaptureLightDirection; float4 ShadowDepthPass_LPV_mEyePos; packed_int3 ShadowDepthPass_LPV_mOldGridOffset; int PrePadding_ShadowDepthPass_LPV_396; packed_int3 ShadowDepthPass_LPV_mLpvGridOffset; float ShadowDepthPass_LPV_ClearMultiplier; float ShadowDepthPass_LPV_LpvScale; float ShadowDepthPass_LPV_OneOverLpvScale; float ShadowDepthPass_LPV_DirectionalOcclusionIntensity; float ShadowDepthPass_LPV_DirectionalOcclusionRadius; float ShadowDepthPass_LPV_RsmAreaIntensityMultiplier; float ShadowDepthPass_LPV_RsmPixelToTexcoordMultiplier; float ShadowDepthPass_LPV_SecondaryOcclusionStrength; float ShadowDepthPass_LPV_SecondaryBounceStrength; float ShadowDepthPass_LPV_VplInjectionBias; float ShadowDepthPass_LPV_GeometryVolumeInjectionBias; float ShadowDepthPass_LPV_EmissiveInjectionMultiplier; int ShadowDepthPass_LPV_PropagationIndex; float4x4 ShadowDepthPass_ProjectionMatrix; float4x4 ShadowDepthPass_ViewMatrix; float4 ShadowDepthPass_ShadowParams; float ShadowDepthPass_bClampToNearPlane; float PrePadding_ShadowDepthPass_612; float PrePadding_ShadowDepthPass_616; float PrePadding_ShadowDepthPass_620; float4x4 ShadowDepthPass_ShadowViewProjectionMatrices[6]; float4x4 ShadowDepthPass_ShadowViewMatrices[6]; }; constant float4 _90 = {}; struct main0_out { float4 out_var_TEXCOORD10_centroid [[user(locn0)]]; float4 out_var_TEXCOORD11_centroid [[user(locn1)]]; float out_var_TEXCOORD6 [[user(locn2)]]; float3 out_var_TEXCOORD7 [[user(locn3)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_PN_POSITION_0 [[attribute(10)]]; float4 in_var_PN_POSITION_1 [[attribute(11)]]; float4 in_var_PN_POSITION_2 [[attribute(12)]]; float4 in_var_TEXCOORD10_centroid [[attribute(16)]]; float4 in_var_TEXCOORD11_centroid [[attribute(17)]]; }; struct main0_patchIn { float4 in_var_PN_POSITION9 [[attribute(13)]]; patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant type_ShadowDepthPass& ShadowDepthPass [[buffer(0)]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray _93 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD10_centroid, patchIn.gl_in[1].in_var_TEXCOORD10_centroid, patchIn.gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _94 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD11_centroid, patchIn.gl_in[1].in_var_TEXCOORD11_centroid, patchIn.gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray, 3> _101 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_PN_POSITION_0, patchIn.gl_in[0].in_var_PN_POSITION_1, patchIn.gl_in[0].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_PN_POSITION_0, patchIn.gl_in[1].in_var_PN_POSITION_1, patchIn.gl_in[1].in_var_PN_POSITION_2 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_PN_POSITION_0, patchIn.gl_in[2].in_var_PN_POSITION_1, patchIn.gl_in[2].in_var_PN_POSITION_2 }) }); float _119 = gl_TessCoord.x * gl_TessCoord.x; float _120 = gl_TessCoord.y * gl_TessCoord.y; float _121 = gl_TessCoord.z * gl_TessCoord.z; float4 _127 = float4(gl_TessCoord.x); float4 _131 = float4(gl_TessCoord.y); float4 _136 = float4(gl_TessCoord.z); float4 _139 = float4(_119 * 3.0); float4 _143 = float4(_120 * 3.0); float4 _150 = float4(_121 * 3.0); float4 _164 = ((((((((((_101[0][0] * float4(_119)) * _127) + ((_101[1][0] * float4(_120)) * _131)) + ((_101[2][0] * float4(_121)) * _136)) + ((_101[0][1] * _139) * _131)) + ((_101[0][2] * _143) * _127)) + ((_101[1][1] * _143) * _136)) + ((_101[1][2] * _150) * _131)) + ((_101[2][1] * _150) * _127)) + ((_101[2][2] * _139) * _136)) + ((((patchIn.in_var_PN_POSITION9 * float4(6.0)) * _136) * _127) * _131); float3 _179 = ((_93[0].xyz * float3(gl_TessCoord.x)) + (_93[1].xyz * float3(gl_TessCoord.y))).xyz + (_93[2].xyz * float3(gl_TessCoord.z)); float4 _182 = ((_94[0] * _127) + (_94[1] * _131)) + (_94[2] * _136); float4x4 _92 = ShadowDepthPass.ShadowDepthPass_ViewMatrix; float4 _189 = ShadowDepthPass.ShadowDepthPass_ProjectionMatrix * float4(_164.x, _164.y, _164.z, _164.w); float4 _200; if ((ShadowDepthPass.ShadowDepthPass_bClampToNearPlane > 0.0) && (_189.z < 0.0)) { float4 _198 = _189; _198.z = 9.9999999747524270787835121154785e-07; float4 _199 = _198; _199.w = 1.0; _200 = _199; } else { _200 = _189; } float _209 = abs(dot(float3(_92[0u].z, _92[1u].z, _92[2u].z), _182.xyz)); float4 _234 = _200; _234.z = ((_200.z * ShadowDepthPass.ShadowDepthPass_ShadowParams.w) + ((ShadowDepthPass.ShadowDepthPass_ShadowParams.y * fast::clamp((abs(_209) > 0.0) ? (sqrt(fast::clamp(1.0 - (_209 * _209), 0.0, 1.0)) / _209) : ShadowDepthPass.ShadowDepthPass_ShadowParams.z, 0.0, ShadowDepthPass.ShadowDepthPass_ShadowParams.z)) + ShadowDepthPass.ShadowDepthPass_ShadowParams.x)) * _200.w; out.out_var_TEXCOORD10_centroid = float4(_179.x, _179.y, _179.z, _90.w); out.out_var_TEXCOORD11_centroid = _182; out.out_var_TEXCOORD6 = 0.0; out.out_var_TEXCOORD7 = _164.xyz; out.gl_Position = _234; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/tese/ds-texcoord-array.asm.tese000066400000000000000000000301611400026215700272050ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_ClipToWorld; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_908; packed_float3 View_ViewUp; float PrePadding_View_924; packed_float3 View_ViewRight; float PrePadding_View_940; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_956; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_972; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_1020; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_1036; packed_float3 View_WorldViewOrigin; float PrePadding_View_1052; packed_float3 View_PreViewTranslation; float PrePadding_View_1068; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1724; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1740; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1756; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2076; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2148; float PrePadding_View_2152; float PrePadding_View_2156; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2228; float PrePadding_View_2232; float PrePadding_View_2236; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2268; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2412; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; float View_AtmosphericFogSunDiscHalfApexAngleRadian; float PrePadding_View_2492; float4 View_AtmosphericFogSunDiscLuminance; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; uint PrePadding_View_2520; uint PrePadding_View_2524; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2584; float PrePadding_View_2588; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2744; float PrePadding_View_2748; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float PrePadding_View_2908; int2 View_CursorPosition; float View_bCheckerboardSubsurfaceProfileRendering; float PrePadding_View_2924; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2940; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2956; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2972; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2988; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_3004; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; float PrePadding_View_3048; float PrePadding_View_3052; float4x4 View_WorldToVirtualTexture; float4 View_VirtualTextureParams; float4 View_XRPassthroughCameraUVs[2]; }; constant float4 _68 = {}; struct main0_out { float4 out_var_TEXCOORD10_centroid [[user(locn0)]]; float4 out_var_TEXCOORD11_centroid [[user(locn1)]]; float4 out_var_TEXCOORD0_0 [[user(locn2)]]; float4 out_var_COLOR1 [[user(locn3)]]; float4 out_var_COLOR2 [[user(locn4)]]; float4 out_var_TEXCOORD6 [[user(locn5)]]; float3 out_var_TEXCOORD7 [[user(locn6)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_COLOR1 [[attribute(0)]]; float4 in_var_COLOR2 [[attribute(1)]]; float4 in_var_TEXCOORD0_0 [[attribute(5)]]; float4 in_var_TEXCOORD10_centroid [[attribute(6)]]; float4 in_var_TEXCOORD11_centroid [[attribute(7)]]; float3 in_var_TEXCOORD7 [[attribute(8)]]; float4 in_var_VS_To_DS_Position [[attribute(9)]]; }; struct main0_patchIn { patch_control_point gl_in; }; [[ patch(triangle, 0) ]] vertex main0_out main0(main0_patchIn patchIn [[stage_in]], constant type_View& View [[buffer(0)]], float3 gl_TessCoord [[position_in_patch]]) { main0_out out = {}; spvUnsafeArray out_var_TEXCOORD0 = {}; spvUnsafeArray _77 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD10_centroid, patchIn.gl_in[1].in_var_TEXCOORD10_centroid, patchIn.gl_in[2].in_var_TEXCOORD10_centroid }); spvUnsafeArray _78 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD11_centroid, patchIn.gl_in[1].in_var_TEXCOORD11_centroid, patchIn.gl_in[2].in_var_TEXCOORD11_centroid }); spvUnsafeArray, 3> _79 = spvUnsafeArray, 3>({ spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD0_0 }), spvUnsafeArray({ patchIn.gl_in[1].in_var_TEXCOORD0_0 }), spvUnsafeArray({ patchIn.gl_in[2].in_var_TEXCOORD0_0 }) }); spvUnsafeArray _80 = spvUnsafeArray({ patchIn.gl_in[0].in_var_COLOR1, patchIn.gl_in[1].in_var_COLOR1, patchIn.gl_in[2].in_var_COLOR1 }); spvUnsafeArray _81 = spvUnsafeArray({ patchIn.gl_in[0].in_var_COLOR2, patchIn.gl_in[1].in_var_COLOR2, patchIn.gl_in[2].in_var_COLOR2 }); spvUnsafeArray _97 = spvUnsafeArray({ patchIn.gl_in[0].in_var_VS_To_DS_Position, patchIn.gl_in[1].in_var_VS_To_DS_Position, patchIn.gl_in[2].in_var_VS_To_DS_Position }); spvUnsafeArray _98 = spvUnsafeArray({ patchIn.gl_in[0].in_var_TEXCOORD7, patchIn.gl_in[1].in_var_TEXCOORD7, patchIn.gl_in[2].in_var_TEXCOORD7 }); float4 _111 = float4(gl_TessCoord.x); float4 _113 = float4(gl_TessCoord.y); float4 _116 = float4(gl_TessCoord.z); float4 _118 = ((_97[0] * _111) + (_97[1] * _113)) + (_97[2] * _116); spvUnsafeArray _72; _72 = _79[0]; spvUnsafeArray _71; _71 = _79[1]; float3 _120 = float3(gl_TessCoord.x); float3 _123 = float3(gl_TessCoord.y); spvUnsafeArray _73; for (int _133 = 0; _133 < 1; ) { _73[_133] = (_72[_133] * _111) + (_71[_133] * _113); _133++; continue; } spvUnsafeArray _75; _75 = _73; spvUnsafeArray _74; _74 = _79[2]; float3 _155 = float3(gl_TessCoord.z); float3 _157 = ((_77[0].xyz * _120) + (_77[1].xyz * _123)).xyz + (_77[2].xyz * _155); spvUnsafeArray _76; for (int _164 = 0; _164 < 1; ) { _76[_164] = _75[_164] + (_74[_164] * _116); _164++; continue; } float4 _181 = float4(_118.x, _118.y, _118.z, _118.w); out.out_var_TEXCOORD10_centroid = float4(_157.x, _157.y, _157.z, _68.w); out.out_var_TEXCOORD11_centroid = ((_78[0] * _111) + (_78[1] * _113)) + (_78[2] * _116); out_var_TEXCOORD0 = _76; out.out_var_COLOR1 = ((_80[0] * _111) + (_80[1] * _113)) + (_80[2] * _116); out.out_var_COLOR2 = ((_81[0] * _111) + (_81[1] * _113)) + (_81[2] * _116); out.out_var_TEXCOORD6 = _181; out.out_var_TEXCOORD7 = ((_98[0] * _120) + (_98[1] * _123)) + (_98[2] * _155); out.gl_Position = View.View_TranslatedWorldToClip * _181; out.out_var_TEXCOORD0_0 = out_var_TEXCOORD0[0]; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/vert/000077500000000000000000000000001400026215700222145ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders-ue4/asm/vert/array-missing-copies.asm.vert000066400000000000000000000457471400026215700277630ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; template struct spvUnsafeArray { T elements[Num ? Num : 1]; thread T& operator [] (size_t pos) thread { return elements[pos]; } constexpr const thread T& operator [] (size_t pos) const thread { return elements[pos]; } device T& operator [] (size_t pos) device { return elements[pos]; } constexpr const device T& operator [] (size_t pos) const device { return elements[pos]; } constexpr const constant T& operator [] (size_t pos) const constant { return elements[pos]; } threadgroup T& operator [] (size_t pos) threadgroup { return elements[pos]; } constexpr const threadgroup T& operator [] (size_t pos) const threadgroup { return elements[pos]; } }; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_MobileBasePass { float4 MobileBasePass_Fog_ExponentialFogParameters; float4 MobileBasePass_Fog_ExponentialFogParameters2; float4 MobileBasePass_Fog_ExponentialFogColorParameter; float4 MobileBasePass_Fog_ExponentialFogParameters3; float4 MobileBasePass_Fog_InscatteringLightDirection; float4 MobileBasePass_Fog_DirectionalInscatteringColor; float2 MobileBasePass_Fog_SinCosInscatteringColorCubemapRotation; float PrePadding_MobileBasePass_Fog_104; float PrePadding_MobileBasePass_Fog_108; packed_float3 MobileBasePass_Fog_FogInscatteringTextureParameters; float MobileBasePass_Fog_ApplyVolumetricFog; float PrePadding_MobileBasePass_PlanarReflection_128; float PrePadding_MobileBasePass_PlanarReflection_132; float PrePadding_MobileBasePass_PlanarReflection_136; float PrePadding_MobileBasePass_PlanarReflection_140; float PrePadding_MobileBasePass_PlanarReflection_144; float PrePadding_MobileBasePass_PlanarReflection_148; float PrePadding_MobileBasePass_PlanarReflection_152; float PrePadding_MobileBasePass_PlanarReflection_156; float4 MobileBasePass_PlanarReflection_ReflectionPlane; float4 MobileBasePass_PlanarReflection_PlanarReflectionOrigin; float4 MobileBasePass_PlanarReflection_PlanarReflectionXAxis; float4 MobileBasePass_PlanarReflection_PlanarReflectionYAxis; float3x4 MobileBasePass_PlanarReflection_InverseTransposeMirrorMatrix; packed_float3 MobileBasePass_PlanarReflection_PlanarReflectionParameters; float PrePadding_MobileBasePass_PlanarReflection_284; float2 MobileBasePass_PlanarReflection_PlanarReflectionParameters2; float PrePadding_MobileBasePass_PlanarReflection_296; float PrePadding_MobileBasePass_PlanarReflection_300; float4x4 MobileBasePass_PlanarReflection_ProjectionWithExtraFOV[2]; float4 MobileBasePass_PlanarReflection_PlanarReflectionScreenScaleBias[2]; float2 MobileBasePass_PlanarReflection_PlanarReflectionScreenBound; uint MobileBasePass_PlanarReflection_bIsStereo; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_UseEditorDepthTest; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; float PrePadding_Primitive_380; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightingChannelMask; uint Primitive_LightmapDataIndex; int Primitive_SingleCaptureIndex; }; struct type_LandscapeParameters { float4 LandscapeParameters_HeightmapUVScaleBias; float4 LandscapeParameters_WeightmapUVScaleBias; float4 LandscapeParameters_LandscapeLightmapScaleBias; float4 LandscapeParameters_SubsectionSizeVertsLayerUVPan; float4 LandscapeParameters_SubsectionOffsetParams; float4 LandscapeParameters_LightmapSubsectionOffsetParams; float4x4 LandscapeParameters_LocalToWorldNoScaling; }; struct type_Globals { float4 LodBias; float4 LodValues; float4 SectionLods; float4 NeighborSectionLod[4]; }; struct main0_out { float2 out_var_TEXCOORD0 [[user(locn0)]]; float2 out_var_TEXCOORD1 [[user(locn1)]]; float4 out_var_TEXCOORD2 [[user(locn2)]]; float4 out_var_TEXCOORD3 [[user(locn3)]]; float4 out_var_TEXCOORD8 [[user(locn4)]]; float4 gl_Position [[position]]; }; struct main0_in { float4 in_var_ATTRIBUTE0 [[attribute(0)]]; float4 in_var_ATTRIBUTE1_0 [[attribute(1)]]; float4 in_var_ATTRIBUTE1_1 [[attribute(2)]]; }; vertex main0_out main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_MobileBasePass& MobileBasePass [[buffer(1)]], constant type_Primitive& Primitive [[buffer(2)]], constant type_LandscapeParameters& LandscapeParameters [[buffer(3)]], constant type_Globals& _Globals [[buffer(4)]]) { main0_out out = {}; spvUnsafeArray in_var_ATTRIBUTE1 = {}; in_var_ATTRIBUTE1[0] = in.in_var_ATTRIBUTE1_0; in_var_ATTRIBUTE1[1] = in.in_var_ATTRIBUTE1_1; spvUnsafeArray _97; for (int _107 = 0; _107 < 1; ) { _97[_107] = float4(0.0); _107++; continue; } float4 _115 = in.in_var_ATTRIBUTE0 * float4(255.0); float2 _116 = _115.zw; float2 _119 = fract(_116 * float2(0.5)) * float2(2.0); float2 _121 = (_116 - _119) * float2(0.0039215688593685626983642578125); float2 _122 = _115.xy; float2 _126 = _122 * float2(_Globals.LodValues.w); float _127 = _126.y; float _128 = _126.x; float4 _132 = float4(_127, _128, 1.0 - _128, 1.0 - _127) * float4(2.0); float4 _186; if (_119.y > 0.5) { float4 _161; if (_119.x > 0.5) { _161 = (_132 * float4(_Globals.SectionLods.w)) + ((float4(1.0) - _132) * _Globals.NeighborSectionLod[3]); } else { _161 = (_132 * float4(_Globals.SectionLods.z)) + ((float4(1.0) - _132) * _Globals.NeighborSectionLod[2]); } _186 = _161; } else { float4 _185; if (_119.x > 0.5) { _185 = (_132 * float4(_Globals.SectionLods.y)) + ((float4(1.0) - _132) * _Globals.NeighborSectionLod[1]); } else { _185 = (_132 * float4(_Globals.SectionLods.x)) + ((float4(1.0) - _132) * _Globals.NeighborSectionLod[0]); } _186 = _185; } float _206; if ((_128 + _127) > 1.0) { float _198; if (_128 < _127) { _198 = _186.w; } else { _198 = _186.z; } _206 = _198; } else { float _205; if (_128 < _127) { _205 = _186.y; } else { _205 = _186.x; } _206 = _205; } float _207 = floor(_206); float _220 = _121.x; float3 _235 = select(select(select(select(select(float3(0.03125, _121.yy), float3(0.0625, _220, _121.y), bool3(_207 < 5.0)), float3(0.125, in_var_ATTRIBUTE1[1].w, _220), bool3(_207 < 4.0)), float3(0.25, in_var_ATTRIBUTE1[1].zw), bool3(_207 < 3.0)), float3(0.5, in_var_ATTRIBUTE1[1].yz), bool3(_207 < 2.0)), float3(1.0, in_var_ATTRIBUTE1[1].xy), bool3(_207 < 1.0)); float _236 = _235.x; float _245 = (((in_var_ATTRIBUTE1[0].x * 65280.0) + (in_var_ATTRIBUTE1[0].y * 255.0)) - 32768.0) * 0.0078125; float _252 = (((in_var_ATTRIBUTE1[0].z * 65280.0) + (in_var_ATTRIBUTE1[0].w * 255.0)) - 32768.0) * 0.0078125; float2 _257 = floor(_122 * float2(_236)); float2 _271 = float2((LandscapeParameters.LandscapeParameters_SubsectionSizeVertsLayerUVPan.x * _236) - 1.0, fast::max((LandscapeParameters.LandscapeParameters_SubsectionSizeVertsLayerUVPan.x * 0.5) * _236, 2.0) - 1.0) * float2(LandscapeParameters.LandscapeParameters_SubsectionSizeVertsLayerUVPan.y); float3 _287 = mix(float3(_257 / float2(_271.x), mix(_245, _252, _235.y)), float3(floor(_257 * float2(0.5)) / float2(_271.y), mix(_245, _252, _235.z)), float3(_206 - _207)); float2 _288 = _119.xy; float2 _292 = _288 * LandscapeParameters.LandscapeParameters_SubsectionOffsetParams.ww; float3 _296 = _287 + float3(_292, 0.0); float4 _322 = float4((((Primitive.Primitive_LocalToWorld[0u].xyz * _296.xxx) + (Primitive.Primitive_LocalToWorld[1u].xyz * _296.yyy)) + (Primitive.Primitive_LocalToWorld[2u].xyz * _296.zzz)) + (Primitive.Primitive_LocalToWorld[3u].xyz + float3(View.View_PreViewTranslation)), 1.0); float2 _323 = _287.xy; float4 _338 = float4(_322.x, _322.y, _322.z, _322.w); float4 _339 = View.View_TranslatedWorldToClip * _338; float3 _341 = _322.xyz - float3(View.View_TranslatedWorldCameraOrigin); float _345 = dot(_341, _341); float _346 = rsqrt(_345); float _347 = _345 * _346; float _354 = _341.z; float _357 = fast::max(0.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters.w); float _393; float _394; float _395; float _396; if (_357 > 0.0) { float _361 = _357 * _346; float _362 = _361 * _354; float _365 = View.View_WorldCameraOrigin[2] + _362; _393 = (1.0 - _361) * _347; _394 = MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.z * exp2(-fast::max(-127.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.y * (_365 - MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.w))); _395 = MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters3.x * exp2(-fast::max(-127.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters.y * (_365 - MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters3.y))); _396 = _354 - _362; } else { _393 = _347; _394 = MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.x; _395 = MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters.x; _396 = _354; } float _400 = fast::max(-127.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters.y * _396); float _405 = log(2.0); float _407 = 0.5 * (_405 * _405); float _417 = fast::max(-127.0, MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters2.y * _396); float _428 = (_395 * ((abs(_400) > 0.00999999977648258209228515625) ? ((1.0 - exp2(-_400)) / _400) : (_405 - (_407 * _400)))) + (_394 * ((abs(_417) > 0.00999999977648258209228515625) ? ((1.0 - exp2(-_417)) / _417) : (_405 - (_407 * _417)))); float3 _459; if (MobileBasePass.MobileBasePass_Fog_InscatteringLightDirection.w >= 0.0) { _459 = (MobileBasePass.MobileBasePass_Fog_DirectionalInscatteringColor.xyz * float3(pow(fast::clamp(dot(_341 * float3(_346), MobileBasePass.MobileBasePass_Fog_InscatteringLightDirection.xyz), 0.0, 1.0), MobileBasePass.MobileBasePass_Fog_DirectionalInscatteringColor.w))) * float3(1.0 - fast::clamp(exp2(-(_428 * fast::max(_393 - MobileBasePass.MobileBasePass_Fog_InscatteringLightDirection.w, 0.0))), 0.0, 1.0)); } else { _459 = float3(0.0); } bool _468 = (MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters3.w > 0.0) && (_347 > MobileBasePass.MobileBasePass_Fog_ExponentialFogParameters3.w); float _471 = _468 ? 1.0 : fast::max(fast::clamp(exp2(-(_428 * _393)), 0.0, 1.0), MobileBasePass.MobileBasePass_Fog_ExponentialFogColorParameter.w); _97[0] = float4((MobileBasePass.MobileBasePass_Fog_ExponentialFogColorParameter.xyz * float3(1.0 - _471)) + select(_459, float3(0.0), bool3(_468)), _471); float4 _482 = _338; _482.w = _339.w; out.out_var_TEXCOORD0 = ((_323 + LandscapeParameters.LandscapeParameters_SubsectionSizeVertsLayerUVPan.zw) + _292).xy; out.out_var_TEXCOORD1 = ((_323 * LandscapeParameters.LandscapeParameters_WeightmapUVScaleBias.xy) + LandscapeParameters.LandscapeParameters_WeightmapUVScaleBias.zw) + (_288 * LandscapeParameters.LandscapeParameters_SubsectionOffsetParams.zz); out.out_var_TEXCOORD2 = float4(float4(0.0).x, float4(0.0).y, _97[0].x, _97[0].y); out.out_var_TEXCOORD3 = float4(float4(0.0).x, float4(0.0).y, _97[0].z, _97[0].w); out.out_var_TEXCOORD8 = _482; out.gl_Position = _339; return out; } spirv-cross-2021.01.15/reference/shaders-ue4/asm/vert/texture-buffer.asm.vert000066400000000000000000000415211400026215700266470ustar00rootroot00000000000000#pragma clang diagnostic ignored "-Wmissing-prototypes" #include #include using namespace metal; struct type_View { float4x4 View_TranslatedWorldToClip; float4x4 View_WorldToClip; float4x4 View_TranslatedWorldToView; float4x4 View_ViewToTranslatedWorld; float4x4 View_TranslatedWorldToCameraView; float4x4 View_CameraViewToTranslatedWorld; float4x4 View_ViewToClip; float4x4 View_ViewToClipNoAA; float4x4 View_ClipToView; float4x4 View_ClipToTranslatedWorld; float4x4 View_SVPositionToTranslatedWorld; float4x4 View_ScreenToWorld; float4x4 View_ScreenToTranslatedWorld; packed_float3 View_ViewForward; float PrePadding_View_844; packed_float3 View_ViewUp; float PrePadding_View_860; packed_float3 View_ViewRight; float PrePadding_View_876; packed_float3 View_HMDViewNoRollUp; float PrePadding_View_892; packed_float3 View_HMDViewNoRollRight; float PrePadding_View_908; float4 View_InvDeviceZToWorldZTransform; float4 View_ScreenPositionScaleBias; packed_float3 View_WorldCameraOrigin; float PrePadding_View_956; packed_float3 View_TranslatedWorldCameraOrigin; float PrePadding_View_972; packed_float3 View_WorldViewOrigin; float PrePadding_View_988; packed_float3 View_PreViewTranslation; float PrePadding_View_1004; float4x4 View_PrevProjection; float4x4 View_PrevViewProj; float4x4 View_PrevViewRotationProj; float4x4 View_PrevViewToClip; float4x4 View_PrevClipToView; float4x4 View_PrevTranslatedWorldToClip; float4x4 View_PrevTranslatedWorldToView; float4x4 View_PrevViewToTranslatedWorld; float4x4 View_PrevTranslatedWorldToCameraView; float4x4 View_PrevCameraViewToTranslatedWorld; packed_float3 View_PrevWorldCameraOrigin; float PrePadding_View_1660; packed_float3 View_PrevWorldViewOrigin; float PrePadding_View_1676; packed_float3 View_PrevPreViewTranslation; float PrePadding_View_1692; float4x4 View_PrevInvViewProj; float4x4 View_PrevScreenToTranslatedWorld; float4x4 View_ClipToPrevClip; float4 View_TemporalAAJitter; float4 View_GlobalClippingPlane; float2 View_FieldOfViewWideAngles; float2 View_PrevFieldOfViewWideAngles; float4 View_ViewRectMin; float4 View_ViewSizeAndInvSize; float4 View_BufferSizeAndInvSize; float4 View_BufferBilinearUVMinMax; int View_NumSceneColorMSAASamples; float View_PreExposure; float View_OneOverPreExposure; float PrePadding_View_2012; float4 View_DiffuseOverrideParameter; float4 View_SpecularOverrideParameter; float4 View_NormalOverrideParameter; float2 View_RoughnessOverrideParameter; float View_PrevFrameGameTime; float View_PrevFrameRealTime; float View_OutOfBoundsMask; float PrePadding_View_2084; float PrePadding_View_2088; float PrePadding_View_2092; packed_float3 View_WorldCameraMovementSinceLastFrame; float View_CullingSign; float View_NearPlane; float View_AdaptiveTessellationFactor; float View_GameTime; float View_RealTime; float View_DeltaTime; float View_MaterialTextureMipBias; float View_MaterialTextureDerivativeMultiply; uint View_Random; uint View_FrameNumber; uint View_StateFrameIndexMod8; uint View_StateFrameIndex; float View_CameraCut; float View_UnlitViewmodeMask; float PrePadding_View_2164; float PrePadding_View_2168; float PrePadding_View_2172; float4 View_DirectionalLightColor; packed_float3 View_DirectionalLightDirection; float PrePadding_View_2204; float4 View_TranslucencyLightingVolumeMin[2]; float4 View_TranslucencyLightingVolumeInvSize[2]; float4 View_TemporalAAParams; float4 View_CircleDOFParams; float View_DepthOfFieldSensorWidth; float View_DepthOfFieldFocalDistance; float View_DepthOfFieldScale; float View_DepthOfFieldFocalLength; float View_DepthOfFieldFocalRegion; float View_DepthOfFieldNearTransitionRegion; float View_DepthOfFieldFarTransitionRegion; float View_MotionBlurNormalizedToPixel; float View_bSubsurfacePostprocessEnabled; float View_GeneralPurposeTweak; float View_DemosaicVposOffset; float PrePadding_View_2348; packed_float3 View_IndirectLightingColorScale; float View_HDR32bppEncodingMode; packed_float3 View_AtmosphericFogSunDirection; float View_AtmosphericFogSunPower; float View_AtmosphericFogPower; float View_AtmosphericFogDensityScale; float View_AtmosphericFogDensityOffset; float View_AtmosphericFogGroundOffset; float View_AtmosphericFogDistanceScale; float View_AtmosphericFogAltitudeScale; float View_AtmosphericFogHeightScaleRayleigh; float View_AtmosphericFogStartDistance; float View_AtmosphericFogDistanceOffset; float View_AtmosphericFogSunDiscScale; uint View_AtmosphericFogRenderMask; uint View_AtmosphericFogInscatterAltitudeSampleNum; float4 View_AtmosphericFogSunColor; packed_float3 View_NormalCurvatureToRoughnessScaleBias; float View_RenderingReflectionCaptureMask; float4 View_AmbientCubemapTint; float View_AmbientCubemapIntensity; float View_SkyLightParameters; float PrePadding_View_2488; float PrePadding_View_2492; float4 View_SkyLightColor; float4 View_SkyIrradianceEnvironmentMap[7]; float View_MobilePreviewMode; float View_HMDEyePaddingOffset; float View_ReflectionCubemapMaxMip; float View_ShowDecalsMask; uint View_DistanceFieldAOSpecularOcclusionMode; float View_IndirectCapsuleSelfShadowingIntensity; float PrePadding_View_2648; float PrePadding_View_2652; packed_float3 View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight; int View_StereoPassIndex; float4 View_GlobalVolumeCenterAndExtent[4]; float4 View_GlobalVolumeWorldToUVAddAndMul[4]; float View_GlobalVolumeDimension; float View_GlobalVolumeTexelSize; float View_MaxGlobalDistance; float View_bCheckerboardSubsurfaceProfileRendering; packed_float3 View_VolumetricFogInvGridSize; float PrePadding_View_2828; packed_float3 View_VolumetricFogGridZParams; float PrePadding_View_2844; float2 View_VolumetricFogSVPosToVolumeUV; float View_VolumetricFogMaxDistance; float PrePadding_View_2860; packed_float3 View_VolumetricLightmapWorldToUVScale; float PrePadding_View_2876; packed_float3 View_VolumetricLightmapWorldToUVAdd; float PrePadding_View_2892; packed_float3 View_VolumetricLightmapIndirectionTextureSize; float View_VolumetricLightmapBrickSize; packed_float3 View_VolumetricLightmapBrickTexelSize; float View_StereoIPD; float View_IndirectLightingCacheShowFlag; float View_EyeToPixelSpreadAngle; }; struct type_Primitive { float4x4 Primitive_LocalToWorld; float4 Primitive_InvNonUniformScaleAndDeterminantSign; float4 Primitive_ObjectWorldPositionAndRadius; float4x4 Primitive_WorldToLocal; float4x4 Primitive_PreviousLocalToWorld; float4x4 Primitive_PreviousWorldToLocal; packed_float3 Primitive_ActorWorldPosition; float Primitive_UseSingleSampleShadowFromStationaryLights; packed_float3 Primitive_ObjectBounds; float Primitive_LpvBiasMultiplier; float Primitive_DecalReceiverMask; float Primitive_PerObjectGBufferData; float Primitive_UseVolumetricLightmapShadowFromStationaryLights; float Primitive_UseEditorDepthTest; float4 Primitive_ObjectOrientation; float4 Primitive_NonUniformScale; packed_float3 Primitive_LocalObjectBoundsMin; float PrePadding_Primitive_380; packed_float3 Primitive_LocalObjectBoundsMax; uint Primitive_LightingChannelMask; uint Primitive_LightmapDataIndex; int Primitive_SingleCaptureIndex; }; struct type_MobileShadowDepthPass { float PrePadding_MobileShadowDepthPass_0; float PrePadding_MobileShadowDepthPass_4; float PrePadding_MobileShadowDepthPass_8; float PrePadding_MobileShadowDepthPass_12; float PrePadding_MobileShadowDepthPass_16; float PrePadding_MobileShadowDepthPass_20; float PrePadding_MobileShadowDepthPass_24; float PrePadding_MobileShadowDepthPass_28; float PrePadding_MobileShadowDepthPass_32; float PrePadding_MobileShadowDepthPass_36; float PrePadding_MobileShadowDepthPass_40; float PrePadding_MobileShadowDepthPass_44; float PrePadding_MobileShadowDepthPass_48; float PrePadding_MobileShadowDepthPass_52; float PrePadding_MobileShadowDepthPass_56; float PrePadding_MobileShadowDepthPass_60; float PrePadding_MobileShadowDepthPass_64; float PrePadding_MobileShadowDepthPass_68; float PrePadding_MobileShadowDepthPass_72; float PrePadding_MobileShadowDepthPass_76; float4x4 MobileShadowDepthPass_ProjectionMatrix; float2 MobileShadowDepthPass_ShadowParams; float MobileShadowDepthPass_bClampToNearPlane; float PrePadding_MobileShadowDepthPass_156; float4x4 MobileShadowDepthPass_ShadowViewProjectionMatrices[6]; }; struct type_EmitterDynamicUniforms { float2 EmitterDynamicUniforms_LocalToWorldScale; float EmitterDynamicUniforms_EmitterInstRandom; float PrePadding_EmitterDynamicUniforms_12; float4 EmitterDynamicUniforms_AxisLockRight; float4 EmitterDynamicUniforms_AxisLockUp; float4 EmitterDynamicUniforms_DynamicColor; float4 EmitterDynamicUniforms_MacroUVParameters; }; struct type_EmitterUniforms { float4 EmitterUniforms_ColorCurve; float4 EmitterUniforms_ColorScale; float4 EmitterUniforms_ColorBias; float4 EmitterUniforms_MiscCurve; float4 EmitterUniforms_MiscScale; float4 EmitterUniforms_MiscBias; float4 EmitterUniforms_SizeBySpeed; float4 EmitterUniforms_SubImageSize; float4 EmitterUniforms_TangentSelector; packed_float3 EmitterUniforms_CameraFacingBlend; float EmitterUniforms_RemoveHMDRoll; float EmitterUniforms_RotationRateScale; float EmitterUniforms_RotationBias; float EmitterUniforms_CameraMotionBlurAmount; float PrePadding_EmitterUniforms_172; float2 EmitterUniforms_PivotOffset; }; struct type_Globals { uint ParticleIndicesOffset; }; struct main0_out { float out_var_TEXCOORD6 [[user(locn0)]]; float4 gl_Position [[position]]; }; struct main0_in { float2 in_var_ATTRIBUTE0 [[attribute(0)]]; }; // Returns 2D texture coords corresponding to 1D texel buffer coords static inline __attribute__((always_inline)) uint2 spvTexelBufferCoord(uint tc) { return uint2(tc % 4096, tc / 4096); } vertex main0_out main0(main0_in in [[stage_in]], constant type_View& View [[buffer(0)]], constant type_Primitive& Primitive [[buffer(1)]], constant type_MobileShadowDepthPass& MobileShadowDepthPass [[buffer(2)]], constant type_EmitterDynamicUniforms& EmitterDynamicUniforms [[buffer(3)]], constant type_EmitterUniforms& EmitterUniforms [[buffer(4)]], constant type_Globals& _Globals [[buffer(5)]], texture2d ParticleIndices [[texture(0)]], texture2d PositionTexture [[texture(1)]], texture2d VelocityTexture [[texture(2)]], texture2d AttributesTexture [[texture(3)]], texture2d CurveTexture [[texture(4)]], sampler PositionTextureSampler [[sampler(0)]], sampler VelocityTextureSampler [[sampler(1)]], sampler AttributesTextureSampler [[sampler(2)]], sampler CurveTextureSampler [[sampler(3)]], uint gl_VertexIndex [[vertex_id]], uint gl_InstanceIndex [[instance_id]]) { main0_out out = {}; float2 _133 = ParticleIndices.read(spvTexelBufferCoord((_Globals.ParticleIndicesOffset + ((gl_InstanceIndex * 16u) + (gl_VertexIndex / 4u))))).xy; float4 _137 = PositionTexture.sample(PositionTextureSampler, _133, level(0.0)); float4 _145 = AttributesTexture.sample(AttributesTextureSampler, _133, level(0.0)); float _146 = _137.w; float3 _158 = float3x3(Primitive.Primitive_LocalToWorld[0].xyz, Primitive.Primitive_LocalToWorld[1].xyz, Primitive.Primitive_LocalToWorld[2].xyz) * VelocityTexture.sample(VelocityTextureSampler, _133, level(0.0)).xyz; float3 _160 = normalize(_158 + float3(0.0, 0.0, 9.9999997473787516355514526367188e-05)); float2 _204 = ((((_145.xy + float2((_145.x < 0.5) ? 0.0 : (-0.5), (_145.y < 0.5) ? 0.0 : (-0.5))) * float2(2.0)) * (((CurveTexture.sample(CurveTextureSampler, (EmitterUniforms.EmitterUniforms_MiscCurve.xy + (EmitterUniforms.EmitterUniforms_MiscCurve.zw * float2(_146))), level(0.0)) * EmitterUniforms.EmitterUniforms_MiscScale) + EmitterUniforms.EmitterUniforms_MiscBias).xy * EmitterDynamicUniforms.EmitterDynamicUniforms_LocalToWorldScale)) * fast::min(fast::max(EmitterUniforms.EmitterUniforms_SizeBySpeed.xy * float2(length(_158)), float2(1.0)), EmitterUniforms.EmitterUniforms_SizeBySpeed.zw)) * float2(step(_146, 1.0)); float3 _239 = float4((((Primitive.Primitive_LocalToWorld[0u].xyz * _137.xxx) + (Primitive.Primitive_LocalToWorld[1u].xyz * _137.yyy)) + (Primitive.Primitive_LocalToWorld[2u].xyz * _137.zzz)) + (Primitive.Primitive_LocalToWorld[3u].xyz + float3(View.View_PreViewTranslation)), 1.0).xyz; float3 _242 = float3(EmitterUniforms.EmitterUniforms_RemoveHMDRoll); float3 _251 = mix(mix(float3(View.View_ViewRight), float3(View.View_HMDViewNoRollRight), _242), EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockRight.xyz, float3(EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockRight.w)); float3 _259 = mix(-mix(float3(View.View_ViewUp), float3(View.View_HMDViewNoRollUp), _242), EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockUp.xyz, float3(EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockUp.w)); float3 _260 = float3(View.View_TranslatedWorldCameraOrigin) - _239; float _261 = dot(_260, _260); float3 _265 = _260 / float3(sqrt(fast::max(_261, 0.00999999977648258209228515625))); float3 _335; float3 _336; if (EmitterUniforms.EmitterUniforms_CameraFacingBlend[0] > 0.0) { float3 _279 = cross(_265, float3(0.0, 0.0, 1.0)); float3 _284 = _279 / float3(sqrt(fast::max(dot(_279, _279), 0.00999999977648258209228515625))); float3 _286 = float3(fast::clamp((_261 * EmitterUniforms.EmitterUniforms_CameraFacingBlend[1]) - EmitterUniforms.EmitterUniforms_CameraFacingBlend[2], 0.0, 1.0)); _335 = normalize(mix(_251, _284, _286)); _336 = normalize(mix(_259, cross(_265, _284), _286)); } else { float3 _333; float3 _334; if (EmitterUniforms.EmitterUniforms_TangentSelector.y > 0.0) { float3 _297 = cross(_265, _160); _333 = _297 / float3(sqrt(fast::max(dot(_297, _297), 0.00999999977648258209228515625))); _334 = -_160; } else { float3 _331; float3 _332; if (EmitterUniforms.EmitterUniforms_TangentSelector.z > 0.0) { float3 _310 = cross(EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockRight.xyz, _265); _331 = EmitterDynamicUniforms.EmitterDynamicUniforms_AxisLockRight.xyz; _332 = -(_310 / float3(sqrt(fast::max(dot(_310, _310), 0.00999999977648258209228515625)))); } else { float3 _329; float3 _330; if (EmitterUniforms.EmitterUniforms_TangentSelector.w > 0.0) { float3 _322 = cross(_265, float3(0.0, 0.0, 1.0)); float3 _327 = _322 / float3(sqrt(fast::max(dot(_322, _322), 0.00999999977648258209228515625))); _329 = _327; _330 = cross(_265, _327); } else { _329 = _251; _330 = _259; } _331 = _329; _332 = _330; } _333 = _331; _334 = _332; } _335 = _333; _336 = _334; } float _339 = ((_145.z + ((_145.w * EmitterUniforms.EmitterUniforms_RotationRateScale) * _146)) * 6.283185482025146484375) + EmitterUniforms.EmitterUniforms_RotationBias; float3 _342 = float3(sin(_339)); float3 _344 = float3(cos(_339)); float4 _371 = float4(_239 + ((float3(_204.x * (in.in_var_ATTRIBUTE0.x + EmitterUniforms.EmitterUniforms_PivotOffset.x)) * ((_342 * _336) + (_344 * _335))) + (float3(_204.y * (in.in_var_ATTRIBUTE0.y + EmitterUniforms.EmitterUniforms_PivotOffset.y)) * ((_344 * _336) - (_342 * _335)))), 1.0); float4 _375 = MobileShadowDepthPass.MobileShadowDepthPass_ProjectionMatrix * float4(_371.x, _371.y, _371.z, _371.w); float4 _386; if ((MobileShadowDepthPass.MobileShadowDepthPass_bClampToNearPlane > 0.0) && (_375.z < 0.0)) { float4 _384 = _375; _384.z = 9.9999999747524270787835121154785e-07; float4 _385 = _384; _385.w = 1.0; _386 = _385; } else { _386 = _375; } float4 _396 = _386; _396.z = ((_386.z * MobileShadowDepthPass.MobileShadowDepthPass_ShadowParams.y) + MobileShadowDepthPass.MobileShadowDepthPass_ShadowParams.x) * _386.w; out.out_var_TEXCOORD6 = 0.0; out.gl_Position = _396; return out; } spirv-cross-2021.01.15/reference/shaders/000077500000000000000000000000001400026215700177615ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/amd/000077500000000000000000000000001400026215700205225ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/amd/gcn_shader.comp000066400000000000000000000004741400026215700235040ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require #extension GL_AMD_gcn_shader : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; void main() { float cubeFace = cubeFaceIndexAMD(vec3(0.0)); vec2 cubeFaceCoord = cubeFaceCoordAMD(vec3(1.0)); uint64_t time = timeAMD(); } spirv-cross-2021.01.15/reference/shaders/amd/shader_ballot.comp000066400000000000000000000021121400026215700242010ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require #extension GL_ARB_shader_ballot : require #extension GL_AMD_shader_ballot : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer inputData { float inputDataArray[]; } _12; layout(binding = 1, std430) buffer outputData { float outputDataArray[]; } _74; void main() { float thisLaneData = _12.inputDataArray[gl_LocalInvocationID.x]; bool laneActive = thisLaneData > 0.0; uint thisLaneOutputSlot = mbcntAMD(packUint2x32(uvec2(uvec4(unpackUint2x32(ballotARB(laneActive)), 0u, 0u).xy))); int firstInvocation = readFirstInvocationARB(1); int invocation = readInvocationARB(1, 0u); vec3 swizzleInvocations = swizzleInvocationsAMD(vec3(0.0, 2.0, 1.0), uvec4(3u)); vec3 swizzelInvocationsMasked = swizzleInvocationsMaskedAMD(vec3(0.0, 2.0, 1.0), uvec3(2u)); vec3 writeInvocation = writeInvocationAMD(swizzleInvocations, swizzelInvocationsMasked, 0u); if (laneActive) { _74.outputDataArray[thisLaneOutputSlot] = thisLaneData; } } spirv-cross-2021.01.15/reference/shaders/amd/shader_group_vote.comp000066400000000000000000000010051400026215700251150ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_group_vote : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer inputData { float inputDataArray[]; } _12; void main() { float thisLaneData = _12.inputDataArray[gl_LocalInvocationID.x]; bool laneActive = thisLaneData > 0.0; bool allInvocations = allInvocationsARB(laneActive); bool anyInvocations = anyInvocationARB(laneActive); bool allInvocationsEqual = allInvocationsEqualARB(laneActive); } spirv-cross-2021.01.15/reference/shaders/amd/shader_trinary_minmax.comp000066400000000000000000000003521400026215700257710ustar00rootroot00000000000000#version 450 #extension GL_AMD_shader_trinary_minmax : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; void main() { int t11 = min3(0, 3, 2); int t12 = max3(0, 3, 2); int t13 = mid3(0, 3, 2); } spirv-cross-2021.01.15/reference/shaders/asm/000077500000000000000000000000001400026215700205415ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/asm/comp/000077500000000000000000000000001400026215700214775ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/asm/comp/atomic-decrement.asm.comp000066400000000000000000000007041400026215700263570ustar00rootroot00000000000000#version 450 layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer u0_counters { uint c; } u0_counter; layout(binding = 0, r32ui) uniform writeonly uimageBuffer u0; void main() { uint _29 = atomicAdd(u0_counter.c, uint(-1)); vec4 r0; r0.x = uintBitsToFloat(_29); imageStore(u0, int((uint(floatBitsToInt(r0.x)) * 1u) + (uint(0) >> 2u)), uvec4(uint(int(gl_GlobalInvocationID.x)))); } spirv-cross-2021.01.15/reference/shaders/asm/comp/atomic-increment.asm.comp000066400000000000000000000006761400026215700264050ustar00rootroot00000000000000#version 450 layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer u0_counters { uint c; } u0_counter; layout(binding = 0, r32ui) uniform writeonly uimageBuffer u0; void main() { uint _29 = atomicAdd(u0_counter.c, 1u); vec4 r0; r0.x = uintBitsToFloat(_29); imageStore(u0, int((uint(floatBitsToInt(r0.x)) * 1u) + (uint(0) >> 2u)), uvec4(uint(int(gl_GlobalInvocationID.x)))); } spirv-cross-2021.01.15/reference/shaders/asm/comp/bitcast_iadd.asm.comp000066400000000000000000000010551400026215700255510ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) restrict buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) restrict buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { _6._m0 = _5._m1 + uvec4(_5._m0); _6._m0 = uvec4(_5._m0) + _5._m1; _6._m0 = _5._m1 + _5._m1; _6._m0 = uvec4(_5._m0 + _5._m0); _6._m1 = ivec4(_5._m1 + _5._m1); _6._m1 = _5._m0 + _5._m0; _6._m1 = ivec4(_5._m1) + _5._m0; _6._m1 = _5._m0 + ivec4(_5._m1); } spirv-cross-2021.01.15/reference/shaders/asm/comp/bitcast_icmp.asm.comp000066400000000000000000000015731400026215700256050ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) restrict buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) restrict buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { _6._m0 = mix(uvec4(0u), uvec4(1u), lessThan(ivec4(_5._m1), _5._m0)); _6._m0 = mix(uvec4(0u), uvec4(1u), lessThanEqual(ivec4(_5._m1), _5._m0)); _6._m0 = mix(uvec4(0u), uvec4(1u), lessThan(_5._m1, uvec4(_5._m0))); _6._m0 = mix(uvec4(0u), uvec4(1u), lessThanEqual(_5._m1, uvec4(_5._m0))); _6._m0 = mix(uvec4(0u), uvec4(1u), greaterThan(ivec4(_5._m1), _5._m0)); _6._m0 = mix(uvec4(0u), uvec4(1u), greaterThanEqual(ivec4(_5._m1), _5._m0)); _6._m0 = mix(uvec4(0u), uvec4(1u), greaterThan(_5._m1, uvec4(_5._m0))); _6._m0 = mix(uvec4(0u), uvec4(1u), greaterThanEqual(_5._m1, uvec4(_5._m0))); } spirv-cross-2021.01.15/reference/shaders/asm/comp/bitcast_iequal.asm.comp000066400000000000000000000014431400026215700261310ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { ivec4 _30 = _5._m0; uvec4 _31 = _5._m1; bvec4 _34 = equal(ivec4(_31), _30); bvec4 _35 = equal(_30, ivec4(_31)); bvec4 _36 = equal(_31, _31); bvec4 _37 = equal(_30, _30); _6._m0 = mix(uvec4(0u), uvec4(1u), _34); _6._m0 = mix(uvec4(0u), uvec4(1u), _35); _6._m0 = mix(uvec4(0u), uvec4(1u), _36); _6._m0 = mix(uvec4(0u), uvec4(1u), _37); _6._m1 = mix(ivec4(0), ivec4(1), _34); _6._m1 = mix(ivec4(0), ivec4(1), _35); _6._m1 = mix(ivec4(0), ivec4(1), _36); _6._m1 = mix(ivec4(0), ivec4(1), _37); } spirv-cross-2021.01.15/reference/shaders/asm/comp/bitcast_sar.asm.comp000066400000000000000000000011151400026215700254320ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { ivec4 _22 = _5._m0; uvec4 _23 = _5._m1; _6._m0 = uvec4(ivec4(_23) >> _22); _6._m0 = uvec4(_22 >> ivec4(_23)); _6._m0 = uvec4(ivec4(_23) >> ivec4(_23)); _6._m0 = uvec4(_22 >> _22); _6._m1 = ivec4(_23) >> ivec4(_23); _6._m1 = _22 >> _22; _6._m1 = ivec4(_23) >> _22; _6._m1 = _22 >> ivec4(_23); } spirv-cross-2021.01.15/reference/shaders/asm/comp/bitcast_sdiv.asm.comp000066400000000000000000000011051400026215700256110ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { ivec4 _22 = _5._m0; uvec4 _23 = _5._m1; _6._m0 = uvec4(ivec4(_23) / _22); _6._m0 = uvec4(_22 / ivec4(_23)); _6._m0 = uvec4(ivec4(_23) / ivec4(_23)); _6._m0 = uvec4(_22 / _22); _6._m1 = ivec4(_23) / ivec4(_23); _6._m1 = _22 / _22; _6._m1 = ivec4(_23) / _22; _6._m1 = _22 / ivec4(_23); } spirv-cross-2021.01.15/reference/shaders/asm/comp/bitcast_slr.asm.comp000066400000000000000000000011151400026215700254450ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_5 { ivec4 _m0; uvec4 _m1; } _5; layout(binding = 1, std430) buffer _4_6 { uvec4 _m0; ivec4 _m1; } _6; void main() { ivec4 _22 = _5._m0; uvec4 _23 = _5._m1; _6._m0 = _23 >> uvec4(_22); _6._m0 = uvec4(_22) >> _23; _6._m0 = _23 >> _23; _6._m0 = uvec4(_22) >> uvec4(_22); _6._m1 = ivec4(_23 >> _23); _6._m1 = ivec4(uvec4(_22) >> uvec4(_22)); _6._m1 = ivec4(_23 >> uvec4(_22)); _6._m1 = ivec4(uvec4(_22) >> _23); } spirv-cross-2021.01.15/reference/shaders/asm/comp/block-name-alias-global.asm.comp000066400000000000000000000013011400026215700274660ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct A { int a; int b; }; layout(binding = 1, std430) buffer C1 { A Data[]; } C1_1; layout(binding = 2, std140) uniform C2 { A Data[1024]; } C2_1; layout(binding = 0, std430) buffer B { A Data[]; } C3; layout(binding = 3, std140) uniform B { A Data[1024]; } C4; void main() { C1_1.Data[gl_GlobalInvocationID.x].a = C2_1.Data[gl_GlobalInvocationID.x].a; C1_1.Data[gl_GlobalInvocationID.x].b = C2_1.Data[gl_GlobalInvocationID.x].b; C3.Data[gl_GlobalInvocationID.x].a = C4.Data[gl_GlobalInvocationID.x].a; C3.Data[gl_GlobalInvocationID.x].b = C4.Data[gl_GlobalInvocationID.x].b; } spirv-cross-2021.01.15/reference/shaders/asm/comp/builtin-compute-bitcast.asm.comp000066400000000000000000000003471400026215700277110ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer BUF { int values[]; } _6; void main() { _6.values[int(gl_WorkGroupID.y)] = int(gl_GlobalInvocationID.z); } spirv-cross-2021.01.15/reference/shaders/asm/comp/decoration-group.asm.comp000066400000000000000000000014131400026215700264160ustar00rootroot00000000000000#version 430 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 5, std430) buffer _6_15 { float _m0[]; } _15; layout(binding = 0, std430) buffer _7_16 { float _m0[]; } _16; layout(binding = 1, std430) buffer _8_17 { float _m0[]; } _17; layout(binding = 2, std430) restrict readonly buffer _9_18 { float _m0[]; } _18; layout(binding = 3, std430) restrict readonly buffer _10_19 { float _m0[]; } _19; layout(binding = 4, std430) restrict readonly buffer _11_20 { float _m0[]; } _20; void main() { _15._m0[gl_GlobalInvocationID.x] = (((_16._m0[gl_GlobalInvocationID.x] + _17._m0[gl_GlobalInvocationID.x]) + _18._m0[gl_GlobalInvocationID.x]) + _19._m0[gl_GlobalInvocationID.x]) + _20._m0[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/reference/shaders/asm/comp/global-parameter-name-alias.asm.comp000066400000000000000000000010311400026215700303540ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) readonly buffer ssbo { uint _data[]; } ssbo_1; void Load(uint size) { int byteAddrTemp = int(size >> uint(2)); uvec4 data = uvec4(ssbo_1._data[byteAddrTemp], ssbo_1._data[byteAddrTemp + 1], ssbo_1._data[byteAddrTemp + 2], ssbo_1._data[byteAddrTemp + 3]); } void _main(uvec3 id) { uint param = 4u; Load(param); } void main() { uvec3 id = gl_GlobalInvocationID; uvec3 param = id; _main(param); } spirv-cross-2021.01.15/reference/shaders/asm/comp/hlsl-functionality.asm.comp000066400000000000000000000005451400026215700267720ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer Buf { vec4 _data[]; } Buf_1; layout(binding = 1, std430) buffer Buf_count { int _count; } Buf_count_1; void _main() { int _29 = atomicAdd(Buf_count_1._count, 1); Buf_1._data[_29] = vec4(1.0); } void main() { _main(); } spirv-cross-2021.01.15/reference/shaders/asm/comp/logical.asm.comp000066400000000000000000000020721400026215700245510ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO0 { float a; vec2 b; vec3 c; vec4 d; } s0; layout(binding = 1, std430) buffer SSBO1 { float a; vec2 b; vec3 c; vec4 d; } s1; bool and(bool a, bool b) { return !((a && b) || b); } bvec2 and(bvec2 a, bvec2 b) { bvec2 _98 = bvec2(a.x && b.x, a.y && b.y); return not(bvec2(_98.x || b.x, _98.y || b.y)); } bvec3 and(bvec3 a, bvec3 b) { return bvec3(a.x && b.x, a.y && b.y, a.z && b.z); } bvec4 and(bvec4 a, bvec4 b) { return bvec4(a.x && b.x, a.y && b.y, a.z && b.z, a.w && b.w); } void main() { bool param = isinf(s0.a); bool param_1 = isnan(s1.a); bool b0 = and(param, param_1); bvec2 param_2 = isinf(s0.b); bvec2 param_3 = isnan(s1.b); bvec2 b1 = and(param_2, param_3); bvec3 param_4 = isinf(s0.c); bvec3 param_5 = isnan(s1.c); bvec3 b2 = and(param_4, param_5); bvec4 param_6 = isinf(s0.d); bvec4 param_7 = isnan(s1.d); bvec4 b3 = and(param_6, param_7); } spirv-cross-2021.01.15/reference/shaders/asm/comp/multiple-entry.asm.comp000066400000000000000000000010551400026215700261310ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) restrict buffer _6_8 { ivec4 _m0; uvec4 _m1; } _8; layout(binding = 1, std430) restrict buffer _7_9 { uvec4 _m0; ivec4 _m1; } _9; void main() { _9._m0 = _8._m1 + uvec4(_8._m0); _9._m0 = uvec4(_8._m0) + _8._m1; _9._m0 = _8._m1 + _8._m1; _9._m0 = uvec4(_8._m0 + _8._m0); _9._m1 = ivec4(_8._m1 + _8._m1); _9._m1 = _8._m0 + _8._m0; _9._m1 = ivec4(_8._m1) + _8._m0; _9._m1 = _8._m0 + ivec4(_8._m1); } spirv-cross-2021.01.15/reference/shaders/asm/comp/nmin-max-clamp.asm.comp000066400000000000000000000036061400026215700257610ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { float a1; vec2 a2; vec3 a3; vec4 a4; float b1; vec2 b2; vec3 b3; vec4 b4; float c1; vec2 c2; vec3 c3; vec4 c4; } _4; void main() { _4.a1 = isnan(_4.c1) ? _4.b1 : (isnan(_4.b1) ? _4.c1 : min(_4.b1, _4.c1)); _4.a2 = mix(mix(min(_4.b2, _4.c2), _4.c2, isnan(_4.b2)), _4.b2, isnan(_4.c2)); _4.a3 = mix(mix(min(_4.b3, _4.c3), _4.c3, isnan(_4.b3)), _4.b3, isnan(_4.c3)); _4.a4 = mix(mix(min(_4.b4, _4.c4), _4.c4, isnan(_4.b4)), _4.b4, isnan(_4.c4)); _4.a1 = isnan(_4.c1) ? _4.b1 : (isnan(_4.b1) ? _4.c1 : max(_4.b1, _4.c1)); _4.a2 = mix(mix(max(_4.b2, _4.c2), _4.c2, isnan(_4.b2)), _4.b2, isnan(_4.c2)); _4.a3 = mix(mix(max(_4.b3, _4.c3), _4.c3, isnan(_4.b3)), _4.b3, isnan(_4.c3)); _4.a4 = mix(mix(max(_4.b4, _4.c4), _4.c4, isnan(_4.b4)), _4.b4, isnan(_4.c4)); float _179 = isnan(_4.b1) ? _4.a1 : (isnan(_4.a1) ? _4.b1 : max(_4.a1, _4.b1)); _4.a1 = isnan(_4.c1) ? _179 : (isnan(_179) ? _4.c1 : min(_179, _4.c1)); vec2 _190 = mix(mix(max(_4.a2, _4.b2), _4.b2, isnan(_4.a2)), _4.a2, isnan(_4.b2)); _4.a2 = mix(mix(min(_190, _4.c2), _4.c2, isnan(_190)), _190, isnan(_4.c2)); vec3 _201 = mix(mix(max(_4.a3, _4.b3), _4.b3, isnan(_4.a3)), _4.a3, isnan(_4.b3)); _4.a3 = mix(mix(min(_201, _4.c3), _4.c3, isnan(_201)), _201, isnan(_4.c3)); vec4 _212 = mix(mix(max(_4.a4, _4.b4), _4.b4, isnan(_4.a4)), _4.a4, isnan(_4.b4)); _4.a4 = mix(mix(min(_212, _4.c4), _4.c4, isnan(_212)), _212, isnan(_4.c4)); float _223; for (int i = 0; i < 2; i++, _223 = isnan(_4.b2.x) ? _4.a1 : (isnan(_4.a1) ? _4.b2.x : max(_4.a1, _4.b2.x)), _4.a1 = isnan(_4.b2.y) ? _223 : (isnan(_223) ? _4.b2.y : min(_223, _4.b2.y))) { _4.a2 = mix(mix(min(_4.b2, _4.c2), _4.c2, isnan(_4.b2)), _4.b2, isnan(_4.c2)); } } spirv-cross-2021.01.15/reference/shaders/asm/comp/op-phi-swap.asm.comp000066400000000000000000000012161400026215700253020ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer _3_4 { float _m0[]; } _4; layout(binding = 1, std430) buffer _3_5 { float _m0[]; } _5; void main() { float _26 = 8.5; bool _34; float _35; float _35_copy; float _36; _34 = true; _35 = _4._m0[gl_GlobalInvocationID.x]; _36 = _26; for (;;) { if (_34) { _34 = false; _35_copy = _35; _35 = _36; _36 = _35_copy; } else { break; } } _5._m0[gl_GlobalInvocationID.x] = _35 - _36; } spirv-cross-2021.01.15/reference/shaders/asm/comp/quantize.asm.comp000066400000000000000000000011101400026215700247670ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO0 { float scalar; vec2 vec2_val; vec3 vec3_val; vec4 vec4_val; } _4; void main() { _4.scalar = unpackHalf2x16(packHalf2x16(vec2(_4.scalar))).x; _4.vec2_val = unpackHalf2x16(packHalf2x16(_4.vec2_val)); _4.vec3_val = vec3(unpackHalf2x16(packHalf2x16(_4.vec3_val.xy)), unpackHalf2x16(packHalf2x16(_4.vec3_val.zz)).x); _4.vec4_val = vec4(unpackHalf2x16(packHalf2x16(_4.vec4_val.xy)), unpackHalf2x16(packHalf2x16(_4.vec4_val.zw))); } spirv-cross-2021.01.15/reference/shaders/asm/comp/recompile-block-naming.asm.comp000066400000000000000000000021131400026215700274510ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer MyFirstBuffer { uint _data[]; } MyFirstBuffer_1; layout(binding = 0, std430) buffer MySecondBuffer { uint _data[]; } MySecondBuffer_1; layout(binding = 0, std430) buffer MyThirdBuffer { uint _data[]; } MyThirdBuffer_1; void _main() { int byteAddrTemp = 0 >> 2; uvec4 a = uvec4(MyFirstBuffer_1._data[byteAddrTemp], MyFirstBuffer_1._data[byteAddrTemp + 1], MyFirstBuffer_1._data[byteAddrTemp + 2], MyFirstBuffer_1._data[byteAddrTemp + 3]); int byteAddrTemp_1 = 4 >> 2; uvec4 b = uvec4(MySecondBuffer_1._data[byteAddrTemp_1], MySecondBuffer_1._data[byteAddrTemp_1 + 1], MySecondBuffer_1._data[byteAddrTemp_1 + 2], MySecondBuffer_1._data[byteAddrTemp_1 + 3]); int byteAddrTemp_2 = 0 >> 2; MyThirdBuffer_1._data[byteAddrTemp_2] = (a + b).x; MyThirdBuffer_1._data[byteAddrTemp_2 + 1] = (a + b).y; MyThirdBuffer_1._data[byteAddrTemp_2 + 2] = (a + b).z; MyThirdBuffer_1._data[byteAddrTemp_2 + 3] = (a + b).w; } void main() { _main(); } spirv-cross-2021.01.15/reference/shaders/asm/comp/specialization-constant-workgroup.asm.comp000066400000000000000000000006071400026215700320430ustar00rootroot00000000000000#version 310 es #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 9u #endif #ifndef SPIRV_CROSS_CONSTANT_ID_12 #define SPIRV_CROSS_CONSTANT_ID_12 4u #endif layout(local_size_x = SPIRV_CROSS_CONSTANT_ID_10, local_size_y = 20, local_size_z = SPIRV_CROSS_CONSTANT_ID_12) in; layout(binding = 0, std430) buffer SSBO { float a; } _4; void main() { _4.a += 1.0; } spirv-cross-2021.01.15/reference/shaders/asm/comp/switch-break-ladder.asm.comp000066400000000000000000000024711400026215700267560ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer BUF { int a; int b; int d; } o; void main() { int c = o.a; int a; for (;;) { bool _22_ladder_break = false; switch (c) { case 5: { for (;;) { bool _30_ladder_break = false; switch (o.d) { case 10: case 20: { c += c; _30_ladder_break = true; break; } default: { continue; } } if (_30_ladder_break) { break; } } break; } case 1: case 2: case 3: { a = c; _22_ladder_break = true; break; } } if (_22_ladder_break) { break; } c++; continue; } o.b = a; } spirv-cross-2021.01.15/reference/shaders/asm/frag/000077500000000000000000000000001400026215700214605ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/asm/frag/combined-sampler-reuse.vk.asm.frag000066400000000000000000000004611400026215700300620ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_CombineduTexuSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; void main() { FragColor = texture(SPIRV_Cross_CombineduTexuSampler, vUV); FragColor += textureOffset(SPIRV_Cross_CombineduTexuSampler, vUV, ivec2(1)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/combined-sampler-reuse.vk.asm.frag.vk000066400000000000000000000005331400026215700305010ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 1) uniform texture2D uTex; layout(set = 0, binding = 0) uniform sampler uSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; void main() { FragColor = texture(sampler2D(uTex, uSampler), vUV); FragColor += textureOffset(sampler2D(uTex, uSampler), vUV, ivec2(1)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/complex-name-workarounds.asm.frag000066400000000000000000000006001400026215700300350ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 _; layout(location = 1) in vec4 a; layout(location = 0) out vec4 b; vec4 fu_nc_(vec4 a_) { return a_; } vec4 fu_nc_1(vec4 _0_1) { return _0_1; } void main() { vec4 b_1 = _; vec4 _0_1 = (_ + a) + fu_nc_(b_1); vec4 b_3 = a; vec4 b_2 = (_ - a) + fu_nc_1(b_3); b = _0_1; b = b_2; b = _0_1; b = b_2; } spirv-cross-2021.01.15/reference/shaders/asm/frag/composite-construct-struct-no-swizzle.asm.frag000066400000000000000000000004321400026215700325640ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct SwizzleTest { float a; float b; }; layout(location = 0) in vec2 foo; layout(location = 0) out float FooOut; void main() { SwizzleTest _22 = SwizzleTest(foo.x, foo.y); FooOut = _22.a + _22.b; } spirv-cross-2021.01.15/reference/shaders/asm/frag/default-member-names.asm.frag000066400000000000000000000005651400026215700271000ustar00rootroot00000000000000#version 450 struct _9 { float _m0; }; struct _10 { float _m0; float _m1; float _m2; float _m3; float _m4; float _m5; float _m6; float _m7; float _m8; float _m9; float _m10; float _m11; _9 _m12; }; layout(location = 0) out vec4 _3; void main() { _10 _21; _3 = vec4(_21._m0, _21._m1, _21._m2, _21._m3); } spirv-cross-2021.01.15/reference/shaders/asm/frag/do-while-statement-fallback.asm.frag000066400000000000000000000013501400026215700303460ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; void main() { float foo = 1.0; for (;;) { foo = 2.0; if (false) { continue; } else { break; } } for (;;) { foo = 3.0; if (false) { continue; } else { break; } } for (;;) { foo = 4.0; if (false) { continue; } else { break; } } for (;;) { foo = 5.0; if (false) { continue; } else { break; } } FragColor = foo; } spirv-cross-2021.01.15/reference/shaders/asm/frag/empty-struct.asm.frag000066400000000000000000000005441400026215700255630ustar00rootroot00000000000000#version 450 struct EmptyStructTest { int empty_struct_member; }; float GetValue(EmptyStructTest self) { return 0.0; } float GetValue_1(EmptyStructTest self) { return 0.0; } void main() { EmptyStructTest _23 = EmptyStructTest(0); EmptyStructTest emptyStruct; float value = GetValue(emptyStruct); value = GetValue_1(_23); } spirv-cross-2021.01.15/reference/shaders/asm/frag/for-loop-phi-only-continue.asm.frag000066400000000000000000000004201400026215700302100ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { float _19; _19 = 0.0; float _20; int _23; for (int _22 = 0; _22 < 16; _19 = _20, _22 = _23) { _20 = _19 + 1.0; _23 = _22 + 1; } FragColor = vec4(_19); } spirv-cross-2021.01.15/reference/shaders/asm/frag/frem.asm.frag000066400000000000000000000003461400026215700240340ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in vec4 vB; void main() { FragColor = vA - vB * trunc(vA / vB); } spirv-cross-2021.01.15/reference/shaders/asm/frag/function-overload-alias.asm.frag000066400000000000000000000012271400026215700276270ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; vec4 foo(vec4 foo_1) { return foo_1 + vec4(1.0); } vec4 foo(vec3 foo_1) { return foo_1.xyzz + vec4(1.0); } vec4 foo_1(vec4 foo_2) { return foo_2 + vec4(2.0); } vec4 foo(vec2 foo_2) { return foo_2.xyxy + vec4(2.0); } void main() { highp vec4 foo_3 = vec4(1.0); vec4 foo_2 = foo(foo_3); highp vec3 foo_5 = vec3(1.0); vec4 foo_4 = foo(foo_5); highp vec4 foo_7 = vec4(1.0); vec4 foo_6 = foo_1(foo_7); highp vec2 foo_9 = vec2(1.0); vec4 foo_8 = foo(foo_9); FragColor = ((foo_2 + foo_4) + foo_6) + foo_8; } spirv-cross-2021.01.15/reference/shaders/asm/frag/hlsl-sample-cmp-level-zero-cube.asm.frag000066400000000000000000000006261400026215700311000ustar00rootroot00000000000000#version 450 uniform samplerCubeShadow SPIRV_Cross_CombinedpointLightShadowMapshadowSamplerPCF; layout(location = 0) out float _entryPointOutput; float _main() { vec4 _33 = vec4(vec3(0.100000001490116119384765625), 0.5); return textureGrad(SPIRV_Cross_CombinedpointLightShadowMapshadowSamplerPCF, vec4(_33.xyz, _33.w), vec3(0.0), vec3(0.0)); } void main() { _entryPointOutput = _main(); } spirv-cross-2021.01.15/reference/shaders/asm/frag/hlsl-sample-cmp-level-zero.asm.frag000066400000000000000000000015071400026215700301630ustar00rootroot00000000000000#version 450 uniform sampler2DArrayShadow SPIRV_Cross_CombinedShadowMapShadowSamplerPCF; layout(location = 0) in vec2 texCoords; layout(location = 1) in float cascadeIndex; layout(location = 2) in float fragDepth; layout(location = 0) out vec4 _entryPointOutput; vec4 _main(vec2 texCoords_1, float cascadeIndex_1, float fragDepth_1) { vec4 _60 = vec4(vec3(texCoords_1, cascadeIndex_1), fragDepth_1); float c = textureGrad(SPIRV_Cross_CombinedShadowMapShadowSamplerPCF, vec4(_60.xyz, _60.w), vec2(0.0), vec2(0.0)); return vec4(c, c, c, c); } void main() { vec2 texCoords_1 = texCoords; float cascadeIndex_1 = cascadeIndex; float fragDepth_1 = fragDepth; vec2 param = texCoords_1; float param_1 = cascadeIndex_1; float param_2 = fragDepth_1; _entryPointOutput = _main(param, param_1, param_2); } spirv-cross-2021.01.15/reference/shaders/asm/frag/image-extract-reuse.asm.frag000066400000000000000000000002661400026215700267570ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uTexture; layout(location = 0) out ivec2 Size; void main() { Size = textureSize(uTexture, 0) + textureSize(uTexture, 1); } spirv-cross-2021.01.15/reference/shaders/asm/frag/image-fetch-no-sampler.asm.vk.frag000066400000000000000000000023231400026215700277430ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_CombinedparamSPIRV_Cross_DummySampler; uniform sampler2D SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler; uniform sampler2D SPIRV_Cross_CombinedparamSampler; uniform sampler2D SPIRV_Cross_CombinedSampledImageSampler; layout(location = 0) out vec4 _entryPointOutput; vec4 sample_fetch(ivec3 UV, sampler2D SPIRV_Cross_CombinedtexSPIRV_Cross_DummySampler) { return texelFetch(SPIRV_Cross_CombinedtexSPIRV_Cross_DummySampler, UV.xy, UV.z); } vec4 sample_sampler(vec2 UV, sampler2D SPIRV_Cross_CombinedtexSampler) { return texture(SPIRV_Cross_CombinedtexSampler, UV); } vec4 _main(vec4 xIn) { ivec3 coord = ivec3(int(xIn.x * 1280.0), int(xIn.y * 720.0), 0); ivec3 param = coord; vec4 value = sample_fetch(param, SPIRV_Cross_CombinedparamSPIRV_Cross_DummySampler); value += texelFetch(SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler, coord.xy, coord.z); vec2 param_1 = xIn.xy; value += sample_sampler(param_1, SPIRV_Cross_CombinedparamSampler); value += texture(SPIRV_Cross_CombinedSampledImageSampler, xIn.xy); return value; } void main() { vec4 xIn = gl_FragCoord; vec4 param = xIn; _entryPointOutput = _main(param); } spirv-cross-2021.01.15/reference/shaders/asm/frag/image-fetch-no-sampler.asm.vk.frag.vk000066400000000000000000000016321400026215700303640ustar00rootroot00000000000000#version 450 #extension GL_EXT_samplerless_texture_functions : require layout(set = 0, binding = 0) uniform sampler Sampler; layout(set = 0, binding = 0) uniform texture2D SampledImage; layout(location = 0) out vec4 _entryPointOutput; vec4 sample_fetch(texture2D tex, ivec3 UV) { return texelFetch(tex, UV.xy, UV.z); } vec4 sample_sampler(texture2D tex, vec2 UV) { return texture(sampler2D(tex, Sampler), UV); } vec4 _main(vec4 xIn) { ivec3 coord = ivec3(int(xIn.x * 1280.0), int(xIn.y * 720.0), 0); ivec3 param = coord; vec4 value = sample_fetch(SampledImage, param); value += texelFetch(SampledImage, coord.xy, coord.z); vec2 param_1 = xIn.xy; value += sample_sampler(SampledImage, param_1); value += texture(sampler2D(SampledImage, Sampler), xIn.xy); return value; } void main() { vec4 xIn = gl_FragCoord; vec4 param = xIn; _entryPointOutput = _main(param); } spirv-cross-2021.01.15/reference/shaders/asm/frag/image-fetch-no-sampler.no-samplerless.asm.vk.frag000066400000000000000000000023231400026215700327060ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_CombinedparamSPIRV_Cross_DummySampler; uniform sampler2D SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler; uniform sampler2D SPIRV_Cross_CombinedparamSampler; uniform sampler2D SPIRV_Cross_CombinedSampledImageSampler; layout(location = 0) out vec4 _entryPointOutput; vec4 sample_fetch(ivec3 UV, sampler2D SPIRV_Cross_CombinedtexSPIRV_Cross_DummySampler) { return texelFetch(SPIRV_Cross_CombinedtexSPIRV_Cross_DummySampler, UV.xy, UV.z); } vec4 sample_sampler(vec2 UV, sampler2D SPIRV_Cross_CombinedtexSampler) { return texture(SPIRV_Cross_CombinedtexSampler, UV); } vec4 _main(vec4 xIn) { ivec3 coord = ivec3(int(xIn.x * 1280.0), int(xIn.y * 720.0), 0); ivec3 param = coord; vec4 value = sample_fetch(param, SPIRV_Cross_CombinedparamSPIRV_Cross_DummySampler); value += texelFetch(SPIRV_Cross_CombinedSampledImageSPIRV_Cross_DummySampler, coord.xy, coord.z); vec2 param_1 = xIn.xy; value += sample_sampler(param_1, SPIRV_Cross_CombinedparamSampler); value += texture(SPIRV_Cross_CombinedSampledImageSampler, xIn.xy); return value; } void main() { vec4 xIn = gl_FragCoord; vec4 param = xIn; _entryPointOutput = _main(param); } image-fetch-no-sampler.no-samplerless.asm.vk.frag.vk000066400000000000000000000017611400026215700332530ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/asm/frag#version 450 layout(set = 0, binding = 0) uniform sampler Sampler; layout(set = 0, binding = 0) uniform texture2D SampledImage; layout(set = 0, binding = 0) uniform sampler SPIRV_Cross_DummySampler; layout(location = 0) out vec4 _entryPointOutput; vec4 sample_fetch(texture2D tex, ivec3 UV) { return texelFetch(sampler2D(tex, SPIRV_Cross_DummySampler), UV.xy, UV.z); } vec4 sample_sampler(texture2D tex, vec2 UV) { return texture(sampler2D(tex, Sampler), UV); } vec4 _main(vec4 xIn) { ivec3 coord = ivec3(int(xIn.x * 1280.0), int(xIn.y * 720.0), 0); ivec3 param = coord; vec4 value = sample_fetch(SampledImage, param); value += texelFetch(sampler2D(SampledImage, SPIRV_Cross_DummySampler), coord.xy, coord.z); vec2 param_1 = xIn.xy; value += sample_sampler(SampledImage, param_1); value += texture(sampler2D(SampledImage, Sampler), xIn.xy); return value; } void main() { vec4 xIn = gl_FragCoord; vec4 param = xIn; _entryPointOutput = _main(param); } spirv-cross-2021.01.15/reference/shaders/asm/frag/image-query-no-sampler.no-samplerless.vk.asm.frag000066400000000000000000000010231400026215700327560ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_CombineduSampler2DSPIRV_Cross_DummySampler; uniform sampler2DMS SPIRV_Cross_CombineduSampler2DMSSPIRV_Cross_DummySampler; void main() { ivec2 b = textureSize(SPIRV_Cross_CombineduSampler2DSPIRV_Cross_DummySampler, 0); ivec2 c = textureSize(SPIRV_Cross_CombineduSampler2DMSSPIRV_Cross_DummySampler); int l1 = textureQueryLevels(SPIRV_Cross_CombineduSampler2DSPIRV_Cross_DummySampler); int s0 = textureSamples(SPIRV_Cross_CombineduSampler2DMSSPIRV_Cross_DummySampler); } image-query-no-sampler.no-samplerless.vk.asm.frag.vk000066400000000000000000000010441400026215700333210ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/asm/frag#version 450 layout(set = 0, binding = 0) uniform texture2D uSampler2D; layout(set = 0, binding = 0) uniform texture2DMS uSampler2DMS; layout(set = 0, binding = 0) uniform sampler SPIRV_Cross_DummySampler; void main() { ivec2 b = textureSize(sampler2D(uSampler2D, SPIRV_Cross_DummySampler), 0); ivec2 c = textureSize(sampler2DMS(uSampler2DMS, SPIRV_Cross_DummySampler)); int l1 = textureQueryLevels(sampler2D(uSampler2D, SPIRV_Cross_DummySampler)); int s0 = textureSamples(sampler2DMS(uSampler2DMS, SPIRV_Cross_DummySampler)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/image-query-no-sampler.vk.asm.frag000066400000000000000000000010231400026215700300130ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_CombineduSampler2DSPIRV_Cross_DummySampler; uniform sampler2DMS SPIRV_Cross_CombineduSampler2DMSSPIRV_Cross_DummySampler; void main() { ivec2 b = textureSize(SPIRV_Cross_CombineduSampler2DSPIRV_Cross_DummySampler, 0); ivec2 c = textureSize(SPIRV_Cross_CombineduSampler2DMSSPIRV_Cross_DummySampler); int l1 = textureQueryLevels(SPIRV_Cross_CombineduSampler2DSPIRV_Cross_DummySampler); int s0 = textureSamples(SPIRV_Cross_CombineduSampler2DMSSPIRV_Cross_DummySampler); } spirv-cross-2021.01.15/reference/shaders/asm/frag/image-query-no-sampler.vk.asm.frag.vk000066400000000000000000000005771400026215700304470ustar00rootroot00000000000000#version 450 #extension GL_EXT_samplerless_texture_functions : require layout(set = 0, binding = 0) uniform texture2D uSampler2D; layout(set = 0, binding = 0) uniform texture2DMS uSampler2DMS; void main() { ivec2 b = textureSize(uSampler2D, 0); ivec2 c = textureSize(uSampler2DMS); int l1 = textureQueryLevels(uSampler2D); int s0 = textureSamples(uSampler2DMS); } spirv-cross-2021.01.15/reference/shaders/asm/frag/implicit-read-dep-phi.asm.frag000066400000000000000000000012471400026215700271530ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uImage; layout(location = 0) in vec4 v0; layout(location = 0) out vec4 FragColor; void main() { int i = 0; float phi; vec4 _36; phi = 1.0; _36 = vec4(1.0, 2.0, 1.0, 2.0); for (;;) { FragColor = _36; if (i < 4) { if (v0[i] > 0.0) { vec2 _48 = vec2(phi); i++; phi += 2.0; _36 = textureLod(uImage, _48, 0.0); continue; } else { break; } } else { break; } } } spirv-cross-2021.01.15/reference/shaders/asm/frag/inf-nan-constant-double.asm.frag000066400000000000000000000005111400026215700275220ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require layout(location = 0) out vec3 FragColor; layout(location = 0) flat in double vTmp; void main() { FragColor = vec3(dvec3(uint64BitsToDouble(0x7ff0000000000000ul), uint64BitsToDouble(0xfff0000000000000ul), uint64BitsToDouble(0x7ff8000000000000ul)) + dvec3(vTmp)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/inf-nan-constant.asm.frag000066400000000000000000000003601400026215700262540ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out highp vec3 FragColor; void main() { FragColor = vec3(uintBitsToFloat(0x7f800000u), uintBitsToFloat(0xff800000u), uintBitsToFloat(0x7fc00000u)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/invalidation.asm.frag000066400000000000000000000003601400026215700255600ustar00rootroot00000000000000#version 450 layout(location = 0) in float v0; layout(location = 1) in float v1; layout(location = 0) out float FragColor; void main() { float a = v0; float b = v1; float _17 = a; a = v1; FragColor = (_17 + b) * b; } spirv-cross-2021.01.15/reference/shaders/asm/frag/line-directive.line.asm.frag000066400000000000000000000025351400026215700267360ustar00rootroot00000000000000#version 450 #extension GL_GOOGLE_cpp_style_line_directive : require layout(location = 0) out float FragColor; layout(location = 0) in float vColor; #line 6 "test.frag" void func() { #line 8 "test.frag" FragColor = 1.0; #line 9 "test.frag" FragColor = 2.0; #line 10 "test.frag" if (vColor < 0.0) { #line 12 "test.frag" FragColor = 3.0; } else { #line 16 "test.frag" FragColor = 4.0; } #line 19 "test.frag" for (int i = 0; float(i) < (40.0 + vColor); i += (int(vColor) + 5)) { #line 21 "test.frag" FragColor += 0.20000000298023223876953125; #line 22 "test.frag" FragColor += 0.300000011920928955078125; } #line 25 "test.frag" switch (int(vColor)) { case 0: { #line 28 "test.frag" FragColor += 0.20000000298023223876953125; #line 29 "test.frag" break; } case 1: { #line 32 "test.frag" FragColor += 0.4000000059604644775390625; #line 33 "test.frag" break; } default: { #line 36 "test.frag" FragColor += 0.800000011920928955078125; #line 37 "test.frag" break; } } do { #line 42 "test.frag" FragColor += (10.0 + vColor); } while (FragColor < 100.0); } #line 46 "test.frag" void main() { #line 48 "test.frag" func(); } spirv-cross-2021.01.15/reference/shaders/asm/frag/locations-components.asm.frag000066400000000000000000000011711400026215700272560ustar00rootroot00000000000000#version 450 layout(location = 1) in vec2 _2; layout(location = 1, component = 2) in float _3; layout(location = 2) flat in float _4; layout(location = 2, component = 1) flat in uint _5; layout(location = 2, component = 2) flat in uint _6; layout(location = 0) out vec4 o0; vec4 v1; vec4 v2; void main() { v1 = vec4(_2.x, _2.y, v1.z, v1.w); v1.z = _3; v2.x = _4; v2.y = uintBitsToFloat(_5); v2.z = uintBitsToFloat(_6); vec4 r0; r0.x = intBitsToFloat(floatBitsToInt(v2.y) + floatBitsToInt(v2.z)); o0.y = float(floatBitsToUint(r0.x)); o0.x = v1.y + v2.x; o0 = vec4(o0.x, o0.y, v1.z, v1.x); } spirv-cross-2021.01.15/reference/shaders/asm/frag/loop-body-dominator-continue-access.asm.frag000066400000000000000000000025731400026215700320660ustar00rootroot00000000000000#version 450 layout(binding = 0, std140) uniform Foo { layout(row_major) mat4 lightVP[64]; uint shadowCascadesNum; int test; } _11; layout(location = 0) in vec3 fragWorld; layout(location = 0) out int _entryPointOutput; mat4 spvWorkaroundRowMajor(mat4 wrap) { return wrap; } mat4 GetClip2TexMatrix() { if (_11.test == 0) { return mat4(vec4(0.5, 0.0, 0.0, 0.0), vec4(0.0, 0.5, 0.0, 0.0), vec4(0.0, 0.0, 0.5, 0.0), vec4(0.0, 0.0, 0.0, 1.0)); } return mat4(vec4(1.0, 0.0, 0.0, 0.0), vec4(0.0, 1.0, 0.0, 0.0), vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0)); } int GetCascade(vec3 fragWorldPosition) { for (uint cascadeIndex = 0u; cascadeIndex < _11.shadowCascadesNum; cascadeIndex++) { mat4 worldToShadowMap = GetClip2TexMatrix() * spvWorkaroundRowMajor(_11.lightVP[cascadeIndex]); vec4 fragShadowMapPos = worldToShadowMap * vec4(fragWorldPosition, 1.0); if ((((fragShadowMapPos.z >= 0.0) && (fragShadowMapPos.z <= 1.0)) && (max(fragShadowMapPos.x, fragShadowMapPos.y) <= 1.0)) && (min(fragShadowMapPos.x, fragShadowMapPos.y) >= 0.0)) { return int(cascadeIndex); } } return -1; } int _main(vec3 fragWorld_1) { vec3 param = fragWorld_1; return GetCascade(param); } void main() { vec3 fragWorld_1 = fragWorld; vec3 param = fragWorld_1; _entryPointOutput = _main(param); } spirv-cross-2021.01.15/reference/shaders/asm/frag/loop-header-to-continue.asm.frag000066400000000000000000000021611400026215700275410ustar00rootroot00000000000000#version 450 struct Params { vec4 TextureSize; vec4 Params1; vec4 Params2; vec4 Params3; vec4 Params4; vec4 Bloom; }; layout(binding = 1, std140) uniform CB1 { Params CB1; } _8; uniform sampler2D SPIRV_Cross_CombinedmapTexturemapSampler; layout(location = 0) in vec2 IN_uv; layout(location = 0) out vec4 _entryPointOutput; void main() { vec2 _45 = vec2(0.0, _8.CB1.TextureSize.w); vec4 _49 = texture(SPIRV_Cross_CombinedmapTexturemapSampler, IN_uv); float _50 = _49.y; float _53 = clamp((_50 * 80.0) * 0.0007999999797903001308441162109375, 7.999999797903001308441162109375e-05, 0.008000000379979610443115234375); float _55; float _58; _55 = 0.0; _58 = 0.0; for (int _60 = -3; _60 <= 3; ) { float _64 = float(_60); vec4 _72 = texture(SPIRV_Cross_CombinedmapTexturemapSampler, IN_uv + (_45 * _64)); float _78 = exp(((-_64) * _64) * 0.2222220003604888916015625) * float(abs(_72.y - _50) < _53); _55 += (_72.x * _78); _58 += _78; _60++; continue; } _entryPointOutput = vec4(_55 / _58, _50, 0.0, 1.0); } spirv-cross-2021.01.15/reference/shaders/asm/frag/lut-promotion-initializer.asm.frag000066400000000000000000000015711400026215700302550ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; const float _46[16] = float[](1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0); const vec4 _76[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); layout(location = 0) out float FragColor; layout(location = 0) flat in mediump int index; void main() { vec4 foobar[4] = _76; vec4 baz[4] = _76; FragColor = _46[index]; if (index < 10) { FragColor += _46[index ^ 1]; } else { FragColor += _46[index & 1]; } if (index > 30) { FragColor += _76[index & 3].y; } else { FragColor += _76[index & 1].x; } if (index > 30) { foobar[1].z = 20.0; } FragColor += foobar[index & 3].z; baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0)); FragColor += baz[index & 3].z; } spirv-cross-2021.01.15/reference/shaders/asm/frag/multi-for-loop-init.asm.frag000066400000000000000000000006331400026215700267300ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int counter; void main() { FragColor = vec4(0.0); mediump int i = 0; mediump uint j = 1u; for (; (i < 10) && (int(j) < int(20u)); i += counter, j += uint(counter)) { FragColor += vec4(float(i)); FragColor += vec4(float(j)); } } spirv-cross-2021.01.15/reference/shaders/asm/frag/op-constant-null.asm.frag000066400000000000000000000005641400026215700263220ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct D { vec4 a; float b; }; const vec4 _14[4] = vec4[](vec4(0.0), vec4(0.0), vec4(0.0), vec4(0.0)); layout(location = 0) out float FragColor; void main() { float a = 0.0; vec4 b = vec4(0.0); mat2x3 c = mat2x3(vec3(0.0), vec3(0.0)); D d = D(vec4(0.0), 0.0); FragColor = a; } spirv-cross-2021.01.15/reference/shaders/asm/frag/op-phi-swap-continue-block.asm.frag000066400000000000000000000006171400026215700301620ustar00rootroot00000000000000#version 450 layout(binding = 0, std140) uniform UBO { int uCount; int uJ; int uK; } _5; layout(location = 0) out float FragColor; void main() { int _23; int _23_copy; int _24; _23 = _5.uK; _24 = _5.uJ; for (int _26 = 0; _26 < _5.uCount; _23_copy = _23, _23 = _24, _24 = _23_copy, _26++) { } FragColor = float(_24 - _23) * float(_5.uJ * _5.uK); } spirv-cross-2021.01.15/reference/shaders/asm/frag/pack-and-unpack-uint2.asm.frag000066400000000000000000000004401400026215700270720ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require layout(location = 0) out vec4 FragColor; void main() { uint64_t _packed = packUint2x32(uvec2(18u, 52u)); uvec2 unpacked = unpackUint2x32(_packed); FragColor = vec4(float(unpacked.x), float(unpacked.y), 1.0, 1.0); } spirv-cross-2021.01.15/reference/shaders/asm/frag/pass-by-value.asm.frag000066400000000000000000000003671400026215700255760ustar00rootroot00000000000000#version 450 struct Registers { float foo; }; uniform Registers registers; layout(location = 0) out float FragColor; float add_value(float v, float w) { return v + w; } void main() { FragColor = add_value(10.0, registers.foo); } spirv-cross-2021.01.15/reference/shaders/asm/frag/phi-loop-variable.asm.frag000066400000000000000000000001231400026215700264060ustar00rootroot00000000000000#version 450 void main() { for (int _22 = 35; _22 >= 0; _22--) { } } spirv-cross-2021.01.15/reference/shaders/asm/frag/sample-and-compare.asm.frag000066400000000000000000000006761400026215700265560ustar00rootroot00000000000000#version 450 uniform sampler2D SPIRV_Cross_Combinedg_Textureg_Sampler; uniform sampler2DShadow SPIRV_Cross_Combinedg_Textureg_CompareSampler; layout(location = 0) in vec2 in_var_TEXCOORD0; layout(location = 0) out float out_var_SV_Target; void main() { out_var_SV_Target = texture(SPIRV_Cross_Combinedg_Textureg_Sampler, in_var_TEXCOORD0).x + textureLod(SPIRV_Cross_Combinedg_Textureg_CompareSampler, vec3(in_var_TEXCOORD0, 0.5), 0.0); } spirv-cross-2021.01.15/reference/shaders/asm/frag/sampler-buffer-array-without-sampler.asm.frag000066400000000000000000000015751400026215700323000ustar00rootroot00000000000000#version 450 struct Registers { int index; }; uniform Registers registers; uniform sampler2D SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler[4]; layout(location = 0) out vec4 FragColor; vec4 sample_from_func(sampler2D SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler_1[4]) { return texelFetch(SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler_1[registers.index], ivec2(4), 0); } vec4 sample_one_from_func(sampler2D SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler_1) { return texelFetch(SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler_1, ivec2(4), 0); } void main() { FragColor = (texelFetch(SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler[registers.index], ivec2(10), 0) + sample_from_func(SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler)) + sample_one_from_func(SPIRV_Cross_CombineduSamplerSPIRV_Cross_DummySampler[registers.index]); } spirv-cross-2021.01.15/reference/shaders/asm/frag/sampler-buffer-without-sampler.asm.frag000066400000000000000000000005771400026215700311650ustar00rootroot00000000000000#version 450 layout(binding = 0, rgba32f) uniform writeonly imageBuffer RWTex; layout(binding = 1) uniform samplerBuffer Tex; layout(location = 0) out vec4 _entryPointOutput; vec4 _main() { vec4 storeTemp = vec4(1.0, 2.0, 3.0, 4.0); imageStore(RWTex, 20, storeTemp); return texelFetch(Tex, 10); } void main() { vec4 _28 = _main(); _entryPointOutput = _28; } spirv-cross-2021.01.15/reference/shaders/asm/frag/single-function-private-lut.asm.frag000066400000000000000000000006771400026215700304700ustar00rootroot00000000000000#version 460 struct myType { float data; }; const myType _21[5] = myType[](myType(0.0), myType(1.0), myType(0.0), myType(1.0), myType(0.0)); layout(location = 0) out vec4 o_color; void main() { vec2 uv = gl_FragCoord.xy; int index = int(mod(uv.x, 4.0)); myType elt = _21[index]; if (elt.data > 0.0) { o_color = vec4(0.0, 1.0, 0.0, 1.0); } else { o_color = vec4(1.0, 0.0, 0.0, 1.0); } } spirv-cross-2021.01.15/reference/shaders/asm/frag/srem.asm.frag000066400000000000000000000003631400026215700240500ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in ivec4 vA; layout(location = 1) flat in ivec4 vB; void main() { FragColor = vec4(vA - vB * (vA / vB)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/storage-class-output-initializer.asm.frag000066400000000000000000000004171400026215700315300ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColors[2]; layout(location = 2) out vec4 FragColor; const vec4 _3_init[2] = vec4[](vec4(1.0, 2.0, 3.0, 4.0), vec4(10.0)); const vec4 _4_init = vec4(5.0); void main() { FragColors = _3_init; FragColor = _4_init; } spirv-cross-2021.01.15/reference/shaders/asm/frag/struct-composite-extract-swizzle.asm.frag000066400000000000000000000004531400026215700316030ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct Foo { float var1; float var2; }; layout(binding = 0) uniform mediump sampler2D uSampler; layout(location = 0) out vec4 FragColor; Foo _22; void main() { FragColor = texture(uSampler, vec2(_22.var1, _22.var2)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/switch-label-shared-block.asm.frag000066400000000000000000000007611400026215700300160ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) flat in mediump int vIndex; layout(location = 0) out float FragColor; void main() { highp float _19; switch (vIndex) { case 0: case 2: { _19 = 1.0; break; } default: { _19 = 3.0; break; } case 8: { _19 = 8.0; break; } } FragColor = _19; } spirv-cross-2021.01.15/reference/shaders/asm/frag/temporary-name-alias.asm.frag000066400000000000000000000004061400026215700271270ustar00rootroot00000000000000#version 450 void main() { float constituent = float(0); mat3 _mat3 = mat3(vec3(constituent), vec3(constituent), vec3(constituent)); float constituent_1 = float(1); _mat3 = mat3(vec3(constituent_1), vec3(constituent_1), vec3(constituent_1)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/temporary-phi-hoisting.asm.frag000066400000000000000000000006241400026215700275240ustar00rootroot00000000000000#version 450 struct MyStruct { vec4 color; }; layout(binding = 0, std140) uniform MyStruct_CB { MyStruct g_MyStruct[4]; } _6; layout(location = 0) out vec4 _entryPointOutput; void main() { vec3 _28; _28 = vec3(0.0); vec3 _29; for (int _31 = 0; _31 < 4; _28 = _29, _31++) { _29 = _28 + _6.g_MyStruct[_31].color.xyz; } _entryPointOutput = vec4(_28, 1.0); } spirv-cross-2021.01.15/reference/shaders/asm/frag/texel-fetch-no-lod.asm.frag000066400000000000000000000002731400026215700265000ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uTexture; layout(location = 0) out vec4 FragColor; void main() { FragColor = texelFetch(uTexture, ivec2(gl_FragCoord.xy), 0); } spirv-cross-2021.01.15/reference/shaders/asm/frag/texture-sampling-fp16.asm.vk.frag000066400000000000000000000006521400026215700276040ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_NV_gpu_shader5) #extension GL_NV_gpu_shader5 : require #else #error No extension available for FP16. #endif layout(binding = 0) uniform sampler2D uTexture; layout(location = 0) out f16vec4 FragColor; layout(location = 0) in f16vec2 UV; void main() { FragColor = f16vec4(texture(uTexture, UV)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/texture-sampling-fp16.asm.vk.frag.vk000066400000000000000000000010401400026215700302130ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_EXT_shader_explicit_arithmetic_types_float16) #extension GL_EXT_shader_explicit_arithmetic_types_float16 : require #else #error No extension available for FP16. #endif #extension GL_EXT_shader_16bit_storage : require layout(set = 0, binding = 0) uniform sampler2D uTexture; layout(location = 0) out f16vec4 FragColor; layout(location = 0) in f16vec2 UV; void main() { FragColor = f16vec4(texture(uTexture, UV)); } spirv-cross-2021.01.15/reference/shaders/asm/frag/undef-variable-store.asm.frag000066400000000000000000000007001400026215700271130ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 _entryPointOutput; vec4 _38; vec4 _47; void main() { vec4 _27; do { vec2 _26 = vec2(0.0); if (_26.x != 0.0) { _27 = vec4(1.0, 0.0, 0.0, 1.0); break; } else { _27 = vec4(1.0, 1.0, 0.0, 1.0); break; } _27 = _38; break; } while (false); _entryPointOutput = _27; } spirv-cross-2021.01.15/reference/shaders/asm/frag/unknown-depth-state.asm.vk.frag000066400000000000000000000007221400026215700274370ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2DShadow uShadow; uniform sampler2DShadow SPIRV_Cross_CombineduTextureuSampler; layout(location = 0) in vec3 vUV; layout(location = 0) out float FragColor; float sample_combined() { return texture(uShadow, vec3(vUV.xy, vUV.z)); } float sample_separate() { return texture(SPIRV_Cross_CombineduTextureuSampler, vec3(vUV.xy, vUV.z)); } void main() { FragColor = sample_combined() + sample_separate(); } spirv-cross-2021.01.15/reference/shaders/asm/frag/unknown-depth-state.asm.vk.frag.vk000066400000000000000000000010221400026215700300500ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform sampler2DShadow uShadow; layout(set = 0, binding = 1) uniform texture2D uTexture; layout(set = 0, binding = 2) uniform samplerShadow uSampler; layout(location = 0) in vec3 vUV; layout(location = 0) out float FragColor; float sample_combined() { return texture(uShadow, vec3(vUV.xy, vUV.z)); } float sample_separate() { return texture(sampler2DShadow(uTexture, uSampler), vec3(vUV.xy, vUV.z)); } void main() { FragColor = sample_combined() + sample_separate(); } spirv-cross-2021.01.15/reference/shaders/asm/frag/unreachable.asm.frag000066400000000000000000000006111400026215700253470ustar00rootroot00000000000000#version 450 layout(location = 0) flat in int counter; layout(location = 0) out vec4 FragColor; vec4 _21; void main() { vec4 _24; _24 = _21; vec4 _33; for (;;) { if (counter == 10) { _33 = vec4(10.0); break; } else { _33 = vec4(30.0); break; } } FragColor = _33; } spirv-cross-2021.01.15/reference/shaders/asm/frag/vector-shuffle-oom.asm.frag000066400000000000000000000224601400026215700266300ustar00rootroot00000000000000#version 450 struct _28 { vec4 _m0; }; layout(binding = 0, std140) uniform _6_7 { vec4 _m0; float _m1; vec4 _m2; } _7; layout(binding = 2, std140) uniform _10_11 { vec3 _m0; vec3 _m1; float _m2; vec3 _m3; float _m4; vec3 _m5; float _m6; vec3 _m7; float _m8; vec3 _m9; float _m10; vec3 _m11; float _m12; vec2 _m13; vec2 _m14; vec3 _m15; float _m16; float _m17; float _m18; float _m19; float _m20; vec4 _m21; vec4 _m22; layout(row_major) mat4 _m23; vec4 _m24; } _11; layout(binding = 1, std140) uniform _18_19 { layout(row_major) mat4 _m0; layout(row_major) mat4 _m1; layout(row_major) mat4 _m2; layout(row_major) mat4 _m3; vec4 _m4; vec4 _m5; float _m6; float _m7; float _m8; float _m9; vec3 _m10; float _m11; vec3 _m12; float _m13; vec3 _m14; float _m15; vec3 _m16; float _m17; float _m18; float _m19; vec2 _m20; vec2 _m21; vec2 _m22; vec4 _m23; vec2 _m24; vec2 _m25; vec2 _m26; vec3 _m27; float _m28; float _m29; float _m30; float _m31; float _m32; vec2 _m33; float _m34; float _m35; vec3 _m36; layout(row_major) mat4 _m37[2]; vec4 _m38[2]; } _19; uniform sampler2D SPIRV_Cross_Combined; uniform sampler2D SPIRV_Cross_Combined_1; uniform sampler2D SPIRV_Cross_Combined_2; layout(location = 0) out vec4 _5; _28 _74; void main() { _28 _77 = _74; _77._m0 = vec4(0.0); vec2 _82 = gl_FragCoord.xy * _19._m23.xy; vec4 _88 = _7._m2 * _7._m0.xyxy; vec2 _97 = clamp(_82 + (vec3(0.0, -2.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _109 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _97, 0.0).w * _7._m1, 0.0, 1.0); vec4 _113 = textureLod(SPIRV_Cross_Combined_1, _97, 0.0); vec3 _129; if (_113.y > 0.0) { _129 = _109 + (textureLod(SPIRV_Cross_Combined_2, _97, 0.0).xyz * clamp(_113.y * _113.z, 0.0, 1.0)); } else { _129 = _109; } vec3 _133 = vec4(0.0).xyz + (_129 * 0.5); vec4 _134 = vec4(_133.x, _133.y, _133.z, vec4(0.0).w); _28 _135 = _77; _135._m0 = _134; vec2 _144 = clamp(_82 + (vec3(-1.0, -1.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _156 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _144, 0.0).w * _7._m1, 0.0, 1.0); vec4 _160 = textureLod(SPIRV_Cross_Combined_1, _144, 0.0); vec3 _176; if (_160.y > 0.0) { _176 = _156 + (textureLod(SPIRV_Cross_Combined_2, _144, 0.0).xyz * clamp(_160.y * _160.z, 0.0, 1.0)); } else { _176 = _156; } vec3 _180 = _134.xyz + (_176 * 0.5); vec4 _181 = vec4(_180.x, _180.y, _180.z, _134.w); _28 _182 = _135; _182._m0 = _181; vec2 _191 = clamp(_82 + (vec3(0.0, -1.0, 0.75).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _203 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _191, 0.0).w * _7._m1, 0.0, 1.0); vec4 _207 = textureLod(SPIRV_Cross_Combined_1, _191, 0.0); vec3 _223; if (_207.y > 0.0) { _223 = _203 + (textureLod(SPIRV_Cross_Combined_2, _191, 0.0).xyz * clamp(_207.y * _207.z, 0.0, 1.0)); } else { _223 = _203; } vec3 _227 = _181.xyz + (_223 * 0.75); vec4 _228 = vec4(_227.x, _227.y, _227.z, _181.w); _28 _229 = _182; _229._m0 = _228; vec2 _238 = clamp(_82 + (vec3(1.0, -1.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _250 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _238, 0.0).w * _7._m1, 0.0, 1.0); vec4 _254 = textureLod(SPIRV_Cross_Combined_1, _238, 0.0); vec3 _270; if (_254.y > 0.0) { _270 = _250 + (textureLod(SPIRV_Cross_Combined_2, _238, 0.0).xyz * clamp(_254.y * _254.z, 0.0, 1.0)); } else { _270 = _250; } vec3 _274 = _228.xyz + (_270 * 0.5); vec4 _275 = vec4(_274.x, _274.y, _274.z, _228.w); _28 _276 = _229; _276._m0 = _275; vec2 _285 = clamp(_82 + (vec3(-2.0, 0.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _297 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _285, 0.0).w * _7._m1, 0.0, 1.0); vec4 _301 = textureLod(SPIRV_Cross_Combined_1, _285, 0.0); vec3 _317; if (_301.y > 0.0) { _317 = _297 + (textureLod(SPIRV_Cross_Combined_2, _285, 0.0).xyz * clamp(_301.y * _301.z, 0.0, 1.0)); } else { _317 = _297; } vec3 _321 = _275.xyz + (_317 * 0.5); vec4 _322 = vec4(_321.x, _321.y, _321.z, _275.w); _28 _323 = _276; _323._m0 = _322; vec2 _332 = clamp(_82 + (vec3(-1.0, 0.0, 0.75).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _344 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _332, 0.0).w * _7._m1, 0.0, 1.0); vec4 _348 = textureLod(SPIRV_Cross_Combined_1, _332, 0.0); vec3 _364; if (_348.y > 0.0) { _364 = _344 + (textureLod(SPIRV_Cross_Combined_2, _332, 0.0).xyz * clamp(_348.y * _348.z, 0.0, 1.0)); } else { _364 = _344; } vec3 _368 = _322.xyz + (_364 * 0.75); vec4 _369 = vec4(_368.x, _368.y, _368.z, _322.w); _28 _370 = _323; _370._m0 = _369; vec2 _379 = clamp(_82 + (vec3(0.0, 0.0, 1.0).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _391 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _379, 0.0).w * _7._m1, 0.0, 1.0); vec4 _395 = textureLod(SPIRV_Cross_Combined_1, _379, 0.0); vec3 _411; if (_395.y > 0.0) { _411 = _391 + (textureLod(SPIRV_Cross_Combined_2, _379, 0.0).xyz * clamp(_395.y * _395.z, 0.0, 1.0)); } else { _411 = _391; } vec3 _415 = _369.xyz + (_411 * 1.0); vec4 _416 = vec4(_415.x, _415.y, _415.z, _369.w); _28 _417 = _370; _417._m0 = _416; vec2 _426 = clamp(_82 + (vec3(1.0, 0.0, 0.75).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _438 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _426, 0.0).w * _7._m1, 0.0, 1.0); vec4 _442 = textureLod(SPIRV_Cross_Combined_1, _426, 0.0); vec3 _458; if (_442.y > 0.0) { _458 = _438 + (textureLod(SPIRV_Cross_Combined_2, _426, 0.0).xyz * clamp(_442.y * _442.z, 0.0, 1.0)); } else { _458 = _438; } vec3 _462 = _416.xyz + (_458 * 0.75); vec4 _463 = vec4(_462.x, _462.y, _462.z, _416.w); _28 _464 = _417; _464._m0 = _463; vec2 _473 = clamp(_82 + (vec3(2.0, 0.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _485 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _473, 0.0).w * _7._m1, 0.0, 1.0); vec4 _489 = textureLod(SPIRV_Cross_Combined_1, _473, 0.0); vec3 _505; if (_489.y > 0.0) { _505 = _485 + (textureLod(SPIRV_Cross_Combined_2, _473, 0.0).xyz * clamp(_489.y * _489.z, 0.0, 1.0)); } else { _505 = _485; } vec3 _509 = _463.xyz + (_505 * 0.5); vec4 _510 = vec4(_509.x, _509.y, _509.z, _463.w); _28 _511 = _464; _511._m0 = _510; vec2 _520 = clamp(_82 + (vec3(-1.0, 1.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _532 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _520, 0.0).w * _7._m1, 0.0, 1.0); vec4 _536 = textureLod(SPIRV_Cross_Combined_1, _520, 0.0); vec3 _552; if (_536.y > 0.0) { _552 = _532 + (textureLod(SPIRV_Cross_Combined_2, _520, 0.0).xyz * clamp(_536.y * _536.z, 0.0, 1.0)); } else { _552 = _532; } vec3 _556 = _510.xyz + (_552 * 0.5); vec4 _557 = vec4(_556.x, _556.y, _556.z, _510.w); _28 _558 = _511; _558._m0 = _557; vec2 _567 = clamp(_82 + (vec3(0.0, 1.0, 0.75).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _579 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _567, 0.0).w * _7._m1, 0.0, 1.0); vec4 _583 = textureLod(SPIRV_Cross_Combined_1, _567, 0.0); vec3 _599; if (_583.y > 0.0) { _599 = _579 + (textureLod(SPIRV_Cross_Combined_2, _567, 0.0).xyz * clamp(_583.y * _583.z, 0.0, 1.0)); } else { _599 = _579; } vec3 _603 = _557.xyz + (_599 * 0.75); vec4 _604 = vec4(_603.x, _603.y, _603.z, _557.w); _28 _605 = _558; _605._m0 = _604; vec2 _614 = clamp(_82 + (vec3(1.0, 1.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _626 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _614, 0.0).w * _7._m1, 0.0, 1.0); vec4 _630 = textureLod(SPIRV_Cross_Combined_1, _614, 0.0); vec3 _646; if (_630.y > 0.0) { _646 = _626 + (textureLod(SPIRV_Cross_Combined_2, _614, 0.0).xyz * clamp(_630.y * _630.z, 0.0, 1.0)); } else { _646 = _626; } vec3 _650 = _604.xyz + (_646 * 0.5); vec4 _651 = vec4(_650.x, _650.y, _650.z, _604.w); _28 _652 = _605; _652._m0 = _651; vec2 _661 = clamp(_82 + (vec3(0.0, 2.0, 0.5).xy * _7._m0.xy), _88.xy, _88.zw); vec3 _673 = _11._m5 * clamp(textureLod(SPIRV_Cross_Combined, _661, 0.0).w * _7._m1, 0.0, 1.0); vec4 _677 = textureLod(SPIRV_Cross_Combined_1, _661, 0.0); vec3 _693; if (_677.y > 0.0) { _693 = _673 + (textureLod(SPIRV_Cross_Combined_2, _661, 0.0).xyz * clamp(_677.y * _677.z, 0.0, 1.0)); } else { _693 = _673; } vec3 _697 = _651.xyz + (_693 * 0.5); vec4 _698 = vec4(_697.x, _697.y, _697.z, _651.w); _28 _699 = _652; _699._m0 = _698; vec3 _702 = _698.xyz / vec3(((((((((((((0.0 + 0.5) + 0.5) + 0.75) + 0.5) + 0.5) + 0.75) + 1.0) + 0.75) + 0.5) + 0.5) + 0.75) + 0.5) + 0.5); _28 _704 = _699; _704._m0 = vec4(_702.x, _702.y, _702.z, _698.w); _28 _705 = _704; _705._m0.w = 1.0; _5 = _705._m0; } spirv-cross-2021.01.15/reference/shaders/asm/geom/000077500000000000000000000000001400026215700214705ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/asm/geom/block-name-namespace.asm.geom000066400000000000000000000010661400026215700270650ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(max_vertices = 4, triangle_strip) out; layout(binding = 0, std140) uniform VertexInput { vec4 a; } VertexInput_1; layout(binding = 0, std430) buffer VertexInput { vec4 b; } VertexInput_2; layout(location = 0) out VertexInput { vec4 vColor; } VertexInput_3; layout(location = 0) in VertexInput { vec4 vColor; } vin[3]; void main() { vec4 VertexInput_4 = vec4(1.0); gl_Position = (VertexInput_4 + VertexInput_1.a) + VertexInput_2.b; VertexInput_3.vColor = vin[0].vColor; EmitVertex(); } spirv-cross-2021.01.15/reference/shaders/asm/geom/inout-split-access-chain-handle.asm.geom000066400000000000000000000006371400026215700311650ustar00rootroot00000000000000#version 440 layout(triangles) in; layout(max_vertices = 5, triangle_strip) out; struct Data { vec4 ApiPerspectivePosition; }; void Copy(inout Data inputStream[3]) { inputStream[0].ApiPerspectivePosition = gl_in[0].gl_Position; } void main() { Data inputStream[3]; Data param[3] = inputStream; Copy(param); inputStream = param; gl_Position = inputStream[0].ApiPerspectivePosition; } spirv-cross-2021.01.15/reference/shaders/asm/geom/split-access-chain-input.asm.geom000066400000000000000000000002131400026215700277230ustar00rootroot00000000000000#version 440 layout(triangles) in; layout(max_vertices = 3, triangle_strip) out; void main() { gl_Position = gl_in[0].gl_Position; } spirv-cross-2021.01.15/reference/shaders/asm/geom/unroll-glposition-load.asm.geom000066400000000000000000000011461400026215700275370ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(max_vertices = 3, triangle_strip) out; struct SceneOut { vec4 pos; }; void _main(vec4 positions[3], SceneOut OUT) { SceneOut o; for (int i = 0; i < 3; i++) { o.pos = positions[i]; gl_Position = o.pos; EmitVertex(); } EndPrimitive(); } void main() { vec4 _35_unrolled[3]; for (int i = 0; i < int(3); i++) { _35_unrolled[i] = gl_in[i].gl_Position; } vec4 positions[3] = _35_unrolled; vec4 param[3] = positions; SceneOut param_1; _main(param, param_1); SceneOut OUT = param_1; } spirv-cross-2021.01.15/reference/shaders/asm/tese/000077500000000000000000000000001400026215700215015ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/asm/tese/unroll-input-array-load.asm.tese000066400000000000000000000016461400026215700276520ustar00rootroot00000000000000#version 450 layout(quads) in; struct HS_INPUT { vec4 foo; vec4 bar; }; struct ControlPoint { vec4 baz; }; struct DS_OUTPUT { vec4 pos; }; layout(location = 0) patch in vec4 input_foo; layout(location = 1) patch in vec4 input_bar; layout(location = 2) in ControlPoint CPData[]; DS_OUTPUT _main(HS_INPUT _input, vec2 uv, ControlPoint CPData_1[4]) { DS_OUTPUT o; o.pos = (((_input.foo + _input.bar) + uv.xyxy) + CPData_1[0].baz) + CPData_1[3].baz; return o; } void main() { HS_INPUT _input; _input.foo = input_foo; _input.bar = input_bar; vec2 uv = vec2(gl_TessCoord.xy); ControlPoint _54_unrolled[4]; for (int i = 0; i < int(4); i++) { _54_unrolled[i] = CPData[i]; } ControlPoint CPData_1[4] = _54_unrolled; HS_INPUT param = _input; vec2 param_1 = uv; ControlPoint param_2[4] = CPData_1; gl_Position = _main(param, param_1, param_2).pos; } spirv-cross-2021.01.15/reference/shaders/asm/vert/000077500000000000000000000000001400026215700215215ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/asm/vert/empty-io.asm.vert000066400000000000000000000007521400026215700247510ustar00rootroot00000000000000#version 450 struct VSInput { vec4 position; }; struct VSOutput { vec4 position; }; struct VSOutput_1 { int empty_struct_member; }; layout(location = 0) in vec4 position; layout(location = 0) out VSOutput_1 _entryPointOutput; VSOutput _main(VSInput _input) { VSOutput _out; _out.position = _input.position; return _out; } void main() { VSInput _input; _input.position = position; VSInput param = _input; gl_Position = _main(param).position; } spirv-cross-2021.01.15/reference/shaders/asm/vert/extract-transposed-matrix-from-struct.asm.vert000066400000000000000000000022641400026215700326250ustar00rootroot00000000000000#version 450 #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif struct V2F { vec4 Position; vec4 Color; }; struct InstanceData { mat4 MATRIX_MVP; vec4 Color; }; layout(binding = 0, std430) readonly buffer gInstanceData { layout(row_major) InstanceData _data[]; } gInstanceData_1; layout(location = 0) in vec3 PosL; #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif layout(location = 0) out vec4 _entryPointOutput_Color; V2F _VS(vec3 PosL_1, uint instanceID) { InstanceData instData; instData.MATRIX_MVP = gInstanceData_1._data[instanceID].MATRIX_MVP; instData.Color = gInstanceData_1._data[instanceID].Color; V2F v2f; v2f.Position = instData.MATRIX_MVP * vec4(PosL_1, 1.0); v2f.Color = instData.Color; return v2f; } void main() { vec3 PosL_1 = PosL; uint instanceID = uint((gl_InstanceID + SPIRV_Cross_BaseInstance)); vec3 param = PosL_1; uint param_1 = instanceID; V2F flattenTemp = _VS(param, param_1); gl_Position = flattenTemp.Position; _entryPointOutput_Color = flattenTemp.Color; } spirv-cross-2021.01.15/reference/shaders/asm/vert/global-builtin.sso.asm.vert000066400000000000000000000006371400026215700267170ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; }; struct VSOut { float a; vec4 pos; }; struct VSOut_1 { float a; }; layout(location = 0) out VSOut_1 _entryPointOutput; VSOut _main() { VSOut vout; vout.a = 40.0; vout.pos = vec4(1.0); return vout; } void main() { VSOut flattenTemp = _main(); _entryPointOutput.a = flattenTemp.a; gl_Position = flattenTemp.pos; } spirv-cross-2021.01.15/reference/shaders/asm/vert/invariant-block.asm.vert000066400000000000000000000001241400026215700262620ustar00rootroot00000000000000#version 450 invariant gl_Position; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/asm/vert/invariant-block.sso.asm.vert000066400000000000000000000003251400026215700270700ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; float gl_PointSize; float gl_ClipDistance[1]; float gl_CullDistance[1]; }; invariant gl_Position; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/asm/vert/invariant.asm.vert000066400000000000000000000002161400026215700251740ustar00rootroot00000000000000#version 450 invariant gl_Position; vec4 _main() { return vec4(1.0); } void main() { vec4 _14 = _main(); gl_Position = _14; } spirv-cross-2021.01.15/reference/shaders/asm/vert/invariant.sso.asm.vert000066400000000000000000000002731400026215700260020ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; }; invariant gl_Position; vec4 _main() { return vec4(1.0); } void main() { vec4 _14 = _main(); gl_Position = _14; } spirv-cross-2021.01.15/reference/shaders/asm/vert/spec-constant-op-composite.asm.vk.vert000066400000000000000000000015161400026215700310210ustar00rootroot00000000000000#version 450 #ifndef SPIRV_CROSS_CONSTANT_ID_201 #define SPIRV_CROSS_CONSTANT_ID_201 -10 #endif const int _7 = SPIRV_CROSS_CONSTANT_ID_201; const int _20 = (_7 + 2); #ifndef SPIRV_CROSS_CONSTANT_ID_202 #define SPIRV_CROSS_CONSTANT_ID_202 100u #endif const uint _8 = SPIRV_CROSS_CONSTANT_ID_202; const uint _25 = (_8 % 5u); const ivec4 _30 = ivec4(20, 30, _20, _20); const ivec2 _32 = ivec2(_30.y, _30.x); const int _33 = _30.y; #ifndef SPIRV_CROSS_CONSTANT_ID_200 #define SPIRV_CROSS_CONSTANT_ID_200 3.141590118408203125 #endif const float _9 = SPIRV_CROSS_CONSTANT_ID_200; layout(location = 0) flat out int _4; void main() { vec4 pos = vec4(0.0); pos.y += float(_20); pos.z += float(_25); pos += vec4(_30); vec2 _56 = pos.xy + vec2(_32); pos = vec4(_56.x, _56.y, pos.z, pos.w); gl_Position = pos; _4 = _33; } spirv-cross-2021.01.15/reference/shaders/asm/vert/spec-constant-op-composite.asm.vk.vert.vk000066400000000000000000000011331400026215700314330ustar00rootroot00000000000000#version 450 layout(constant_id = 201) const int _7 = -10; const int _20 = (_7 + 2); layout(constant_id = 202) const uint _8 = 100u; const uint _25 = (_8 % 5u); const ivec4 _30 = ivec4(20, 30, _20, _20); const ivec2 _32 = ivec2(_30.y, _30.x); const int _33 = _30.y; layout(constant_id = 200) const float _9 = 3.141590118408203125; layout(location = 0) flat out int _4; void main() { vec4 pos = vec4(0.0); pos.y += float(_20); pos.z += float(_25); pos += vec4(_30); vec2 _56 = pos.xy + vec2(_32); pos = vec4(_56.x, _56.y, pos.z, pos.w); gl_Position = pos; _4 = _33; } spirv-cross-2021.01.15/reference/shaders/asm/vert/uint-vertex-id-instance-id.asm.vert000066400000000000000000000010131400026215700302550ustar00rootroot00000000000000#version 450 #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif vec4 _main(uint vid, uint iid) { return vec4(float(vid + iid)); } void main() { uint vid = uint(gl_VertexID); uint iid = uint((gl_InstanceID + SPIRV_Cross_BaseInstance)); uint param = vid; uint param_1 = iid; gl_Position = _main(param, param_1); } spirv-cross-2021.01.15/reference/shaders/comp/000077500000000000000000000000001400026215700207175ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/comp/atomic.comp000066400000000000000000000035411400026215700230560ustar00rootroot00000000000000#version 310 es #extension GL_OES_shader_image_atomic : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 2, std430) buffer SSBO { uint u32; int i32; } ssbo; layout(binding = 0, r32ui) uniform highp uimage2D uImage; layout(binding = 1, r32i) uniform highp iimage2D iImage; void main() { uint _19 = imageAtomicAdd(uImage, ivec2(1, 5), 1u); uint _27 = imageAtomicAdd(uImage, ivec2(1, 5), 1u); imageStore(iImage, ivec2(1, 6), ivec4(int(_27))); uint _32 = imageAtomicOr(uImage, ivec2(1, 5), 1u); uint _34 = imageAtomicXor(uImage, ivec2(1, 5), 1u); uint _36 = imageAtomicAnd(uImage, ivec2(1, 5), 1u); uint _38 = imageAtomicMin(uImage, ivec2(1, 5), 1u); uint _40 = imageAtomicMax(uImage, ivec2(1, 5), 1u); uint _44 = imageAtomicCompSwap(uImage, ivec2(1, 5), 10u, 2u); int _47 = imageAtomicAdd(iImage, ivec2(1, 6), 1); int _49 = imageAtomicOr(iImage, ivec2(1, 6), 1); int _51 = imageAtomicXor(iImage, ivec2(1, 6), 1); int _53 = imageAtomicAnd(iImage, ivec2(1, 6), 1); int _55 = imageAtomicMin(iImage, ivec2(1, 6), 1); int _57 = imageAtomicMax(iImage, ivec2(1, 6), 1); int _61 = imageAtomicCompSwap(iImage, ivec2(1, 5), 10, 2); uint _68 = atomicAdd(ssbo.u32, 1u); uint _70 = atomicOr(ssbo.u32, 1u); uint _72 = atomicXor(ssbo.u32, 1u); uint _74 = atomicAnd(ssbo.u32, 1u); uint _76 = atomicMin(ssbo.u32, 1u); uint _78 = atomicMax(ssbo.u32, 1u); uint _80 = atomicExchange(ssbo.u32, 1u); uint _82 = atomicCompSwap(ssbo.u32, 10u, 2u); int _85 = atomicAdd(ssbo.i32, 1); int _87 = atomicOr(ssbo.i32, 1); int _89 = atomicXor(ssbo.i32, 1); int _91 = atomicAnd(ssbo.i32, 1); int _93 = atomicMin(ssbo.i32, 1); int _95 = atomicMax(ssbo.i32, 1); int _97 = atomicExchange(ssbo.i32, 1); int _99 = atomicCompSwap(ssbo.i32, 10, 2); } spirv-cross-2021.01.15/reference/shaders/comp/bake_gradient.comp000066400000000000000000000035041400026215700243600ustar00rootroot00000000000000#version 310 es layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in; layout(binding = 4, std140) uniform UBO { vec4 uInvSize; vec4 uScale; } _46; layout(binding = 0) uniform mediump sampler2D uHeight; layout(binding = 1) uniform mediump sampler2D uDisplacement; layout(binding = 2, rgba16f) uniform writeonly mediump image2D iHeightDisplacement; layout(binding = 3, rgba16f) uniform writeonly mediump image2D iGradJacobian; mediump float jacobian(mediump vec2 dDdx, mediump vec2 dDdy) { return ((1.0 + dDdx.x) * (1.0 + dDdy.y)) - (dDdx.y * dDdy.x); } void main() { vec4 uv = (vec2(gl_GlobalInvocationID.xy) * _46.uInvSize.xy).xyxy + (_46.uInvSize * 0.5); float h = textureLod(uHeight, uv.xy, 0.0).x; float x0 = textureLodOffset(uHeight, uv.xy, 0.0, ivec2(-1, 0)).x; float x1 = textureLodOffset(uHeight, uv.xy, 0.0, ivec2(1, 0)).x; float y0 = textureLodOffset(uHeight, uv.xy, 0.0, ivec2(0, -1)).x; float y1 = textureLodOffset(uHeight, uv.xy, 0.0, ivec2(0, 1)).x; vec2 grad = (_46.uScale.xy * 0.5) * vec2(x1 - x0, y1 - y0); vec2 displacement = textureLod(uDisplacement, uv.zw, 0.0).xy * 1.2000000476837158203125; vec2 dDdx = (textureLodOffset(uDisplacement, uv.zw, 0.0, ivec2(1, 0)).xy - textureLodOffset(uDisplacement, uv.zw, 0.0, ivec2(-1, 0)).xy) * 0.60000002384185791015625; vec2 dDdy = (textureLodOffset(uDisplacement, uv.zw, 0.0, ivec2(0, 1)).xy - textureLodOffset(uDisplacement, uv.zw, 0.0, ivec2(0, -1)).xy) * 0.60000002384185791015625; mediump vec2 param = dDdx * _46.uScale.z; mediump vec2 param_1 = dDdy * _46.uScale.z; float j = jacobian(param, param_1); displacement = vec2(0.0); imageStore(iHeightDisplacement, ivec2(gl_GlobalInvocationID.xy), vec4(h, displacement, 0.0)); imageStore(iGradJacobian, ivec2(gl_GlobalInvocationID.xy), vec4(grad, j, 0.0)); } spirv-cross-2021.01.15/reference/shaders/comp/barriers.comp000066400000000000000000000017311400026215700234120ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; void barrier_shared() { memoryBarrierShared(); } void full_barrier() { memoryBarrier(); } void image_barrier() { memoryBarrierImage(); } void buffer_barrier() { memoryBarrierBuffer(); } void group_barrier() { groupMemoryBarrier(); } void barrier_shared_exec() { barrier(); } void full_barrier_exec() { memoryBarrier(); barrier(); } void image_barrier_exec() { memoryBarrierImage(); barrier(); } void buffer_barrier_exec() { memoryBarrierBuffer(); barrier(); } void group_barrier_exec() { groupMemoryBarrier(); barrier(); } void exec_barrier() { barrier(); } void main() { barrier_shared(); full_barrier(); image_barrier(); buffer_barrier(); group_barrier(); barrier_shared_exec(); full_barrier_exec(); image_barrier_exec(); buffer_barrier_exec(); group_barrier_exec(); exec_barrier(); } spirv-cross-2021.01.15/reference/shaders/comp/basic.comp000066400000000000000000000010751400026215700226630ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { vec4 in_data[]; } _23; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _45; layout(binding = 2, std430) buffer SSBO3 { uint counter; } _48; void main() { uint ident = gl_GlobalInvocationID.x; vec4 idata = _23.in_data[ident]; if (dot(idata, vec4(1.0, 5.0, 6.0, 2.0)) > 8.19999980926513671875) { uint _52 = atomicAdd(_48.counter, 1u); _45.out_data[_52] = idata; } } spirv-cross-2021.01.15/reference/shaders/comp/casts.comp000066400000000000000000000006121400026215700227130ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) buffer SSBO1 { ivec4 outputs[]; } _21; layout(binding = 0, std430) buffer SSBO0 { ivec4 inputs[]; } _27; void main() { uint ident = gl_GlobalInvocationID.x; _21.outputs[ident] = mix(ivec4(0), ivec4(1), notEqual((_27.inputs[ident] & ivec4(3)), ivec4(uvec4(0u)))); } spirv-cross-2021.01.15/reference/shaders/comp/cfg-preserve-parameter.comp000066400000000000000000000021311400026215700261420ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; void out_test_0(int cond, out int i) { if (cond == 0) { i = 40; } else { i = 60; } } void out_test_1(int cond, out int i) { switch (cond) { case 40: { i = 40; break; } default: { i = 70; break; } } } void inout_test_0(int cond, inout int i) { if (cond == 0) { i = 40; } } void inout_test_1(int cond, inout int i) { switch (cond) { case 40: { i = 40; break; } } } void main() { int cond = 40; int i = 50; int param = cond; int param_1 = i; out_test_0(param, param_1); i = param_1; int param_2 = cond; int param_3 = i; out_test_1(param_2, param_3); i = param_3; int param_4 = cond; int param_5 = i; inout_test_0(param_4, param_5); i = param_5; int param_6 = cond; int param_7 = i; inout_test_1(param_6, param_7); i = param_7; } spirv-cross-2021.01.15/reference/shaders/comp/cfg.comp000066400000000000000000000023431400026215700223400ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { float data; } _11; void test() { if (!(_11.data == 0.0)) { float tmp = 10.0; _11.data = tmp; } else { float tmp_1 = 15.0; _11.data = tmp_1; } if (!(_11.data == 0.0)) { float e; if (!(_11.data == 5.0)) { if (!(_11.data == 6.0)) { e = 10.0; } } else { e = 20.0; } } switch (int(_11.data)) { case 0: { float tmp_2 = 20.0; _11.data = tmp_2; break; } case 1: { float tmp_3 = 30.0; _11.data = tmp_3; break; } } float f; switch (int(_11.data)) { case 0: { f = 30.0; break; } case 1: { f = 40.0; break; } } float h; for (int i = 0; i < 20; i++, h += 10.0) { } _11.data = h; float m; do { } while (!(m == 20.0)); _11.data = m; } void main() { test(); } spirv-cross-2021.01.15/reference/shaders/comp/coherent-block.comp000066400000000000000000000003351400026215700244770ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) coherent restrict writeonly buffer SSBO { vec4 value; } _10; void main() { _10.value = vec4(20.0); } spirv-cross-2021.01.15/reference/shaders/comp/coherent-image.comp000066400000000000000000000005071400026215700244700ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) coherent restrict writeonly buffer SSBO { ivec4 value; } _10; layout(binding = 3, r32i) uniform coherent restrict readonly mediump iimage2D uImage; void main() { _10.value = imageLoad(uImage, ivec2(10)); } spirv-cross-2021.01.15/reference/shaders/comp/composite-array-initialization.comp000066400000000000000000000013771400026215700277520ustar00rootroot00000000000000#version 310 es layout(local_size_x = 2, local_size_y = 1, local_size_z = 1) in; struct Data { float a; float b; }; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 4.0 #endif const float X = SPIRV_CROSS_CONSTANT_ID_0; layout(binding = 0, std430) buffer SSBO { Data outdata[]; } _53; Data data[2]; Data data2[2]; Data combine(Data a, Data b) { return Data(a.a + b.a, a.b + b.b); } void main() { data = Data[](Data(1.0, 2.0), Data(3.0, 4.0)); data2 = Data[](Data(X, 2.0), Data(3.0, 5.0)); Data param = data[gl_LocalInvocationID.x]; Data param_1 = data2[gl_LocalInvocationID.x]; Data _73 = combine(param, param_1); _53.outdata[gl_WorkGroupID.x].a = _73.a; _53.outdata[gl_WorkGroupID.x].b = _73.b; } spirv-cross-2021.01.15/reference/shaders/comp/composite-construct.comp000066400000000000000000000016431400026215700256270ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; const vec4 _66[2] = vec4[](vec4(10.0), vec4(30.0)); struct Composite { vec4 a[2]; vec4 b[2]; }; const float _94[2][3] = float[][](float[](1.0, 1.0, 1.0), float[](2.0, 2.0, 2.0)); layout(binding = 0, std430) buffer SSBO0 { vec4 as[]; } _41; layout(binding = 1, std430) buffer SSBO1 { vec4 bs[]; } _55; vec4 summe(vec4 values[3][2]) { return ((values[0][0] + values[2][1]) + values[0][1]) + values[1][0]; } void main() { vec4 values[2] = vec4[](_41.as[gl_GlobalInvocationID.x], _55.bs[gl_GlobalInvocationID.x]); vec4 copy_values[2] = _66; vec4 copy_values2[2] = values; vec4 param[3][2] = vec4[][](values, copy_values, copy_values2); _41.as[gl_GlobalInvocationID.x] = summe(param); Composite c = Composite(values, copy_values); float b = 10.0; float values_scalar[4] = float[](b, b, b, b); } spirv-cross-2021.01.15/reference/shaders/comp/culling.comp000066400000000000000000000010131400026215700232270ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { float in_data[]; } _22; layout(binding = 1, std430) writeonly buffer SSBO2 { float out_data[]; } _38; layout(binding = 2, std430) buffer SSBO3 { uint count; } _41; void main() { uint ident = gl_GlobalInvocationID.x; float idata = _22.in_data[ident]; if (idata > 12.0) { uint _45 = atomicAdd(_41.count, 1u); _38.out_data[_45] = idata; } } spirv-cross-2021.01.15/reference/shaders/comp/defer-parens.comp000066400000000000000000000006761400026215700241630ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { vec4 data; int index; } _13; void main() { vec4 d = _13.data; _13.data = vec4(d.x, d.yz + vec2(10.0), d.w); _13.data = (d + d) + d; _13.data = (d.yz + vec2(10.0)).xxyy; float t = (d.yz + vec2(10.0)).y; _13.data = vec4(t); t = (d.zw + vec2(10.0))[_13.index]; _13.data = vec4(t); } spirv-cross-2021.01.15/reference/shaders/comp/dowhile.comp000066400000000000000000000007421400026215700232350ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; } _28; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _52; int i; void main() { uint ident = gl_GlobalInvocationID.x; i = 0; vec4 idat = _28.in_data[ident]; do { idat = _28.mvp * idat; i++; } while (i < 16); _52.out_data[ident] = idat; } spirv-cross-2021.01.15/reference/shaders/comp/generate_height.comp000066400000000000000000000035601400026215700247250ustar00rootroot00000000000000#version 310 es layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer Distribution { vec2 distribution[]; } _137; layout(binding = 2, std140) uniform UBO { vec4 uModTime; } _166; layout(binding = 1, std430) writeonly buffer HeightmapFFT { uint heights[]; } _225; uvec2 workaround_mix(uvec2 a, uvec2 b, bvec2 sel) { uint _86; if (sel.x) { _86 = b.x; } else { _86 = a.x; } uint _97; if (sel.y) { _97 = b.y; } else { _97 = a.y; } return uvec2(_86, _97); } vec2 alias(vec2 i, vec2 N) { return mix(i, i - N, greaterThan(i, N * 0.5)); } vec2 cmul(vec2 a, vec2 b) { vec2 r3 = a.yx; vec2 r1 = b.xx; vec2 R0 = a * r1; vec2 r2 = b.yy; vec2 R1 = r2 * r3; return R0 + vec2(-R1.x, R1.y); } uint pack2(vec2 v) { return packHalf2x16(v); } void generate_heightmap() { uvec2 N = uvec2(64u, 1u) * gl_NumWorkGroups.xy; uvec2 i = gl_GlobalInvocationID.xy; uvec2 param = N - i; uvec2 param_1 = uvec2(0u); bvec2 param_2 = equal(i, uvec2(0u)); uvec2 wi = workaround_mix(param, param_1, param_2); vec2 a = _137.distribution[(i.y * N.x) + i.x]; vec2 b = _137.distribution[(wi.y * N.x) + wi.x]; vec2 param_3 = vec2(i); vec2 param_4 = vec2(N); vec2 k = _166.uModTime.xy * alias(param_3, param_4); float k_len = length(k); float w = sqrt(9.81000041961669921875 * k_len) * _166.uModTime.z; float cw = cos(w); float sw = sin(w); vec2 param_5 = a; vec2 param_6 = vec2(cw, sw); a = cmul(param_5, param_6); vec2 param_7 = b; vec2 param_8 = vec2(cw, sw); b = cmul(param_7, param_8); b = vec2(b.x, -b.y); vec2 res = a + b; vec2 param_9 = res; _225.heights[(i.y * N.x) + i.x] = pack2(param_9); } void main() { generate_heightmap(); } spirv-cross-2021.01.15/reference/shaders/comp/image.comp000066400000000000000000000006121400026215700226600ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, rgba8) uniform readonly mediump image2D uImageIn; layout(binding = 1, rgba8) uniform writeonly mediump image2D uImageOut; void main() { vec4 v = imageLoad(uImageIn, ivec2(gl_GlobalInvocationID.xy) + imageSize(uImageIn)); imageStore(uImageOut, ivec2(gl_GlobalInvocationID.xy), v); } spirv-cross-2021.01.15/reference/shaders/comp/insert.comp000066400000000000000000000005431400026215700231050ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) writeonly buffer SSBO { vec4 out_data[]; } _27; void main() { vec4 v; v.x = 10.0; v.y = 30.0; v.z = 70.0; v.w = 90.0; _27.out_data[gl_GlobalInvocationID.x] = v; _27.out_data[gl_GlobalInvocationID.x].y = 20.0; } spirv-cross-2021.01.15/reference/shaders/comp/mat3.comp000066400000000000000000000004431400026215700224440ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std430) writeonly buffer SSBO2 { mat3 out_data[]; } _22; void main() { uint ident = gl_GlobalInvocationID.x; _22.out_data[ident] = mat3(vec3(10.0), vec3(20.0), vec3(40.0)); } spirv-cross-2021.01.15/reference/shaders/comp/mod.comp000066400000000000000000000012271400026215700223600ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { vec4 in_data[]; } _23; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _33; void main() { uint ident = gl_GlobalInvocationID.x; vec4 v = mod(_23.in_data[ident], _33.out_data[ident]); _33.out_data[ident] = v; uvec4 vu = floatBitsToUint(_23.in_data[ident]) % floatBitsToUint(_33.out_data[ident]); _33.out_data[ident] = uintBitsToFloat(vu); ivec4 vi = floatBitsToInt(_23.in_data[ident]) % floatBitsToInt(_33.out_data[ident]); _33.out_data[ident] = intBitsToFloat(vi); } spirv-cross-2021.01.15/reference/shaders/comp/modf.comp000066400000000000000000000006251400026215700225270ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { vec4 in_data[]; } _23; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _35; void main() { uint ident = gl_GlobalInvocationID.x; vec4 i; vec4 _31 = modf(_23.in_data[ident], i); vec4 v = _31; _35.out_data[ident] = v; } spirv-cross-2021.01.15/reference/shaders/comp/outer-product.comp000066400000000000000000000014301400026215700244110ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) writeonly buffer SSBO { mat2 m22; mat2x3 m23; mat2x4 m24; mat3x2 m32; mat3 m33; mat3x4 m34; mat4x2 m42; mat4x3 m43; mat4 m44; } _21; layout(binding = 1, std430) readonly buffer ReadSSBO { vec2 v2; vec3 v3; vec4 v4; } _26; void main() { _21.m22 = outerProduct(_26.v2, _26.v2); _21.m23 = outerProduct(_26.v3, _26.v2); _21.m24 = outerProduct(_26.v4, _26.v2); _21.m32 = outerProduct(_26.v2, _26.v3); _21.m33 = outerProduct(_26.v3, _26.v3); _21.m34 = outerProduct(_26.v4, _26.v3); _21.m42 = outerProduct(_26.v2, _26.v4); _21.m43 = outerProduct(_26.v3, _26.v4); _21.m44 = outerProduct(_26.v4, _26.v4); } spirv-cross-2021.01.15/reference/shaders/comp/read-write-only.comp000066400000000000000000000007171400026215700246260ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 2, std430) restrict writeonly buffer SSBO2 { vec4 data4; vec4 data5; } _10; layout(binding = 0, std430) readonly buffer SSBO0 { vec4 data0; vec4 data1; } _15; layout(binding = 1, std430) restrict buffer SSBO1 { vec4 data2; vec4 data3; } _21; void main() { _10.data4 = _15.data0 + _21.data2; _10.data5 = _15.data1 + _21.data3; } spirv-cross-2021.01.15/reference/shaders/comp/rmw-matrix.comp000066400000000000000000000004501400026215700237050ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { float a; vec4 b; mat4 c; float a1; vec4 b1; mat4 c1; } _11; void main() { _11.a *= _11.a1; _11.b *= _11.b1; _11.c = _11.c * _11.c1; } spirv-cross-2021.01.15/reference/shaders/comp/rmw-opt.comp000066400000000000000000000006511400026215700232060ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { int a; } _9; void main() { _9.a += 10; _9.a -= 10; _9.a *= 10; _9.a /= 10; _9.a = _9.a << 2; _9.a = _9.a >> 3; _9.a &= 40; _9.a ^= 10; _9.a %= 40; _9.a |= 1; bool c = false; bool d = true; c = c && d; d = d || c; _9.a = int(c && d); } spirv-cross-2021.01.15/reference/shaders/comp/scalar-std450-distance-length-normalize.comp000066400000000000000000000004501400026215700311310ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { float a; float b; float c; float d; float e; } _9; void main() { _9.c = distance(_9.a, _9.b); _9.d = length(_9.a); _9.e = normalize(_9.a); } spirv-cross-2021.01.15/reference/shaders/comp/shared.comp000066400000000000000000000007651400026215700230550ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { float in_data[]; } _22; layout(binding = 1, std430) writeonly buffer SSBO2 { float out_data[]; } _44; shared float sShared[4]; void main() { uint ident = gl_GlobalInvocationID.x; float idata = _22.in_data[ident]; sShared[gl_LocalInvocationIndex] = idata; barrier(); _44.out_data[ident] = sShared[(4u - gl_LocalInvocationIndex) - 1u]; } spirv-cross-2021.01.15/reference/shaders/comp/ssbo-array-length.comp000066400000000000000000000003401400026215700251350ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 1, std140) buffer SSBO { uint size; float v[]; } _11; void main() { _11.size = uint(int(uint(_11.v.length()))); } spirv-cross-2021.01.15/reference/shaders/comp/ssbo-array.comp000066400000000000000000000004061400026215700236610ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO { vec4 data[]; } ssbos[2]; void main() { uint ident = gl_GlobalInvocationID.x; ssbos[1].data[ident] = ssbos[0].data[ident]; } spirv-cross-2021.01.15/reference/shaders/comp/struct-layout.comp000066400000000000000000000006221400026215700244360ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct Foo { mat4 m; }; layout(binding = 1, std430) writeonly buffer SSBO2 { Foo out_data[]; } _23; layout(binding = 0, std430) readonly buffer SSBO { Foo in_data[]; } _30; void main() { uint ident = gl_GlobalInvocationID.x; _23.out_data[ident].m = _30.in_data[ident].m * _30.in_data[ident].m; } spirv-cross-2021.01.15/reference/shaders/comp/struct-packing.comp000066400000000000000000000046051400026215700245420ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct S0 { vec2 a[1]; float b; }; struct S1 { vec3 a; float b; }; struct S2 { vec3 a[1]; float b; }; struct S3 { vec2 a; float b; }; struct S4 { vec2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; S4 m3s[8]; }; layout(binding = 1, std430) restrict buffer SSBO1 { Content content; Content content1[2]; Content content2; mat2 m0; mat2 m1; mat2x3 m2[4]; mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_430; layout(binding = 0, std140) restrict buffer SSBO0 { Content content; Content content1[2]; Content content2; mat2 m0; mat2 m1; mat2x3 m2[4]; mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_140; void main() { ssbo_430.content.m0s[0].a[0] = ssbo_140.content.m0s[0].a[0]; ssbo_430.content.m0s[0].b = ssbo_140.content.m0s[0].b; ssbo_430.content.m1s[0].a = ssbo_140.content.m1s[0].a; ssbo_430.content.m1s[0].b = ssbo_140.content.m1s[0].b; ssbo_430.content.m2s[0].a[0] = ssbo_140.content.m2s[0].a[0]; ssbo_430.content.m2s[0].b = ssbo_140.content.m2s[0].b; ssbo_430.content.m0.a[0] = ssbo_140.content.m0.a[0]; ssbo_430.content.m0.b = ssbo_140.content.m0.b; ssbo_430.content.m1.a = ssbo_140.content.m1.a; ssbo_430.content.m1.b = ssbo_140.content.m1.b; ssbo_430.content.m2.a[0] = ssbo_140.content.m2.a[0]; ssbo_430.content.m2.b = ssbo_140.content.m2.b; ssbo_430.content.m3.a = ssbo_140.content.m3.a; ssbo_430.content.m3.b = ssbo_140.content.m3.b; ssbo_430.content.m4 = ssbo_140.content.m4; ssbo_430.content.m3s[0].c = ssbo_140.content.m3s[0].c; ssbo_430.content.m3s[1].c = ssbo_140.content.m3s[1].c; ssbo_430.content.m3s[2].c = ssbo_140.content.m3s[2].c; ssbo_430.content.m3s[3].c = ssbo_140.content.m3s[3].c; ssbo_430.content.m3s[4].c = ssbo_140.content.m3s[4].c; ssbo_430.content.m3s[5].c = ssbo_140.content.m3s[5].c; ssbo_430.content.m3s[6].c = ssbo_140.content.m3s[6].c; ssbo_430.content.m3s[7].c = ssbo_140.content.m3s[7].c; } spirv-cross-2021.01.15/reference/shaders/comp/torture-loop.comp000066400000000000000000000015131400026215700242520ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; } _24; layout(binding = 1, std430) writeonly buffer SSBO2 { vec4 out_data[]; } _89; void main() { uint ident = gl_GlobalInvocationID.x; vec4 idat = _24.in_data[ident]; int k = 0; for (;;) { int _39 = k; int _40 = _39 + 1; k = _40; if (_40 < 10) { idat *= 2.0; k++; continue; } else { break; } } for (uint i = 0u; i < 16u; i++, k++) { for (uint j = 0u; j < 30u; j++) { idat = _24.mvp * idat; } } do { k++; } while (k > 10); _89.out_data[ident] = idat; } spirv-cross-2021.01.15/reference/shaders/comp/type-alias.comp000066400000000000000000000012461400026215700236520ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct S0 { vec4 a; }; struct S1 { vec4 a; }; layout(binding = 0, std430) buffer SSBO0 { S0 s0s[]; } _36; layout(binding = 1, std430) buffer SSBO1 { S1 s1s[]; } _55; layout(binding = 2, std430) buffer SSBO2 { vec4 outputs[]; } _66; vec4 overload(S0 s0) { return s0.a; } vec4 overload(S1 s1) { return s1.a; } void main() { S0 s0; s0.a = _36.s0s[gl_GlobalInvocationID.x].a; S1 s1; s1.a = _55.s1s[gl_GlobalInvocationID.x].a; S0 param = s0; S1 param_1 = s1; _66.outputs[gl_GlobalInvocationID.x] = overload(param) + overload(param_1); } spirv-cross-2021.01.15/reference/shaders/comp/udiv.comp000066400000000000000000000005051400026215700225460ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, std430) buffer SSBO2 { uint outputs[]; } _10; layout(binding = 0, std430) buffer SSBO { uint inputs[]; } _23; void main() { _10.outputs[gl_GlobalInvocationID.x] = _23.inputs[gl_GlobalInvocationID.x] / 29u; } spirv-cross-2021.01.15/reference/shaders/desktop-only/000077500000000000000000000000001400026215700224115ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/desktop-only/comp/000077500000000000000000000000001400026215700233475ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/desktop-only/comp/enhanced-layouts.comp000066400000000000000000000013271400026215700274750ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct Foo { int a; int b; int c; }; layout(binding = 1, std140) buffer SSBO1 { layout(offset = 4) int a; layout(offset = 8) int b; layout(offset = 16) Foo foo; layout(offset = 48) int c[8]; } ssbo1; layout(binding = 2, std430) buffer SSBO2 { layout(offset = 4) int a; layout(offset = 8) int b; layout(offset = 16) Foo foo; layout(offset = 48) int c[8]; } ssbo2; layout(binding = 0, std140) uniform UBO { layout(offset = 4) int a; layout(offset = 8) int b; layout(offset = 16) Foo foo; layout(offset = 48) int c[8]; } ubo; void main() { ssbo1.a = ssbo2.a; ssbo1.b = ubo.b; } spirv-cross-2021.01.15/reference/shaders/desktop-only/comp/extended-arithmetic.desktop.comp000066400000000000000000000053161400026215700316330ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct ResType { uint _m0; uint _m1; }; struct ResType_1 { uvec2 _m0; uvec2 _m1; }; struct ResType_2 { uvec3 _m0; uvec3 _m1; }; struct ResType_3 { uvec4 _m0; uvec4 _m1; }; struct ResType_4 { int _m0; int _m1; }; struct ResType_5 { ivec2 _m0; ivec2 _m1; }; struct ResType_6 { ivec3 _m0; ivec3 _m1; }; struct ResType_7 { ivec4 _m0; ivec4 _m1; }; layout(binding = 0, std430) buffer SSBOUint { uint a; uint b; uint c; uint d; uvec2 a2; uvec2 b2; uvec2 c2; uvec2 d2; uvec3 a3; uvec3 b3; uvec3 c3; uvec3 d3; uvec4 a4; uvec4 b4; uvec4 c4; uvec4 d4; } u; layout(binding = 1, std430) buffer SSBOInt { int a; int b; int c; int d; ivec2 a2; ivec2 b2; ivec2 c2; ivec2 d2; ivec3 a3; ivec3 b3; ivec3 c3; ivec3 d3; ivec4 a4; ivec4 b4; ivec4 c4; ivec4 d4; } i; void main() { ResType _25; _25._m0 = uaddCarry(u.a, u.b, _25._m1); u.d = _25._m1; u.c = _25._m0; ResType_1 _40; _40._m0 = uaddCarry(u.a2, u.b2, _40._m1); u.d2 = _40._m1; u.c2 = _40._m0; ResType_2 _55; _55._m0 = uaddCarry(u.a3, u.b3, _55._m1); u.d3 = _55._m1; u.c3 = _55._m0; ResType_3 _70; _70._m0 = uaddCarry(u.a4, u.b4, _70._m1); u.d4 = _70._m1; u.c4 = _70._m0; ResType _79; _79._m0 = usubBorrow(u.a, u.b, _79._m1); u.d = _79._m1; u.c = _79._m0; ResType_1 _88; _88._m0 = usubBorrow(u.a2, u.b2, _88._m1); u.d2 = _88._m1; u.c2 = _88._m0; ResType_2 _97; _97._m0 = usubBorrow(u.a3, u.b3, _97._m1); u.d3 = _97._m1; u.c3 = _97._m0; ResType_3 _106; _106._m0 = usubBorrow(u.a4, u.b4, _106._m1); u.d4 = _106._m1; u.c4 = _106._m0; ResType _116; umulExtended(u.a, u.b, _116._m1, _116._m0); u.d = _116._m0; u.c = _116._m1; ResType_1 _125; umulExtended(u.a2, u.b2, _125._m1, _125._m0); u.d2 = _125._m0; u.c2 = _125._m1; ResType_2 _134; umulExtended(u.a3, u.b3, _134._m1, _134._m0); u.d3 = _134._m0; u.c3 = _134._m1; ResType_3 _143; umulExtended(u.a4, u.b4, _143._m1, _143._m0); u.d4 = _143._m0; u.c4 = _143._m1; ResType_4 _160; imulExtended(i.a, i.b, _160._m1, _160._m0); i.d = _160._m0; i.c = _160._m1; ResType_5 _171; imulExtended(i.a2, i.b2, _171._m1, _171._m0); i.d2 = _171._m0; i.c2 = _171._m1; ResType_6 _182; imulExtended(i.a3, i.b3, _182._m1, _182._m0); i.d3 = _182._m0; i.c3 = _182._m1; ResType_7 _193; imulExtended(i.a4, i.b4, _193._m1, _193._m0); i.d4 = _193._m0; i.c4 = _193._m1; } spirv-cross-2021.01.15/reference/shaders/desktop-only/comp/fp64.desktop.comp000066400000000000000000000033751400026215700264660ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct M0 { double v; dvec2 b[2]; dmat2x3 c; dmat3x2 d; }; layout(binding = 0, std430) buffer SSBO0 { dvec4 a; M0 m0; dmat4 b; } ssbo_0; layout(binding = 1, std430) buffer SSBO1 { dmat4 a; dvec4 b; M0 m0; } ssbo_1; layout(binding = 2, std430) buffer SSBO2 { double a[4]; dvec2 b[4]; } ssbo_2; layout(binding = 3, std140) buffer SSBO3 { double a[4]; dvec2 b[4]; } ssbo_3; void main() { ssbo_0.a += dvec4(10.0lf, 20.0lf, 30.0lf, 40.0lf); ssbo_0.a += dvec4(20.0lf); dvec4 a = ssbo_0.a; dmat4 amat = ssbo_0.b; ssbo_0.a = abs(a); ssbo_0.a = sign(a); ssbo_0.a = floor(a); ssbo_0.a = trunc(a); ssbo_0.a = round(a); ssbo_0.a = roundEven(a); ssbo_0.a = ceil(a); ssbo_0.a = fract(a); ssbo_0.a = mod(a, dvec4(20.0lf)); ssbo_0.a = mod(a, a); ssbo_0.a = min(a, a); ssbo_0.a = max(a, a); ssbo_0.a = clamp(a, a, a); ssbo_0.a = mix(a, a, a); ssbo_0.a = step(a, a); ssbo_0.a = smoothstep(a, a, a); bvec4 b = isnan(a); bvec4 c = isinf(a); double f = packDouble2x32(uvec2(10u, 40u)); uvec2 g = unpackDouble2x32(f); double d = length(a); d = distance(a, a); d = dot(a, a); dvec3 e = cross(a.xyz, a.yzw); a = faceforward(a, a, a); a = reflect(a, a); dmat4 l = dmat4(amat[0] * amat[0], amat[1] * amat[1], amat[2] * amat[2], amat[3] * amat[3]); l = outerProduct(a, a); l = transpose(l); double m = determinant(l); l = inverse(l); bvec4 k = lessThan(a, a); k = lessThanEqual(a, a); k = greaterThan(a, a); k = greaterThanEqual(a, a); ssbo_1.b.x += 1.0lf; ssbo_2.b[0].x += 1.0lf; ssbo_3.b[0].x += 1.0lf; } spirv-cross-2021.01.15/reference/shaders/desktop-only/comp/image-formats.desktop.noeliminate.comp000066400000000000000000000056231400026215700327430ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(binding = 0, rgba32f) uniform readonly writeonly image2D uImg00; layout(binding = 1, rgba16f) uniform readonly writeonly image2D uImg01; layout(binding = 2, rg32f) uniform readonly writeonly image2D uImg02; layout(binding = 3, rg16f) uniform readonly writeonly image2D uImg03; layout(binding = 4, r11f_g11f_b10f) uniform readonly writeonly image2D uImg04; layout(binding = 5, r32f) uniform readonly writeonly image2D uImg05; layout(binding = 6, r16f) uniform readonly writeonly image2D uImg06; layout(binding = 7, rgba16) uniform readonly writeonly image2D uImg07; layout(binding = 8, rgb10_a2) uniform readonly writeonly image2D uImg08; layout(binding = 9, rgba8) uniform readonly writeonly image2D uImg09; layout(binding = 10, rg16) uniform readonly writeonly image2D uImg10; layout(binding = 11, rg8) uniform readonly writeonly image2D uImg11; layout(binding = 12, r16) uniform readonly writeonly image2D uImg12; layout(binding = 13, r8) uniform readonly writeonly image2D uImg13; layout(binding = 14, rgba16_snorm) uniform readonly writeonly image2D uImg14; layout(binding = 15, rgba8_snorm) uniform readonly writeonly image2D uImg15; layout(binding = 16, rg16_snorm) uniform readonly writeonly image2D uImg16; layout(binding = 17, rg8_snorm) uniform readonly writeonly image2D uImg17; layout(binding = 18, r16_snorm) uniform readonly writeonly image2D uImg18; layout(binding = 19, r8_snorm) uniform readonly writeonly image2D uImg19; layout(binding = 20, rgba32i) uniform readonly writeonly iimage2D uImage20; layout(binding = 21, rgba16i) uniform readonly writeonly iimage2D uImage21; layout(binding = 22, rgba8i) uniform readonly writeonly iimage2D uImage22; layout(binding = 23, rg32i) uniform readonly writeonly iimage2D uImage23; layout(binding = 24, rg16i) uniform readonly writeonly iimage2D uImage24; layout(binding = 25, rg8i) uniform readonly writeonly iimage2D uImage25; layout(binding = 26, r32i) uniform readonly writeonly iimage2D uImage26; layout(binding = 27, r16i) uniform readonly writeonly iimage2D uImage27; layout(binding = 28, r8i) uniform readonly writeonly iimage2D uImage28; layout(binding = 29, rgba32ui) uniform readonly writeonly uimage2D uImage29; layout(binding = 30, rgba16ui) uniform readonly writeonly uimage2D uImage30; layout(binding = 31, rgb10_a2ui) uniform readonly writeonly uimage2D uImage31; layout(binding = 32, rgba8ui) uniform readonly writeonly uimage2D uImage32; layout(binding = 33, rg32ui) uniform readonly writeonly uimage2D uImage33; layout(binding = 34, rg16ui) uniform readonly writeonly uimage2D uImage34; layout(binding = 35, rg8ui) uniform readonly writeonly uimage2D uImage35; layout(binding = 36, r32ui) uniform readonly writeonly uimage2D uImage36; layout(binding = 37, r16ui) uniform readonly writeonly uimage2D uImage37; layout(binding = 38, r8ui) uniform readonly writeonly uimage2D uImage38; void main() { } spirv-cross-2021.01.15/reference/shaders/desktop-only/comp/int64.desktop.comp000066400000000000000000000021221400026215700266400ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; struct M0 { int64_t v; i64vec2 b[2]; uint64_t c; uint64_t d[5]; }; layout(binding = 0, std430) buffer SSBO0 { i64vec4 a; M0 m0; } ssbo_0; layout(binding = 1, std430) buffer SSBO1 { u64vec4 b; M0 m0; } ssbo_1; layout(binding = 2, std430) buffer SSBO2 { int64_t a[4]; i64vec2 b[4]; } ssbo_2; layout(binding = 3, std140) buffer SSBO3 { int64_t a[4]; i64vec2 b[4]; } ssbo_3; void main() { ssbo_0.a += i64vec4(10l, 20l, 30l, 40l); ssbo_1.b += u64vec4(999999999999999999ul, 8888888888888888ul, 77777777777777777ul, 6666666666666666ul); ssbo_0.a += i64vec4(20l); ssbo_0.a = abs(ssbo_0.a + i64vec4(ssbo_1.b)); ssbo_0.a += i64vec4(1l); ssbo_1.b += u64vec4(i64vec4(1l)); ssbo_0.a -= i64vec4(1l); ssbo_1.b -= u64vec4(i64vec4(1l)); ssbo_1.b = doubleBitsToUint64(int64BitsToDouble(ssbo_0.a)); ssbo_0.a = doubleBitsToInt64(uint64BitsToDouble(ssbo_1.b)); ssbo_2.a[0] += 1l; ssbo_3.a[0] += 2l; } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/000077500000000000000000000000001400026215700233305ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/clip-cull-distance.desktop.frag000066400000000000000000000002761400026215700313220ustar00rootroot00000000000000#version 450 in float gl_ClipDistance[4]; in float gl_CullDistance[3]; layout(location = 0) out float FragColor; void main() { FragColor = gl_ClipDistance[0] + gl_CullDistance[0]; } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/control-dependent-in-branch.desktop.frag000066400000000000000000000015641400026215700331320ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vInput; void main() { FragColor = vInput; vec4 t = texture(uSampler, vInput.xy); vec4 d0 = dFdx(vInput); vec4 d1 = dFdy(vInput); vec4 d2 = fwidth(vInput); vec4 d3 = dFdxCoarse(vInput); vec4 d4 = dFdyCoarse(vInput); vec4 d5 = fwidthCoarse(vInput); vec4 d6 = dFdxFine(vInput); vec4 d7 = dFdyFine(vInput); vec4 d8 = fwidthFine(vInput); vec2 lod = textureQueryLod(uSampler, vInput.zw); if (vInput.y > 10.0) { FragColor += t; FragColor += d0; FragColor += d1; FragColor += d2; FragColor += d3; FragColor += d4; FragColor += d5; FragColor += d6; FragColor += d7; FragColor += d8; FragColor += lod.xyxy; } } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/depth-greater-than.desktop.frag000066400000000000000000000002061400026215700313220ustar00rootroot00000000000000#version 450 layout(depth_greater) out float gl_FragDepth; layout(early_fragment_tests) in; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/depth-less-than.desktop.frag000066400000000000000000000002031400026215700306340ustar00rootroot00000000000000#version 450 layout(depth_less) out float gl_FragDepth; layout(early_fragment_tests) in; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/dual-source-blending.desktop.frag000066400000000000000000000003021400026215700316370ustar00rootroot00000000000000#version 450 layout(location = 0, index = 0) out vec4 FragColor0; layout(location = 0, index = 1) out vec4 FragColor1; void main() { FragColor0 = vec4(1.0); FragColor1 = vec4(2.0); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/hlsl-uav-block-alias.asm.frag000066400000000000000000000005141400026215700306620ustar00rootroot00000000000000#version 450 layout(binding = 0, std430) buffer Foobar { vec4 _data[]; } Foobar_1; layout(binding = 1, std430) buffer Foobaz { vec4 _data[]; } Foobaz_1; layout(location = 0) out vec4 _entryPointOutput; vec4 _main() { return Foobar_1._data[0] + Foobaz_1._data[0]; } void main() { _entryPointOutput = _main(); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/image-ms.desktop.frag000066400000000000000000000005321400026215700273400ustar00rootroot00000000000000#version 450 layout(binding = 0, rgba8) uniform image2DMS uImage; layout(binding = 1, rgba8) uniform image2DMSArray uImageArray; void main() { vec4 a = imageLoad(uImage, ivec2(1, 2), 2); vec4 b = imageLoad(uImageArray, ivec3(1, 2, 4), 3); imageStore(uImage, ivec2(2, 3), 1, a); imageStore(uImageArray, ivec3(2, 3, 7), 1, b); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/image-query.desktop.frag000066400000000000000000000044571400026215700301000ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1D uSampler1D; layout(binding = 1) uniform sampler2D uSampler2D; layout(binding = 2) uniform sampler2DArray uSampler2DArray; layout(binding = 3) uniform sampler3D uSampler3D; layout(binding = 4) uniform samplerCube uSamplerCube; layout(binding = 5) uniform samplerCubeArray uSamplerCubeArray; layout(binding = 6) uniform samplerBuffer uSamplerBuffer; layout(binding = 7) uniform sampler2DMS uSamplerMS; layout(binding = 8) uniform sampler2DMSArray uSamplerMSArray; layout(binding = 9, r32f) uniform readonly writeonly image1D uImage1D; layout(binding = 10, r32f) uniform readonly writeonly image2D uImage2D; layout(binding = 11, r32f) uniform readonly writeonly image2DArray uImage2DArray; layout(binding = 12, r32f) uniform readonly writeonly image3D uImage3D; layout(binding = 13, r32f) uniform readonly writeonly imageCube uImageCube; layout(binding = 14, r32f) uniform readonly writeonly imageCubeArray uImageCubeArray; layout(binding = 15, r32f) uniform readonly writeonly imageBuffer uImageBuffer; layout(binding = 16, r32f) uniform readonly writeonly image2DMS uImageMS; layout(binding = 17, r32f) uniform readonly writeonly image2DMSArray uImageMSArray; void main() { int a = textureSize(uSampler1D, 0); ivec2 b = textureSize(uSampler2D, 0); ivec3 c = textureSize(uSampler2DArray, 0); ivec3 d = textureSize(uSampler3D, 0); ivec2 e = textureSize(uSamplerCube, 0); ivec3 f = textureSize(uSamplerCubeArray, 0); int g = textureSize(uSamplerBuffer); ivec2 h = textureSize(uSamplerMS); ivec3 i = textureSize(uSamplerMSArray); int l0 = textureQueryLevels(uSampler1D); int l1 = textureQueryLevels(uSampler2D); int l2 = textureQueryLevels(uSampler2DArray); int l3 = textureQueryLevels(uSampler3D); int l4 = textureQueryLevels(uSamplerCube); int l5 = textureQueryLevels(uSamplerCubeArray); a = imageSize(uImage1D); b = imageSize(uImage2D); c = imageSize(uImage2DArray); d = imageSize(uImage3D); e = imageSize(uImageCube); f = imageSize(uImageCubeArray); g = imageSize(uImageBuffer); h = imageSize(uImageMS); i = imageSize(uImageMSArray); int s0 = textureSamples(uSamplerMS); int s1 = textureSamples(uSamplerMSArray); int s2 = imageSamples(uImageMS); int s3 = imageSamples(uImageMSArray); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/image-size.frag000066400000000000000000000004401400026215700262210ustar00rootroot00000000000000#version 450 layout(binding = 0, r32f) uniform readonly writeonly image2D uImage1; layout(binding = 1, r32f) uniform readonly writeonly image2D uImage2; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(vec2(imageSize(uImage1)), vec2(imageSize(uImage2))); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/image-size.no-qualifier-deduction.frag000066400000000000000000000003721400026215700325730ustar00rootroot00000000000000#version 450 layout(binding = 0, r32f) uniform image2D uImage1; layout(binding = 1, r32f) uniform image2D uImage2; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(vec2(imageSize(uImage1)), vec2(imageSize(uImage2))); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/in-block-qualifiers.frag000066400000000000000000000007221400026215700300320ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in VertexData { flat float f; centroid vec4 g; flat int h; float i; } vin; layout(location = 4) flat in float f; layout(location = 5) centroid in vec4 g; layout(location = 6) flat in int h; layout(location = 7) sample in float i; void main() { FragColor = ((((((vec4(vin.f) + vin.g) + vec4(float(vin.h))) + vec4(vin.i)) + vec4(f)) + g) + vec4(float(h))) + vec4(i); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/layout-component.desktop.frag000066400000000000000000000004401400026215700311540ustar00rootroot00000000000000#version 450 layout(location = 0) out vec2 FragColor; layout(location = 0, component = 0) in vec2 v0; layout(location = 0, component = 2) in float v1; in Vertex { layout(location = 1, component = 2) float v3; } _20; void main() { FragColor = (v0 + vec2(v1)) + vec2(_20.v3); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/query-levels.desktop.frag000066400000000000000000000002651400026215700303010ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(textureQueryLevels(uSampler))); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/query-lod.desktop.frag000066400000000000000000000003351400026215700275630ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTexCoord; void main() { FragColor = textureQueryLod(uSampler, vTexCoord).xyxy; } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/sampler-ms-query.desktop.frag000066400000000000000000000007401400026215700310650ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2DMS uSampler; layout(binding = 1) uniform sampler2DMSArray uSamplerArray; layout(binding = 2, rgba8) uniform readonly writeonly image2DMS uImage; layout(binding = 3, rgba8) uniform readonly writeonly image2DMSArray uImageArray; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(((textureSamples(uSampler) + textureSamples(uSamplerArray)) + imageSamples(uImage)) + imageSamples(uImageArray))); } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/stencil-export.desktop.frag000066400000000000000000000003651400026215700306250ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_stencil_export : require layout(location = 0) out vec4 MRT0; layout(location = 1) out vec4 MRT1; void main() { MRT0 = vec4(1.0); MRT1 = vec4(1.0, 0.0, 1.0, 1.0); gl_FragStencilRefARB = 100; } spirv-cross-2021.01.15/reference/shaders/desktop-only/frag/texture-proj-shadow.desktop.frag000066400000000000000000000015031400026215700315730ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1DShadow uShadow1D; layout(binding = 1) uniform sampler2DShadow uShadow2D; layout(binding = 2) uniform sampler1D uSampler1D; layout(binding = 3) uniform sampler2D uSampler2D; layout(binding = 4) uniform sampler3D uSampler3D; layout(location = 0) out float FragColor; layout(location = 1) in vec4 vClip4; layout(location = 2) in vec2 vClip2; layout(location = 0) in vec3 vClip3; void main() { vec4 _20 = vClip4; _20.y = vClip4.w; FragColor = textureProj(uShadow1D, vec4(_20.x, 0.0, vClip4.z, _20.y)); vec4 _30 = vClip4; _30.z = vClip4.w; FragColor = textureProj(uShadow2D, vec4(_30.xy, vClip4.z, _30.z)); FragColor = textureProj(uSampler1D, vClip2).x; FragColor = textureProj(uSampler2D, vClip3).x; FragColor = textureProj(uSampler3D, vClip4).x; } spirv-cross-2021.01.15/reference/shaders/desktop-only/geom/000077500000000000000000000000001400026215700233405ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/desktop-only/geom/basic.desktop.sso.geom000066400000000000000000000013001400026215700275370ustar00rootroot00000000000000#version 450 layout(invocations = 4, triangles) in; layout(max_vertices = 3, triangle_strip) out; in gl_PerVertex { vec4 gl_Position; } gl_in[]; out gl_PerVertex { vec4 gl_Position; }; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[3]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal + vec3(float(gl_InvocationID)); EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal + vec3(4.0 * float(gl_InvocationID)); EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal + vec3(2.0 * float(gl_InvocationID)); EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/shaders/desktop-only/geom/viewport-index.desktop.geom000066400000000000000000000001751400026215700306500ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(max_vertices = 4, triangle_strip) out; void main() { gl_ViewportIndex = 1; } spirv-cross-2021.01.15/reference/shaders/desktop-only/tesc/000077500000000000000000000000001400026215700233475ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/desktop-only/tesc/basic.desktop.sso.tesc000066400000000000000000000011601400026215700275610ustar00rootroot00000000000000#version 450 layout(vertices = 1) out; in gl_PerVertex { vec4 gl_Position; } gl_in[]; out gl_PerVertex { vec4 gl_Position; } gl_out[1]; layout(location = 0) patch out vec3 vFoo; void main() { gl_TessLevelInner[0] = 8.8999996185302734375; gl_TessLevelInner[1] = 6.900000095367431640625; gl_TessLevelOuter[0] = 8.8999996185302734375; gl_TessLevelOuter[1] = 6.900000095367431640625; gl_TessLevelOuter[2] = 3.900000095367431640625; gl_TessLevelOuter[3] = 4.900000095367431640625; vFoo = vec3(1.0); gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position; } spirv-cross-2021.01.15/reference/shaders/desktop-only/tese/000077500000000000000000000000001400026215700233515ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/desktop-only/tese/triangle.desktop.sso.tese000066400000000000000000000005041400026215700303120ustar00rootroot00000000000000#version 450 layout(triangles, cw, fractional_even_spacing) in; in gl_PerVertex { vec4 gl_Position; } gl_in[]; out gl_PerVertex { vec4 gl_Position; }; void main() { gl_Position = ((gl_in[0].gl_Position * gl_TessCoord.x) + (gl_in[1].gl_Position * gl_TessCoord.y)) + (gl_in[2].gl_Position * gl_TessCoord.z); } spirv-cross-2021.01.15/reference/shaders/desktop-only/vert/000077500000000000000000000000001400026215700233715ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/desktop-only/vert/basic.desktop.sso.vert000066400000000000000000000004761400026215700276360ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; }; layout(binding = 0, std140) uniform UBO { mat4 uMVP; } _16; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec3 vNormal; layout(location = 1) in vec3 aNormal; void main() { gl_Position = _16.uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/reference/shaders/desktop-only/vert/clip-cull-distance.desktop.sso.vert000066400000000000000000000005231400026215700322220ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; float gl_PointSize; float gl_ClipDistance[4]; float gl_CullDistance[3]; }; void main() { gl_Position = vec4(1.0); gl_ClipDistance[0] = 0.0; gl_ClipDistance[1] = 0.0; gl_ClipDistance[2] = 0.0; gl_ClipDistance[3] = 0.0; gl_CullDistance[1] = 4.0; } spirv-cross-2021.01.15/reference/shaders/desktop-only/vert/clip-cull-distance.desktop.vert000066400000000000000000000004171400026215700314210ustar00rootroot00000000000000#version 450 out float gl_ClipDistance[4]; out float gl_CullDistance[3]; void main() { gl_Position = vec4(1.0); gl_ClipDistance[0] = 0.0; gl_ClipDistance[1] = 0.0; gl_ClipDistance[2] = 0.0; gl_ClipDistance[3] = 0.0; gl_CullDistance[1] = 4.0; } spirv-cross-2021.01.15/reference/shaders/desktop-only/vert/out-block-qualifiers.vert000066400000000000000000000006671400026215700303450ustar00rootroot00000000000000#version 450 layout(location = 0) out VertexData { flat float f; centroid vec4 g; flat int h; float i; } vout; layout(location = 4) flat out float f; layout(location = 5) centroid out vec4 g; layout(location = 6) flat out int h; layout(location = 7) out float i; void main() { vout.f = 10.0; vout.g = vec4(20.0); vout.h = 20; vout.i = 30.0; f = 10.0; g = vec4(20.0); h = 20; i = 30.0; } shader-draw-parameters-450.desktop.vk.vert000066400000000000000000000011461400026215700331550ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/desktop-only/vert#version 450 #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseVertex gl_BaseVertexARB #else uniform int SPIRV_Cross_BaseVertex; #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif #ifndef GL_ARB_shader_draw_parameters #error GL_ARB_shader_draw_parameters is not supported. #endif void main() { gl_Position = vec4(float(SPIRV_Cross_BaseVertex), float(SPIRV_Cross_BaseInstance), float(gl_DrawIDARB), 1.0); } shader-draw-parameters-450.desktop.vk.vert.vk000066400000000000000000000002701400026215700335710ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/desktop-only/vert#version 450 #extension GL_ARB_shader_draw_parameters : require void main() { gl_Position = vec4(float(gl_BaseVertexARB), float(gl_BaseInstanceARB), float(gl_DrawIDARB), 1.0); } spirv-cross-2021.01.15/reference/shaders/desktop-only/vert/shader-draw-parameters.desktop.vk.vert000066400000000000000000000011461400026215700327260ustar00rootroot00000000000000#version 460 #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseVertex gl_BaseVertexARB #else uniform int SPIRV_Cross_BaseVertex; #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif #ifndef GL_ARB_shader_draw_parameters #error GL_ARB_shader_draw_parameters is not supported. #endif void main() { gl_Position = vec4(float(SPIRV_Cross_BaseVertex), float(SPIRV_Cross_BaseInstance), float(gl_DrawIDARB), 1.0); } spirv-cross-2021.01.15/reference/shaders/desktop-only/vert/shader-draw-parameters.desktop.vk.vert.vk000066400000000000000000000001741400026215700333450ustar00rootroot00000000000000#version 460 void main() { gl_Position = vec4(float(gl_BaseVertex), float(gl_BaseInstance), float(gl_DrawID), 1.0); } spirv-cross-2021.01.15/reference/shaders/flatten/000077500000000000000000000000001400026215700214165ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/flatten/array.flatten.vert000066400000000000000000000004141400026215700250710ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[56]; layout(location = 0) in vec4 aVertex; void main() { vec4 a4 = UBO[23]; vec4 offset = (UBO[50] + UBO[45]) + vec4(UBO[54].x); gl_Position = ((mat4(UBO[40], UBO[41], UBO[42], UBO[43]) * aVertex) + UBO[55]) + offset; } spirv-cross-2021.01.15/reference/shaders/flatten/basic.flatten.vert000066400000000000000000000004041400026215700250330ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[4]; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec3 vNormal; layout(location = 1) in vec3 aNormal; void main() { gl_Position = mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/reference/shaders/flatten/copy.flatten.vert000066400000000000000000000013541400026215700247310ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; uniform vec4 UBO[12]; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec4 vColor; layout(location = 1) in vec3 aNormal; void main() { gl_Position = mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex; vColor = vec4(0.0); Light light; for (int i = 0; i < 4; i++) { Light _52 = Light(UBO[i * 2 + 4].xyz, UBO[i * 2 + 4].w, UBO[i * 2 + 5]); light.Position = _52.Position; light.Radius = _52.Radius; light.Color = _52.Color; vec3 L = aVertex.xyz - light.Position; vColor += ((UBO[i * 2 + 5] * clamp(1.0 - (length(L) / light.Radius), 0.0, 1.0)) * dot(aNormal, normalize(L))); } } spirv-cross-2021.01.15/reference/shaders/flatten/dynamic.flatten.vert000066400000000000000000000010471400026215700254020ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; uniform vec4 UBO[12]; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec4 vColor; layout(location = 1) in vec3 aNormal; void main() { gl_Position = mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex; vColor = vec4(0.0); for (int i = 0; i < 4; i++) { vec3 L = aVertex.xyz - UBO[i * 2 + 4].xyz; vColor += ((UBO[i * 2 + 5] * clamp(1.0 - (length(L) / UBO[i * 2 + 4].w), 0.0, 1.0)) * dot(aNormal, normalize(L))); } } spirv-cross-2021.01.15/reference/shaders/flatten/matrix-conversion.flatten.frag000066400000000000000000000004631400026215700274050ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform vec4 UBO[4]; layout(location = 0) out vec3 FragColor; layout(location = 0) flat in vec3 vNormal; void main() { mat4 _19 = mat4(UBO[0], UBO[1], UBO[2], UBO[3]); FragColor = mat3(_19[0].xyz, _19[1].xyz, _19[2].xyz) * vNormal; } spirv-cross-2021.01.15/reference/shaders/flatten/matrixindex.flatten.vert000066400000000000000000000007141400026215700263120ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[14]; layout(location = 0) out vec4 oA; layout(location = 1) out vec4 oB; layout(location = 2) out vec4 oC; layout(location = 3) out vec4 oD; layout(location = 4) out vec4 oE; void main() { gl_Position = vec4(0.0); oA = UBO[1]; oB = vec4(UBO[4].y, UBO[5].y, UBO[6].y, UBO[7].y); oC = UBO[9]; oD = vec4(UBO[10].x, UBO[11].x, UBO[12].x, UBO[13].x); oE = vec4(UBO[1].z, UBO[6].y, UBO[9].z, UBO[12].y); } spirv-cross-2021.01.15/reference/shaders/flatten/multiindex.flatten.vert000066400000000000000000000002271400026215700261370ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[15]; layout(location = 0) in ivec2 aIndex; void main() { gl_Position = UBO[aIndex.x * 5 + aIndex.y * 1 + 0]; } spirv-cross-2021.01.15/reference/shaders/flatten/push-constant.flatten.vert000066400000000000000000000004661400026215700265700ustar00rootroot00000000000000#version 310 es uniform vec4 PushMe[6]; layout(location = 1) in vec4 Pos; layout(location = 0) out vec2 vRot; layout(location = 0) in vec2 Rot; void main() { gl_Position = mat4(PushMe[0], PushMe[1], PushMe[2], PushMe[3]) * Pos; vRot = (mat2(PushMe[4].xy, PushMe[4].zw) * Rot) + vec2(PushMe[5].z); } spirv-cross-2021.01.15/reference/shaders/flatten/rowmajor.flatten.vert000066400000000000000000000004431400026215700256150ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[12]; layout(location = 0) in vec4 aVertex; void main() { vec2 v = mat4x2(UBO[8].xy, UBO[9].xy, UBO[10].xy, UBO[11].xy) * aVertex; gl_Position = (mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex) + (aVertex * mat4(UBO[4], UBO[5], UBO[6], UBO[7])); } spirv-cross-2021.01.15/reference/shaders/flatten/struct.flatten.vert000066400000000000000000000007321400026215700253020ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; uniform vec4 UBO[6]; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec4 vColor; layout(location = 1) in vec3 aNormal; void main() { gl_Position = mat4(UBO[0], UBO[1], UBO[2], UBO[3]) * aVertex; vColor = vec4(0.0); vec3 L = aVertex.xyz - UBO[4].xyz; vColor += ((UBO[5] * clamp(1.0 - (length(L) / UBO[4].w), 0.0, 1.0)) * dot(aNormal, normalize(L))); } spirv-cross-2021.01.15/reference/shaders/flatten/struct.rowmajor.flatten.vert000066400000000000000000000010171400026215700271360ustar00rootroot00000000000000#version 310 es struct Foo { mat3x4 MVP0; mat3x4 MVP1; }; uniform vec4 UBO[8]; layout(location = 0) in vec4 v0; layout(location = 1) in vec4 v1; layout(location = 0) out vec3 V0; layout(location = 1) out vec3 V1; void main() { Foo _20 = Foo(transpose(mat4x3(UBO[0].xyz, UBO[1].xyz, UBO[2].xyz, UBO[3].xyz)), transpose(mat4x3(UBO[4].xyz, UBO[5].xyz, UBO[6].xyz, UBO[7].xyz))); Foo f; f.MVP0 = _20.MVP0; f.MVP1 = _20.MVP1; vec3 a = v0 * f.MVP0; vec3 b = v1 * f.MVP1; V0 = a; V1 = b; } spirv-cross-2021.01.15/reference/shaders/flatten/swizzle.flatten.vert000066400000000000000000000010061400026215700254600ustar00rootroot00000000000000#version 310 es uniform vec4 UBO[8]; layout(location = 0) out vec4 oA; layout(location = 1) out vec4 oB; layout(location = 2) out vec4 oC; layout(location = 3) out vec4 oD; layout(location = 4) out vec4 oE; layout(location = 5) out vec4 oF; void main() { gl_Position = vec4(0.0); oA = UBO[0]; oB = vec4(UBO[1].xy, UBO[1].zw); oC = vec4(UBO[2].x, UBO[3].xyz); oD = vec4(UBO[4].xyz, UBO[4].w); oE = vec4(UBO[5].x, UBO[5].y, UBO[5].z, UBO[5].w); oF = vec4(UBO[6].x, UBO[6].zw, UBO[7].x); } spirv-cross-2021.01.15/reference/shaders/flatten/types.flatten.frag000066400000000000000000000004711400026215700250610ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump ivec4 UBO1[2]; uniform mediump uvec4 UBO2[2]; uniform vec4 UBO0[2]; layout(location = 0) out vec4 FragColor; void main() { FragColor = ((((vec4(UBO1[0]) + vec4(UBO1[1])) + vec4(UBO2[0])) + vec4(UBO2[1])) + UBO0[0]) + UBO0[1]; } spirv-cross-2021.01.15/reference/shaders/frag/000077500000000000000000000000001400026215700207005ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/frag/array-lut-no-loop-variable.frag000066400000000000000000000004011400026215700266200ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; const float _17[5] = float[](1.0, 2.0, 3.0, 4.0, 5.0); layout(location = 0) out vec4 FragColor; void main() { for (mediump int i = 0; i < 4; i++, FragColor += vec4(_17[i])) { } } spirv-cross-2021.01.15/reference/shaders/frag/avoid-expression-lowering-to-loop.frag000066400000000000000000000007711400026215700302600ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 1, std140) uniform Count { float count; } _44; layout(binding = 0) uniform mediump sampler2D tex; layout(location = 0) in highp vec4 vertex; layout(location = 0) out vec4 fragColor; void main() { highp float size = 1.0 / float(textureSize(tex, 0).x); float r = 0.0; float d = dFdx(vertex.x); for (float i = 0.0; i < _44.count; i += 1.0) { r += (size * d); } fragColor = vec4(r); } spirv-cross-2021.01.15/reference/shaders/frag/barycentric-nv.frag000066400000000000000000000010661400026215700244720ustar00rootroot00000000000000#version 450 #extension GL_NV_fragment_shader_barycentric : require layout(binding = 0, std430) readonly buffer Vertices { vec2 uvs[]; } _19; layout(location = 0) out vec2 value; void main() { int prim = gl_PrimitiveID; vec2 uv0 = _19.uvs[(3 * prim) + 0]; vec2 uv1 = _19.uvs[(3 * prim) + 1]; vec2 uv2 = _19.uvs[(3 * prim) + 2]; value = ((uv0 * gl_BaryCoordNV.x) + (uv1 * gl_BaryCoordNV.y)) + (uv2 * gl_BaryCoordNV.z); value += (((uv0 * gl_BaryCoordNoPerspNV.x) + (uv1 * gl_BaryCoordNoPerspNV.y)) + (uv2 * gl_BaryCoordNoPerspNV.z)); } spirv-cross-2021.01.15/reference/shaders/frag/basic.frag000066400000000000000000000004451400026215700226250ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uTex; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; void main() { FragColor = vColor * texture(uTex, vTex); } spirv-cross-2021.01.15/reference/shaders/frag/complex-expression-in-access-chain.frag000066400000000000000000000010671400026215700303340ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0, std430) buffer UBO { vec4 results[1024]; } _34; layout(binding = 1) uniform highp isampler2D Buf; layout(location = 0) flat in mediump int vIn; layout(location = 1) flat in mediump int vIn2; layout(location = 0) out vec4 FragColor; void main() { mediump ivec4 coords = texelFetch(Buf, ivec2(gl_FragCoord.xy), 0); vec4 foo = _34.results[coords.x % 16]; mediump int c = vIn * vIn; mediump int d = vIn2 * vIn2; FragColor = (foo + foo) + _34.results[c + d]; } spirv-cross-2021.01.15/reference/shaders/frag/composite-extract-forced-temporary.frag000066400000000000000000000004441400026215700304750ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D Texture; layout(location = 0) in vec2 vTexCoord; layout(location = 0) out vec4 FragColor; void main() { float f = texture(Texture, vTexCoord).x; FragColor = vec4(f * f); } spirv-cross-2021.01.15/reference/shaders/frag/constant-array.frag000066400000000000000000000012301400026215700245020ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct Foobar { float a; float b; }; const vec4 _37[3] = vec4[](vec4(1.0), vec4(2.0), vec4(3.0)); const vec4 _55[2][2] = vec4[][](vec4[](vec4(1.0), vec4(2.0)), vec4[](vec4(8.0), vec4(10.0))); const Foobar _75[2] = Foobar[](Foobar(10.0, 40.0), Foobar(90.0, 70.0)); layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int index; vec4 resolve(Foobar f) { return vec4(f.a + f.b); } void main() { Foobar param = Foobar(10.0, 20.0); Foobar param_1 = _75[index]; FragColor = ((_37[index] + _55[index][index + 1]) + resolve(param)) + resolve(param_1); } spirv-cross-2021.01.15/reference/shaders/frag/constant-composites.frag000066400000000000000000000006331400026215700255570ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; const float _16[4] = float[](1.0, 4.0, 3.0, 2.0); struct Foo { float a; float b; }; const Foo _28[2] = Foo[](Foo(10.0, 20.0), Foo(30.0, 40.0)); layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int line; void main() { FragColor = vec4(_16[line]); FragColor += vec4(_28[line].a * _28[1 - line].a); } spirv-cross-2021.01.15/reference/shaders/frag/false-loop-init.frag000066400000000000000000000006271400026215700245500ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 result; layout(location = 0) in vec4 accum; void main() { result = vec4(0.0); mediump uint j; for (mediump int i = 0; i < 4; i += int(j)) { if (accum.y > 10.0) { j = 40u; } else { j = 30u; } result += accum; } } spirv-cross-2021.01.15/reference/shaders/frag/flush_params.frag000066400000000000000000000005311400026215700242240ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct Structy { vec4 c; }; layout(location = 0) out vec4 FragColor; void foo2(inout Structy f) { f.c = vec4(10.0); } Structy foo() { Structy param; foo2(param); Structy f = param; return f; } void main() { Structy s = foo(); FragColor = s.c; } spirv-cross-2021.01.15/reference/shaders/frag/for-loop-continue-control-flow.frag000066400000000000000000000010251400026215700275410ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(0.0); int i = 0; int _36; for (;;) { if (i < 3) { int a = i; FragColor[a] += float(i); if (false) { _36 = 1; } else { int _41 = i; i = _41 + 1; _36 = _41; } continue; } else { break; } } } spirv-cross-2021.01.15/reference/shaders/frag/for-loop-init.frag000066400000000000000000000015671400026215700242500ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out mediump int FragColor; void main() { FragColor = 16; for (mediump int i = 0; i < 25; i++) { FragColor += 10; } for (mediump int i_1 = 1, j = 4; i_1 < 30; i_1++, j += 4) { FragColor += 11; } mediump int k = 0; for (; k < 20; k++) { FragColor += 12; } k += 3; FragColor += k; mediump int l; if (k == 40) { l = 0; for (; l < 40; l++) { FragColor += 13; } return; } else { l = k; FragColor += l; } mediump ivec2 i_2 = ivec2(0); for (; i_2.x < 10; i_2.x += 4) { FragColor += i_2.y; } mediump int o = k; for (mediump int m = k; m < 40; m++) { FragColor += m; } FragColor += o; } spirv-cross-2021.01.15/reference/shaders/frag/frexp-modf.frag000066400000000000000000000014331400026215700236110ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct ResType { highp float _m0; int _m1; }; struct ResType_1 { highp vec2 _m0; ivec2 _m1; }; layout(location = 0) in float v0; layout(location = 1) in vec2 v1; layout(location = 0) out float FragColor; void main() { ResType _16; _16._m0 = frexp(v0, _16._m1); mediump int e0 = _16._m1; float f0 = _16._m0; ResType _22; _22._m0 = frexp(v0 + 1.0, _22._m1); e0 = _22._m1; f0 = _22._m0; ResType_1 _35; _35._m0 = frexp(v1, _35._m1); mediump ivec2 e1 = _35._m1; vec2 f1 = _35._m0; float r0; float _41 = modf(v0, r0); float m0 = _41; vec2 r1; vec2 _45 = modf(v1, r1); vec2 m1 = _45; FragColor = ((((f0 + f1.x) + f1.y) + m0) + m1.x) + m1.y; } spirv-cross-2021.01.15/reference/shaders/frag/front-facing.frag000066400000000000000000000004451400026215700241210ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in vec4 vB; void main() { if (gl_FrontFacing) { FragColor = vA; } else { FragColor = vB; } } spirv-cross-2021.01.15/reference/shaders/frag/gather-dref.frag000066400000000000000000000004071400026215700237320ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2DShadow uT; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec3 vUV; void main() { FragColor = textureGather(uT, vUV.xy, vUV.z); } spirv-cross-2021.01.15/reference/shaders/frag/ground.frag000066400000000000000000000037111400026215700230410ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 4, std140) uniform GlobalPSData { vec4 g_CamPos; vec4 g_SunDir; vec4 g_SunColor; vec4 g_ResolutionParams; vec4 g_TimeParams; vec4 g_FogColor_Distance; } _101; layout(binding = 2) uniform mediump sampler2D TexNormalmap; layout(location = 3) out vec4 LightingOut; layout(location = 2) out vec4 NormalOut; layout(location = 1) out vec4 SpecularOut; layout(location = 0) out vec4 AlbedoOut; layout(location = 0) in vec2 TexCoord; layout(location = 1) in vec3 EyeVec; float saturate(float x) { return clamp(x, 0.0, 1.0); } void Resolve(vec3 Albedo, vec3 Normal, float Roughness, float Metallic) { LightingOut = vec4(0.0); NormalOut = vec4((Normal * 0.5) + vec3(0.5), 0.0); SpecularOut = vec4(Roughness, Metallic, 0.0, 0.0); AlbedoOut = vec4(Albedo, 1.0); } void main() { vec3 Normal = (texture(TexNormalmap, TexCoord).xyz * 2.0) - vec3(1.0); Normal = normalize(Normal); float param = length(EyeVec) / 1000.0; vec2 scatter_uv; scatter_uv.x = saturate(param); vec3 nEye = normalize(EyeVec); scatter_uv.y = 0.0; vec3 Color = vec3(0.100000001490116119384765625, 0.300000011920928955078125, 0.100000001490116119384765625); vec3 grass = vec3(0.100000001490116119384765625, 0.300000011920928955078125, 0.100000001490116119384765625); vec3 dirt = vec3(0.100000001490116119384765625); vec3 snow = vec3(0.800000011920928955078125); float grass_snow = smoothstep(0.0, 0.1500000059604644775390625, (_101.g_CamPos.y + EyeVec.y) / 200.0); vec3 base = mix(grass, snow, vec3(grass_snow)); float edge = smoothstep(0.699999988079071044921875, 0.75, Normal.y); Color = mix(dirt, base, vec3(edge)); Color *= Color; float Roughness = 1.0 - (edge * grass_snow); vec3 param_1 = Color; vec3 param_2 = Normal; float param_3 = Roughness; float param_4 = 0.0; Resolve(param_1, param_2, param_3, param_4); } spirv-cross-2021.01.15/reference/shaders/frag/helper-invocation.frag000066400000000000000000000006501400026215700251700ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uSampler; layout(location = 0) in vec2 vUV; layout(location = 0) out vec4 FragColor; vec4 foo() { vec4 color; if (!gl_HelperInvocation) { color = textureLod(uSampler, vUV, 0.0); } else { color = vec4(1.0); } return color; } void main() { FragColor = foo(); } spirv-cross-2021.01.15/reference/shaders/frag/hoisted-temporary-use-continue-block-as-value.frag000066400000000000000000000010761400026215700324430ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int vA; layout(location = 1) flat in mediump int vB; void main() { FragColor = vec4(0.0); mediump int k = 0; mediump int j; for (mediump int i = 0; i < vA; i += j) { if ((vA + i) == 20) { k = 50; } else { if ((vB + i) == 40) { k = 60; } } j = k + 10; FragColor += vec4(1.0); } } spirv-cross-2021.01.15/reference/shaders/frag/image-load-store-uint-coord.asm.frag000066400000000000000000000012161400026215700275320ustar00rootroot00000000000000#version 450 layout(binding = 1, rgba32f) uniform image2D RWIm; layout(binding = 0, rgba32f) uniform writeonly imageBuffer RWBuf; layout(binding = 1) uniform sampler2D ROIm; layout(binding = 0) uniform samplerBuffer ROBuf; layout(location = 0) out vec4 _entryPointOutput; vec4 _main() { vec4 storeTemp = vec4(10.0, 0.5, 8.0, 2.0); imageStore(RWIm, ivec2(uvec2(10u)), storeTemp); vec4 v = imageLoad(RWIm, ivec2(uvec2(30u))); imageStore(RWBuf, int(80u), v); v += texelFetch(ROIm, ivec2(uvec2(50u, 60u)), 0); v += texelFetch(ROBuf, int(80u)); return v; } void main() { vec4 _45 = _main(); _entryPointOutput = _45; } spirv-cross-2021.01.15/reference/shaders/frag/inside-loop-dominated-variable-preservation.frag000066400000000000000000000010271400026215700322270ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; void main() { bool written = false; float v; for (mediump int j = 0; j < 10; j++) { for (mediump int i = 0; i < 4; i++) { float w = 0.0; if (written) { w += v; } else { v = 20.0; } v += float(i); written = true; } } FragColor = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/frag/loop-dominator-and-switch-default.frag000066400000000000000000000020101400026215700301560ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 fragColor; void main() { vec4 f4; mediump int c = int(f4.x); for (mediump int j = 0; j < c; j++) { switch (c) { case 0: { f4.y = 0.0; break; } case 1: { f4.y = 1.0; break; } default: { mediump int i = 0; for (;;) { mediump int _48 = i; mediump int _50 = _48 + 1; i = _50; if (_48 < c) { f4.y += 0.5; continue; } else { break; } } continue; } } f4.y += 0.5; } fragColor = f4; } spirv-cross-2021.01.15/reference/shaders/frag/lut-promotion.frag000066400000000000000000000015711400026215700243750ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; const float _16[16] = float[](1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0); const vec4 _60[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); layout(location = 0) out float FragColor; layout(location = 0) flat in mediump int index; void main() { FragColor = _16[index]; if (index < 10) { FragColor += _16[index ^ 1]; } else { FragColor += _16[index & 1]; } if (index > 30) { FragColor += _60[index & 3].y; } else { FragColor += _60[index & 1].x; } vec4 foobar[4] = _60; if (index > 30) { foobar[1].z = 20.0; } FragColor += foobar[index & 3].z; vec4 baz[4] = _60; baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0)); FragColor += baz[index & 3].z; } spirv-cross-2021.01.15/reference/shaders/frag/mix.frag000066400000000000000000000007501400026215700223400ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vIn0; layout(location = 1) in vec4 vIn1; layout(location = 2) in float vIn2; layout(location = 3) in float vIn3; void main() { bvec4 l = bvec4(false, true, false, false); FragColor = mix(vIn0, vIn1, l); bool f = true; FragColor = vec4(f ? vIn3 : vIn2); FragColor = mix(vIn1, vIn0, bvec4(f)); FragColor = vec4(f ? vIn2 : vIn3); } spirv-cross-2021.01.15/reference/shaders/frag/partial-write-preserve.frag000066400000000000000000000030171400026215700261570ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct B { float a; float b; }; layout(binding = 0, std140) uniform UBO { mediump int some_value; } _51; void partial_inout(inout vec4 x) { x.x = 10.0; } void complete_inout(out vec4 x) { x = vec4(50.0); } void branchy_inout(inout vec4 v) { v.y = 20.0; if (_51.some_value == 20) { v = vec4(50.0); } } void branchy_inout_2(out vec4 v) { if (_51.some_value == 20) { v = vec4(50.0); } else { v = vec4(70.0); } v.y = 20.0; } void partial_inout(inout B b) { b.b = 40.0; } void complete_inout(out B b) { b = B(100.0, 200.0); } void branchy_inout(inout B b) { b.b = 20.0; if (_51.some_value == 20) { b = B(10.0, 40.0); } } void branchy_inout_2(out B b) { if (_51.some_value == 20) { b = B(10.0, 40.0); } else { b = B(70.0, 70.0); } b.b = 20.0; } void main() { vec4 a = vec4(10.0); vec4 param = a; partial_inout(param); a = param; vec4 param_1; complete_inout(param_1); a = param_1; vec4 param_2 = a; branchy_inout(param_2); a = param_2; vec4 param_3; branchy_inout_2(param_3); a = param_3; B b = B(10.0, 20.0); B param_4 = b; partial_inout(param_4); b = param_4; B param_5; complete_inout(param_5); b = param_5; B param_6 = b; branchy_inout(param_6); b = param_6; B param_7; branchy_inout_2(param_7); b = param_7; } spirv-cross-2021.01.15/reference/shaders/frag/pixel-interlock-ordered.frag000066400000000000000000000010521400026215700262720ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 2, std430) coherent buffer Buffer { int foo; uint bar; } _30; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0), vec4(1.0, 0.0, 0.0, 1.0)); uint _27 = imageAtomicAdd(img2, ivec2(0), 1u); _30.foo += 42; uint _41 = atomicAnd(_30.bar, 255u); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/shaders/frag/pixel-interlock-unordered.frag000066400000000000000000000010541400026215700266370ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_unordered) in; layout(binding = 2, std430) coherent buffer Buffer { int foo; uint bar; } _30; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0), vec4(1.0, 0.0, 0.0, 1.0)); uint _27 = imageAtomicAdd(img2, ivec2(0), 1u); _30.foo += 42; uint _41 = atomicAnd(_30.bar, 255u); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/shaders/frag/pls.frag000066400000000000000000000007611400026215700223430ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 PLSOut0; layout(location = 0) in vec4 PLSIn0; layout(location = 1) out vec4 PLSOut1; layout(location = 1) in vec4 PLSIn1; layout(location = 2) out vec4 PLSOut2; layout(location = 2) in vec4 PLSIn2; layout(location = 3) out vec4 PLSOut3; layout(location = 3) in vec4 PLSIn3; void main() { PLSOut0 = PLSIn0 * 2.0; PLSOut1 = PLSIn1 * 6.0; PLSOut2 = PLSIn2 * 7.0; PLSOut3 = PLSIn3 * 4.0; } spirv-cross-2021.01.15/reference/shaders/frag/post-depth-coverage-es.frag000066400000000000000000000004761400026215700260350ustar00rootroot00000000000000#version 310 es #extension GL_EXT_post_depth_coverage : require #extension GL_OES_sample_variables : require precision mediump float; precision highp int; layout(early_fragment_tests, post_depth_coverage) in; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(gl_SampleMaskIn[0])); } spirv-cross-2021.01.15/reference/shaders/frag/post-depth-coverage.frag000066400000000000000000000005041400026215700254200ustar00rootroot00000000000000#version 450 #if defined(GL_ARB_post_depth_coverge) #extension GL_ARB_post_depth_coverage : require #else #extension GL_EXT_post_depth_coverage : require #endif layout(early_fragment_tests, post_depth_coverage) in; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(gl_SampleMaskIn[0])); } spirv-cross-2021.01.15/reference/shaders/frag/round-even.frag000066400000000000000000000003131400026215700236200ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in float vB; void main() { FragColor = roundEven(vA); FragColor *= roundEven(vB); } spirv-cross-2021.01.15/reference/shaders/frag/round.frag000066400000000000000000000003031400026215700226640ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in float vB; void main() { FragColor = round(vA); FragColor *= round(vB); } spirv-cross-2021.01.15/reference/shaders/frag/sample-interlock-ordered.frag000066400000000000000000000010771400026215700264410ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(sample_interlock_ordered) in; layout(binding = 2, std430) coherent buffer Buffer { int foo; uint bar; } _30; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0), vec4(1.0, 0.0, 0.0, 1.0)); uint _27 = imageAtomicAdd(img2, ivec2(0), 1u); _30.foo += 42; uint _47 = atomicAnd(_30.bar, uint(gl_SampleMaskIn[0])); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/shaders/frag/sample-interlock-unordered.frag000066400000000000000000000010551400026215700270000ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(sample_interlock_unordered) in; layout(binding = 2, std430) coherent buffer Buffer { int foo; uint bar; } _30; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0), vec4(1.0, 0.0, 0.0, 1.0)); uint _27 = imageAtomicAdd(img2, ivec2(0), 1u); _30.foo += 42; uint _41 = atomicAnd(_30.bar, 255u); endInvocationInterlockARB(); } spirv-cross-2021.01.15/reference/shaders/frag/sample-parameter.frag000066400000000000000000000004431400026215700250010ustar00rootroot00000000000000#version 310 es #extension GL_OES_sample_variables : require precision mediump float; precision highp int; layout(location = 0) out vec2 FragColor; void main() { FragColor = (gl_SamplePosition + vec2(float(gl_SampleMaskIn[0]))) + vec2(float(gl_SampleID)); gl_SampleMask[0] = 1; } spirv-cross-2021.01.15/reference/shaders/frag/sampler-ms.frag000066400000000000000000000005661400026215700236300ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2DMS uSampler; layout(location = 0) out vec4 FragColor; void main() { ivec2 coord = ivec2(gl_FragCoord.xy); FragColor = ((texelFetch(uSampler, coord, 0) + texelFetch(uSampler, coord, 1)) + texelFetch(uSampler, coord, 2)) + texelFetch(uSampler, coord, 3); } spirv-cross-2021.01.15/reference/shaders/frag/sampler-proj.frag000066400000000000000000000004551400026215700241600ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uTex; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vTex; void main() { highp vec4 _19 = vTex; _19.z = vTex.w; FragColor = textureProj(uTex, _19.xyz); } spirv-cross-2021.01.15/reference/shaders/frag/sampler.frag000066400000000000000000000006321400026215700232050ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uTex; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; vec4 sample_texture(mediump sampler2D tex, vec2 uv) { return texture(tex, uv); } void main() { vec2 param = vTex; FragColor = vColor * sample_texture(uTex, param); } spirv-cross-2021.01.15/reference/shaders/frag/scalar-refract-reflect.frag000066400000000000000000000005301400026215700260520ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(location = 0) in vec3 vRefract; void main() { FragColor = refract(vRefract.x, vRefract.y, vRefract.z); FragColor += reflect(vRefract.x, vRefract.y); FragColor += refract(vRefract.xy, vRefract.yz, vRefract.z).y; FragColor += reflect(vRefract.xy, vRefract.zy).y; } spirv-cross-2021.01.15/reference/shaders/frag/selection-block-dominator.frag000066400000000000000000000004221400026215700266060ustar00rootroot00000000000000#version 450 layout(location = 0) flat in int vIndex; layout(location = 0) out vec4 FragColor; void main() { int v; if (vIndex != 1) { FragColor = vec4(1.0); return; } else { v = 10; } FragColor = vec4(float(v)); } spirv-cross-2021.01.15/reference/shaders/frag/struct-type-unrelated-alias.frag000066400000000000000000000002771400026215700271220ustar00rootroot00000000000000#version 450 struct T { float a; }; layout(location = 0) out float FragColor; void main() { T foo; foo.a = 10.0; T bar; bar.a = 20.0; FragColor = foo.a + bar.a; } spirv-cross-2021.01.15/reference/shaders/frag/switch-unsigned-case.frag000066400000000000000000000007701400026215700255710ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0, std140) uniform Buff { mediump uint TestVal; } _15; layout(location = 0) out vec4 fsout_Color; void main() { fsout_Color = vec4(1.0); switch (_15.TestVal) { case 0u: { fsout_Color = vec4(0.100000001490116119384765625); break; } case 1u: { fsout_Color = vec4(0.20000000298023223876953125); break; } } } spirv-cross-2021.01.15/reference/shaders/frag/swizzle.frag000066400000000000000000000011651400026215700232530ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D samp; layout(location = 0) out vec4 FragColor; layout(location = 2) in vec2 vUV; layout(location = 1) in vec3 vNormal; void main() { FragColor = vec4(texture(samp, vUV).xyz, 1.0); FragColor = vec4(texture(samp, vUV).xz, 1.0, 4.0); FragColor = vec4(texture(samp, vUV).xx, texture(samp, vUV + vec2(0.100000001490116119384765625)).yy); FragColor = vec4(vNormal, 1.0); FragColor = vec4(vNormal + vec3(1.7999999523162841796875), 1.0); FragColor = vec4(vUV, vUV + vec2(1.7999999523162841796875)); } spirv-cross-2021.01.15/reference/shaders/frag/texel-fetch-offset.frag000066400000000000000000000005321400026215700252350ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uTexture; layout(location = 0) out vec4 FragColor; void main() { FragColor = texelFetchOffset(uTexture, ivec2(gl_FragCoord.xy), 0, ivec2(1)); FragColor += texelFetchOffset(uTexture, ivec2(gl_FragCoord.xy), 0, ivec2(-1, 1)); } spirv-cross-2021.01.15/reference/shaders/frag/ubo-load-row-major-workaround.frag000066400000000000000000000017041400026215700273510ustar00rootroot00000000000000#version 450 struct RowMajor { mat4 B; }; struct NestedRowMajor { RowMajor rm; }; layout(binding = 2, std140) uniform UBO3 { layout(row_major) NestedRowMajor rm2; } _17; layout(binding = 1, std140) uniform UBO2 { layout(row_major) RowMajor rm; } _35; layout(binding = 0, std140) uniform UBO { layout(row_major) mat4 A; mat4 C; } _42; layout(binding = 3, std140) uniform UBONoWorkaround { mat4 D; } _56; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 Clip; NestedRowMajor spvWorkaroundRowMajor(NestedRowMajor wrap) { return wrap; } mat4 spvWorkaroundRowMajor(mat4 wrap) { return wrap; } void main() { NestedRowMajor rm2_loaded; rm2_loaded.rm.B = spvWorkaroundRowMajor(_17.rm2).rm.B; FragColor = (((rm2_loaded.rm.B * spvWorkaroundRowMajor(_35.rm.B)) * spvWorkaroundRowMajor(_42.A)) * spvWorkaroundRowMajor(_42.C)) * Clip; FragColor += (_56.D * Clip); FragColor += (_42.A[1] * Clip); } spirv-cross-2021.01.15/reference/shaders/frag/ubo_layout.frag000066400000000000000000000005401400026215700237220ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct Str { mat4 foo; }; layout(binding = 0, std140) uniform UBO1 { layout(row_major) Str foo; } ubo1; layout(binding = 1, std140) uniform UBO2 { Str foo; } ubo0; layout(location = 0) out vec4 FragColor; void main() { FragColor = ubo1.foo.foo[0] + ubo0.foo.foo[0]; } spirv-cross-2021.01.15/reference/shaders/frag/unary-enclose.frag000066400000000000000000000004511400026215700243250ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vIn; layout(location = 1) flat in mediump ivec4 vIn1; void main() { FragColor = -(-vIn); mediump ivec4 a = ~(~vIn1); bool b = false; b = !(!b); } spirv-cross-2021.01.15/reference/shaders/geom/000077500000000000000000000000001400026215700207105ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/geom/basic.geom000066400000000000000000000012161400026215700226420ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(invocations = 4, triangles) in; layout(max_vertices = 3, triangle_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[3]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal + vec3(float(gl_InvocationID)); EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal + vec3(4.0 * float(gl_InvocationID)); EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal + vec3(2.0 * float(gl_InvocationID)); EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/shaders/geom/geometry-passthrough.geom000066400000000000000000000006311400026215700257610ustar00rootroot00000000000000#version 450 #extension GL_NV_geometry_shader_passthrough : require layout(triangles) in; layout(passthrough) in gl_PerVertex { vec4 gl_Position; } gl_in[]; layout(passthrough, location = 0) in VertexBlock { int a; int b; } v1[3]; layout(location = 2) in VertexBlock2 { int a; layout(passthrough) int b; } v2[3]; void main() { gl_Layer = (gl_InvocationID + v1[0].a) + v2[1].b; } spirv-cross-2021.01.15/reference/shaders/geom/lines-adjacency.geom000066400000000000000000000010261400026215700246110ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(lines_adjacency) in; layout(max_vertices = 3, line_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[4]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/shaders/geom/lines.geom000066400000000000000000000006651400026215700227020ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(lines) in; layout(max_vertices = 2, line_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[2]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/shaders/geom/multi-stream.geom000066400000000000000000000004371400026215700242100ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(max_vertices = 2, points) out; void main() { gl_Position = gl_in[0].gl_Position; EmitStreamVertex(0); EndStreamPrimitive(0); gl_Position = gl_in[0].gl_Position + vec4(2.0); EmitStreamVertex(1); EndStreamPrimitive(1); } spirv-cross-2021.01.15/reference/shaders/geom/points.geom000066400000000000000000000010111400026215700230660ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(points) in; layout(max_vertices = 3, points) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[1]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/shaders/geom/single-invocation.geom000066400000000000000000000010241400026215700252060ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles) in; layout(max_vertices = 3, triangle_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[3]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/shaders/geom/transform-feedback-streams.geom000066400000000000000000000011101400026215700267630ustar00rootroot00000000000000#version 450 layout(points) in; layout(max_vertices = 2, points) out; layout(xfb_buffer = 1, xfb_stride = 20, stream = 1) out gl_PerVertex { layout(xfb_offset = 4) vec4 gl_Position; float gl_PointSize; }; layout(location = 0, xfb_buffer = 2, xfb_stride = 32, xfb_offset = 16, stream = 1) out vec4 vFoo; layout(xfb_buffer = 3, xfb_stride = 16, stream = 2) out VertOut { layout(location = 1, xfb_offset = 0) vec4 vBar; } _23; void main() { gl_Position = vec4(1.0); vFoo = vec4(3.0); EmitStreamVertex(1); _23.vBar = vec4(5.0); EmitStreamVertex(2); } spirv-cross-2021.01.15/reference/shaders/geom/triangles-adjacency.geom000066400000000000000000000010361400026215700254700ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles_adjacency) in; layout(max_vertices = 3, triangle_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[6]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/shaders/geom/triangles.geom000066400000000000000000000010241400026215700235460ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles) in; layout(max_vertices = 3, triangle_strip) out; layout(location = 0) out vec3 vNormal; layout(location = 0) in VertexData { vec3 normal; } vin[3]; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/reference/shaders/legacy/000077500000000000000000000000001400026215700212255ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/legacy/fragment/000077500000000000000000000000001400026215700230305ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/legacy/fragment/explicit-lod.legacy.frag000066400000000000000000000004121400026215700275260ustar00rootroot00000000000000#version 100 #extension GL_EXT_shader_texture_lod : require precision mediump float; precision highp int; uniform mediump sampler2D tex; void main() { gl_FragData[0] = texture2DLodEXT(tex, vec2(0.4000000059604644775390625, 0.60000002384185791015625), 0.0); } spirv-cross-2021.01.15/reference/shaders/legacy/fragment/explicit-lod.legacy.vert000066400000000000000000000003061400026215700275710ustar00rootroot00000000000000#version 100 uniform mediump sampler2D tex; varying mediump vec4 FragColor; void main() { FragColor = texture2DLod(tex, vec2(0.4000000059604644775390625, 0.60000002384185791015625), 3.0); } spirv-cross-2021.01.15/reference/shaders/legacy/fragment/fma.legacy.frag000066400000000000000000000002661400026215700257030ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; varying highp vec4 vA; varying highp vec4 vB; varying highp vec4 vC; void main() { gl_FragData[0] = vA * vB + vC; } spirv-cross-2021.01.15/reference/shaders/legacy/fragment/io-blocks.legacy.frag000066400000000000000000000002671400026215700270230ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; varying vec4 vin_color; varying highp vec3 vin_normal; void main() { gl_FragData[0] = vin_color + vin_normal.xyzz; } spirv-cross-2021.01.15/reference/shaders/legacy/fragment/multiple-struct-flattening.legacy.frag000066400000000000000000000013141400026215700324410ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; struct Foo { highp vec4 a; highp vec4 b; }; struct Bar { highp vec4 a; highp vec4 b; }; struct Baz { Foo foo; Bar bar; }; varying highp vec4 baz_foo_a; varying highp vec4 baz_foo_b; varying highp vec4 baz_bar_a; varying highp vec4 baz_bar_b; varying highp vec4 _33_a_a; varying highp vec4 _33_a_b; varying highp vec4 _33_b_a; varying highp vec4 _33_b_b; void main() { Baz bazzy = Baz(Foo(baz_foo_a, baz_foo_b), Bar(baz_bar_a, baz_bar_b)); Foo bazzy_foo = Foo(baz_foo_a, baz_foo_b); Bar bazzy_bar = Bar(baz_bar_a, baz_bar_b); gl_FragData[0] = (((_33_a_a + _33_b_b) + bazzy.foo.b) + bazzy_foo.a) + bazzy_bar.b; } spirv-cross-2021.01.15/reference/shaders/legacy/fragment/round.legacy.frag000066400000000000000000000003271400026215700262650ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; varying highp vec4 vA; varying highp float vB; void main() { gl_FragData[0] = floor(vA + vec4(0.5)); gl_FragData[0] *= floor(vB + float(0.5)); } spirv-cross-2021.01.15/reference/shaders/legacy/fragment/struct-varying.legacy.frag000066400000000000000000000006111400026215700301330ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; struct Inputs { highp vec4 a; highp vec2 b; }; varying highp vec4 vin_a; varying highp vec2 vin_b; void main() { Inputs v0 = Inputs(vin_a, vin_b); Inputs v1 = Inputs(vin_a, vin_b); highp vec4 a = vin_a; highp vec4 b = vin_b.xxyy; gl_FragData[0] = ((((v0.a + v0.b.xxyy) + v1.a) + v1.b.yyxx) + a) + b; } spirv-cross-2021.01.15/reference/shaders/legacy/fragment/switch.legacy.frag000066400000000000000000000035001400026215700264330ustar00rootroot00000000000000#version 100 precision mediump float; precision highp int; varying highp float vIndexF; void main() { int vIndex = int(vIndexF); highp vec4 v = vec4(0.0); for (int spvDummy21 = 0; spvDummy21 < 1; spvDummy21++) { if (vIndex == 2) { v = vec4(0.0, 2.0, 3.0, 4.0); break; } else if ((vIndex == 4) || (vIndex == 5)) { v = vec4(1.0, 2.0, 3.0, 4.0); break; } else if ((vIndex == 8) || (vIndex == 9)) { v = vec4(40.0, 20.0, 30.0, 40.0); break; } else if (vIndex == 10) { v = vec4(10.0); highp vec4 _43 = v; highp vec4 _44 = vec4(1.0); highp vec4 _45 = _43 + _44; v = _45; highp vec4 _46 = v; highp vec4 _47 = vec4(2.0); highp vec4 _48 = _46 + _47; v = _48; break; } else if (vIndex == 11) { highp vec4 _43 = v; highp vec4 _44 = vec4(1.0); highp vec4 _45 = _43 + _44; v = _45; highp vec4 _46 = v; highp vec4 _47 = vec4(2.0); highp vec4 _48 = _46 + _47; v = _48; break; } else if (vIndex == 12) { highp vec4 _46 = v; highp vec4 _47 = vec4(2.0); highp vec4 _48 = _46 + _47; v = _48; break; } else { v = vec4(10.0, 20.0, 30.0, 40.0); break; } } highp vec4 w = vec4(20.0); for (int spvDummy165 = 0; spvDummy165 < 1; spvDummy165++) { if ((vIndex == 10) || (vIndex == 20)) { w = vec4(40.0); break; } } gl_FragData[0] = v + w; } spirv-cross-2021.01.15/reference/shaders/legacy/vert/000077500000000000000000000000001400026215700222055ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/legacy/vert/implicit-lod.legacy.vert000066400000000000000000000002471400026215700267430ustar00rootroot00000000000000#version 100 uniform mediump sampler2D tex; void main() { gl_Position = texture2DLod(tex, vec2(0.4000000059604644775390625, 0.60000002384185791015625), 0.0); } spirv-cross-2021.01.15/reference/shaders/legacy/vert/io-block.legacy.vert000066400000000000000000000003011400026215700260430ustar00rootroot00000000000000#version 100 attribute vec4 Position; varying vec4 vout_color; varying vec3 vout_normal; void main() { gl_Position = Position; vout_color = vec4(1.0); vout_normal = vec3(0.5); } spirv-cross-2021.01.15/reference/shaders/legacy/vert/struct-flatten-inner-array.legacy.vert000066400000000000000000000003031400026215700315520ustar00rootroot00000000000000#version 100 struct Foo { float a[4]; }; varying float foo_a[4]; void main() { gl_Position = vec4(1.0); for (int i = 0; i < 4; i++) { foo_a[i] = float(i + 2); } } struct-flatten-stores-multi-dimension.legacy.vert000066400000000000000000000022511400026215700337020ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/legacy/vert#version 100 struct Foo { vec4 a; vec4 b; }; struct Bar { vec4 a; vec4 b; }; struct Baz { Foo foo; Bar bar; }; varying vec4 _12_a_a; varying vec4 _12_a_b; varying vec4 _12_b_a; varying vec4 _12_b_b; varying vec4 baz_foo_a; varying vec4 baz_foo_b; varying vec4 baz_bar_a; varying vec4 baz_bar_b; void main() { _12_a_a = vec4(10.0); _12_a_b = vec4(20.0); _12_b_a = vec4(30.0); _12_b_b = vec4(40.0); _12_a_a = Foo(vec4(50.0), vec4(60.0)).a; _12_a_b = Foo(vec4(50.0), vec4(60.0)).b; _12_b_a = Bar(vec4(50.0), vec4(60.0)).a; _12_b_b = Bar(vec4(50.0), vec4(60.0)).b; baz_foo_a = Foo(vec4(100.0), vec4(200.0)).a; baz_foo_b = Foo(vec4(100.0), vec4(200.0)).b; baz_bar_a = Bar(vec4(300.0), vec4(400.0)).a; baz_bar_b = Bar(vec4(300.0), vec4(400.0)).b; baz_foo_a = Baz(Foo(vec4(1000.0), vec4(2000.0)), Bar(vec4(3000.0), vec4(4000.0))).foo.a; baz_foo_b = Baz(Foo(vec4(1000.0), vec4(2000.0)), Bar(vec4(3000.0), vec4(4000.0))).foo.b; baz_bar_a = Baz(Foo(vec4(1000.0), vec4(2000.0)), Bar(vec4(3000.0), vec4(4000.0))).bar.a; baz_bar_b = Baz(Foo(vec4(1000.0), vec4(2000.0)), Bar(vec4(3000.0), vec4(4000.0))).bar.b; } spirv-cross-2021.01.15/reference/shaders/legacy/vert/struct-varying.legacy.vert000066400000000000000000000005751400026215700273620ustar00rootroot00000000000000#version 100 struct Output { vec4 a; vec2 b; }; varying vec4 vout_a; varying vec2 vout_b; void main() { Output s = Output(vec4(0.5), vec2(0.25)); vout_a = s.a; vout_b = s.b; vout_a = s.a; vout_b = s.b; Output tmp = Output(vout_a, vout_b); vout_a = tmp.a; vout_b = tmp.b; vout_a.x = 1.0; vout_b.y = 1.0; float c = vout_a.x; } spirv-cross-2021.01.15/reference/shaders/legacy/vert/switch-nested.legacy.vert000066400000000000000000000007551400026215700271420ustar00rootroot00000000000000#version 100 struct UBO { int func_arg; int inner_func_arg; }; uniform UBO _34; vec4 test_inner_func(bool b) { if (b) { return vec4(1.0); } else { return vec4(0.0); } } vec4 test_func(bool b) { if (b) { bool param = _34.inner_func_arg != 0; return test_inner_func(param); } else { return vec4(0.0); } } void main() { bool param = _34.func_arg != 0; gl_Position = test_func(param); } spirv-cross-2021.01.15/reference/shaders/legacy/vert/transpose.legacy.vert000066400000000000000000000025251400026215700263740ustar00rootroot00000000000000#version 100 struct Buffer { mat4 MVPRowMajor; mat4 MVPColMajor; mat4 M; }; uniform Buffer _13; attribute vec4 Position; mat4 spvWorkaroundRowMajor(mat4 wrap) { return wrap; } mat4 spvTranspose(mat4 m) { return mat4(m[0][0], m[1][0], m[2][0], m[3][0], m[0][1], m[1][1], m[2][1], m[3][1], m[0][2], m[1][2], m[2][2], m[3][2], m[0][3], m[1][3], m[2][3], m[3][3]); } void main() { vec4 c0 = spvWorkaroundRowMajor(_13.M) * (Position * _13.MVPRowMajor); vec4 c1 = spvWorkaroundRowMajor(_13.M) * (spvWorkaroundRowMajor(_13.MVPColMajor) * Position); vec4 c2 = spvWorkaroundRowMajor(_13.M) * (_13.MVPRowMajor * Position); vec4 c3 = spvWorkaroundRowMajor(_13.M) * (Position * spvWorkaroundRowMajor(_13.MVPColMajor)); vec4 c4 = _13.MVPRowMajor * Position; vec4 c5 = Position * spvWorkaroundRowMajor(_13.MVPColMajor); vec4 c6 = Position * _13.MVPRowMajor; vec4 c7 = spvWorkaroundRowMajor(_13.MVPColMajor) * Position; vec4 c8 = (spvTranspose(_13.MVPRowMajor) * 2.0) * Position; vec4 c9 = (spvTranspose(spvWorkaroundRowMajor(_13.MVPColMajor)) * 2.0) * Position; vec4 c10 = Position * (spvTranspose(_13.MVPRowMajor) * 2.0); vec4 c11 = Position * (spvTranspose(spvWorkaroundRowMajor(_13.MVPColMajor)) * 2.0); gl_Position = ((((((((((c0 + c1) + c2) + c3) + c4) + c5) + c6) + c7) + c8) + c9) + c10) + c11; } spirv-cross-2021.01.15/reference/shaders/tesc/000077500000000000000000000000001400026215700207175ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/tesc/basic.tesc000066400000000000000000000007411400026215700226620ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(vertices = 1) out; layout(location = 0) patch out vec3 vFoo; void main() { gl_TessLevelInner[0] = 8.8999996185302734375; gl_TessLevelInner[1] = 6.900000095367431640625; gl_TessLevelOuter[0] = 8.8999996185302734375; gl_TessLevelOuter[1] = 6.900000095367431640625; gl_TessLevelOuter[2] = 3.900000095367431640625; gl_TessLevelOuter[3] = 4.900000095367431640625; vFoo = vec3(1.0); } spirv-cross-2021.01.15/reference/shaders/tesc/water_tess.tesc000066400000000000000000000072311400026215700237620ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(vertices = 1) out; layout(binding = 0, std140) uniform UBO { vec4 uScale; vec3 uCamPos; vec2 uPatchSize; vec2 uMaxTessLevel; float uDistanceMod; vec4 uFrustum[6]; } _41; layout(location = 1) patch out vec2 vOutPatchPosBase; layout(location = 2) patch out vec4 vPatchLods; layout(location = 0) in vec2 vPatchPosBase[]; bool frustum_cull(vec2 p0) { vec2 min_xz = (p0 - vec2(10.0)) * _41.uScale.xy; vec2 max_xz = ((p0 + _41.uPatchSize) + vec2(10.0)) * _41.uScale.xy; vec3 bb_min = vec3(min_xz.x, -10.0, min_xz.y); vec3 bb_max = vec3(max_xz.x, 10.0, max_xz.y); vec3 center = (bb_min + bb_max) * 0.5; float radius = 0.5 * length(bb_max - bb_min); vec3 f0 = vec3(dot(_41.uFrustum[0], vec4(center, 1.0)), dot(_41.uFrustum[1], vec4(center, 1.0)), dot(_41.uFrustum[2], vec4(center, 1.0))); vec3 f1 = vec3(dot(_41.uFrustum[3], vec4(center, 1.0)), dot(_41.uFrustum[4], vec4(center, 1.0)), dot(_41.uFrustum[5], vec4(center, 1.0))); bool _205 = any(lessThanEqual(f0, vec3(-radius))); bool _215; if (!_205) { _215 = any(lessThanEqual(f1, vec3(-radius))); } else { _215 = _205; } return !_215; } float lod_factor(vec2 pos_) { vec2 pos = pos_ * _41.uScale.xy; vec3 dist_to_cam = _41.uCamPos - vec3(pos.x, 0.0, pos.y); float level = log2((length(dist_to_cam) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod); return clamp(level, 0.0, _41.uMaxTessLevel.x); } vec4 tess_level(vec4 lod) { return exp2(-lod) * _41.uMaxTessLevel.y; } float tess_level(float lod) { return _41.uMaxTessLevel.y * exp2(-lod); } void compute_tess_levels(vec2 p0) { vOutPatchPosBase = p0; vec2 param = p0 + (vec2(-0.5) * _41.uPatchSize); float l00 = lod_factor(param); vec2 param_1 = p0 + (vec2(0.5, -0.5) * _41.uPatchSize); float l10 = lod_factor(param_1); vec2 param_2 = p0 + (vec2(1.5, -0.5) * _41.uPatchSize); float l20 = lod_factor(param_2); vec2 param_3 = p0 + (vec2(-0.5, 0.5) * _41.uPatchSize); float l01 = lod_factor(param_3); vec2 param_4 = p0 + (vec2(0.5) * _41.uPatchSize); float l11 = lod_factor(param_4); vec2 param_5 = p0 + (vec2(1.5, 0.5) * _41.uPatchSize); float l21 = lod_factor(param_5); vec2 param_6 = p0 + (vec2(-0.5, 1.5) * _41.uPatchSize); float l02 = lod_factor(param_6); vec2 param_7 = p0 + (vec2(0.5, 1.5) * _41.uPatchSize); float l12 = lod_factor(param_7); vec2 param_8 = p0 + (vec2(1.5) * _41.uPatchSize); float l22 = lod_factor(param_8); vec4 lods = vec4(dot(vec4(l01, l11, l02, l12), vec4(0.25)), dot(vec4(l00, l10, l01, l11), vec4(0.25)), dot(vec4(l10, l20, l11, l21), vec4(0.25)), dot(vec4(l11, l21, l12, l22), vec4(0.25))); vPatchLods = lods; vec4 outer_lods = min(lods, lods.yzwx); vec4 param_9 = outer_lods; vec4 levels = tess_level(param_9); gl_TessLevelOuter[0] = levels.x; gl_TessLevelOuter[1] = levels.y; gl_TessLevelOuter[2] = levels.z; gl_TessLevelOuter[3] = levels.w; float min_lod = min(min(lods.x, lods.y), min(lods.z, lods.w)); float param_10 = min(min_lod, l11); float inner = tess_level(param_10); gl_TessLevelInner[0] = inner; gl_TessLevelInner[1] = inner; } void main() { vec2 p0 = vPatchPosBase[0]; vec2 param = p0; if (!frustum_cull(param)) { gl_TessLevelOuter[0] = -1.0; gl_TessLevelOuter[1] = -1.0; gl_TessLevelOuter[2] = -1.0; gl_TessLevelOuter[3] = -1.0; gl_TessLevelInner[0] = -1.0; gl_TessLevelInner[1] = -1.0; } else { vec2 param_1 = p0; compute_tess_levels(param_1); } } spirv-cross-2021.01.15/reference/shaders/tese/000077500000000000000000000000001400026215700207215ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/tese/ccw.tese000066400000000000000000000002431400026215700223560ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, ccw, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/tese/cw.tese000066400000000000000000000002421400026215700222120ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/tese/equal.tese000066400000000000000000000002301400026215700227050ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, equal_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/tese/fractional_even.tese000066400000000000000000000002421400026215700247400ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/tese/fractional_odd.tese000066400000000000000000000002411400026215700245500ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, fractional_odd_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/tese/input-array.tese000066400000000000000000000003561400026215700240620ustar00rootroot00000000000000#version 450 layout(quads, ccw, fractional_odd_spacing) in; layout(location = 0) in vec4 Floats[]; layout(location = 2) in vec4 Floats2[]; void main() { gl_Position = (Floats[0] * gl_TessCoord.x) + (Floats2[1] * gl_TessCoord.y); } spirv-cross-2021.01.15/reference/shaders/tese/line.tese000066400000000000000000000002511400026215700225300ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(isolines, point_mode, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/tese/load-array-of-array.tese000066400000000000000000000005061400026215700253550ustar00rootroot00000000000000#version 450 layout(quads, ccw, equal_spacing) in; layout(location = 0) in vec4 vTexCoord[][1]; void main() { vec4 _17_unrolled[32][1]; for (int i = 0; i < int(32); i++) { _17_unrolled[i] = vTexCoord[i]; } vec4 tmp[32][1] = _17_unrolled; gl_Position = (tmp[0][0] + tmp[2][0]) + tmp[3][0]; } spirv-cross-2021.01.15/reference/shaders/tese/patch-input-array.tese000066400000000000000000000002401400026215700251470ustar00rootroot00000000000000#version 450 layout(quads, ccw, equal_spacing) in; layout(location = 0) patch in float P[4]; void main() { gl_Position = vec4(P[0], P[1], P[2], P[3]); } spirv-cross-2021.01.15/reference/shaders/tese/triangle.tese000066400000000000000000000002421400026215700234060ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(triangles, cw, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/reference/shaders/tese/water_tess.tese000066400000000000000000000036371400026215700237740ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(quads, cw, fractional_even_spacing) in; layout(binding = 1, std140) uniform UBO { mat4 uMVP; vec4 uScale; vec2 uInvScale; vec3 uCamPos; vec2 uPatchSize; vec2 uInvHeightmapSize; } _31; layout(binding = 0) uniform mediump sampler2D uHeightmapDisplacement; layout(location = 0) patch in vec2 vOutPatchPosBase; layout(location = 1) patch in vec4 vPatchLods; layout(location = 1) out vec4 vGradNormalTex; layout(location = 0) out vec3 vWorld; vec2 lerp_vertex(vec2 tess_coord) { return vOutPatchPosBase + (tess_coord * _31.uPatchSize); } mediump vec2 lod_factor(vec2 tess_coord) { mediump vec2 x = mix(vPatchLods.yx, vPatchLods.zw, vec2(tess_coord.x)); mediump float level = mix(x.x, x.y, tess_coord.y); mediump float floor_level = floor(level); mediump float fract_level = level - floor_level; return vec2(floor_level, fract_level); } mediump vec3 sample_height_displacement(vec2 uv, vec2 off, mediump vec2 lod) { return mix(textureLod(uHeightmapDisplacement, uv + (off * 0.5), lod.x).xyz, textureLod(uHeightmapDisplacement, uv + (off * 1.0), lod.x + 1.0).xyz, vec3(lod.y)); } void main() { vec2 tess_coord = gl_TessCoord.xy; vec2 param = tess_coord; vec2 pos = lerp_vertex(param); vec2 param_1 = tess_coord; mediump vec2 lod = lod_factor(param_1); vec2 tex = pos * _31.uInvHeightmapSize; pos *= _31.uScale.xy; mediump float delta_mod = exp2(lod.x); vec2 off = _31.uInvHeightmapSize * delta_mod; vGradNormalTex = vec4(tex + (_31.uInvHeightmapSize * 0.5), tex * _31.uScale.zw); vec2 param_2 = tex; vec2 param_3 = off; mediump vec2 param_4 = lod; vec3 height_displacement = sample_height_displacement(param_2, param_3, param_4); pos += height_displacement.yz; vWorld = vec3(pos.x, height_displacement.x, pos.y); gl_Position = _31.uMVP * vec4(vWorld, 1.0); } spirv-cross-2021.01.15/reference/shaders/vert/000077500000000000000000000000001400026215700207415ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vert/basic.vert000066400000000000000000000004241400026215700227240ustar00rootroot00000000000000#version 310 es layout(binding = 0, std140) uniform UBO { mat4 uMVP; } _16; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec3 vNormal; layout(location = 1) in vec3 aNormal; void main() { gl_Position = _16.uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/reference/shaders/vert/ground.vert000066400000000000000000000065741400026215700231550ustar00rootroot00000000000000#version 310 es #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif struct PatchData { vec4 Position; vec4 LODs; }; layout(binding = 0, std140) uniform PerPatch { PatchData Patches[256]; } _53; layout(binding = 2, std140) uniform GlobalGround { vec4 GroundScale; vec4 GroundPosition; vec4 InvGroundSize_PatchScale; } _156; layout(binding = 0, std140) uniform GlobalVSData { vec4 g_ViewProj_Row0; vec4 g_ViewProj_Row1; vec4 g_ViewProj_Row2; vec4 g_ViewProj_Row3; vec4 g_CamPos; vec4 g_CamRight; vec4 g_CamUp; vec4 g_CamFront; vec4 g_SunDir; vec4 g_SunColor; vec4 g_TimeParams; vec4 g_ResolutionParams; vec4 g_CamAxisRight; vec4 g_FogColor_Distance; vec4 g_ShadowVP_Row0; vec4 g_ShadowVP_Row1; vec4 g_ShadowVP_Row2; vec4 g_ShadowVP_Row3; } _236; layout(binding = 1) uniform mediump sampler2D TexLOD; layout(binding = 0) uniform mediump sampler2D TexHeightmap; layout(location = 1) in vec4 LODWeights; #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif layout(location = 0) in vec2 Position; layout(location = 1) out vec3 EyeVec; layout(location = 0) out vec2 TexCoord; vec2 warp_position() { float vlod = dot(LODWeights, _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].LODs); vlod = all(equal(LODWeights, vec4(0.0))) ? _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].Position.w : vlod; float floor_lod = floor(vlod); float fract_lod = vlod - floor_lod; uint ufloor_lod = uint(floor_lod); uvec2 uPosition = uvec2(Position); uvec2 mask = (uvec2(1u) << uvec2(ufloor_lod, ufloor_lod + 1u)) - uvec2(1u); uint _110; if (uPosition.x < 32u) { _110 = mask.x; } else { _110 = 0u; } uint _120; if (uPosition.y < 32u) { _120 = mask.y; } else { _120 = 0u; } uvec2 rounding = uvec2(_110, _120); vec4 lower_upper_snapped = vec4((uPosition + rounding).xyxy & (~mask).xxyy); return mix(lower_upper_snapped.xy, lower_upper_snapped.zw, vec2(fract_lod)); } vec2 lod_factor(vec2 uv) { float level = textureLod(TexLOD, uv, 0.0).x * 7.96875; float floor_level = floor(level); float fract_level = level - floor_level; return vec2(floor_level, fract_level); } void main() { vec2 PatchPos = _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].Position.xz * _156.InvGroundSize_PatchScale.zw; vec2 WarpedPos = warp_position(); vec2 VertexPos = PatchPos + WarpedPos; vec2 NormalizedPos = VertexPos * _156.InvGroundSize_PatchScale.xy; vec2 param = NormalizedPos; vec2 lod = lod_factor(param); vec2 Offset = _156.InvGroundSize_PatchScale.xy * exp2(lod.x); float Elevation = mix(textureLod(TexHeightmap, NormalizedPos + (Offset * 0.5), lod.x).x, textureLod(TexHeightmap, NormalizedPos + (Offset * 1.0), lod.x + 1.0).x, lod.y); vec3 WorldPos = vec3(NormalizedPos.x, Elevation, NormalizedPos.y); WorldPos *= _156.GroundScale.xyz; WorldPos += _156.GroundPosition.xyz; EyeVec = WorldPos - _236.g_CamPos.xyz; TexCoord = NormalizedPos + (_156.InvGroundSize_PatchScale.xy * 0.5); gl_Position = (((_236.g_ViewProj_Row0 * WorldPos.x) + (_236.g_ViewProj_Row1 * WorldPos.y)) + (_236.g_ViewProj_Row2 * WorldPos.z)) + _236.g_ViewProj_Row3; } spirv-cross-2021.01.15/reference/shaders/vert/invariant.vert000066400000000000000000000006061400026215700236400ustar00rootroot00000000000000#version 310 es invariant gl_Position; layout(location = 0) in vec4 vInput0; layout(location = 1) in vec4 vInput1; layout(location = 2) in vec4 vInput2; layout(location = 0) invariant out vec4 vColor; void main() { vec4 _20 = vInput1 * vInput2; vec4 _21 = vInput0 + _20; gl_Position = _21; vec4 _27 = vInput0 - vInput1; vec4 _29 = _27 * vInput2; vColor = _29; } spirv-cross-2021.01.15/reference/shaders/vert/ocean.vert000066400000000000000000000076341400026215700227420ustar00rootroot00000000000000#version 310 es #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif struct PatchData { vec4 Position; vec4 LODs; }; layout(binding = 0, std140) uniform Offsets { PatchData Patches[256]; } _53; layout(binding = 4, std140) uniform GlobalOcean { vec4 OceanScale; vec4 OceanPosition; vec4 InvOceanSize_PatchScale; vec4 NormalTexCoordScale; } _180; layout(binding = 0, std140) uniform GlobalVSData { vec4 g_ViewProj_Row0; vec4 g_ViewProj_Row1; vec4 g_ViewProj_Row2; vec4 g_ViewProj_Row3; vec4 g_CamPos; vec4 g_CamRight; vec4 g_CamUp; vec4 g_CamFront; vec4 g_SunDir; vec4 g_SunColor; vec4 g_TimeParams; vec4 g_ResolutionParams; vec4 g_CamAxisRight; vec4 g_FogColor_Distance; vec4 g_ShadowVP_Row0; vec4 g_ShadowVP_Row1; vec4 g_ShadowVP_Row2; vec4 g_ShadowVP_Row3; } _273; layout(binding = 1) uniform mediump sampler2D TexLOD; layout(binding = 0) uniform mediump sampler2D TexDisplacement; layout(location = 1) in vec4 LODWeights; #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif layout(location = 0) in vec4 Position; layout(location = 0) out vec3 EyeVec; layout(location = 1) out vec4 TexCoord; vec2 warp_position() { float vlod = dot(LODWeights, _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].LODs); vlod = all(equal(LODWeights, vec4(0.0))) ? _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].Position.w : vlod; float floor_lod = floor(vlod); float fract_lod = vlod - floor_lod; uint ufloor_lod = uint(floor_lod); uvec4 uPosition = uvec4(Position); uvec2 mask = (uvec2(1u) << uvec2(ufloor_lod, ufloor_lod + 1u)) - uvec2(1u); uint _111; if (uPosition.x < 32u) { _111 = mask.x; } else { _111 = 0u; } uvec4 rounding; rounding.x = _111; uint _122; if (uPosition.y < 32u) { _122 = mask.x; } else { _122 = 0u; } rounding.y = _122; uint _133; if (uPosition.x < 32u) { _133 = mask.y; } else { _133 = 0u; } rounding.z = _133; uint _145; if (uPosition.y < 32u) { _145 = mask.y; } else { _145 = 0u; } rounding.w = _145; vec4 lower_upper_snapped = vec4((uPosition.xyxy + rounding) & (~mask).xxyy); return mix(lower_upper_snapped.xy, lower_upper_snapped.zw, vec2(fract_lod)); } vec2 lod_factor(vec2 uv) { float level = textureLod(TexLOD, uv, 0.0).x * 7.96875; float floor_level = floor(level); float fract_level = level - floor_level; return vec2(floor_level, fract_level); } void main() { vec2 PatchPos = _53.Patches[(gl_InstanceID + SPIRV_Cross_BaseInstance)].Position.xz * _180.InvOceanSize_PatchScale.zw; vec2 WarpedPos = warp_position(); vec2 VertexPos = PatchPos + WarpedPos; vec2 NormalizedPos = VertexPos * _180.InvOceanSize_PatchScale.xy; vec2 NormalizedTex = NormalizedPos * _180.NormalTexCoordScale.zw; vec2 param = NormalizedPos; vec2 lod = lod_factor(param); vec2 Offset = (_180.InvOceanSize_PatchScale.xy * exp2(lod.x)) * _180.NormalTexCoordScale.zw; vec3 Displacement = mix(textureLod(TexDisplacement, NormalizedTex + (Offset * 0.5), lod.x).yxz, textureLod(TexDisplacement, NormalizedTex + (Offset * 1.0), lod.x + 1.0).yxz, vec3(lod.y)); vec3 WorldPos = vec3(NormalizedPos.x, 0.0, NormalizedPos.y) + Displacement; WorldPos *= _180.OceanScale.xyz; WorldPos += _180.OceanPosition.xyz; EyeVec = WorldPos - _273.g_CamPos.xyz; TexCoord = vec4(NormalizedTex, NormalizedTex * _180.NormalTexCoordScale.xy) + ((_180.InvOceanSize_PatchScale.xyxy * 0.5) * _180.NormalTexCoordScale.zwzw); gl_Position = (((_273.g_ViewProj_Row0 * WorldPos.x) + (_273.g_ViewProj_Row1 * WorldPos.y)) + (_273.g_ViewProj_Row2 * WorldPos.z)) + _273.g_ViewProj_Row3; } spirv-cross-2021.01.15/reference/shaders/vert/read-from-row-major-array.vert000066400000000000000000000022511400026215700265460ustar00rootroot00000000000000#version 310 es layout(binding = 0, std140) uniform Block { layout(row_major) mat2x3 var[3][4]; } _104; layout(location = 0) in vec4 a_position; layout(location = 0) out mediump float v_vtxResult; mat2x3 spvWorkaroundRowMajor(mat2x3 wrap) { return wrap; } mediump float compare_float(float a, float b) { return float(abs(a - b) < 0.0500000007450580596923828125); } mediump float compare_vec3(vec3 a, vec3 b) { float param = a.x; float param_1 = b.x; float param_2 = a.y; float param_3 = b.y; float param_4 = a.z; float param_5 = b.z; return (compare_float(param, param_1) * compare_float(param_2, param_3)) * compare_float(param_4, param_5); } mediump float compare_mat2x3(mat2x3 a, mat2x3 b) { vec3 param = a[0]; vec3 param_1 = b[0]; vec3 param_2 = a[1]; vec3 param_3 = b[1]; return compare_vec3(param, param_1) * compare_vec3(param_2, param_3); } void main() { gl_Position = a_position; mediump float result = 1.0; mat2x3 param = spvWorkaroundRowMajor(_104.var[0][0]); mat2x3 param_1 = mat2x3(vec3(2.0, 6.0, -6.0), vec3(0.0, 5.0, 5.0)); result *= compare_mat2x3(param, param_1); v_vtxResult = result; } spirv-cross-2021.01.15/reference/shaders/vert/return-array.vert000066400000000000000000000005061400026215700242770ustar00rootroot00000000000000#version 310 es layout(location = 0) in vec4 vInput0; layout(location = 1) in vec4 vInput1; vec4[2] test() { return vec4[](vec4(10.0), vec4(20.0)); } vec4[2] test2() { vec4 foobar[2]; foobar[0] = vInput0; foobar[1] = vInput1; return foobar; } void main() { gl_Position = test()[0] + test2()[1]; } spirv-cross-2021.01.15/reference/shaders/vert/texture_buffer.vert000066400000000000000000000004171400026215700246760ustar00rootroot00000000000000#version 310 es #extension GL_OES_texture_buffer : require layout(binding = 4) uniform highp samplerBuffer uSamp; layout(binding = 5, rgba32f) uniform readonly highp imageBuffer uSampo; void main() { gl_Position = texelFetch(uSamp, 10) + imageLoad(uSampo, 100); } spirv-cross-2021.01.15/reference/shaders/vert/transform-feedback-decorations.vert000066400000000000000000000006711400026215700277140ustar00rootroot00000000000000#version 450 layout(xfb_buffer = 1, xfb_stride = 20) out gl_PerVertex { layout(xfb_offset = 4) vec4 gl_Position; float gl_PointSize; }; layout(location = 0, xfb_buffer = 2, xfb_stride = 32, xfb_offset = 16) out vec4 vFoo; layout(xfb_buffer = 3, xfb_stride = 16) out VertOut { layout(location = 1, xfb_offset = 0) vec4 vBar; } _22; void main() { gl_Position = vec4(1.0); vFoo = vec4(3.0); _22.vBar = vec4(5.0); } spirv-cross-2021.01.15/reference/shaders/vert/ubo.vert000066400000000000000000000004221400026215700224260ustar00rootroot00000000000000#version 310 es layout(binding = 0, std140) uniform UBO { mat4 mvp; } _16; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec3 vNormal; layout(location = 1) in vec3 aNormal; void main() { gl_Position = _16.mvp * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/reference/shaders/vulkan/000077500000000000000000000000001400026215700212615ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/comp/000077500000000000000000000000001400026215700222175ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/comp/array-of-buffer-reference.nocompat.vk.comp.vk000066400000000000000000000007751400026215700327100ustar00rootroot00000000000000#version 450 #extension GL_EXT_buffer_reference : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer Block; layout(buffer_reference, std430) buffer Block { float v; }; layout(set = 0, binding = 0, std140) uniform UBO { Block blocks[4]; } ubo; void main() { Block blocks[4]; blocks[0] = ubo.blocks[0]; blocks[1] = ubo.blocks[1]; blocks[2] = ubo.blocks[2]; blocks[3] = ubo.blocks[3]; blocks[gl_WorkGroupID.x].v = 20.0; } spirv-cross-2021.01.15/reference/shaders/vulkan/comp/buffer-reference-bitcast.nocompat.vk.comp.vk000066400000000000000000000007231400026215700326120ustar00rootroot00000000000000#version 450 #extension GL_EXT_buffer_reference : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer PtrUint; layout(buffer_reference) buffer PtrInt; layout(buffer_reference, std430) buffer PtrUint { uint value; }; layout(buffer_reference, std430) buffer PtrInt { int value; }; layout(set = 0, binding = 0, std430) buffer Buf { PtrUint ptr; } _11; void main() { PtrInt(_11.ptr).value = 10; } buffer-reference-decorations.nocompat.vk.comp.vk000066400000000000000000000013531400026215700334140ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/comp#version 450 #extension GL_EXT_buffer_reference : require layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer RO; layout(buffer_reference) buffer RW; layout(buffer_reference) buffer WO; layout(buffer_reference, std430) readonly buffer RO { vec4 v[]; }; layout(buffer_reference, std430) restrict buffer RW { vec4 v[]; }; layout(buffer_reference, std430) coherent writeonly buffer WO { vec4 v[]; }; layout(push_constant, std430) uniform Registers { RO ro; RW rw; WO wo; } registers; void main() { registers.rw.v[gl_GlobalInvocationID.x] = registers.ro.v[gl_GlobalInvocationID.x]; registers.wo.v[gl_GlobalInvocationID.x] = registers.ro.v[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/reference/shaders/vulkan/comp/buffer-reference.nocompat.vk.comp.vk000066400000000000000000000022621400026215700311630ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require #extension GL_EXT_buffer_reference : require layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(buffer_reference) buffer Node; layout(buffer_reference, std430) buffer Node { layout(offset = 0) int value; layout(offset = 16) Node next; layout(offset = 32) Node prev; }; layout(set = 0, binding = 0, std430) restrict buffer LinkedList { Node head1; Node head2; } _50; void copy_node(restrict Node dst, restrict Node a, restrict Node b) { dst.value = a.value + b.value; } void overwrite_node(out restrict Node dst, restrict Node src) { dst = src; } void main() { Node _45; if (gl_WorkGroupID.x < 4u) { _45 = _50.head1; } else { _45 = _50.head2; } restrict Node n = _45; Node param = n.next; Node param_1 = _50.head1; Node param_2 = _50.head2; copy_node(param, param_1, param_2); Node param_4 = _50.head1; Node param_3; overwrite_node(param_3, param_4); n = param_3; int v = _50.head2.value; n.value = 20; n.value = v * 10; uint64_t uptr = uint64_t(_50.head2.next); Node unode = Node(uptr); } spirv-cross-2021.01.15/reference/shaders/vulkan/comp/spec-constant-op-member-array.vk.comp000066400000000000000000000016021400026215700312730ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 100 #endif const int a = SPIRV_CROSS_CONSTANT_ID_0; #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 200 #endif const int b = SPIRV_CROSS_CONSTANT_ID_1; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; #ifndef SPIRV_CROSS_CONSTANT_ID_2 #define SPIRV_CROSS_CONSTANT_ID_2 300 #endif const int c = SPIRV_CROSS_CONSTANT_ID_2; const int d = (c + 50); #ifndef SPIRV_CROSS_CONSTANT_ID_3 #define SPIRV_CROSS_CONSTANT_ID_3 400 #endif const int e = SPIRV_CROSS_CONSTANT_ID_3; layout(binding = 0, std430) buffer SSBO { A member_a; B member_b; int v[a]; int w[d]; } _22; void main() { _22.w[gl_GlobalInvocationID.x] += (_22.v[gl_GlobalInvocationID.x] + e); } spirv-cross-2021.01.15/reference/shaders/vulkan/comp/spec-constant-op-member-array.vk.comp.vk000066400000000000000000000011271400026215700317140ustar00rootroot00000000000000#version 450 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(constant_id = 0) const int a = 100; layout(constant_id = 1) const int b = 200; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; layout(constant_id = 2) const int c = 300; const int d = (c + 50); layout(constant_id = 3) const int e = 400; layout(set = 1, binding = 0, std430) buffer SSBO { A member_a; B member_b; int v[a]; int w[d]; } _22; void main() { _22.w[gl_GlobalInvocationID.x] += (_22.v[gl_GlobalInvocationID.x] + e); } spirv-cross-2021.01.15/reference/shaders/vulkan/comp/spec-constant-work-group-size.vk.comp000066400000000000000000000014661400026215700313700ustar00rootroot00000000000000#version 450 #ifndef SPIRV_CROSS_CONSTANT_ID_1 #define SPIRV_CROSS_CONSTANT_ID_1 2 #endif const int b = SPIRV_CROSS_CONSTANT_ID_1; #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 1 #endif const int a = SPIRV_CROSS_CONSTANT_ID_0; const uint _21 = (uint(a) + 0u); #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 1u #endif const uint _27 = gl_WorkGroupSize.x; const uint _28 = (_21 + _27); const uint _29 = gl_WorkGroupSize.y; const uint _30 = (_28 + _29); const int _32 = (1 - a); layout(local_size_x = SPIRV_CROSS_CONSTANT_ID_10, local_size_y = 20, local_size_z = 1) in; layout(binding = 0, std430) writeonly buffer SSBO { int v[]; } _17; void main() { int spec_const_array_size[b]; spec_const_array_size[a] = a; _17.v[_30] = b + spec_const_array_size[_32]; } spirv-cross-2021.01.15/reference/shaders/vulkan/comp/spec-constant-work-group-size.vk.comp.vk000066400000000000000000000010771400026215700320050ustar00rootroot00000000000000#version 450 layout(local_size_x_id = 10, local_size_y = 20, local_size_z = 1) in; layout(constant_id = 1) const int b = 2; layout(constant_id = 0) const int a = 1; const uint _21 = (uint(a) + 0u); const uint _27 = gl_WorkGroupSize.x; const uint _28 = (_21 + _27); const uint _29 = gl_WorkGroupSize.y; const uint _30 = (_28 + _29); const int _32 = (1 - a); layout(set = 1, binding = 0, std430) writeonly buffer SSBO { int v[]; } _17; void main() { int spec_const_array_size[b]; spec_const_array_size[a] = a; _17.v[_30] = b + spec_const_array_size[_32]; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/000077500000000000000000000000001400026215700222005ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/frag/combined-texture-sampler-shadow.vk.frag000066400000000000000000000014741400026215700316700ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump sampler2DShadow SPIRV_Cross_CombineduDepthuSampler; uniform mediump sampler2D SPIRV_Cross_CombineduDepthuSampler1; layout(location = 0) out float FragColor; float samp2(mediump sampler2DShadow SPIRV_Cross_Combinedts) { return texture(SPIRV_Cross_Combinedts, vec3(vec3(1.0).xy, vec3(1.0).z)); } float samp3(mediump sampler2D SPIRV_Cross_Combinedts) { return texture(SPIRV_Cross_Combinedts, vec2(1.0)).x; } float samp(mediump sampler2DShadow SPIRV_Cross_Combinedts, mediump sampler2D SPIRV_Cross_Combinedts1) { float r0 = samp2(SPIRV_Cross_Combinedts); float r1 = samp3(SPIRV_Cross_Combinedts1); return r0 + r1; } void main() { FragColor = samp(SPIRV_Cross_CombineduDepthuSampler, SPIRV_Cross_CombineduDepthuSampler1); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/combined-texture-sampler-shadow.vk.frag.vk000066400000000000000000000014101400026215700322750ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(set = 0, binding = 2) uniform mediump texture2D uDepth; layout(set = 0, binding = 0) uniform mediump samplerShadow uSampler; layout(set = 0, binding = 1) uniform mediump sampler uSampler1; layout(location = 0) out float FragColor; float samp2(mediump texture2D t, mediump samplerShadow s) { return texture(sampler2DShadow(t, s), vec3(vec3(1.0).xy, vec3(1.0).z)); } float samp3(mediump texture2D t, mediump sampler s) { return texture(sampler2D(t, s), vec2(1.0)).x; } float samp(mediump texture2D t, mediump samplerShadow s, mediump sampler s1) { float r0 = samp2(t, s); float r1 = samp3(t, s1); return r0 + r1; } void main() { FragColor = samp(uDepth, uSampler, uSampler1); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/combined-texture-sampler.vk.frag000066400000000000000000000034211400026215700303770ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump sampler2D SPIRV_Cross_CombineduTexture0uSampler0; uniform mediump sampler2D SPIRV_Cross_CombineduTexture1uSampler1; uniform mediump sampler2D SPIRV_Cross_CombineduTexture1uSampler0; uniform mediump sampler2D SPIRV_Cross_CombineduTexture0uSampler1; layout(location = 0) in vec2 vTex; layout(location = 0) out vec4 FragColor; vec4 sample_dual(mediump sampler2D SPIRV_Cross_Combinedtexsamp) { return texture(SPIRV_Cross_Combinedtexsamp, vTex); } vec4 sample_duals() { vec4 a = sample_dual(SPIRV_Cross_CombineduTexture0uSampler0); vec4 b = sample_dual(SPIRV_Cross_CombineduTexture1uSampler1); return a + b; } vec4 sample_global_tex(mediump sampler2D SPIRV_Cross_CombineduTexture0samp, mediump sampler2D SPIRV_Cross_CombineduTexture1samp) { vec4 a = texture(SPIRV_Cross_CombineduTexture0samp, vTex); vec4 b = sample_dual(SPIRV_Cross_CombineduTexture1samp); return a + b; } vec4 sample_global_sampler(mediump sampler2D SPIRV_Cross_CombinedtexuSampler0, mediump sampler2D SPIRV_Cross_CombinedtexuSampler1) { vec4 a = texture(SPIRV_Cross_CombinedtexuSampler0, vTex); vec4 b = sample_dual(SPIRV_Cross_CombinedtexuSampler1); return a + b; } void main() { vec4 c0 = sample_duals(); vec4 c1 = sample_global_tex(SPIRV_Cross_CombineduTexture0uSampler0, SPIRV_Cross_CombineduTexture1uSampler0); vec4 c2 = sample_global_tex(SPIRV_Cross_CombineduTexture0uSampler1, SPIRV_Cross_CombineduTexture1uSampler1); vec4 c3 = sample_global_sampler(SPIRV_Cross_CombineduTexture0uSampler0, SPIRV_Cross_CombineduTexture0uSampler1); vec4 c4 = sample_global_sampler(SPIRV_Cross_CombineduTexture1uSampler0, SPIRV_Cross_CombineduTexture1uSampler1); FragColor = (((c0 + c1) + c2) + c3) + c4; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/combined-texture-sampler.vk.frag.vk000066400000000000000000000023651400026215700310240ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(set = 0, binding = 2) uniform mediump texture2D uTexture0; layout(set = 0, binding = 3) uniform mediump texture2D uTexture1; layout(set = 0, binding = 0) uniform mediump sampler uSampler0; layout(set = 0, binding = 1) uniform mediump sampler uSampler1; layout(location = 0) in vec2 vTex; layout(location = 0) out vec4 FragColor; vec4 sample_dual(mediump sampler samp, mediump texture2D tex) { return texture(sampler2D(tex, samp), vTex); } vec4 sample_duals() { vec4 a = sample_dual(uSampler0, uTexture0); vec4 b = sample_dual(uSampler1, uTexture1); return a + b; } vec4 sample_global_tex(mediump sampler samp) { vec4 a = texture(sampler2D(uTexture0, samp), vTex); vec4 b = sample_dual(samp, uTexture1); return a + b; } vec4 sample_global_sampler(mediump texture2D tex) { vec4 a = texture(sampler2D(tex, uSampler0), vTex); vec4 b = sample_dual(uSampler1, tex); return a + b; } void main() { vec4 c0 = sample_duals(); vec4 c1 = sample_global_tex(uSampler0); vec4 c2 = sample_global_tex(uSampler1); vec4 c3 = sample_global_sampler(uTexture0); vec4 c4 = sample_global_sampler(uTexture1); FragColor = (((c0 + c1) + c2) + c3) + c4; } demote-to-helper-forwarding.asm.vk.nocompat.frag.vk000066400000000000000000000003731400026215700337330ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/frag#version 450 #extension GL_EXT_demote_to_helper_invocation : require layout(location = 0) out vec4 FragColor; void main() { bool _15 = helperInvocationEXT(); demote; if (!_15) { FragColor = vec4(1.0, 0.0, 0.0, 1.0); } } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/demote-to-helper.vk.nocompat.frag.vk000066400000000000000000000002361400026215700310710ustar00rootroot00000000000000#version 450 #extension GL_EXT_demote_to_helper_invocation : require void main() { demote; bool _9 = helperInvocationEXT(); bool helper = _9; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/desktop-mediump.vk.frag000066400000000000000000000003361400026215700265710ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 F; layout(location = 1) flat in ivec4 I; layout(location = 2) flat in uvec4 U; void main() { FragColor = (F + vec4(I)) + vec4(U); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/desktop-mediump.vk.frag.vk000066400000000000000000000003761400026215700272140ustar00rootroot00000000000000#version 450 layout(location = 0) out mediump vec4 FragColor; layout(location = 0) in mediump vec4 F; layout(location = 1) flat in mediump ivec4 I; layout(location = 2) flat in mediump uvec4 U; void main() { FragColor = (F + vec4(I)) + vec4(U); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/input-attachment-ms.vk.frag000066400000000000000000000005441400026215700273650ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2DMS uSubpass0; layout(binding = 1) uniform sampler2DMS uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = (texelFetch(uSubpass0, ivec2(gl_FragCoord.xy), 1) + texelFetch(uSubpass1, ivec2(gl_FragCoord.xy), 2)) + texelFetch(uSubpass0, ivec2(gl_FragCoord.xy), gl_SampleID); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/input-attachment-ms.vk.frag.vk000066400000000000000000000005571400026215700300100ustar00rootroot00000000000000#version 450 layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInputMS uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform subpassInputMS uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = (subpassLoad(uSubpass0, 1) + subpassLoad(uSubpass1, 2)) + subpassLoad(uSubpass0, gl_SampleID); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/input-attachment.vk.frag000066400000000000000000000005421400026215700267460ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2D uSubpass0; layout(binding = 1) uniform mediump sampler2D uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = texelFetch(uSubpass0, ivec2(gl_FragCoord.xy), 0) + texelFetch(uSubpass1, ivec2(gl_FragCoord.xy), 0); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/input-attachment.vk.frag.vk000066400000000000000000000005761400026215700273740ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = subpassLoad(uSubpass0) + subpassLoad(uSubpass1); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/nonuniform-qualifier.vk.nocompat.frag.vk000066400000000000000000000017351400026215700320750ustar00rootroot00000000000000#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(set = 0, binding = 2, std140) uniform UBO { vec4 v[64]; } ubos[]; layout(set = 0, binding = 3, std430) readonly buffer SSBO { vec4 v[]; } ssbos[]; layout(set = 0, binding = 0) uniform texture2D uSamplers[]; layout(set = 0, binding = 1) uniform sampler uSamps[]; layout(set = 0, binding = 4) uniform sampler2D uCombinedSamplers[]; layout(location = 0) flat in int vIndex; layout(location = 0) out vec4 FragColor; layout(location = 1) in vec2 vUV; void main() { int i = vIndex; int _23 = i + 10; int _34 = i + 40; FragColor = texture(sampler2D(uSamplers[nonuniformEXT(_23)], uSamps[nonuniformEXT(_34)]), vUV); int _50 = i + 10; FragColor = texture(uCombinedSamplers[nonuniformEXT(_50)], vUV); int _66 = i + 20; int _70 = i + 40; FragColor += ubos[nonuniformEXT(_66)].v[_70]; int _84 = i + 50; int _88 = i + 60; FragColor += ssbos[nonuniformEXT(_84)].v[_88]; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/push-constant-as-ubo.push-ubo.vk.frag000066400000000000000000000002351400026215700312130ustar00rootroot00000000000000#version 450 layout(std140) uniform UBO { float ubo[4]; } _14; layout(location = 0) out float FragColor; void main() { FragColor = _14.ubo[1]; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/push-constant-as-ubo.push-ubo.vk.frag.vk000066400000000000000000000002541400026215700316330ustar00rootroot00000000000000#version 450 layout(push_constant, std140) uniform UBO { float ubo[4]; } _14; layout(location = 0) out float FragColor; void main() { FragColor = _14.ubo[1]; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/push-constant.vk.frag000066400000000000000000000004571400026215700262740ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; struct PushConstants { vec4 value0; vec4 value1; }; uniform PushConstants push; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; void main() { FragColor = (vColor + push.value0) + push.value1; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/push-constant.vk.frag.vk000066400000000000000000000004661400026215700267130ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(push_constant, std430) uniform PushConstants { vec4 value0; vec4 value1; } push; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; void main() { FragColor = (vColor + push.value0) + push.value1; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/separate-combined-fake-overload.vk.frag000066400000000000000000000006271400026215700315640ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSamp; uniform sampler2D SPIRV_Cross_CombineduTuS; layout(location = 0) out vec4 FragColor; vec4 samp(sampler2D uSamp_1) { return texture(uSamp_1, vec2(0.5)); } vec4 samp_1(sampler2D SPIRV_Cross_CombinedTS) { return texture(SPIRV_Cross_CombinedTS, vec2(0.5)); } void main() { FragColor = samp(uSamp) + samp_1(SPIRV_Cross_CombineduTuS); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/separate-combined-fake-overload.vk.frag.vk000066400000000000000000000006611400026215700322010ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform sampler2D uSamp; layout(set = 0, binding = 1) uniform texture2D uT; layout(set = 0, binding = 2) uniform sampler uS; layout(location = 0) out vec4 FragColor; vec4 samp(sampler2D uSamp_1) { return texture(uSamp_1, vec2(0.5)); } vec4 samp(texture2D T, sampler S) { return texture(sampler2D(T, S), vec2(0.5)); } void main() { FragColor = samp(uSamp) + samp(uT, uS); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/separate-sampler-texture-array.vk.frag000066400000000000000000000032761400026215700315470ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump sampler2D SPIRV_Cross_CombineduTextureuSampler[4]; uniform mediump sampler2DArray SPIRV_Cross_CombineduTextureArrayuSampler[4]; uniform mediump samplerCube SPIRV_Cross_CombineduTextureCubeuSampler[4]; uniform mediump sampler3D SPIRV_Cross_CombineduTexture3DuSampler[4]; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; layout(location = 0) out vec4 FragColor; vec4 sample_func(vec2 uv, mediump sampler2D SPIRV_Cross_CombineduTexturesamp[4]) { return texture(SPIRV_Cross_CombineduTexturesamp[2], uv); } vec4 sample_func_dual(vec2 uv, mediump sampler2D SPIRV_Cross_Combinedtexsamp) { return texture(SPIRV_Cross_Combinedtexsamp, uv); } vec4 sample_func_dual_array(vec2 uv, mediump sampler2D SPIRV_Cross_Combinedtexsamp[4]) { return texture(SPIRV_Cross_Combinedtexsamp[1], uv); } void main() { vec2 off = vec2(1.0) / vec2(textureSize(SPIRV_Cross_CombineduTextureuSampler[1], 0)); vec2 off2 = vec2(1.0) / vec2(textureSize(SPIRV_Cross_CombineduTextureuSampler[2], 1)); vec2 param = (vTex + off) + off2; vec4 c0 = sample_func(param, SPIRV_Cross_CombineduTextureuSampler); vec2 param_1 = (vTex + off) + off2; vec4 c1 = sample_func_dual(param_1, SPIRV_Cross_CombineduTextureuSampler[1]); vec2 param_2 = (vTex + off) + off2; vec4 c2 = sample_func_dual_array(param_2, SPIRV_Cross_CombineduTextureuSampler); vec4 c3 = texture(SPIRV_Cross_CombineduTextureArrayuSampler[3], vTex3); vec4 c4 = texture(SPIRV_Cross_CombineduTextureCubeuSampler[1], vTex3); vec4 c5 = texture(SPIRV_Cross_CombineduTexture3DuSampler[2], vTex3); FragColor = ((((c0 + c1) + c2) + c3) + c4) + c5; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/separate-sampler-texture-array.vk.frag.vk000066400000000000000000000031531400026215700321600ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(set = 0, binding = 1) uniform mediump texture2D uTexture[4]; layout(set = 0, binding = 0) uniform mediump sampler uSampler; layout(set = 0, binding = 4) uniform mediump texture2DArray uTextureArray[4]; layout(set = 0, binding = 3) uniform mediump textureCube uTextureCube[4]; layout(set = 0, binding = 2) uniform mediump texture3D uTexture3D[4]; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; layout(location = 0) out vec4 FragColor; vec4 sample_func(mediump sampler samp, vec2 uv) { return texture(sampler2D(uTexture[2], samp), uv); } vec4 sample_func_dual(mediump sampler samp, mediump texture2D tex, vec2 uv) { return texture(sampler2D(tex, samp), uv); } vec4 sample_func_dual_array(mediump sampler samp, mediump texture2D tex[4], vec2 uv) { return texture(sampler2D(tex[1], samp), uv); } void main() { vec2 off = vec2(1.0) / vec2(textureSize(sampler2D(uTexture[1], uSampler), 0)); vec2 off2 = vec2(1.0) / vec2(textureSize(sampler2D(uTexture[2], uSampler), 1)); vec2 param = (vTex + off) + off2; vec4 c0 = sample_func(uSampler, param); vec2 param_1 = (vTex + off) + off2; vec4 c1 = sample_func_dual(uSampler, uTexture[1], param_1); vec2 param_2 = (vTex + off) + off2; vec4 c2 = sample_func_dual_array(uSampler, uTexture, param_2); vec4 c3 = texture(sampler2DArray(uTextureArray[3], uSampler), vTex3); vec4 c4 = texture(samplerCube(uTextureCube[1], uSampler), vTex3); vec4 c5 = texture(sampler3D(uTexture3D[2], uSampler), vTex3); FragColor = ((((c0 + c1) + c2) + c3) + c4) + c5; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/separate-sampler-texture.vk.frag000066400000000000000000000026021400026215700304230ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; uniform mediump sampler2D SPIRV_Cross_CombineduTextureuSampler; uniform mediump sampler2DArray SPIRV_Cross_CombineduTextureArrayuSampler; uniform mediump samplerCube SPIRV_Cross_CombineduTextureCubeuSampler; uniform mediump sampler3D SPIRV_Cross_CombineduTexture3DuSampler; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; layout(location = 0) out vec4 FragColor; vec4 sample_func(vec2 uv, mediump sampler2D SPIRV_Cross_CombineduTexturesamp) { return texture(SPIRV_Cross_CombineduTexturesamp, uv); } vec4 sample_func_dual(vec2 uv, mediump sampler2D SPIRV_Cross_Combinedtexsamp) { return texture(SPIRV_Cross_Combinedtexsamp, uv); } void main() { vec2 off = vec2(1.0) / vec2(textureSize(SPIRV_Cross_CombineduTextureuSampler, 0)); vec2 off2 = vec2(1.0) / vec2(textureSize(SPIRV_Cross_CombineduTextureuSampler, 1)); vec2 param = (vTex + off) + off2; vec4 c0 = sample_func(param, SPIRV_Cross_CombineduTextureuSampler); vec2 param_1 = (vTex + off) + off2; vec4 c1 = sample_func_dual(param_1, SPIRV_Cross_CombineduTextureuSampler); vec4 c2 = texture(SPIRV_Cross_CombineduTextureArrayuSampler, vTex3); vec4 c3 = texture(SPIRV_Cross_CombineduTextureCubeuSampler, vTex3); vec4 c4 = texture(SPIRV_Cross_CombineduTexture3DuSampler, vTex3); FragColor = (((c0 + c1) + c2) + c3) + c4; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/separate-sampler-texture.vk.frag.vk000066400000000000000000000025151400026215700310450ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(set = 0, binding = 1) uniform mediump texture2D uTexture; layout(set = 0, binding = 0) uniform mediump sampler uSampler; layout(set = 0, binding = 4) uniform mediump texture2DArray uTextureArray; layout(set = 0, binding = 3) uniform mediump textureCube uTextureCube; layout(set = 0, binding = 2) uniform mediump texture3D uTexture3D; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; layout(location = 0) out vec4 FragColor; vec4 sample_func(mediump sampler samp, vec2 uv) { return texture(sampler2D(uTexture, samp), uv); } vec4 sample_func_dual(mediump sampler samp, mediump texture2D tex, vec2 uv) { return texture(sampler2D(tex, samp), uv); } void main() { vec2 off = vec2(1.0) / vec2(textureSize(sampler2D(uTexture, uSampler), 0)); vec2 off2 = vec2(1.0) / vec2(textureSize(sampler2D(uTexture, uSampler), 1)); vec2 param = (vTex + off) + off2; vec4 c0 = sample_func(uSampler, param); vec2 param_1 = (vTex + off) + off2; vec4 c1 = sample_func_dual(uSampler, uTexture, param_1); vec4 c2 = texture(sampler2DArray(uTextureArray, uSampler), vTex3); vec4 c3 = texture(samplerCube(uTextureCube, uSampler), vTex3); vec4 c4 = texture(sampler3D(uTexture3D, uSampler), vTex3); FragColor = (((c0 + c1) + c2) + c3) + c4; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/shader-arithmetic-8bit.nocompat.vk.frag.vk000066400000000000000000000036231400026215700321630ustar00rootroot00000000000000#version 450 #extension GL_EXT_shader_explicit_arithmetic_types_int16 : require #extension GL_EXT_shader_16bit_storage : require #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require #extension GL_EXT_shader_8bit_storage : require layout(set = 0, binding = 1, std430) buffer SSBO { int8_t i8[16]; uint8_t u8[16]; } ssbo; layout(set = 0, binding = 0, std140) uniform UBO { int8_t i8; uint8_t u8; } ubo; layout(push_constant, std430) uniform Push { int8_t i8; uint8_t u8; } registers; layout(location = 0) flat in ivec4 vColor; layout(location = 0) out ivec4 FragColorInt; layout(location = 1) out uvec4 FragColorUint; void packing_int8() { int16_t i16 = 10s; int i32 = 20; i8vec2 i8_2 = unpack8(i16); i8vec4 i8_4 = unpack8(i32); i16 = pack16(i8_2); i32 = pack32(i8_4); ssbo.i8[0] = i8_4.x; ssbo.i8[1] = i8_4.y; ssbo.i8[2] = i8_4.z; ssbo.i8[3] = i8_4.w; } void packing_uint8() { uint16_t u16 = 10us; uint u32 = 20u; u8vec2 u8_2 = unpack8(u16); u8vec4 u8_4 = unpack8(u32); u16 = pack16(u8_2); u32 = pack32(u8_4); ssbo.u8[0] = u8_4.x; ssbo.u8[1] = u8_4.y; ssbo.u8[2] = u8_4.z; ssbo.u8[3] = u8_4.w; } void compute_int8() { i8vec4 tmp = i8vec4(vColor); tmp += i8vec4(registers.i8); tmp += i8vec4(int8_t(-40)); tmp += i8vec4(-50); tmp += i8vec4(int8_t(10), int8_t(20), int8_t(30), int8_t(40)); tmp += i8vec4(ssbo.i8[4]); tmp += i8vec4(ubo.i8); FragColorInt = ivec4(tmp); } void compute_uint8() { u8vec4 tmp = u8vec4(i8vec4(vColor)); tmp += u8vec4(registers.u8); tmp += u8vec4(uint8_t(216)); tmp += u8vec4(206); tmp += u8vec4(uint8_t(10), uint8_t(20), uint8_t(30), uint8_t(40)); tmp += u8vec4(ssbo.u8[4]); tmp += u8vec4(ubo.u8); FragColorUint = uvec4(tmp); } void main() { packing_int8(); packing_uint8(); compute_int8(); compute_uint8(); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/spec-constant-block-size.vk.frag000066400000000000000000000006421400026215700303030ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; #ifndef SPIRV_CROSS_CONSTANT_ID_10 #define SPIRV_CROSS_CONSTANT_ID_10 2 #endif const int Value = SPIRV_CROSS_CONSTANT_ID_10; layout(binding = 0, std140) uniform SpecConstArray { vec4 samples[Value]; } _15; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int Index; void main() { FragColor = _15.samples[Index]; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/spec-constant-block-size.vk.frag.vk000066400000000000000000000005341400026215700307220ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(constant_id = 10) const int Value = 2; layout(set = 0, binding = 0, std140) uniform SpecConstArray { vec4 samples[Value]; } _15; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in mediump int Index; void main() { FragColor = _15.samples[Index]; } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/spec-constant-ternary.vk.frag000066400000000000000000000004321400026215700277220ustar00rootroot00000000000000#version 450 #ifndef SPIRV_CROSS_CONSTANT_ID_0 #define SPIRV_CROSS_CONSTANT_ID_0 10u #endif const uint s = SPIRV_CROSS_CONSTANT_ID_0; const bool _13 = (s > 20u); const uint f = _13 ? 30u : 50u; layout(location = 0) out float FragColor; void main() { FragColor = float(f); } spirv-cross-2021.01.15/reference/shaders/vulkan/frag/spec-constant-ternary.vk.frag.vk000066400000000000000000000003151400026215700303410ustar00rootroot00000000000000#version 450 layout(constant_id = 0) const uint s = 10u; const bool _13 = (s > 20u); const uint f = _13 ? 30u : 50u; layout(location = 0) out float FragColor; void main() { FragColor = float(f); } spirv-cross-2021.01.15/reference/shaders/vulkan/rahit/000077500000000000000000000000001400026215700223705ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rahit/terminators.khr.spv14.nocompat.vk.rahit.vk000066400000000000000000000003721400026215700324060ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require rayPayloadInEXT float payload; void in_func() { if (payload > 0.0) { ignoreIntersectionEXT; } else { terminateRayEXT; } } void main() { in_func(); } spirv-cross-2021.01.15/reference/shaders/vulkan/rahit/terminators.nocompat.vk.rahit.vk000066400000000000000000000003721400026215700306470ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require rayPayloadInNV float payload; void in_func() { if (payload > 0.0) { ignoreIntersectionNV(); } else { terminateRayNV(); } } void main() { in_func(); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/000077500000000000000000000000001400026215700223725ustar00rootroot00000000000000hit_attribute_block.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000004311400026215700340010ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require struct Foo { float a; float b; }; struct Foo2 { float a; float b; }; layout(location = 0) rayPayloadInEXT Foo payload; hitAttributeEXT Foo2 hit; void main() { payload.a = hit.a; payload.b = hit.b; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/hit_attribute_block.nocompat.vk.rchit.vk000066400000000000000000000004261400026215700323250ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Foo { float a; float b; }; struct Foo2 { float a; float b; }; layout(location = 0) rayPayloadInNV Foo payload; hitAttributeNV Foo2 hit; void main() { payload.a = hit.a; payload.b = hit.b; } hit_attribute_block_in_function.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000005041400026215700363750ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require struct Foo { float a; float b; }; struct Foo2 { float a; float b; }; layout(location = 0) rayPayloadInEXT Foo payload; hitAttributeEXT Foo2 hit; void in_function() { payload.a = hit.a; payload.b = hit.b; } void main() { in_function(); } hit_attribute_block_in_function.nocompat.vk.rchit.vk000066400000000000000000000005011400026215700346330ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_NV_ray_tracing : require struct Foo { float a; float b; }; struct Foo2 { float a; float b; }; layout(location = 0) rayPayloadInNV Foo payload; hitAttributeNV Foo2 hit; void in_function() { payload.a = hit.a; payload.b = hit.b; } void main() { in_function(); } hit_attribute_plain.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002501400026215700340110ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec2 payload; hitAttributeEXT vec2 hit; void main() { payload = hit; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/hit_attribute_plain.nocompat.vk.rchit.vk000066400000000000000000000002451400026215700323350ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec2 payload; hitAttributeNV vec2 hit; void main() { payload = hit; } hit_attribute_struct.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000003211400026215700342310ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require struct Foo { float a; float b; }; layout(location = 0) rayPayloadInEXT Foo payload; hitAttributeEXT Foo hit; void main() { payload = hit; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/hit_attribute_struct.nocompat.vk.rchit.vk000066400000000000000000000003161400026215700325550ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Foo { float a; float b; }; layout(location = 0) rayPayloadInNV Foo payload; hitAttributeNV Foo hit; void main() { payload = hit; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/hit_kind.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002301400026215700316250ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = gl_HitKindEXT; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/hit_kind.nocompat.vk.rchit.vk000066400000000000000000000002251400026215700300720ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = gl_HitKindNV; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/hit_t.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002311400026215700311440ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = gl_RayTmaxEXT; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/hit_t.nocompat.vk.rchit.vk000066400000000000000000000002231400026215700274060ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = gl_HitTNV; } incoming_ray_flags.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002411400026215700336110ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = gl_IncomingRayFlagsEXT; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/incoming_ray_flags.nocompat.vk.rchit.vk000066400000000000000000000002361400026215700321350ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = gl_IncomingRayFlagsNV; } instance_custom_id.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002521400026215700336330ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = uint(gl_InstanceCustomIndexEXT); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/instance_custom_id.nocompat.vk.rchit.vk000066400000000000000000000002471400026215700321570ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = uint(gl_InstanceCustomIndexNV); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/instance_id.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002361400026215700323220ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = uint(gl_InstanceID); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/instance_id.nocompat.vk.rchit.vk000066400000000000000000000002341400026215700305610ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = uint(gl_InstanceID); } object_ray_direction.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002431400026215700341420ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_ObjectRayDirectionEXT; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/object_ray_direction.nocompat.vk.rchit.vk000066400000000000000000000002401400026215700324570ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_ObjectRayDirectionNV; } object_ray_origin.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002401400026215700334460ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_ObjectRayOriginEXT; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/object_ray_origin.nocompat.vk.rchit.vk000066400000000000000000000002351400026215700317720ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_ObjectRayOriginNV; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/object_to_world.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002631400026215700332210ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_ObjectToWorldEXT * vec4(payload, 1.0); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/object_to_world.nocompat.vk.rchit.vk000066400000000000000000000002601400026215700314570ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_ObjectToWorldNV * vec4(payload, 1.0); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/payloads.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000004241400026215700316550ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require struct Payload { vec4 a; }; layout(location = 0) rayPayloadInEXT Payload payload; void write_incoming_payload_in_function() { payload.a = vec4(10.0); } void main() { write_incoming_payload_in_function(); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/payloads.nocompat.vk.rchit.vk000066400000000000000000000004221400026215700301140ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Payload { vec4 a; }; layout(location = 0) rayPayloadInNV Payload payload; void write_incoming_payload_in_function() { payload.a = vec4(10.0); } void main() { write_incoming_payload_in_function(); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/primitive_id.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002371400026215700325270ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = uint(gl_PrimitiveID); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/primitive_id.nocompat.vk.rchit.vk000066400000000000000000000002351400026215700307660ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = uint(gl_PrimitiveID); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/ray_tmax.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002311400026215700316610ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = gl_RayTmaxEXT; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/ray_tmax.nocompat.vk.rchit.vk000066400000000000000000000002261400026215700301260ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = gl_RayTmaxNV; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/ray_tmin.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002311400026215700316570ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = gl_RayTminEXT; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/ray_tmin.nocompat.vk.rchit.vk000066400000000000000000000002261400026215700301240ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = gl_RayTminNV; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/ray_tracing.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002461400026215700323450ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = 1.0 + float(gl_InstanceID); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/ray_tracing.nocompat.vk.rchit.vk000066400000000000000000000002441400026215700306040ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = 1.0 + float(gl_InstanceID); } world_ray_direction.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002421400026215700340220ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_WorldRayDirectionEXT; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/world_ray_direction.nocompat.vk.rchit.vk000066400000000000000000000002371400026215700323460ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_WorldRayDirectionNV; } world_ray_origin.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002371400026215700333350ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_WorldRayOriginEXT; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/world_ray_origin.nocompat.vk.rchit.vk000066400000000000000000000002341400026215700316520ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_WorldRayOriginNV; } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/world_to_object.khr.spv14.nocompat.vk.rchit.vk000066400000000000000000000002631400026215700332210ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_WorldToObjectEXT * vec4(payload, 1.0); } spirv-cross-2021.01.15/reference/shaders/vulkan/rchit/world_to_object.nocompat.vk.rchit.vk000066400000000000000000000002601400026215700314570ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_WorldToObjectNV * vec4(payload, 1.0); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/000077500000000000000000000000001400026215700222145ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/convert-u-to-as.spv14.vk.nocompat.rgen.vk000066400000000000000000000005661400026215700316740ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(push_constant, std430) uniform Registers { uvec2 ptr; } _19; layout(location = 0) rayPayloadEXT vec4 payload; void main() { vec3 origin = vec3(0.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceRayEXT(accelerationStructureEXT(_19.ptr), 1u, 255u, 0u, 0u, 0u, origin, 0.0, direction, 100.0, 0); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/execute_callable.nocompat.khr.spv14.vk.rgen.vk000066400000000000000000000010601400026215700327630ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT vec4 payload; layout(location = 1) callableDataEXT float blend; layout(set = 0, binding = 1, rgba32f) uniform writeonly image2D image; void main() { vec3 origin = vec3(0.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceRayEXT(as, 1u, 255u, 0u, 0u, 0u, origin, 0.0, direction, 100.0, 0); executeCallableEXT(0u, 1); imageStore(image, ivec2(gl_LaunchIDEXT.xy), payload + vec4(blend)); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/execute_callable.nocompat.vk.rgen.vk000066400000000000000000000010461400026215700312300ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0) uniform accelerationStructureNV as; layout(set = 0, binding = 1, rgba32f) uniform writeonly image2D image; layout(location = 0) rayPayloadNV vec4 payload; layout(location = 0) callableDataNV float blend; void main() { vec3 origin = vec3(0.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceNV(as, 1u, 255u, 0u, 0u, 0u, origin, 0.0, direction, 100.0, 0); executeCallableNV(0u, 0); imageStore(image, ivec2(gl_LaunchIDNV.xy), payload + vec4(blend)); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/launch_id.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000003041400026215700314300ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchIDEXT.xy), vec4(1.0)); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/launch_id.nocompat.vk.rgen.vk000066400000000000000000000003021400026215700276670ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchIDNV.xy), vec4(1.0)); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/launch_size.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000003211400026215700320050ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchSizeEXT.xy) - ivec2(1), vec4(1.0)); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/launch_size.nocompat.vk.rgen.vk000066400000000000000000000003171400026215700302530ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchSizeNV.xy) - ivec2(1), vec4(1.0)); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/payloads.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000023361400026215700313250ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require struct Payload { float a; float b; }; struct Block { float a; float b; Payload c; Payload d; }; layout(set = 0, binding = 1) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT Payload payload2; layout(location = 1) rayPayloadEXT float payload1; layout(location = 2) rayPayloadEXT Block _71; layout(set = 0, binding = 0, rgba8) uniform writeonly image2D image; vec4 trace_in_function() { vec4 result = vec4(0.0); vec3 origin = vec3(1.0, 0.0, 0.0); vec3 direction = vec3(0.0, 1.0, 0.0); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); result += vec4(payload2.a); result += vec4(payload2.b); return result; } void main() { vec3 origin = vec3(1.0, 0.0, 0.0); vec3 direction = vec3(0.0, 1.0, 0.0); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 1); vec4 result = vec4(payload1); vec4 _62 = trace_in_function(); result += _62; traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 2); result += vec4(((((_71.a + _71.b) + _71.c.a) + _71.c.b) + _71.d.a) + _71.d.b); imageStore(image, ivec2(gl_LaunchIDEXT.xy), result); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/payloads.nocompat.vk.rgen.vk000066400000000000000000000023141400026215700275620ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Payload { float a; float b; }; struct Block { float a; float b; Payload c; Payload d; }; layout(set = 0, binding = 1) uniform accelerationStructureNV as; layout(location = 1) rayPayloadNV Payload payload2; layout(location = 0) rayPayloadNV float payload1; layout(location = 2) rayPayloadNV Block _71; layout(set = 0, binding = 0, rgba8) uniform writeonly image2D image; vec4 trace_in_function() { vec4 result = vec4(0.0); vec3 origin = vec3(1.0, 0.0, 0.0); vec3 direction = vec3(0.0, 1.0, 0.0); traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 1); result += vec4(payload2.a); result += vec4(payload2.b); return result; } void main() { vec3 origin = vec3(1.0, 0.0, 0.0); vec3 direction = vec3(0.0, 1.0, 0.0); traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); vec4 result = vec4(payload1); vec4 _62 = trace_in_function(); result += _62; traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 2); result += vec4(((((_71.a + _71.b) + _71.c.a) + _71.c.b) + _71.d.a) + _71.d.b); imageStore(image, ivec2(gl_LaunchIDNV.xy), result); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/pure_call.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000011201400026215700314450ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT float payload; float pure_call(vec2 launchID, vec2 launchSize) { vec3 origin = vec3(launchID.x / launchSize.x, launchID.y / launchSize.y, 1.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); return 0.0; } void main() { vec2 param = vec2(gl_LaunchIDEXT.xy); vec2 param_1 = vec2(gl_LaunchSizeEXT.xy); float _64 = pure_call(param, param_1); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/pure_call.nocompat.vk.rgen.vk000066400000000000000000000011071400026215700277130ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureNV as; layout(location = 0) rayPayloadNV float payload; float pure_call(vec2 launchID, vec2 launchSize) { vec3 origin = vec3(launchID.x / launchSize.x, launchID.y / launchSize.y, 1.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); return 0.0; } void main() { vec2 param = vec2(gl_LaunchIDNV.xy); vec2 param_1 = vec2(gl_LaunchSizeNV.xy); float _62 = pure_call(param, param_1); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/ray_tracing.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000011651400026215700320120ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT float payload; layout(set = 0, binding = 0, rgba8) uniform writeonly image2D image; void main() { vec4 col = vec4(0.0, 0.0, 0.0, 1.0); vec3 origin = vec3(float(gl_LaunchIDEXT.x) / float(gl_LaunchSizeEXT.x), float(gl_LaunchIDEXT.y) / float(gl_LaunchSizeEXT.y), 1.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); col.y = payload; imageStore(image, ivec2(gl_LaunchIDEXT.xy), col); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/ray_tracing.nocompat.vk.rgen.vk000066400000000000000000000011511400026215700302460ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureNV as; layout(location = 0) rayPayloadNV float payload; layout(set = 0, binding = 0, rgba8) uniform writeonly image2D image; void main() { vec4 col = vec4(0.0, 0.0, 0.0, 1.0); vec3 origin = vec3(float(gl_LaunchIDNV.x) / float(gl_LaunchSizeNV.x), float(gl_LaunchIDNV.y) / float(gl_LaunchSizeNV.y), 1.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); col.y = payload; imageStore(image, ivec2(gl_LaunchIDNV.xy), col); } shader_record_buffer.khr.spv14.nocompat.vk.rgen.vk000066400000000000000000000005541400026215700335670ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rgen#version 460 #extension GL_EXT_ray_tracing : require layout(shaderRecordEXT, std430) buffer sbt { vec3 direction; float tmax; } _20; layout(set = 0, binding = 0) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT float payload; void main() { traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, vec3(0.0), 0.0, _20.direction, _20.tmax, 0); } spirv-cross-2021.01.15/reference/shaders/vulkan/rgen/shader_record_buffer.nocompat.vk.rgen.vk000066400000000000000000000005441400026215700321060ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(shaderRecordNV, std430) buffer sbt { vec3 direction; float tmax; } _20; layout(set = 0, binding = 0) uniform accelerationStructureNV as; layout(location = 0) rayPayloadNV float payload; void main() { traceNV(as, 0u, 255u, 0u, 1u, 0u, vec3(0.0), 0.0, _20.direction, _20.tmax, 0); } spirv-cross-2021.01.15/reference/shaders/vulkan/rint/000077500000000000000000000000001400026215700222355ustar00rootroot00000000000000report-intersection.khr.spv14.nocompat.vk.rint.vk000066400000000000000000000002321400026215700335040ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rint#version 460 #extension GL_EXT_ray_tracing : require void in_func() { bool _13 = reportIntersectionEXT(0.5, 10u); } void main() { in_func(); } spirv-cross-2021.01.15/reference/shaders/vulkan/rint/report-intersection.nocompat.vk.rint.vk000066400000000000000000000002301400026215700320220ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require void in_func() { bool _13 = reportIntersectionNV(0.5, 10u); } void main() { in_func(); } spirv-cross-2021.01.15/reference/shaders/vulkan/rmiss/000077500000000000000000000000001400026215700224165ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/rmiss/ray_tracing.khr.spv14.nocompat.vk.rmiss.vk000066400000000000000000000002171400026215700324130ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = 0.0; } spirv-cross-2021.01.15/reference/shaders/vulkan/rmiss/ray_tracing.nocompat.vk.rmiss.vk000066400000000000000000000002151400026215700306520ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = 0.0; } spirv-cross-2021.01.15/reference/shaders/vulkan/vert/000077500000000000000000000000001400026215700222415ustar00rootroot00000000000000spirv-cross-2021.01.15/reference/shaders/vulkan/vert/device-group.nocompat.vk.vert.vk000066400000000000000000000001671400026215700304150ustar00rootroot00000000000000#version 450 #extension GL_EXT_device_group : require void main() { gl_Position = vec4(float(gl_DeviceIndex)); } spirv-cross-2021.01.15/reference/shaders/vulkan/vert/multiview.nocompat.vk.vert.vk000066400000000000000000000003611400026215700300450ustar00rootroot00000000000000#version 310 es #extension GL_EXT_multiview : require layout(set = 0, binding = 0, std140) uniform MVPs { mat4 MVP[2]; } _19; layout(location = 0) in vec4 Position; void main() { gl_Position = _19.MVP[gl_ViewIndex] * Position; } spirv-cross-2021.01.15/reference/shaders/vulkan/vert/small-storage.vk.vert000066400000000000000000000027711400026215700263430ustar00rootroot00000000000000#version 450 #if defined(GL_AMD_gpu_shader_int16) #extension GL_AMD_gpu_shader_int16 : require #else #error No extension available for Int16. #endif #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_NV_gpu_shader5) #extension GL_NV_gpu_shader5 : require #else #error No extension available for FP16. #endif layout(binding = 0, std140) uniform block { i16vec2 a; u16vec2 b; i8vec2 c; u8vec2 d; f16vec2 e; } _26; layout(binding = 1, std430) readonly buffer storage { i16vec3 f; u16vec3 g; i8vec3 h; u8vec3 i; f16vec3 j; } _53; struct pushconst { i16vec4 k; u16vec4 l; i8vec4 m; u8vec4 n; f16vec4 o; }; uniform pushconst _76; layout(location = 0) out i16vec4 p; layout(location = 0, component = 0) in int16_t foo; layout(location = 1) out u16vec4 q; layout(location = 0, component = 1) in uint16_t bar; layout(location = 2) out f16vec4 r; layout(location = 1) in float16_t baz; void main() { p = i16vec4((((ivec4(int(foo)) + ivec4(ivec2(_26.a), ivec2(_26.c))) - ivec4(ivec3(_53.f) / ivec3(_53.h), 1)) + ivec4(_76.k)) + ivec4(_76.m)); q = u16vec4((((uvec4(uint(bar)) + uvec4(uvec2(_26.b), uvec2(_26.d))) - uvec4(uvec3(_53.g) / uvec3(_53.i), 1u)) + uvec4(_76.l)) + uvec4(_76.n)); r = f16vec4(((vec4(float(baz)) + vec4(vec2(_26.e), 0.0, 1.0)) - vec4(vec3(_53.j), 1.0)) + vec4(_76.o)); gl_Position = vec4(0.0, 0.0, 0.0, 1.0); } spirv-cross-2021.01.15/reference/shaders/vulkan/vert/small-storage.vk.vert.vk000066400000000000000000000031561400026215700267600ustar00rootroot00000000000000#version 450 #extension GL_EXT_shader_explicit_arithmetic_types_int16 : require #extension GL_EXT_shader_16bit_storage : require #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require #extension GL_EXT_shader_8bit_storage : require #if defined(GL_AMD_gpu_shader_half_float) #extension GL_AMD_gpu_shader_half_float : require #elif defined(GL_EXT_shader_explicit_arithmetic_types_float16) #extension GL_EXT_shader_explicit_arithmetic_types_float16 : require #else #error No extension available for FP16. #endif layout(set = 0, binding = 0, std140) uniform block { i16vec2 a; u16vec2 b; i8vec2 c; u8vec2 d; f16vec2 e; } _26; layout(set = 0, binding = 1, std430) readonly buffer storage { i16vec3 f; u16vec3 g; i8vec3 h; u8vec3 i; f16vec3 j; } _53; layout(push_constant, std430) uniform pushconst { i16vec4 k; u16vec4 l; i8vec4 m; u8vec4 n; f16vec4 o; } _76; layout(location = 0) out i16vec4 p; layout(location = 0, component = 0) in int16_t foo; layout(location = 1) out u16vec4 q; layout(location = 0, component = 1) in uint16_t bar; layout(location = 2) out f16vec4 r; layout(location = 1) in float16_t baz; void main() { p = i16vec4((((ivec4(int(foo)) + ivec4(ivec2(_26.a), ivec2(_26.c))) - ivec4(ivec3(_53.f) / ivec3(_53.h), 1)) + ivec4(_76.k)) + ivec4(_76.m)); q = u16vec4((((uvec4(uint(bar)) + uvec4(uvec2(_26.b), uvec2(_26.d))) - uvec4(uvec3(_53.g) / uvec3(_53.i), 1u)) + uvec4(_76.l)) + uvec4(_76.n)); r = f16vec4(((vec4(float(baz)) + vec4(vec2(_26.e), 0.0, 1.0)) - vec4(vec3(_53.j), 1.0)) + vec4(_76.o)); gl_Position = vec4(0.0, 0.0, 0.0, 1.0); } spirv-cross-2021.01.15/reference/shaders/vulkan/vert/vulkan-vertex.vk.vert000066400000000000000000000005731400026215700264020ustar00rootroot00000000000000#version 310 es #ifdef GL_ARB_shader_draw_parameters #extension GL_ARB_shader_draw_parameters : enable #endif #ifdef GL_ARB_shader_draw_parameters #define SPIRV_Cross_BaseInstance gl_BaseInstanceARB #else uniform int SPIRV_Cross_BaseInstance; #endif void main() { gl_Position = vec4(1.0, 2.0, 3.0, 4.0) * float(gl_VertexID + (gl_InstanceID + SPIRV_Cross_BaseInstance)); } spirv-cross-2021.01.15/reference/shaders/vulkan/vert/vulkan-vertex.vk.vert.vk000066400000000000000000000001711400026215700270130ustar00rootroot00000000000000#version 310 es void main() { gl_Position = vec4(1.0, 2.0, 3.0, 4.0) * float(gl_VertexIndex + gl_InstanceIndex); } spirv-cross-2021.01.15/samples/000077500000000000000000000000001400026215700160365ustar00rootroot00000000000000spirv-cross-2021.01.15/samples/cpp/000077500000000000000000000000001400026215700166205ustar00rootroot00000000000000spirv-cross-2021.01.15/samples/cpp/Makefile000066400000000000000000000011421400026215700202560ustar00rootroot00000000000000SOURCES := $(wildcard *.comp) SPIRV := $(SOURCES:.comp=.spv) CPP_INTERFACE := $(SOURCES:.comp=.spv.cpp) CPP_DRIVER := $(SOURCES:.comp=.cpp) EXECUTABLES := $(SOURCES:.comp=.shader) OBJECTS := $(CPP_DRIVER:.cpp=.o) $(CPP_INTERFACE:.cpp=.o) CXXFLAGS += -std=c++11 -I../../include -I. LDFLAGS += -pthread -lm all: $(EXECUTABLES) %.spv: %.comp glslangValidator -V -o $@ $< %.spv.cpp: %.spv ../../spirv-cross --cpp --output $@ $< %.o: %.cpp $(CXX) -c -o $@ $< $(CXXFLAGS) %.shader: %.o %.spv.o $(CXX) -o $@ $^ $(LDFLAGS) clean: $(RM) -f $(EXECUTABLES) $(SPIRV) $(CPP_INTERFACE) $(OBJECTS) .PHONY: clean spirv-cross-2021.01.15/samples/cpp/atomics.comp000066400000000000000000000010431400026215700211350ustar00rootroot00000000000000#version 310 es layout(local_size_x = 64) in; layout(set = 0, binding = 0, std430) readonly buffer SSBO0 { float inputs[]; }; layout(set = 0, binding = 1, std430) writeonly buffer SSBO1 { float outputs[]; }; layout(set = 0, binding = 2, std430) buffer SSBO2 { uint counter; }; void main() { // Builds a tightly packed list of all values less than 10.0. // The output order is random. float value = inputs[gl_GlobalInvocationID.x]; if (value < 10.0) { uint output_index = atomicAdd(counter, 1u); outputs[output_index] = value; } } spirv-cross-2021.01.15/samples/cpp/atomics.cpp000066400000000000000000000053561400026215700207740ustar00rootroot00000000000000/* * Copyright 2015-2017 ARM Limited * * 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 "spirv_cross/external_interface.h" #include #ifndef GLM_SWIZZLE #define GLM_SWIZZLE #endif #ifndef GLM_FORCE_RADIANS #define GLM_FORCE_RADIANS #endif #include using namespace glm; int main() { // First, we get the C interface to the shader. // This can be loaded from a dynamic library, or as here, // linked in as a static library. auto *iface = spirv_cross_get_interface(); // Create an instance of the shader interface. auto *shader = iface->construct(); // Build some input data for our compute shader. #define NUM_WORKGROUPS 4 float a[64 * NUM_WORKGROUPS]; float b[64 * NUM_WORKGROUPS] = {}; uint32_t counter = 0; for (int i = 0; i < 64 * NUM_WORKGROUPS; i++) { a[i] = i * 0.46f; } void *aptr = a; void *bptr = b; void *cptr = &counter; // Bind resources to the shader. // For resources like samplers and buffers, we provide a list of pointers, // since UBOs, SSBOs and samplers can be arrays, and can point to different types, // which is especially true for samplers. spirv_cross_set_resource(shader, 0, 0, &aptr, sizeof(aptr)); spirv_cross_set_resource(shader, 0, 1, &bptr, sizeof(bptr)); spirv_cross_set_resource(shader, 0, 2, &cptr, sizeof(cptr)); // We also have to set builtins. // The relevant builtins will depend on the shader, // but for compute, there are few builtins, which are gl_NumWorkGroups and gl_WorkGroupID. // LocalInvocationID and GlobalInvocationID are inferred when executing the invocation. uvec3 num_workgroups(NUM_WORKGROUPS, 1, 1); uvec3 work_group_id(0, 0, 0); spirv_cross_set_builtin(shader, SPIRV_CROSS_BUILTIN_NUM_WORK_GROUPS, &num_workgroups, sizeof(num_workgroups)); spirv_cross_set_builtin(shader, SPIRV_CROSS_BUILTIN_WORK_GROUP_ID, &work_group_id, sizeof(work_group_id)); // Execute 4 work groups. for (unsigned i = 0; i < NUM_WORKGROUPS; i++) { work_group_id.x = i; iface->invoke(shader); } // Call destructor. iface->destruct(shader); // Verify our output. // TODO: Implement a test framework that asserts results computed. fprintf(stderr, "Counter = %u\n", counter); for (unsigned i = 0; i < counter; i++) { fprintf(stderr, "[%3u] = %.1f\n", i, b[i]); } } spirv-cross-2021.01.15/samples/cpp/multiply.comp000066400000000000000000000005611400026215700213610ustar00rootroot00000000000000#version 310 es layout(local_size_x = 64) in; layout(set = 0, binding = 0, std430) readonly buffer SSBO0 { vec4 a[]; }; layout(set = 0, binding = 1, std430) readonly buffer SSBO1 { vec4 b[]; }; layout(set = 0, binding = 2, std430) buffer SSBO2 { vec4 c[]; }; void main() { c[gl_GlobalInvocationID.x] = a[gl_GlobalInvocationID.x] * b[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/samples/cpp/multiply.cpp000066400000000000000000000056761400026215700212210ustar00rootroot00000000000000/* * Copyright 2015-2017 ARM Limited * * 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 "spirv_cross/external_interface.h" #include #ifndef GLM_SWIZZLE #define GLM_SWIZZLE #endif #ifndef GLM_FORCE_RADIANS #define GLM_FORCE_RADIANS #endif #include using namespace glm; int main() { // First, we get the C interface to the shader. // This can be loaded from a dynamic library, or as here, // linked in as a static library. auto *iface = spirv_cross_get_interface(); // Create an instance of the shader interface. auto *shader = iface->construct(); // Build some input data for our compute shader. #define NUM_WORKGROUPS 4 vec4 a[64 * NUM_WORKGROUPS]; vec4 b[64 * NUM_WORKGROUPS]; vec4 c[64 * NUM_WORKGROUPS] = {}; for (int i = 0; i < 64 * NUM_WORKGROUPS; i++) { a[i] = vec4(100 + i, 101 + i, 102 + i, 103 + i); b[i] = vec4(100 - i, 99 - i, 98 - i, 97 - i); } void *aptr = a; void *bptr = b; void *cptr = c; // Bind resources to the shader. // For resources like samplers and buffers, we provide a list of pointers, // since UBOs, SSBOs and samplers can be arrays, and can point to different types, // which is especially true for samplers. spirv_cross_set_resource(shader, 0, 0, &aptr, sizeof(aptr)); spirv_cross_set_resource(shader, 0, 1, &bptr, sizeof(bptr)); spirv_cross_set_resource(shader, 0, 2, &cptr, sizeof(cptr)); // We also have to set builtins. // The relevant builtins will depend on the shader, // but for compute, there are few builtins, which are gl_NumWorkGroups and gl_WorkGroupID. // LocalInvocationID and GlobalInvocationID are inferred when executing the invocation. uvec3 num_workgroups(NUM_WORKGROUPS, 1, 1); uvec3 work_group_id(0, 0, 0); spirv_cross_set_builtin(shader, SPIRV_CROSS_BUILTIN_NUM_WORK_GROUPS, &num_workgroups, sizeof(num_workgroups)); spirv_cross_set_builtin(shader, SPIRV_CROSS_BUILTIN_WORK_GROUP_ID, &work_group_id, sizeof(work_group_id)); // Execute 4 work groups. for (unsigned i = 0; i < NUM_WORKGROUPS; i++) { work_group_id.x = i; iface->invoke(shader); } // Call destructor. iface->destruct(shader); // Verify our output. // TODO: Implement a test framework that asserts results computed. for (unsigned i = 0; i < 64 * NUM_WORKGROUPS; i++) { fprintf(stderr, "(%.1f, %.1f, %.1f, %.1f) * (%.1f, %.1f, %.1f, %.1f) => (%.1f, %.1f, %.1f, %.1f)\n", a[i].x, a[i].y, a[i].z, a[i].w, b[i].x, b[i].y, b[i].z, b[i].w, c[i].x, c[i].y, c[i].z, c[i].w); } } spirv-cross-2021.01.15/samples/cpp/shared.comp000066400000000000000000000014531400026215700207510ustar00rootroot00000000000000#version 310 es layout(local_size_x = 64) in; layout(set = 0, binding = 0, std430) readonly buffer SSBO0 { float inputs[]; }; layout(set = 0, binding = 1, std430) writeonly buffer SSBO1 { float outputs[]; }; shared float tmp[gl_WorkGroupSize.x]; void main() { uint local = gl_LocalInvocationIndex; uint work_group = gl_WorkGroupID.x; // Does a trivial parallel reduction through shared memory. tmp[local] = inputs[work_group * gl_WorkGroupSize.x * 2u + local] + inputs[work_group * gl_WorkGroupSize.x * 2u + local + gl_WorkGroupSize.x]; memoryBarrierShared(); barrier(); for (uint limit = 32u; limit > 1u; limit >>= 1u) { if (local < limit) tmp[local] = tmp[local] + tmp[local + limit]; memoryBarrierShared(); barrier(); } if (local == 0u) outputs[work_group] = tmp[0] + tmp[1]; } spirv-cross-2021.01.15/samples/cpp/shared.cpp000066400000000000000000000053561400026215700206030ustar00rootroot00000000000000/* * Copyright 2015-2017 ARM Limited * * 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 "spirv_cross/external_interface.h" #include #ifndef GLM_SWIZZLE #define GLM_SWIZZLE #endif #ifndef GLM_FORCE_RADIANS #define GLM_FORCE_RADIANS #endif #include using namespace glm; int main() { // First, we get the C interface to the shader. // This can be loaded from a dynamic library, or as here, // linked in as a static library. auto *iface = spirv_cross_get_interface(); // Create an instance of the shader interface. auto *shader = iface->construct(); // Build some input data for our compute shader. #define NUM_WORKGROUPS 4 float a[128 * NUM_WORKGROUPS]; float b[NUM_WORKGROUPS] = {}; for (int i = 0; i < 128 * NUM_WORKGROUPS; i++) { a[i] = float(i); } void *aptr = a; void *bptr = b; // Bind resources to the shader. // For resources like samplers and buffers, we provide a list of pointers, // since UBOs, SSBOs and samplers can be arrays, and can point to different types, // which is especially true for samplers. spirv_cross_set_resource(shader, 0, 0, &aptr, sizeof(aptr)); spirv_cross_set_resource(shader, 0, 1, &bptr, sizeof(bptr)); // We also have to set builtins. // The relevant builtins will depend on the shader, // but for compute, there are few builtins, which are gl_NumWorkGroups and gl_WorkGroupID. // LocalInvocationID and GlobalInvocationID are inferred when executing the invocation. uvec3 num_workgroups(NUM_WORKGROUPS, 1, 1); uvec3 work_group_id(0, 0, 0); spirv_cross_set_builtin(shader, SPIRV_CROSS_BUILTIN_NUM_WORK_GROUPS, &num_workgroups, sizeof(num_workgroups)); spirv_cross_set_builtin(shader, SPIRV_CROSS_BUILTIN_WORK_GROUP_ID, &work_group_id, sizeof(work_group_id)); // Execute 4 work groups. for (unsigned i = 0; i < NUM_WORKGROUPS; i++) { work_group_id.x = i; iface->invoke(shader); } // Call destructor. iface->destruct(shader); // Verify our output. // TODO: Implement a test framework that asserts results computed. for (unsigned i = 0; i < NUM_WORKGROUPS; i++) { float expected_sum = 0.0f; for (unsigned j = i * 128; j < (i + 1) * 128; j++) expected_sum += a[j]; fprintf(stderr, "Sum in workgroup #%u = %.1f, expected %.1f\n", i, b[i], expected_sum); } } spirv-cross-2021.01.15/shaders-hlsl-no-opt/000077500000000000000000000000001400026215700201755ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/000077500000000000000000000000001400026215700207555ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/000077500000000000000000000000001400026215700217135ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/access-chain-load-store-composite.asm.comp000066400000000000000000000125621400026215700317500ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 437 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Baz "Baz" OpMemberName %Baz 0 "c" OpName %Bar "Bar" OpMemberName %Bar 0 "d" OpMemberName %Bar 1 "baz" OpName %Foo "Foo" OpMemberName %Foo 0 "a" OpMemberName %Foo 1 "b" OpMemberName %Foo 2 "c" OpName %Baz_0 "Baz" OpMemberName %Baz_0 0 "c" OpName %Bar_0 "Bar" OpMemberName %Bar_0 0 "d" OpMemberName %Bar_0 1 "baz" OpName %Foo_0 "Foo" OpMemberName %Foo_0 0 "a" OpMemberName %Foo_0 1 "b" OpMemberName %Foo_0 2 "c" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "foo" OpMemberName %SSBO 1 "foo2" OpName %_ "" OpDecorate %_arr_float_uint_4_0 ArrayStride 4 OpDecorate %_arr__arr_float_uint_4_0_uint_2 ArrayStride 16 OpMemberDecorate %Baz_0 0 Offset 0 OpDecorate %_arr_Baz_0_uint_2 ArrayStride 4 OpMemberDecorate %Bar_0 0 Offset 0 OpMemberDecorate %Bar_0 1 Offset 32 OpDecorate %_arr_Bar_0_uint_5 ArrayStride 40 OpMemberDecorate %Foo_0 0 RowMajor OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %Foo_0 0 MatrixStride 8 OpMemberDecorate %Foo_0 1 Offset 16 OpMemberDecorate %Foo_0 2 Offset 24 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 224 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat2v2float = OpTypeMatrix %v2float 2 %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %uint_2 = OpConstant %uint 2 %_arr__arr_float_uint_4_uint_2 = OpTypeArray %_arr_float_uint_4 %uint_2 %Baz = OpTypeStruct %float %_arr_Baz_uint_2 = OpTypeArray %Baz %uint_2 %Bar = OpTypeStruct %_arr__arr_float_uint_4_uint_2 %_arr_Baz_uint_2 %uint_5 = OpConstant %uint 5 %_arr_Bar_uint_5 = OpTypeArray %Bar %uint_5 %Foo = OpTypeStruct %mat2v2float %v2float %_arr_Bar_uint_5 %_ptr_Function_Foo = OpTypePointer Function %Foo %_arr_float_uint_4_0 = OpTypeArray %float %uint_4 %_arr__arr_float_uint_4_0_uint_2 = OpTypeArray %_arr_float_uint_4_0 %uint_2 %Baz_0 = OpTypeStruct %float %_arr_Baz_0_uint_2 = OpTypeArray %Baz_0 %uint_2 %Bar_0 = OpTypeStruct %_arr__arr_float_uint_4_0_uint_2 %_arr_Baz_0_uint_2 %_arr_Bar_0_uint_5 = OpTypeArray %Bar_0 %uint_5 %Foo_0 = OpTypeStruct %mat2v2float %v2float %_arr_Bar_0_uint_5 %SSBO = OpTypeStruct %Foo_0 %Foo_0 %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float %int_1 = OpConstant %int 1 %_ptr_Function_v2float = OpTypePointer Function %v2float %int_2 = OpConstant %int 2 %_ptr_Function__arr_Bar_uint_5 = OpTypePointer Function %_arr_Bar_uint_5 %_ptr_Function_Bar = OpTypePointer Function %Bar %_ptr_Function__arr__arr_float_uint_4_uint_2 = OpTypePointer Function %_arr__arr_float_uint_4_uint_2 %_ptr_Function__arr_float_uint_4 = OpTypePointer Function %_arr_float_uint_4 %_ptr_Function_float = OpTypePointer Function %float %int_3 = OpConstant %int 3 %_ptr_Function__arr_Baz_uint_2 = OpTypePointer Function %_arr_Baz_uint_2 %_ptr_Function_Baz = OpTypePointer Function %Baz %int_4 = OpConstant %int 4 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_5 = OpConstant %float 5 %_ptr_Uniform_mat2v2float = OpTypePointer Uniform %mat2v2float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Uniform__arr_Bar_0_uint_5 = OpTypePointer Uniform %_arr_Bar_0_uint_5 %_ptr_Uniform_Bar_0 = OpTypePointer Uniform %Bar_0 %_ptr_Uniform__arr__arr_float_uint_4_0_uint_2 = OpTypePointer Uniform %_arr__arr_float_uint_4_0_uint_2 %_ptr_Uniform__arr_float_uint_4_0 = OpTypePointer Uniform %_arr_float_uint_4_0 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform__arr_Baz_0_uint_2 = OpTypePointer Uniform %_arr_Baz_0_uint_2 %_ptr_Uniform_Baz_0 = OpTypePointer Uniform %Baz_0 %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %ptr_load = OpAccessChain %_ptr_Uniform_Foo_0 %_ %int_0 %ptr_store = OpAccessChain %_ptr_Uniform_Foo_0 %_ %int_1 %loaded = OpLoad %Foo_0 %ptr_load OpStore %ptr_store %loaded OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/aliased-struct-divergent-member-name.asm.comp000066400000000000000000000060021400026215700324440ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 37 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %T "T" OpMemberName %T 0 "a" OpName %v "v" OpName %T_0 "T" OpMemberName %T_0 0 "b" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "foo" OpName %_ "" OpName %T_1 "T" OpMemberName %T_1 0 "c" OpName %SSBO2 "SSBO2" OpMemberName %SSBO2 0 "bar" OpName %__0 "" OpMemberDecorate %T_0 0 Offset 0 OpDecorate %_runtimearr_T_0 ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpMemberDecorate %T_1 0 Offset 0 OpDecorate %_runtimearr_T_1 ArrayStride 16 OpMemberDecorate %SSBO2 0 Offset 0 OpDecorate %SSBO2 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %T = OpTypeStruct %float %_ptr_Function_T = OpTypePointer Function %T %float_40 = OpConstant %float 40 %11 = OpConstantComposite %T %float_40 %T_0 = OpTypeStruct %float %_runtimearr_T_0 = OpTypeRuntimeArray %T_0 %SSBO1 = OpTypeStruct %_runtimearr_T_0 %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %_ptr_Uniform_T_0 = OpTypePointer Uniform %T_0 %_ptr_Uniform_float = OpTypePointer Uniform %float %T_1 = OpTypeStruct %float %_runtimearr_T_1 = OpTypeRuntimeArray %T_1 %SSBO2 = OpTypeStruct %_runtimearr_T_1 %_ptr_Uniform_SSBO2 = OpTypePointer Uniform %SSBO2 %__0 = OpVariable %_ptr_Uniform_SSBO2 Uniform %int_30 = OpConstant %int 30 %_ptr_Uniform_T_1 = OpTypePointer Uniform %T_1 %main = OpFunction %void None %3 %5 = OpLabel %v = OpVariable %_ptr_Function_T Function OpStore %v %11 %20 = OpLoad %T %v %22 = OpAccessChain %_ptr_Uniform_T_0 %_ %int_0 %int_10 %23 = OpCompositeExtract %float %20 0 %25 = OpAccessChain %_ptr_Uniform_float %22 %int_0 OpStore %25 %23 %32 = OpLoad %T %v %34 = OpAccessChain %_ptr_Uniform_T_1 %__0 %int_0 %int_30 %35 = OpCompositeExtract %float %32 0 %36 = OpAccessChain %_ptr_Uniform_float %34 %int_0 OpStore %36 %35 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/atomic-load-store.asm.comp000066400000000000000000000035361400026215700267040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 23 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %c "c" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a" OpMemberName %SSBO 1 "b" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %SSBO = OpTypeStruct %uint %uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_0 = OpConstant %int 0 %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %c = OpVariable %_ptr_Function_uint Function %15 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %16 = OpAtomicLoad %uint %15 %int_1 %int_0 OpStore %c %16 %18 = OpLoad %uint %c %19 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 OpAtomicStore %19 %int_1 %int_0 %18 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/atomic-result-temporary.asm.comp000066400000000000000000000045461400026215700301730ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "count" OpMemberName %SSBO 1 "data" OpName %_ "" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO = OpTypeStruct %uint %_runtimearr_uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %uint_1024 = OpConstant %uint 1024 %bool = OpTypeBool %int_1 = OpConstant %int 1 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %_ptr_Input_uint = OpTypePointer Input %uint %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %19 = OpAtomicIAdd %uint %16 %uint_1 %uint_0 %uint_1 %23 = OpULessThan %bool %19 %uint_1024 OpSelectionMerge %25 None OpBranchConditional %23 %24 %25 %24 = OpLabel %32 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %33 = OpLoad %uint %32 %34 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %19 OpStore %34 %33 OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/bitfield-signed-operations.asm.comp000066400000000000000000000077351400026215700306000ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 26 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "ints" OpMemberName %SSBO 1 "uints" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 16 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %uint = OpTypeInt 32 0 %v4uint = OpTypeVector %uint 4 %int_1 = OpConstant %int 1 %uint_11 = OpConstant %uint 11 %SSBO = OpTypeStruct %v4int %v4uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_v4int = OpTypePointer Uniform %v4int %_ptr_Uniform_v4uint = OpTypePointer Uniform %v4uint %main = OpFunction %void None %3 %5 = OpLabel %ints_ptr = OpAccessChain %_ptr_Uniform_v4int %_ %int_0 %uints_ptr = OpAccessChain %_ptr_Uniform_v4uint %_ %int_1 %ints = OpLoad %v4int %ints_ptr %uints = OpLoad %v4uint %uints_ptr %ints_alt = OpVectorShuffle %v4int %ints %ints 3 2 1 0 %uints_alt = OpVectorShuffle %v4uint %uints %uints 3 2 1 0 %int_to_int_popcount = OpBitCount %v4int %ints %int_to_uint_popcount = OpBitCount %v4uint %ints %uint_to_int_popcount = OpBitCount %v4int %uints %uint_to_uint_popcount = OpBitCount %v4uint %uints ; BitReverse must have matching types w.r.t. sign, yay. %int_to_int_reverse = OpBitReverse %v4int %ints ;%int_to_uint_reverse = OpBitReverse %v4uint %ints ;%uint_to_int_reverse = OpBitReverse %v4int %uints %uint_to_uint_reverse = OpBitReverse %v4uint %uints ; Base and Result must match. %int_to_int_sbit = OpBitFieldSExtract %v4int %ints %int_1 %uint_11 ;%int_to_uint_sbit = OpBitFieldSExtract %v4uint %ints %offset %count ;%uint_to_int_sbit = OpBitFieldSExtract %v4int %uints %offset %count %uint_to_uint_sbit = OpBitFieldSExtract %v4uint %uints %uint_11 %int_1 ; Base and Result must match. %int_to_int_ubit = OpBitFieldUExtract %v4int %ints %int_1 %uint_11 ;%int_to_uint_ubit = OpBitFieldUExtract %v4uint %ints %offset %count ;%uint_to_int_ubit = OpBitFieldUExtract %v4int %uints %offset %count %uint_to_uint_ubit = OpBitFieldUExtract %v4uint %uints %uint_11 %int_1 %int_to_int_insert = OpBitFieldInsert %v4int %ints %ints_alt %int_1 %uint_11 %uint_to_uint_insert = OpBitFieldInsert %v4uint %uints %uints_alt %uint_11 %int_1 OpStore %ints_ptr %int_to_int_popcount OpStore %uints_ptr %int_to_uint_popcount OpStore %ints_ptr %uint_to_int_popcount OpStore %uints_ptr %uint_to_uint_popcount OpStore %ints_ptr %int_to_int_reverse ;OpStore %uints_ptr %int_to_uint_reverse ;OpStore %ints_ptr %uint_to_int_reverse OpStore %uints_ptr %uint_to_uint_reverse OpStore %ints_ptr %int_to_int_sbit ;OpStore %uints_ptr %int_to_uint_sbit ;OpStore %ints_ptr %uint_to_int_sbit OpStore %uints_ptr %uint_to_uint_sbit OpStore %ints_ptr %int_to_int_ubit ;OpStore %uints_ptr %int_to_uint_ubit ;OpStore %ints_ptr %uint_to_int_ubit OpStore %uints_ptr %uint_to_uint_ubit OpStore %ints_ptr %int_to_int_insert OpStore %uints_ptr %uint_to_uint_insert OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/bitscan.asm.comp000066400000000000000000000052741400026215700250050ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "u" OpMemberName %SSBO 1 "i" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 16 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %SSBO = OpTypeStruct %uvec4 %ivec4 %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_uvec4 = OpTypePointer Uniform %uvec4 %int_1 = OpConstant %int 1 %_ptr_Uniform_ivec4 = OpTypePointer Uniform %ivec4 %main = OpFunction %void None %3 %5 = OpLabel %uptr = OpAccessChain %_ptr_Uniform_uvec4 %_ %int_0 %iptr = OpAccessChain %_ptr_Uniform_ivec4 %_ %int_1 %uvalue = OpLoad %uvec4 %uptr %ivalue = OpLoad %ivec4 %iptr %lsb_uint_to_uint = OpExtInst %uvec4 %1 FindILsb %uvalue %lsb_uint_to_int = OpExtInst %ivec4 %1 FindILsb %uvalue %lsb_int_to_uint = OpExtInst %uvec4 %1 FindILsb %ivalue %lsb_int_to_int = OpExtInst %ivec4 %1 FindILsb %ivalue %umsb_uint_to_uint = OpExtInst %uvec4 %1 FindUMsb %uvalue %umsb_uint_to_int = OpExtInst %ivec4 %1 FindUMsb %uvalue %umsb_int_to_uint = OpExtInst %uvec4 %1 FindUMsb %ivalue %umsb_int_to_int = OpExtInst %ivec4 %1 FindUMsb %ivalue %smsb_uint_to_uint = OpExtInst %uvec4 %1 FindSMsb %uvalue %smsb_uint_to_int = OpExtInst %ivec4 %1 FindSMsb %uvalue %smsb_int_to_uint = OpExtInst %uvec4 %1 FindSMsb %ivalue %smsb_int_to_int = OpExtInst %ivec4 %1 FindSMsb %ivalue OpStore %uptr %lsb_uint_to_uint OpStore %iptr %lsb_uint_to_int OpStore %uptr %lsb_int_to_uint OpStore %iptr %lsb_int_to_int OpStore %uptr %umsb_uint_to_uint OpStore %iptr %umsb_uint_to_int OpStore %uptr %umsb_int_to_uint OpStore %iptr %umsb_int_to_int OpStore %uptr %smsb_uint_to_uint OpStore %iptr %smsb_uint_to_int OpStore %uptr %smsb_int_to_uint OpStore %iptr %smsb_int_to_int OpReturn OpFunctionEnd buffer-atomic-nonuniform.asm.sm51.nonuniformresource.comp000066400000000000000000000043621400026215700347400ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 26 ; Schema: 0 OpCapability Shader OpCapability ShaderNonUniform OpCapability RuntimeDescriptorArray OpCapability StorageBufferArrayNonUniformIndexing OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "v" OpName %ssbos "ssbos" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %ssbos DescriptorSet 0 OpDecorate %ssbos Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %22 NonUniform %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %SSBO = OpTypeStruct %uint %_runtimearr_SSBO = OpTypeRuntimeArray %SSBO %_ptr_Uniform__runtimearr_SSBO = OpTypePointer Uniform %_runtimearr_SSBO %ssbos = OpVariable %_ptr_Uniform__runtimearr_SSBO Uniform %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_2 = OpConstant %uint 2 %_ptr_Input_uint = OpTypePointer Input %uint %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_2 %17 = OpLoad %uint %16 %18 = OpCopyObject %uint %17 %22 = OpAccessChain %_ptr_Uniform_uint %ssbos %18 %int_0 %25 = OpAtomicIAdd %uint %22 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/constant-composite-undef.asm.comp000066400000000000000000000030601400026215700303010ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Block "Block" OpMemberName %Block 0 "f" OpName %block "block" OpMemberDecorate %Block 0 Offset 0 OpDecorate %Block BufferBlock OpDecorate %block DescriptorSet 0 OpDecorate %block Binding 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Block = OpTypeStruct %v4float %_ptr_Uniform_Block = OpTypePointer Uniform %Block %block = OpVariable %_ptr_Uniform_Block Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_0_100000001 = OpConstant %float 0.100000001 %float_0_200000003 = OpConstant %float 0.200000003 %float_0_300000012 = OpConstant %float 0.300000012 %15 = OpUndef %float %16 = OpConstantComposite %v4float %float_0_100000001 %float_0_200000003 %float_0_300000012 %15 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %main = OpFunction %void None %6 %18 = OpLabel %19 = OpAccessChain %_ptr_Uniform_v4float %block %int_0 OpStore %19 %16 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/glsl-signed-operations.asm.comp000066400000000000000000000124761400026215700277550ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 26 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "ints" OpMemberName %SSBO 1 "uints" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 16 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %uint = OpTypeInt 32 0 %v4uint = OpTypeVector %uint 4 %SSBO = OpTypeStruct %v4int %v4uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_v4int = OpTypePointer Uniform %v4int %int_1 = OpConstant %int 1 %_ptr_Uniform_v4uint = OpTypePointer Uniform %v4uint %main = OpFunction %void None %3 %5 = OpLabel %ints_ptr = OpAccessChain %_ptr_Uniform_v4int %_ %int_0 %uints_ptr = OpAccessChain %_ptr_Uniform_v4uint %_ %int_1 %ints = OpLoad %v4int %ints_ptr %uints = OpLoad %v4uint %uints_ptr %int_to_int_sabs = OpExtInst %v4int %1 SAbs %ints %int_to_uint_sabs = OpExtInst %v4uint %1 SAbs %ints %uint_to_int_sabs = OpExtInst %v4int %1 SAbs %uints %uint_to_uint_sabs = OpExtInst %v4uint %1 SAbs %uints %int_to_int_ssign = OpExtInst %v4int %1 SSign %ints %int_to_uint_ssign = OpExtInst %v4uint %1 SSign %ints %uint_to_int_ssign = OpExtInst %v4int %1 SSign %uints %uint_to_uint_ssign = OpExtInst %v4uint %1 SSign %uints %int_to_int_smsb = OpExtInst %v4int %1 FindSMsb %uints %int_to_uint_smsb = OpExtInst %v4uint %1 FindSMsb %uints %uint_to_int_umsb = OpExtInst %v4int %1 FindUMsb %ints %uint_to_uint_umsb = OpExtInst %v4uint %1 FindUMsb %ints %int_to_int_smin = OpExtInst %v4int %1 SMin %ints %ints %int_to_uint_smin = OpExtInst %v4uint %1 SMin %ints %uints %uint_to_int_smin = OpExtInst %v4int %1 SMin %uints %uints %uint_to_uint_smin = OpExtInst %v4uint %1 SMin %uints %ints %int_to_int_umin = OpExtInst %v4int %1 UMin %ints %uints %int_to_uint_umin = OpExtInst %v4uint %1 UMin %ints %uints %uint_to_int_umin = OpExtInst %v4int %1 UMin %uints %ints %uint_to_uint_umin = OpExtInst %v4uint %1 UMin %uints %ints %int_to_int_smax = OpExtInst %v4int %1 SMax %ints %ints %int_to_uint_smax = OpExtInst %v4uint %1 SMax %ints %ints %uint_to_int_smax = OpExtInst %v4int %1 SMax %uints %ints %uint_to_uint_smax = OpExtInst %v4uint %1 SMax %uints %ints %int_to_int_umax = OpExtInst %v4int %1 UMax %ints %uints %int_to_uint_umax = OpExtInst %v4uint %1 UMax %ints %ints %uint_to_int_umax = OpExtInst %v4int %1 UMax %uints %ints %uint_to_uint_umax = OpExtInst %v4uint %1 UMax %uints %ints %int_to_int_sclamp = OpExtInst %v4int %1 SClamp %uints %uints %uints %int_to_uint_sclamp = OpExtInst %v4uint %1 SClamp %uints %uints %uints %uint_to_int_uclamp = OpExtInst %v4int %1 UClamp %ints %ints %ints %uint_to_uint_uclamp = OpExtInst %v4uint %1 UClamp %ints %ints %ints OpStore %ints_ptr %int_to_int_sabs OpStore %uints_ptr %int_to_uint_sabs OpStore %ints_ptr %uint_to_int_sabs OpStore %uints_ptr %uint_to_uint_sabs OpStore %ints_ptr %int_to_int_ssign OpStore %uints_ptr %int_to_uint_ssign OpStore %ints_ptr %uint_to_int_ssign OpStore %uints_ptr %uint_to_uint_ssign OpStore %ints_ptr %int_to_int_smsb OpStore %uints_ptr %int_to_uint_smsb OpStore %ints_ptr %uint_to_int_umsb OpStore %uints_ptr %uint_to_uint_umsb OpStore %ints_ptr %int_to_int_smin OpStore %uints_ptr %int_to_uint_smin OpStore %ints_ptr %uint_to_int_smin OpStore %uints_ptr %uint_to_uint_smin OpStore %ints_ptr %int_to_int_umin OpStore %uints_ptr %int_to_uint_umin OpStore %ints_ptr %uint_to_int_umin OpStore %uints_ptr %uint_to_uint_umin OpStore %ints_ptr %int_to_int_smax OpStore %uints_ptr %int_to_uint_smax OpStore %ints_ptr %uint_to_int_smax OpStore %uints_ptr %uint_to_uint_smax OpStore %ints_ptr %int_to_int_umax OpStore %uints_ptr %int_to_uint_umax OpStore %ints_ptr %uint_to_int_umax OpStore %uints_ptr %uint_to_uint_umax OpStore %ints_ptr %int_to_int_sclamp OpStore %uints_ptr %int_to_uint_sclamp OpStore %ints_ptr %uint_to_int_uclamp OpStore %uints_ptr %uint_to_uint_uclamp OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/glsl.std450.frexp-modf-struct.fxconly.asm.comp000066400000000000000000000041771400026215700324170ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %ResTypeMod = OpTypeStruct %float %float %_ptr_Function_ResTypeMod = OpTypePointer Function %ResTypeMod %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_20 = OpConstant %float 20 %int_1 = OpConstant %int 1 %_ptr_Function_float = OpTypePointer Function %float %ResTypeFrexp = OpTypeStruct %float %int %_ptr_Function_ResTypeFrexp = OpTypePointer Function %ResTypeFrexp %float_40 = OpConstant %float 40 %_ptr_Function_int = OpTypePointer Function %int %SSBO = OpTypeStruct %float %int %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_int = OpTypePointer Uniform %int %main = OpFunction %void None %3 %5 = OpLabel %modres = OpExtInst %ResTypeMod %1 ModfStruct %float_20 %frexpres = OpExtInst %ResTypeFrexp %1 FrexpStruct %float_40 %modres_f = OpCompositeExtract %float %modres 0 %modres_i = OpCompositeExtract %float %modres 1 %frexpres_f = OpCompositeExtract %float %frexpres 0 %frexpres_i = OpCompositeExtract %int %frexpres 1 %float_ptr = OpAccessChain %_ptr_Uniform_float %_ %int_0 %int_ptr = OpAccessChain %_ptr_Uniform_int %_ %int_1 OpStore %float_ptr %modres_f OpStore %float_ptr %modres_i OpStore %float_ptr %frexpres_f OpStore %int_ptr %frexpres_i OpReturn OpFunctionEnd image-atomic-nonuniform.asm.sm51.nonuniformresource.comp000066400000000000000000000046321400026215700345510ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 32 ; Schema: 0 OpCapability Shader OpCapability ShaderNonUniform OpCapability RuntimeDescriptorArray OpCapability StorageImageArrayNonUniformIndexing OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %uImage "uImage" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %uImage DescriptorSet 0 OpDecorate %uImage Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %30 NonUniform %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %7 = OpTypeImage %uint 2D 0 0 0 2 R32ui %_runtimearr_7 = OpTypeRuntimeArray %7 %_ptr_UniformConstant__runtimearr_7 = OpTypePointer UniformConstant %_runtimearr_7 %uImage = OpVariable %_ptr_UniformConstant__runtimearr_7 UniformConstant %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_2 = OpConstant %uint 2 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_UniformConstant_7 = OpTypePointer UniformConstant %7 %v2uint = OpTypeVector %uint 2 %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %_ptr_Image_uint = OpTypePointer Image %uint %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_2 %17 = OpLoad %uint %16 %18 = OpCopyObject %uint %17 %20 = OpAccessChain %_ptr_UniformConstant_7 %uImage %18 %22 = OpLoad %v3uint %gl_GlobalInvocationID %23 = OpVectorShuffle %v2uint %22 %22 0 1 %26 = OpBitcast %v2int %23 %30 = OpImageTexelPointer %_ptr_Image_uint %20 %26 %uint_0 %31 = OpAtomicIAdd %uint %30 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/specialization-constant-workgroup.nofxc.asm.comp000066400000000000000000000033751400026215700334000ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 24 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 20 1 OpSource ESSL 310 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %19 SpecId 10 OpDecorate %21 SpecId 12 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %SSBO = OpTypeStruct %float %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %uint = OpTypeInt 32 0 %19 = OpSpecConstant %uint 9 %uint_20 = OpConstant %uint 20 %21 = OpSpecConstant %uint 4 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %19 %uint_20 %21 %main = OpFunction %void None %3 %5 = OpLabel %14 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %15 = OpLoad %float %14 %16 = OpFAdd %float %15 %float_1 %17 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %17 %16 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/comp/storage-buffer-basic.nofxc.asm.comp000066400000000000000000000047031400026215700304640ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Codeplay; 0 ; Bound: 31 ; Schema: 0 OpCapability Shader ;OpCapability VariablePointers OpExtension "SPV_KHR_storage_buffer_storage_class" ;OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %22 "main" %gl_WorkGroupID OpSource OpenCL_C 120 OpDecorate %15 SpecId 0 ;OpDecorate %16 SpecId 1 OpDecorate %17 SpecId 2 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_4 0 Offset 0 OpDecorate %_struct_4 Block OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize OpDecorate %20 DescriptorSet 0 OpDecorate %20 Binding 0 OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 %float = OpTypeFloat 32 %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_runtimearr_float = OpTypeRuntimeArray %float %_struct_4 = OpTypeStruct %_runtimearr_float %_ptr_StorageBuffer__struct_4 = OpTypePointer StorageBuffer %_struct_4 %uint = OpTypeInt 32 0 %void = OpTypeVoid %8 = OpTypeFunction %void %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Private_v3uint = OpTypePointer Private %v3uint %uint_0 = OpConstant %uint 0 %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %15 = OpSpecConstant %uint 1 %16 = OpConstant %uint 2 %17 = OpSpecConstant %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %15 %16 %17 %19 = OpVariable %_ptr_Private_v3uint Private %gl_WorkGroupSize %20 = OpVariable %_ptr_StorageBuffer__struct_4 StorageBuffer %21 = OpVariable %_ptr_StorageBuffer__struct_4 StorageBuffer %22 = OpFunction %void None %8 %23 = OpLabel %24 = OpAccessChain %_ptr_Input_uint %gl_WorkGroupID %uint_0 %25 = OpLoad %uint %24 %26 = OpAccessChain %_ptr_StorageBuffer_float %21 %uint_0 %25 %27 = OpLoad %float %26 %28 = OpAccessChain %_ptr_StorageBuffer_float %20 %uint_0 %25 %29 = OpLoad %float %28 %30 = OpFAdd %float %27 %29 OpStore %28 %30 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/000077500000000000000000000000001400026215700216745ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/empty-struct-in-struct.asm.frag000066400000000000000000000046141400026215700277270ustar00rootroot00000000000000; SPIR-V ; Version: 1.2 ; Generator: Khronos; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %EntryPoint_Main "main" OpExecutionMode %EntryPoint_Main OriginUpperLeft OpSource Unknown 100 OpName %EmptyStructTest "EmptyStructTest" OpName %EmptyStruct2Test "EmptyStruct2Test" OpName %GetValue "GetValue" OpName %GetValue2 "GetValue" OpName %self "self" OpName %self2 "self" OpName %emptyStruct "emptyStruct" OpName %value "value" OpName %EntryPoint_Main "EntryPoint_Main" %EmptyStructTest = OpTypeStruct %EmptyStruct2Test = OpTypeStruct %EmptyStructTest %_ptr_Function_EmptyStruct2Test = OpTypePointer Function %EmptyStruct2Test %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %5 = OpTypeFunction %float %_ptr_Function_EmptyStruct2Test %6 = OpTypeFunction %float %EmptyStruct2Test %void = OpTypeVoid %_ptr_Function_void = OpTypePointer Function %void %8 = OpTypeFunction %void %_ptr_Function_EmptyStruct2Test %9 = OpTypeFunction %void %float_0 = OpConstant %float 0 %value4 = OpConstantNull %EmptyStruct2Test %GetValue = OpFunction %float None %5 %self = OpFunctionParameter %_ptr_Function_EmptyStruct2Test %13 = OpLabel OpReturnValue %float_0 OpFunctionEnd %GetValue2 = OpFunction %float None %6 %self2 = OpFunctionParameter %EmptyStruct2Test %14 = OpLabel OpReturnValue %float_0 OpFunctionEnd %EntryPoint_Main = OpFunction %void None %9 %37 = OpLabel %emptyStruct = OpVariable %_ptr_Function_EmptyStruct2Test Function %18 = OpVariable %_ptr_Function_EmptyStruct2Test Function %value = OpVariable %_ptr_Function_float Function %value2 = OpCompositeConstruct %EmptyStructTest %value3 = OpCompositeConstruct %EmptyStruct2Test %value2 %22 = OpFunctionCall %float %GetValue %emptyStruct %23 = OpFunctionCall %float %GetValue2 %value3 %24 = OpFunctionCall %float %GetValue2 %value4 OpStore %value %22 OpStore %value %23 OpStore %value %24 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/image-fetch-uint-coord.asm.frag000066400000000000000000000035171400026215700275540ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 29 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_TEXCOORD0 %out_var_SV_Target0 OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_2d_image "type.2d.image" OpName %Tex "Tex" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %main "main" OpDecorate %in_var_TEXCOORD0 Flat OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %Tex DescriptorSet 0 OpDecorate %Tex Binding 0 %int = OpTypeInt 32 1 %int_2 = OpConstant %int 2 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %16 = OpTypeFunction %void %Tex = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v3uint Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %16 %19 = OpLabel %20 = OpLoad %v3uint %in_var_TEXCOORD0 %21 = OpCompositeExtract %uint %20 2 %27 = OpLoad %type_2d_image %Tex %28 = OpImageFetch %v4float %27 %20 Lod %21 OpStore %out_var_SV_Target0 %28 OpReturn OpFunctionEnd nonuniform-bracket-handling-2.nonuniformresource.sm51.asm.frag000066400000000000000000000102231400026215700355040ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 53 ; Schema: 0 OpCapability Shader OpCapability ShaderNonUniform OpCapability RuntimeDescriptorArray OpCapability SampledImageArrayNonUniformIndexing OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vUV %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %FragColor "FragColor" OpName %uSamplers "uSamplers" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "indices" OpName %_ "" OpName %vUV "vUV" OpName %uSampler "uSampler" OpName %gl_FragCoord "gl_FragCoord" OpDecorate %FragColor Location 0 OpDecorate %uSamplers DescriptorSet 0 OpDecorate %uSamplers Binding 0 OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO 0 NonWritable OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 2 OpDecorate %_ Binding 0 OpDecorate %26 NonUniform OpDecorate %28 NonUniform OpDecorate %29 NonUniform OpDecorate %vUV Location 0 OpDecorate %uSampler DescriptorSet 1 OpDecorate %uSampler Binding 1 OpDecorate %38 NonUniform OpDecorate %gl_FragCoord BuiltIn FragCoord %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_runtimearr_11 = OpTypeRuntimeArray %11 %_ptr_UniformConstant__runtimearr_11 = OpTypePointer UniformConstant %_runtimearr_11 %uSamplers = OpVariable %_ptr_UniformConstant__runtimearr_11 UniformConstant %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %float_0 = OpConstant %float 0 %uSampler = OpVariable %_ptr_UniformConstant_11 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_1 = OpConstant %uint 1 %_ptr_Input_float = OpTypePointer Input %float %main = OpFunction %void None %3 %5 = OpLabel %24 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %int_10 %26 = OpLoad %uint %24 %28 = OpAccessChain %_ptr_UniformConstant_11 %uSamplers %26 %29 = OpLoad %11 %28 %33 = OpLoad %v2float %vUV %35 = OpImageSampleExplicitLod %v4float %29 %33 Lod %float_0 OpStore %FragColor %35 %37 = OpLoad %11 %uSampler %38 = OpCopyObject %11 %37 %39 = OpLoad %v2float %vUV %44 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_1 %45 = OpLoad %float %44 %46 = OpConvertFToS %int %45 %47 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %46 %48 = OpLoad %uint %47 %49 = OpConvertUToF %float %48 %50 = OpImageSampleExplicitLod %v4float %38 %39 Lod %49 %51 = OpLoad %v4float %FragColor %52 = OpFAdd %v4float %51 %50 OpStore %FragColor %52 OpReturn OpFunctionEnd nonuniform-qualifier-propagation.nonuniformresource.sm51.asm.frag000066400000000000000000000160611400026215700364600ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 93 ; Schema: 0 OpCapability Shader OpCapability ShaderNonUniformEXT OpCapability RuntimeDescriptorArrayEXT OpCapability UniformBufferArrayNonUniformIndexingEXT OpCapability SampledImageArrayNonUniformIndexingEXT OpCapability StorageBufferArrayNonUniformIndexingEXT OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vIndex %FragColor %vUV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %i "i" OpName %vIndex "vIndex" OpName %FragColor "FragColor" OpName %uSamplers "uSamplers" OpName %uSamps "uSamps" OpName %vUV "vUV" OpName %uCombinedSamplers "uCombinedSamplers" OpName %UBO "UBO" OpMemberName %UBO 0 "v" OpName %ubos "ubos" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "v" OpName %ssbos "ssbos" OpDecorate %vIndex Flat OpDecorate %vIndex Location 0 OpDecorate %FragColor Location 0 OpDecorate %uSamplers DescriptorSet 0 OpDecorate %uSamplers Binding 0 OpDecorate %sampled_image NonUniformEXT OpDecorate %combined_sampler NonUniformEXT OpDecorate %ubo_ptr_copy NonUniformEXT OpDecorate %ssbo_ptr_copy NonUniformEXT OpDecorate %uSamps DescriptorSet 1 OpDecorate %uSamps Binding 0 OpDecorate %vUV Location 1 OpDecorate %uCombinedSamplers DescriptorSet 0 OpDecorate %uCombinedSamplers Binding 4 OpDecorate %_arr_v4float_uint_64 ArrayStride 16 OpMemberDecorate %UBO 0 Offset 0 OpDecorate %UBO Block OpDecorate %ubos DescriptorSet 2 OpDecorate %ubos Binding 0 OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %SSBO 0 NonWritable OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %ssbos DescriptorSet 3 OpDecorate %ssbos Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_int = OpTypePointer Input %int %vIndex = OpVariable %_ptr_Input_int Input %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %16 = OpTypeImage %float 2D 0 0 0 1 Unknown %_runtimearr_16 = OpTypeRuntimeArray %16 %_ptr_UniformConstant__runtimearr_16 = OpTypePointer UniformConstant %_runtimearr_16 %uSamplers = OpVariable %_ptr_UniformConstant__runtimearr_16 UniformConstant %int_10 = OpConstant %int 10 %_ptr_UniformConstant_16 = OpTypePointer UniformConstant %16 %27 = OpTypeSampler %_runtimearr_27 = OpTypeRuntimeArray %27 %_ptr_UniformConstant__runtimearr_27 = OpTypePointer UniformConstant %_runtimearr_27 %uSamps = OpVariable %_ptr_UniformConstant__runtimearr_27 UniformConstant %int_40 = OpConstant %int 40 %_ptr_UniformConstant_27 = OpTypePointer UniformConstant %27 %38 = OpTypeSampledImage %16 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %_runtimearr_38 = OpTypeRuntimeArray %38 %_ptr_UniformConstant__runtimearr_38 = OpTypePointer UniformConstant %_runtimearr_38 %uCombinedSamplers = OpVariable %_ptr_UniformConstant__runtimearr_38 UniformConstant %_ptr_UniformConstant_38 = OpTypePointer UniformConstant %38 %uint = OpTypeInt 32 0 %uint_64 = OpConstant %uint 64 %_arr_v4float_uint_64 = OpTypeArray %v4float %uint_64 %UBO = OpTypeStruct %_arr_v4float_uint_64 %_runtimearr_UBO = OpTypeRuntimeArray %UBO %_ptr_Uniform__runtimearr_UBO = OpTypePointer Uniform %_runtimearr_UBO %ubos = OpVariable %_ptr_Uniform__runtimearr_UBO Uniform %int_20 = OpConstant %int 20 %int_0 = OpConstant %int 0 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_runtimearr_v4float = OpTypeRuntimeArray %v4float %SSBO = OpTypeStruct %_runtimearr_v4float %_runtimearr_SSBO = OpTypeRuntimeArray %SSBO %_ptr_Uniform__runtimearr_SSBO = OpTypePointer Uniform %_runtimearr_SSBO %ssbos = OpVariable %_ptr_Uniform__runtimearr_SSBO Uniform %int_50 = OpConstant %int 50 %int_60 = OpConstant %int 60 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function %11 = OpLoad %int %vIndex OpStore %i %11 %20 = OpLoad %int %i %22 = OpIAdd %int %20 %int_10 %23 = OpCopyObject %int %22 %25 = OpAccessChain %_ptr_UniformConstant_16 %uSamplers %23 %26 = OpLoad %16 %25 %31 = OpLoad %int %i %33 = OpIAdd %int %31 %int_40 %34 = OpCopyObject %int %33 %36 = OpAccessChain %_ptr_UniformConstant_27 %uSamps %34 %37 = OpLoad %27 %36 %sampled_image = OpSampledImage %38 %26 %37 %43 = OpLoad %v2float %vUV %44 = OpImageSampleImplicitLod %v4float %sampled_image %43 OpStore %FragColor %44 %48 = OpLoad %int %i %49 = OpIAdd %int %48 %int_10 %50 = OpCopyObject %int %49 %52 = OpAccessChain %_ptr_UniformConstant_38 %uCombinedSamplers %50 %combined_sampler = OpLoad %38 %52 %54 = OpLoad %v2float %vUV %55 = OpImageSampleImplicitLod %v4float %combined_sampler %54 OpStore %FragColor %55 %63 = OpLoad %int %i %65 = OpIAdd %int %63 %int_20 %66 = OpCopyObject %int %65 %68 = OpLoad %int %i %69 = OpIAdd %int %68 %int_40 %70 = OpCopyObject %int %69 %ubo_ptr = OpAccessChain %_ptr_Uniform_v4float %ubos %66 %int_0 %70 %ubo_ptr_copy = OpCopyObject %_ptr_Uniform_v4float %ubo_ptr %73 = OpLoad %v4float %ubo_ptr_copy %74 = OpLoad %v4float %FragColor %75 = OpFAdd %v4float %74 %73 OpStore %FragColor %75 %81 = OpLoad %int %i %83 = OpIAdd %int %81 %int_50 %84 = OpCopyObject %int %83 %85 = OpLoad %int %i %87 = OpIAdd %int %85 %int_60 %88 = OpCopyObject %int %87 %ssbo_ptr = OpAccessChain %_ptr_Uniform_v4float %ssbos %84 %int_0 %88 %ssbo_ptr_copy = OpCopyObject %_ptr_Uniform_v4float %ssbo_ptr %90 = OpLoad %v4float %ssbo_ptr_copy %91 = OpLoad %v4float %FragColor %92 = OpFAdd %v4float %91 %90 OpStore %FragColor %92 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/only-initializer-frag-depth.asm.frag000066400000000000000000000016431400026215700306410ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 10 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragDepth OpExecutionMode %main OriginUpperLeft OpExecutionMode %main DepthReplacing OpSource GLSL 450 OpName %main "main" OpName %gl_FragDepth "gl_FragDepth" OpDecorate %gl_FragDepth BuiltIn FragDepth %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %float_0_5 = OpConstant %float 0.5 %gl_FragDepth = OpVariable %_ptr_Output_float Output %float_0_5 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/phi.zero-initialize.asm.frag000066400000000000000000000052031400026215700272110ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 40 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vColor %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %vColor "vColor" OpName %uninit_function_int "uninit_function_int" OpName %FragColor "FragColor" OpName %uninit_int "uninit_int" OpName %uninit_vector "uninit_vector" OpName %uninit_matrix "uninit_matrix" OpName %Foo "Foo" OpMemberName %Foo 0 "a" OpName %uninit_foo "uninit_foo" OpDecorate %vColor Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %vColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_10 = OpConstant %float 10 %bool = OpTypeBool %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_10 = OpConstant %int 10 %int_20 = OpConstant %int 20 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Private_int = OpTypePointer Private %int %uninit_int = OpUndef %int %v4int = OpTypeVector %int 4 %_ptr_Private_v4int = OpTypePointer Private %v4int %uninit_vector = OpUndef %v4int %mat4v4float = OpTypeMatrix %v4float 4 %_ptr_Private_mat4v4float = OpTypePointer Private %mat4v4float %uninit_matrix = OpUndef %mat4v4float %Foo = OpTypeStruct %int %_ptr_Private_Foo = OpTypePointer Private %Foo %uninit_foo = OpUndef %Foo %main = OpFunction %void None %3 %5 = OpLabel %uninit_function_int = OpVariable %_ptr_Function_int Function %13 = OpAccessChain %_ptr_Input_float %vColor %uint_0 %14 = OpLoad %float %13 %17 = OpFOrdGreaterThan %bool %14 %float_10 OpSelectionMerge %19 None OpBranchConditional %17 %18 %24 %18 = OpLabel OpBranch %19 %24 = OpLabel OpBranch %19 %19 = OpLabel %27 = OpPhi %int %int_10 %18 %int_20 %24 %28 = OpLoad %v4float %vColor OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/pixel-interlock-callstack.sm51.fxconly.asm.frag000066400000000000000000000072021400026215700326320ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpSource GLSL 450 OpSourceExtension "GL_ARB_fragment_shader_interlock" OpName %main "main" OpName %callee2_ "callee2(" OpName %callee_ "callee(" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "values1" OpName %_ "" OpName %gl_FragCoord "gl_FragCoord" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "values0" OpName %__0 "" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_runtimearr_uint_0 ArrayStride 4 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO1 = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_runtimearr_uint_0 = OpTypeRuntimeArray %uint %SSBO0 = OpTypeStruct %_runtimearr_uint_0 %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %__0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %44 = OpFunctionCall %void %callee_ OpReturn OpFunctionEnd %callee2_ = OpFunction %void None %3 %7 = OpLabel %23 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %24 = OpLoad %float %23 %25 = OpConvertFToS %int %24 %28 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 %29 = OpLoad %uint %28 %30 = OpIAdd %uint %29 %uint_1 %31 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 OpStore %31 %30 OpReturn OpFunctionEnd %callee_ = OpFunction %void None %3 %9 = OpLabel %36 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %37 = OpLoad %float %36 %38 = OpConvertFToS %int %37 %39 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpIAdd %uint %40 %uint_1 %42 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 OpStore %42 %41 OpBeginInvocationInterlockEXT %43 = OpFunctionCall %void %callee2_ OpEndInvocationInterlockEXT OpReturn OpFunctionEnd pixel-interlock-control-flow.sm51.fxconly.asm.frag000066400000000000000000000112201400026215700332320ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpSource GLSL 450 OpSourceExtension "GL_ARB_fragment_shader_interlock" OpName %main "main" OpName %callee2_ "callee2(" OpName %callee_ "callee(" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "values1" OpName %_ "" OpName %gl_FragCoord "gl_FragCoord" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "values0" OpName %__0 "" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_runtimearr_uint_0 ArrayStride 4 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 OpMemberDecorate %SSBO2 0 Offset 0 OpDecorate %SSBO2 BufferBlock OpDecorate %ssbo2 DescriptorSet 0 OpDecorate %ssbo2 Binding 2 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO1 = OpTypeStruct %_runtimearr_uint %SSBO2 = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ptr_Uniform_SSBO2 = OpTypePointer Uniform %SSBO2 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %ssbo2 = OpVariable %_ptr_Uniform_SSBO2 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_4 = OpConstant %uint 4 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %bool = OpTypeBool %true = OpConstantTrue %bool %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_runtimearr_uint_0 = OpTypeRuntimeArray %uint %SSBO0 = OpTypeStruct %_runtimearr_uint_0 %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %__0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %44 = OpFunctionCall %void %callee_ %callee3_res = OpFunctionCall %void %callee3_ OpReturn OpFunctionEnd %callee3_ = OpFunction %void None %3 %calle3_block = OpLabel %frag_coord_x_ptr = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %frag_coord_x = OpLoad %float %frag_coord_x_ptr %frag_coord_int = OpConvertFToS %int %frag_coord_x %ssbo_ptr = OpAccessChain %_ptr_Uniform_uint %ssbo2 %int_0 %frag_coord_int OpStore %ssbo_ptr %uint_4 OpReturn OpFunctionEnd %callee2_ = OpFunction %void None %3 %7 = OpLabel %23 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %24 = OpLoad %float %23 %25 = OpConvertFToS %int %24 %28 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 %29 = OpLoad %uint %28 %30 = OpIAdd %uint %29 %uint_1 %31 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 OpStore %31 %30 OpReturn OpFunctionEnd %callee_ = OpFunction %void None %3 %9 = OpLabel %36 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %37 = OpLoad %float %36 %38 = OpConvertFToS %int %37 %39 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpIAdd %uint %40 %uint_1 %42 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 OpStore %42 %41 %43 = OpFunctionCall %void %callee2_ OpSelectionMerge %merged_block None OpBranchConditional %true %dummy_block %merged_block %dummy_block = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpBranch %merged_block %merged_block = OpLabel OpReturn OpFunctionEnd pixel-interlock-split-functions.sm51.fxconly.asm.frag000066400000000000000000000077011400026215700337570ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpSource GLSL 450 OpSourceExtension "GL_ARB_fragment_shader_interlock" OpName %main "main" OpName %callee2_ "callee2(" OpName %callee_ "callee(" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "values1" OpName %_ "" OpName %gl_FragCoord "gl_FragCoord" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "values0" OpName %__0 "" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_runtimearr_uint_0 ArrayStride 4 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO1 = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_runtimearr_uint_0 = OpTypeRuntimeArray %uint %SSBO0 = OpTypeStruct %_runtimearr_uint_0 %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %__0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %44 = OpFunctionCall %void %callee_ %call3res = OpFunctionCall %void %callee3_ %call4res = OpFunctionCall %void %callee4_ OpReturn OpFunctionEnd %callee3_ = OpFunction %void None %3 %begin3 = OpLabel OpBeginInvocationInterlockEXT OpReturn OpFunctionEnd %callee4_ = OpFunction %void None %3 %begin4 = OpLabel OpEndInvocationInterlockEXT OpReturn OpFunctionEnd %callee2_ = OpFunction %void None %3 %7 = OpLabel %23 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %24 = OpLoad %float %23 %25 = OpConvertFToS %int %24 %28 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 %29 = OpLoad %uint %28 %30 = OpIAdd %uint %29 %uint_1 %31 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 OpStore %31 %30 OpReturn OpFunctionEnd %callee_ = OpFunction %void None %3 %9 = OpLabel %36 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %37 = OpLoad %float %36 %38 = OpConvertFToS %int %37 %39 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpIAdd %uint %40 %uint_1 %42 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 OpStore %42 %41 %43 = OpFunctionCall %void %callee2_ OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/reserved-function-identifier.asm.frag000066400000000000000000000043741400026215700311060ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 37 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %ACOS_f1_ "mat3" OpName %a "a" OpName %ACOS_i1_ "gl_Foo" OpName %a_0 "a" OpName %FragColor "FragColor" OpName %param "param" OpName %param_0 "param" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %8 = OpTypeFunction %float %_ptr_Function_float %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %14 = OpTypeFunction %float %_ptr_Function_int %float_1 = OpConstant %float 1 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %float_2 = OpConstant %float 2 %int_4 = OpConstant %int 4 %main = OpFunction %void None %3 %5 = OpLabel %param = OpVariable %_ptr_Function_float Function %param_0 = OpVariable %_ptr_Function_int Function OpStore %param %float_2 %32 = OpFunctionCall %float %ACOS_f1_ %param OpStore %param_0 %int_4 %35 = OpFunctionCall %float %ACOS_i1_ %param_0 %36 = OpFAdd %float %32 %35 OpStore %FragColor %36 OpReturn OpFunctionEnd %ACOS_f1_ = OpFunction %float None %8 %a = OpFunctionParameter %_ptr_Function_float %11 = OpLabel %18 = OpLoad %float %a %20 = OpFAdd %float %18 %float_1 OpReturnValue %20 OpFunctionEnd %ACOS_i1_ = OpFunction %float None %14 %a_0 = OpFunctionParameter %_ptr_Function_int %17 = OpLabel %23 = OpLoad %int %a_0 %24 = OpConvertSToF %float %23 %25 = OpFAdd %float %24 %float_1 OpReturnValue %25 OpFunctionEnd struct-packing-last-element-array-matrix-rule.invalid.asm.frag000066400000000000000000000061711400026215700356000ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 33 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %Foo "Foo" OpMemberName %Foo 0 "m" OpMemberName %Foo 1 "v" OpName %FooUBO "FooUBO" OpMemberName %FooUBO 0 "foo" OpName %_ "" OpName %Bar "Bar" OpMemberName %Bar 0 "m" OpMemberName %Bar 1 "v" OpName %BarUBO "BarUBO" OpMemberName %BarUBO 0 "bar" OpName %__0 "" OpDecorate %FragColor Location 0 OpDecorate %_arr_mat3v3float_uint_2 ArrayStride 48 OpMemberDecorate %Foo 0 ColMajor OpMemberDecorate %Foo 0 Offset 0 OpMemberDecorate %Foo 0 MatrixStride 16 OpMemberDecorate %Foo 1 Offset 92 OpMemberDecorate %FooUBO 0 Offset 0 OpDecorate %FooUBO Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpMemberDecorate %Bar 0 ColMajor OpMemberDecorate %Bar 0 Offset 0 OpMemberDecorate %Bar 0 MatrixStride 16 OpMemberDecorate %Bar 1 Offset 44 OpMemberDecorate %BarUBO 0 Offset 0 OpDecorate %BarUBO Block OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %v3float = OpTypeVector %float 3 %mat3v3float = OpTypeMatrix %v3float 3 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_mat3v3float_uint_2 = OpTypeArray %mat3v3float %uint_2 %Foo = OpTypeStruct %_arr_mat3v3float_uint_2 %float %FooUBO = OpTypeStruct %Foo %_ptr_Uniform_FooUBO = OpTypePointer Uniform %FooUBO %_ = OpVariable %_ptr_Uniform_FooUBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %Bar = OpTypeStruct %mat3v3float %float %BarUBO = OpTypeStruct %Bar %_ptr_Uniform_BarUBO = OpTypePointer Uniform %BarUBO %__0 = OpVariable %_ptr_Uniform_BarUBO Uniform %main = OpFunction %void None %3 %5 = OpLabel %23 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %int_1 %24 = OpLoad %float %23 %29 = OpAccessChain %_ptr_Uniform_float %__0 %int_0 %int_1 %30 = OpLoad %float %29 %31 = OpFAdd %float %24 %30 %32 = OpCompositeConstruct %v4float %31 %31 %31 %31 OpStore %FragColor %32 OpReturn OpFunctionEnd subgroup-arithmetic-cast.invalid.nofxc.sm60.asm.frag000066400000000000000000000056411400026215700335150ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 78 ; Schema: 0 OpCapability Shader OpCapability GroupNonUniform OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %index %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_KHR_shader_subgroup_arithmetic" OpSourceExtension "GL_KHR_shader_subgroup_basic" OpSourceExtension "GL_KHR_shader_subgroup_clustered" OpName %main "main" OpName %index "index" OpName %FragColor "FragColor" OpDecorate %index Flat OpDecorate %index Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %index = OpVariable %_ptr_Input_int Input %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %_ptr_Output_uint = OpTypePointer Output %uint %FragColor = OpVariable %_ptr_Output_uint Output %main = OpFunction %void None %3 %5 = OpLabel %i = OpLoad %int %index %u = OpBitcast %uint %i %res0 = OpGroupNonUniformSMin %uint %uint_3 Reduce %i %res1 = OpGroupNonUniformSMax %uint %uint_3 Reduce %u %res2 = OpGroupNonUniformUMin %uint %uint_3 Reduce %i %res3 = OpGroupNonUniformUMax %uint %uint_3 Reduce %u ;%res4 = OpGroupNonUniformSMax %uint %uint_3 InclusiveScan %i ;%res5 = OpGroupNonUniformSMin %uint %uint_3 InclusiveScan %u ;%res6 = OpGroupNonUniformUMax %uint %uint_3 ExclusiveScan %i ;%res7 = OpGroupNonUniformUMin %uint %uint_3 ExclusiveScan %u ;%res8 = OpGroupNonUniformSMin %uint %uint_3 ClusteredReduce %i %uint_4 ;%res9 = OpGroupNonUniformSMax %uint %uint_3 ClusteredReduce %u %uint_4 ;%res10 = OpGroupNonUniformUMin %uint %uint_3 ClusteredReduce %i %uint_4 ;%res11 = OpGroupNonUniformUMax %uint %uint_3 ClusteredReduce %u %uint_4 OpStore %FragColor %res0 OpStore %FragColor %res1 OpStore %FragColor %res2 OpStore %FragColor %res3 ;OpStore %FragColor %res4 ;OpStore %FragColor %res5 ;OpStore %FragColor %res6 ;OpStore %FragColor %res7 ;OpStore %FragColor %res8 ;OpStore %FragColor %res9 ;OpStore %FragColor %res10 ;OpStore %FragColor %res11 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/switch-block-case-fallthrough.asm.invalid.frag000066400000000000000000000057031400026215700325650ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vIndex %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %vIndex "vIndex" OpName %FragColor "FragColor" OpName %i "i" OpName %j "j" OpDecorate %vIndex Flat OpDecorate %vIndex Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %_ptr_Input_int = OpTypePointer Input %int %vIndex = OpVariable %_ptr_Input_int Input %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Function_int = OpTypePointer Function %int %main = OpFunction %void None %3 %header = OpLabel %i = OpVariable %_ptr_Function_int Function %int_0 %j = OpVariable %_ptr_Function_int Function %9 = OpLoad %int %vIndex OpSelectionMerge %switch_merge None OpSwitch %9 %default_case 100 %default_case 0 %case_0 1 %case_1 11 %case_1 2 %case_2 3 %case_3 4 %case_4 5 %case_5 %case_0 = OpLabel OpBranch %default_case %default_case = OpLabel %default_case_phi = OpPhi %int %int_2 %header %int_3 %case_0 ; Test what happens when a case block dominates access to a variable. OpStore %j %default_case_phi OpBranch %case_1 %case_1 = OpLabel ; Test phi nodes between case labels. %case_1_phi = OpPhi %int %int_0 %default_case %int_1 %header OpStore %j %case_1_phi OpBranch %case_2 %case_2 = OpLabel OpBranch %switch_merge %case_3 = OpLabel ; Conditionally branch to another case block. This is really dumb, but it is apparently legal. %case_3_cond = OpSGreaterThan %bool %9 %int_3 OpBranchConditional %case_3_cond %case_4 %switch_merge %case_4 = OpLabel ; When emitted from case 3, we should *not* see fallthrough behavior. OpBranch %case_5 %case_5 = OpLabel OpStore %i %int_0 OpBranch %switch_merge %switch_merge = OpLabel %26 = OpLoad %int %i %27 = OpConvertSToF %float %26 %28 = OpCompositeConstruct %v4float %27 %27 %27 %27 OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/unordered-compare.asm.frag000066400000000000000000000162031400026215700267310ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 132 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %A %B %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %test_vector_ "test_vector(" OpName %test_scalar_ "test_scalar(" OpName %le "le" OpName %A "A" OpName %B "B" OpName %leq "leq" OpName %ge "ge" OpName %geq "geq" OpName %eq "eq" OpName %neq "neq" OpName %le_0 "le" OpName %leq_0 "leq" OpName %ge_0 "ge" OpName %geq_0 "geq" OpName %eq_0 "eq" OpName %neq_0 "neq" OpName %FragColor "FragColor" OpDecorate %A Location 0 OpDecorate %B Location 1 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %11 = OpTypeFunction %float %bool = OpTypeBool %v4bool = OpTypeVector %bool 4 %_ptr_Function_v4bool = OpTypePointer Function %v4bool %_ptr_Input_v4float = OpTypePointer Input %v4float %A = OpVariable %_ptr_Input_v4float Input %B = OpVariable %_ptr_Input_v4float Input %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %47 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %48 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Function_bool = OpTypePointer Function %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %128 = OpFunctionCall %v4float %test_vector_ %129 = OpFunctionCall %float %test_scalar_ %130 = OpCompositeConstruct %v4float %129 %129 %129 %129 %131 = OpFAdd %v4float %128 %130 OpStore %FragColor %131 OpReturn OpFunctionEnd %test_vector_ = OpFunction %v4float None %8 %10 = OpLabel %le = OpVariable %_ptr_Function_v4bool Function %leq = OpVariable %_ptr_Function_v4bool Function %ge = OpVariable %_ptr_Function_v4bool Function %geq = OpVariable %_ptr_Function_v4bool Function %eq = OpVariable %_ptr_Function_v4bool Function %neq = OpVariable %_ptr_Function_v4bool Function %20 = OpLoad %v4float %A %22 = OpLoad %v4float %B %23 = OpFUnordLessThan %v4bool %20 %22 OpStore %le %23 %25 = OpLoad %v4float %A %26 = OpLoad %v4float %B %27 = OpFUnordLessThanEqual %v4bool %25 %26 OpStore %leq %27 %29 = OpLoad %v4float %A %30 = OpLoad %v4float %B %31 = OpFUnordGreaterThan %v4bool %29 %30 OpStore %ge %31 %33 = OpLoad %v4float %A %34 = OpLoad %v4float %B %35 = OpFUnordGreaterThanEqual %v4bool %33 %34 OpStore %geq %35 %37 = OpLoad %v4float %A %38 = OpLoad %v4float %B %39 = OpFUnordEqual %v4bool %37 %38 OpStore %eq %39 %41 = OpLoad %v4float %A %42 = OpLoad %v4float %B %43 = OpFUnordNotEqual %v4bool %41 %42 OpStore %neq %43 %44 = OpLoad %v4bool %le %49 = OpSelect %v4float %44 %48 %47 %50 = OpLoad %v4bool %leq %51 = OpSelect %v4float %50 %48 %47 %52 = OpFAdd %v4float %49 %51 %53 = OpLoad %v4bool %ge %54 = OpSelect %v4float %53 %48 %47 %55 = OpFAdd %v4float %52 %54 %56 = OpLoad %v4bool %geq %57 = OpSelect %v4float %56 %48 %47 %58 = OpFAdd %v4float %55 %57 %59 = OpLoad %v4bool %eq %60 = OpSelect %v4float %59 %48 %47 %61 = OpFAdd %v4float %58 %60 %62 = OpLoad %v4bool %neq %63 = OpSelect %v4float %62 %48 %47 %64 = OpFAdd %v4float %61 %63 OpReturnValue %64 OpFunctionEnd %test_scalar_ = OpFunction %float None %11 %13 = OpLabel %le_0 = OpVariable %_ptr_Function_bool Function %leq_0 = OpVariable %_ptr_Function_bool Function %ge_0 = OpVariable %_ptr_Function_bool Function %geq_0 = OpVariable %_ptr_Function_bool Function %eq_0 = OpVariable %_ptr_Function_bool Function %neq_0 = OpVariable %_ptr_Function_bool Function %72 = OpAccessChain %_ptr_Input_float %A %uint_0 %73 = OpLoad %float %72 %74 = OpAccessChain %_ptr_Input_float %B %uint_0 %75 = OpLoad %float %74 %76 = OpFUnordLessThan %bool %73 %75 OpStore %le_0 %76 %78 = OpAccessChain %_ptr_Input_float %A %uint_0 %79 = OpLoad %float %78 %80 = OpAccessChain %_ptr_Input_float %B %uint_0 %81 = OpLoad %float %80 %82 = OpFUnordLessThanEqual %bool %79 %81 OpStore %leq_0 %82 %84 = OpAccessChain %_ptr_Input_float %A %uint_0 %85 = OpLoad %float %84 %86 = OpAccessChain %_ptr_Input_float %B %uint_0 %87 = OpLoad %float %86 %88 = OpFUnordGreaterThan %bool %85 %87 OpStore %ge_0 %88 %90 = OpAccessChain %_ptr_Input_float %A %uint_0 %91 = OpLoad %float %90 %92 = OpAccessChain %_ptr_Input_float %B %uint_0 %93 = OpLoad %float %92 %94 = OpFUnordGreaterThanEqual %bool %91 %93 OpStore %geq_0 %94 %96 = OpAccessChain %_ptr_Input_float %A %uint_0 %97 = OpLoad %float %96 %98 = OpAccessChain %_ptr_Input_float %B %uint_0 %99 = OpLoad %float %98 %100 = OpFUnordEqual %bool %97 %99 OpStore %eq_0 %100 %102 = OpAccessChain %_ptr_Input_float %A %uint_0 %103 = OpLoad %float %102 %104 = OpAccessChain %_ptr_Input_float %B %uint_0 %105 = OpLoad %float %104 %106 = OpFUnordNotEqual %bool %103 %105 OpStore %neq_0 %106 %107 = OpLoad %bool %le_0 %108 = OpSelect %float %107 %float_1 %float_0 %109 = OpLoad %bool %leq_0 %110 = OpSelect %float %109 %float_1 %float_0 %111 = OpFAdd %float %108 %110 %112 = OpLoad %bool %ge_0 %113 = OpSelect %float %112 %float_1 %float_0 %114 = OpFAdd %float %111 %113 %115 = OpLoad %bool %geq_0 %116 = OpSelect %float %115 %float_1 %float_0 %117 = OpFAdd %float %114 %116 %118 = OpLoad %bool %eq_0 %119 = OpSelect %float %118 %float_1 %float_0 %120 = OpFAdd %float %117 %119 %121 = OpLoad %bool %neq_0 %122 = OpSelect %float %121 %float_1 %float_0 %123 = OpFAdd %float %120 %122 OpReturnValue %123 OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/frag/vector-shuffle-undef-index.asm.frag000066400000000000000000000031661400026215700304620ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vFloat OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %vFloat "vFloat" OpName %undef "undef" OpDecorate %FragColor Location 0 OpDecorate %vFloat Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %vFloat = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %_ptr_Private_v4float = OpTypePointer Private %v4float %undef = OpUndef %v4float %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_Private_float = OpTypePointer Private %float %uint_3 = OpConstant %uint 3 %_ptr_Input_float = OpTypePointer Input %float %main = OpFunction %void None %3 %5 = OpLabel %13 = OpLoad %v4float %vFloat %26 = OpVectorShuffle %v4float %13 %undef 4 1 0xffffffff 3 %27 = OpVectorShuffle %v4float %13 %13 2 1 0xffffffff 3 %28 = OpFAdd %v4float %26 %27 OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/temporary.zero-initialize.asm.frag000066400000000000000000000067461400026215700275510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 65 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vA %vB OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %vA "vA" OpName %vB "vB" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %vA RelaxedPrecision OpDecorate %vA Flat OpDecorate %vA Location 0 OpDecorate %25 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %vB RelaxedPrecision OpDecorate %vB Flat OpDecorate %vB Location 1 OpDecorate %38 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %51 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %64 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %60 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %11 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_int = OpTypePointer Input %int %vA = OpVariable %_ptr_Input_int Input %bool = OpTypeBool %int_20 = OpConstant %int 20 %int_50 = OpConstant %int 50 %vB = OpVariable %_ptr_Input_int Input %int_40 = OpConstant %int 40 %int_60 = OpConstant %int 60 %int_10 = OpConstant %int 10 %float_1 = OpConstant %float 1 %63 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %main = OpFunction %void None %3 %5 = OpLabel OpStore %FragColor %11 OpBranch %17 %17 = OpLabel %60 = OpPhi %int %int_0 %5 %58 %20 %57 = OpPhi %int %int_0 %5 %56 %20 %25 = OpLoad %int %vA %27 = OpSLessThan %bool %57 %25 OpLoopMerge %19 %20 None OpBranchConditional %27 %18 %19 %18 = OpLabel %30 = OpIAdd %int %25 %57 %32 = OpIEqual %bool %30 %int_20 OpSelectionMerge %34 None OpBranchConditional %32 %33 %36 %33 = OpLabel OpBranch %34 %36 = OpLabel %38 = OpLoad %int %vB %40 = OpIAdd %int %38 %57 %42 = OpIEqual %bool %40 %int_40 %64 = OpSelect %int %42 %int_60 %60 OpBranch %34 %34 = OpLabel %58 = OpPhi %int %int_50 %33 %64 %36 %49 = OpIAdd %int %58 %int_10 %51 = OpLoad %v4float %FragColor %53 = OpFAdd %v4float %51 %63 OpStore %FragColor %53 OpBranch %20 %20 = OpLabel %56 = OpIAdd %int %57 %49 OpBranch %17 %19 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/vert/000077500000000000000000000000001400026215700217355ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/vert/block-struct-initializer.asm.vert000066400000000000000000000024641400026215700303610ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 13 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %foo OpSource GLSL 450 OpName %main "main" OpName %Vert "Vert" OpMemberName %Vert 0 "a" OpMemberName %Vert 1 "b" OpName %_ "" OpName %Foo "Foo" OpMemberName %Foo 0 "c" OpMemberName %Foo 1 "d" OpName %foo "foo" OpDecorate %Vert Block OpDecorate %_ Location 0 OpDecorate %foo Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Vert = OpTypeStruct %float %float %_ptr_Output_Vert = OpTypePointer Output %Vert %zero_vert = OpConstantNull %Vert %_ = OpVariable %_ptr_Output_Vert Output %zero_vert %Foo = OpTypeStruct %float %float %_ptr_Output_Foo = OpTypePointer Output %Foo %zero_foo = OpConstantNull %Foo %foo = OpVariable %_ptr_Output_Foo Output %zero_foo %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/vert/builtin-output-initializer.asm.vert000066400000000000000000000035651400026215700307540ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %zero = OpConstantNull %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %zero %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %17 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/vert/complex-link-by-name.asm.vert000066400000000000000000000124731400026215700273550ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 59 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %output_location_0 %output_location_2 %output_location_3 OpSource GLSL 450 OpName %main "main" OpName %Foo "Struct_vec4" OpMemberName %Foo 0 "m0" OpName %c "c" OpName %Foo_0 "Struct_vec4" OpMemberName %Foo_0 0 "m0" OpName %Bar "Struct_vec4" OpMemberName %Bar 0 "m0" OpName %UBO "UBO" OpMemberName %UBO 0 "m0" OpMemberName %UBO 1 "m1" OpName %ubo_binding_0 "ubo_binding_0" OpName %Bar_0 "Struct_vec4" OpMemberName %Bar_0 0 "m0" OpName %b "b" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %VertexOut "VertexOut" OpMemberName %VertexOut 0 "m0" OpMemberName %VertexOut 1 "m1" OpName %output_location_0 "output_location_0" OpName %output_location_2 "output_location_2" OpName %output_location_3 "output_location_3" OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %Bar 0 Offset 0 OpMemberDecorate %UBO 0 Offset 0 OpMemberDecorate %UBO 1 Offset 16 OpDecorate %UBO Block OpDecorate %ubo_binding_0 DescriptorSet 0 OpDecorate %ubo_binding_0 Binding 0 OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %VertexOut Block OpDecorate %output_location_0 Location 0 OpDecorate %output_location_2 Location 2 OpDecorate %output_location_3 Location 3 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Foo = OpTypeStruct %v4float %_ptr_Function_Foo = OpTypePointer Function %Foo %Foo_0 = OpTypeStruct %v4float %Bar = OpTypeStruct %v4float %UBO = OpTypeStruct %Foo_0 %Bar %_ptr_Uniform_UBO = OpTypePointer Uniform %UBO %ubo_binding_0 = OpVariable %_ptr_Uniform_UBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Function_v4float = OpTypePointer Function %v4float %Bar_0 = OpTypeStruct %v4float %_ptr_Function_Bar_0 = OpTypePointer Function %Bar_0 %int_1 = OpConstant %int 1 %_ptr_Uniform_Bar = OpTypePointer Uniform %Bar %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %_ptr_Output_v4float = OpTypePointer Output %v4float %VertexOut = OpTypeStruct %Foo %Bar_0 %_ptr_Output_VertexOut = OpTypePointer Output %VertexOut %output_location_0 = OpVariable %_ptr_Output_VertexOut Output %_ptr_Output_Foo = OpTypePointer Output %Foo %_ptr_Output_Bar_0 = OpTypePointer Output %Bar_0 %output_location_2 = OpVariable %_ptr_Output_Foo Output %output_location_3 = OpVariable %_ptr_Output_Bar_0 Output %main = OpFunction %void None %3 %5 = OpLabel %c = OpVariable %_ptr_Function_Foo Function %b = OpVariable %_ptr_Function_Bar_0 Function %19 = OpAccessChain %_ptr_Uniform_Foo_0 %ubo_binding_0 %int_0 %20 = OpLoad %Foo_0 %19 %21 = OpCompositeExtract %v4float %20 0 %23 = OpAccessChain %_ptr_Function_v4float %c %int_0 OpStore %23 %21 %29 = OpAccessChain %_ptr_Uniform_Bar %ubo_binding_0 %int_1 %30 = OpLoad %Bar %29 %31 = OpCompositeExtract %v4float %30 0 %32 = OpAccessChain %_ptr_Function_v4float %b %int_0 OpStore %32 %31 %39 = OpAccessChain %_ptr_Function_v4float %c %int_0 %40 = OpLoad %v4float %39 %41 = OpAccessChain %_ptr_Function_v4float %b %int_0 %42 = OpLoad %v4float %41 %43 = OpFAdd %v4float %40 %42 %45 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %45 %43 %49 = OpLoad %Foo %c %51 = OpAccessChain %_ptr_Output_Foo %output_location_0 %int_0 OpStore %51 %49 %52 = OpLoad %Bar_0 %b %54 = OpAccessChain %_ptr_Output_Bar_0 %output_location_0 %int_1 OpStore %54 %52 %56 = OpLoad %Foo %c OpStore %output_location_2 %56 %58 = OpLoad %Bar_0 %b OpStore %output_location_3 %58 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/asm/vert/empty-struct-composite.asm.vert000066400000000000000000000022461400026215700301020ustar00rootroot00000000000000; SPIR-V ; Version: 1.1 ; Generator: Google rspirv; 0 ; Bound: 17 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %2 "main" OpName %Test "Test" OpName %t "t" OpName %retvar "retvar" OpName %main "main" OpName %retvar_0 "retvar" %void = OpTypeVoid %6 = OpTypeFunction %void %Test = OpTypeStruct %_ptr_Function_Test = OpTypePointer Function %Test %_ptr_Function_void = OpTypePointer Function %void %2 = OpFunction %void None %6 %7 = OpLabel %t = OpVariable %_ptr_Function_Test Function %retvar = OpVariable %_ptr_Function_void Function OpBranch %4 %4 = OpLabel %13 = OpCompositeConstruct %Test OpStore %t %13 OpReturn OpFunctionEnd %main = OpFunction %void None %6 %15 = OpLabel %retvar_0 = OpVariable %_ptr_Function_void Function OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/comp/000077500000000000000000000000001400026215700211335ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/comp/bitfield.comp000066400000000000000000000015021400026215700235730ustar00rootroot00000000000000#version 310 es void main() { int signed_value = 0; uint unsigned_value = 0u; ivec3 signed_values = ivec3(0); uvec3 unsigned_values = uvec3(0u); { int s = bitfieldExtract(signed_value, 5, 20); uint u = bitfieldExtract(unsigned_value, 6, 21); s = bitfieldInsert(s, 40, 5, 4); u = bitfieldInsert(u, 60u, 5, 4); u = bitfieldReverse(u); s = bitfieldReverse(s); int v0 = bitCount(u); int v1 = bitCount(s); int v2 = findMSB(u); int v3 = findLSB(s); } { ivec3 s = bitfieldExtract(signed_values, 5, 20); uvec3 u = bitfieldExtract(unsigned_values, 6, 21); s = bitfieldInsert(s, ivec3(40), 5, 4); u = bitfieldInsert(u, uvec3(60u), 5, 4); u = bitfieldReverse(u); s = bitfieldReverse(s); ivec3 v0 = bitCount(u); ivec3 v1 = bitCount(s); ivec3 v2 = findMSB(u); ivec3 v3 = findLSB(s); } } spirv-cross-2021.01.15/shaders-hlsl-no-opt/comp/glsl.std450.fxconly.comp000066400000000000000000000046761400026215700254740ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO { float res; int ires; uint ures; vec4 f32; ivec4 s32; uvec4 u32; mat2 m2; mat3 m3; mat4 m4; }; void main() { float tmp; vec2 v2; vec3 v3; vec4 v4; int itmp; res = round(f32.x); //res = roundEven(f32.x); res = trunc(f32.x); res = abs(f32.x); ires = abs(s32.x); res = sign(f32.x); ires = sign(s32.x); res = floor(f32.x); res = ceil(f32.x); res = fract(f32.x); res = radians(f32.x); res = degrees(f32.x); res = sin(f32.x); res = cos(f32.x); res = tan(f32.x); res = asin(f32.x); res = acos(f32.x); res = atan(f32.x); res = sinh(f32.x); res = cosh(f32.x); res = tanh(f32.x); //res = asinh(f32.x); //res = acosh(f32.x); //res = atanh(f32.x); res = atan(f32.x, f32.y); res = pow(f32.x, f32.y); res = exp(f32.x); res = log(f32.x); res = exp2(f32.x); res = log2(f32.x); res = sqrt(f32.x); res = inversesqrt(f32.x); res = length(f32.x); res = distance(f32.x, f32.y); res = normalize(f32.x); res = faceforward(f32.x, f32.y, f32.z); res = reflect(f32.x, f32.y); res = refract(f32.x, f32.y, f32.z); res = length(f32.xy); res = distance(f32.xy, f32.zw); v2 = normalize(f32.xy); v2 = faceforward(f32.xy, f32.yz, f32.zw); v2 = reflect(f32.xy, f32.zw); v2 = refract(f32.xy, f32.yz, f32.w); v3 = cross(f32.xyz, f32.yzw); res = determinant(m2); res = determinant(m3); res = determinant(m4); m2 = inverse(m2); m3 = inverse(m3); m4 = inverse(m4); res = modf(f32.x, tmp); // ModfStruct res = min(f32.x, f32.y); ures = min(u32.x, u32.y); ires = min(s32.x, s32.y); res = max(f32.x, f32.y); ures = max(u32.x, u32.y); ires = max(s32.x, s32.y); res = clamp(f32.x, f32.y, f32.z); ures = clamp(u32.x, u32.y, u32.z); ires = clamp(s32.x, s32.y, s32.z); res = mix(f32.x, f32.y, f32.z); res = step(f32.x, f32.y); res = smoothstep(f32.x, f32.y, f32.z); res = fma(f32.x, f32.y, f32.z); res = frexp(f32.x, itmp); // FrexpStruct res = ldexp(f32.x, itmp); ures = packSnorm4x8(f32); ures = packUnorm4x8(f32); ures = packSnorm2x16(f32.xy); ures = packUnorm2x16(f32.xy); ures = packHalf2x16(f32.xy); // packDouble2x32 v2 = unpackSnorm2x16(u32.x); v2 = unpackUnorm2x16(u32.x); v2 = unpackHalf2x16(u32.x); v4 = unpackSnorm4x8(u32.x); v4 = unpackUnorm4x8(u32.x); // unpackDouble2x32 s32 = findLSB(s32); s32 = findLSB(u32); s32 = findMSB(s32); s32 = findMSB(u32); // interpolateAtSample // interpolateAtOffset // NMin, NMax, NClamp } spirv-cross-2021.01.15/shaders-hlsl-no-opt/comp/illegal-struct-name.asm.comp000066400000000000000000000046201400026215700264450ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 31 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Foo "Foo" OpMemberName %Foo 0 "abs" OpName %f "f" OpName %Foo_0 "Foo" OpMemberName %Foo_0 0 "abs" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "foo" OpMemberName %SSBO 1 "foo2" OpName %_ "" OpName %linear "abs" OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Foo = OpTypeStruct %float %_ptr_Function_Foo = OpTypePointer Function %Foo %Foo_0 = OpTypeStruct %float %SSBO = OpTypeStruct %Foo_0 %Foo_0 %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Function_int = OpTypePointer Function %int %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %main = OpFunction %void None %3 %5 = OpLabel %f = OpVariable %_ptr_Function_Foo Function %linear = OpVariable %_ptr_Function_int Function %17 = OpAccessChain %_ptr_Uniform_Foo_0 %_ %int_0 %18 = OpLoad %Foo_0 %17 %19 = OpCompositeExtract %float %18 0 %21 = OpAccessChain %_ptr_Function_float %f %int_0 OpStore %21 %19 OpStore %linear %int_10 %26 = OpLoad %Foo %f %27 = OpAccessChain %_ptr_Uniform_Foo_0 %_ %int_1 %28 = OpCompositeExtract %float %26 0 %30 = OpAccessChain %_ptr_Uniform_float %27 %int_0 OpStore %30 %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl-no-opt/comp/subgroups.invalid.nofxc.sm60.comp000066400000000000000000000105261400026215700273750ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_vote : require #extension GL_KHR_shader_subgroup_shuffle : require #extension GL_KHR_shader_subgroup_shuffle_relative : require #extension GL_KHR_shader_subgroup_arithmetic : require #extension GL_KHR_shader_subgroup_clustered : require #extension GL_KHR_shader_subgroup_quad : require layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float FragColor; }; void main() { // basic //FragColor = float(gl_NumSubgroups); //FragColor = float(gl_SubgroupID); FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); // ballot FragColor = float(gl_SubgroupEqMask); FragColor = float(gl_SubgroupGeMask); FragColor = float(gl_SubgroupGtMask); FragColor = float(gl_SubgroupLeMask); FragColor = float(gl_SubgroupLtMask); vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); uvec4 ballot_value = subgroupBallot(true); //bool inverse_ballot_value = subgroupInverseBallot(ballot_value); //bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); //uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); //uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); //uint lsb = subgroupBallotFindLSB(ballot_value); //uint msb = subgroupBallotFindMSB(ballot_value); // shuffle //uint shuffled = subgroupShuffle(10u, 8u); //uint shuffled_xor = subgroupShuffleXor(30u, 8u); // shuffle relative //uint shuffled_up = subgroupShuffleUp(20u, 4u); //uint shuffled_down = subgroupShuffleDown(20u, 4u); // vote bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal = subgroupAllEqual(true); // arithmetic vec4 added = subgroupAdd(vec4(20.0)); ivec4 iadded = subgroupAdd(ivec4(20)); vec4 multiplied = subgroupMul(vec4(20.0)); ivec4 imultiplied = subgroupMul(ivec4(20)); vec4 lo = subgroupMin(vec4(20.0)); vec4 hi = subgroupMax(vec4(20.0)); ivec4 slo = subgroupMin(ivec4(20)); ivec4 shi = subgroupMax(ivec4(20)); uvec4 ulo = subgroupMin(uvec4(20)); uvec4 uhi = subgroupMax(uvec4(20)); uvec4 anded = subgroupAnd(ballot_value); uvec4 ored = subgroupOr(ballot_value); uvec4 xored = subgroupXor(ballot_value); added = subgroupInclusiveAdd(added); iadded = subgroupInclusiveAdd(iadded); multiplied = subgroupInclusiveMul(multiplied); imultiplied = subgroupInclusiveMul(imultiplied); #if 0 lo = subgroupInclusiveMin(lo); hi = subgroupInclusiveMax(hi); slo = subgroupInclusiveMin(slo); shi = subgroupInclusiveMax(shi); ulo = subgroupInclusiveMin(ulo); uhi = subgroupInclusiveMax(uhi); anded = subgroupInclusiveAnd(anded); ored = subgroupInclusiveOr(ored); xored = subgroupInclusiveXor(ored); added = subgroupExclusiveAdd(lo); #endif added = subgroupExclusiveAdd(multiplied); multiplied = subgroupExclusiveMul(multiplied); iadded = subgroupExclusiveAdd(imultiplied); imultiplied = subgroupExclusiveMul(imultiplied); #if 0 lo = subgroupExclusiveMin(lo); hi = subgroupExclusiveMax(hi); ulo = subgroupExclusiveMin(ulo); uhi = subgroupExclusiveMax(uhi); slo = subgroupExclusiveMin(slo); shi = subgroupExclusiveMax(shi); anded = subgroupExclusiveAnd(anded); ored = subgroupExclusiveOr(ored); xored = subgroupExclusiveXor(ored); #endif #if 0 // clustered added = subgroupClusteredAdd(added, 4u); multiplied = subgroupClusteredMul(multiplied, 4u); iadded = subgroupClusteredAdd(iadded, 4u); imultiplied = subgroupClusteredMul(imultiplied, 4u); lo = subgroupClusteredMin(lo, 4u); hi = subgroupClusteredMax(hi, 4u); ulo = subgroupClusteredMin(ulo, 4u); uhi = subgroupClusteredMax(uhi, 4u); slo = subgroupClusteredMin(slo, 4u); shi = subgroupClusteredMax(shi, 4u); anded = subgroupClusteredAnd(anded, 4u); ored = subgroupClusteredOr(ored, 4u); xored = subgroupClusteredXor(xored, 4u); #endif // quad vec4 swap_horiz = subgroupQuadSwapHorizontal(vec4(20.0)); vec4 swap_vertical = subgroupQuadSwapVertical(vec4(20.0)); vec4 swap_diagonal = subgroupQuadSwapDiagonal(vec4(20.0)); vec4 quad_broadcast = subgroupQuadBroadcast(vec4(20.0), 3u); } spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/000077500000000000000000000000001400026215700211145ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/cbuffer-packing-straddle.frag000066400000000000000000000010151400026215700266000ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform UBO { vec4 a[2]; // 0 vec4 b; // 32 vec4 c; // 48 mat4x4 d; // 64 float e; // 128 vec2 f; // 136 float g; // 144 vec2 h; // 152 float i; // 160 vec2 j; // 168 float k; vec2 l; float m; float n; float o; vec4 p; vec4 q; vec3 r; vec4 s; vec4 t; vec4 u; float v; float w; float x; float y; float z; float aa; float ab; float ac; float ad; float ae; vec4 ef; }; layout(location = 0) out vec4 FragColor; void main() { FragColor = a[1]; } spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/constant-buffer-array.invalid.sm51.frag000066400000000000000000000007041400026215700304030ustar00rootroot00000000000000#version 450 layout(std140, binding = 4) uniform CBO { vec4 a; vec4 b; vec4 c; vec4 d; } cbo[2][4]; layout(std430, push_constant) uniform PushMe { vec4 a; vec4 b; vec4 c; vec4 d; } push; layout(location = 0) out vec4 FragColor; void main() { FragColor = cbo[1][2].a; FragColor += cbo[1][2].b; FragColor += cbo[1][2].c; FragColor += cbo[1][2].d; FragColor += push.a; FragColor += push.b; FragColor += push.c; FragColor += push.d; } spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/fp16.invalid.desktop.frag000066400000000000000000000063371400026215700256370ustar00rootroot00000000000000#version 450 #extension GL_AMD_gpu_shader_half_float : require layout(location = 0) in float16_t v1; layout(location = 1) in f16vec2 v2; layout(location = 2) in f16vec3 v3; layout(location = 3) in f16vec4 v4; layout(location = 0) out float o1; layout(location = 1) out vec2 o2; layout(location = 2) out vec3 o3; layout(location = 3) out vec4 o4; #if 0 // Doesn't work on glslang yet. f16mat2 test_mat2(f16vec2 a, f16vec2 b, f16vec2 c, f16vec2 d) { return f16mat2(a, b) * f16mat2(c, d); } f16mat3 test_mat3(f16vec3 a, f16vec3 b, f16vec3 c, f16vec3 d, f16vec3 e, f16vec3 f) { return f16mat3(a, b, c) * f16mat3(d, e, f); } #endif void test_constants() { float16_t a = 1.0hf; float16_t b = 1.5hf; float16_t c = -1.5hf; // Negatives float16_t d = (0.0hf / 0.0hf); // NaN float16_t e = (1.0hf / 0.0hf); // +Inf float16_t f = (-1.0hf / 0.0hf); // -Inf float16_t g = 1014.0hf; // Large. float16_t h = 0.000001hf; // Denormal } float16_t test_result() { return 1.0hf; } void test_conversions() { float16_t one = test_result(); int a = int(one); uint b = uint(one); bool c = bool(one); float d = float(one); double e = double(one); float16_t a2 = float16_t(a); float16_t b2 = float16_t(b); float16_t c2 = float16_t(c); float16_t d2 = float16_t(d); float16_t e2 = float16_t(e); } void test_builtins() { f16vec4 res; res = radians(v4); res = degrees(v4); res = sin(v4); res = cos(v4); res = tan(v4); res = asin(v4); res = atan(v4, v3.xyzz); res = atan(v4); res = sinh(v4); res = cosh(v4); res = tanh(v4); //res = asinh(v4); //res = acosh(v4); //res = atanh(v4); res = pow(v4, v4); res = exp(v4); res = log(v4); res = exp2(v4); res = log2(v4); res = sqrt(v4); res = inversesqrt(v4); res = abs(v4); res = sign(v4); res = floor(v4); res = trunc(v4); res = round(v4); //res = roundEven(v4); res = ceil(v4); res = fract(v4); res = mod(v4, v4); f16vec4 tmp; res = modf(v4, tmp); res = min(v4, v4); res = max(v4, v4); res = clamp(v4, v4, v4); res = mix(v4, v4, v4); res = mix(v4, v4, lessThan(v4, v4)); res = step(v4, v4); res = smoothstep(v4, v4, v4); bvec4 btmp = isnan(v4); btmp = isinf(v4); res = fma(v4, v4, v4); //ivec4 itmp; //res = frexp(v4, itmp); //res = ldexp(res, itmp); uint pack0 = packFloat2x16(v4.xy); uint pack1 = packFloat2x16(v4.zw); res = f16vec4(unpackFloat2x16(pack0), unpackFloat2x16(pack1)); float16_t t0 = length(v4); t0 = distance(v4, v4); t0 = dot(v4, v4); f16vec3 res3 = cross(v3, v3); res = normalize(v4); res = faceforward(v4, v4, v4); res = reflect(v4, v4); res = refract(v4, v4, v1); btmp = lessThan(v4, v4); btmp = lessThanEqual(v4, v4); btmp = greaterThan(v4, v4); btmp = greaterThanEqual(v4, v4); btmp = equal(v4, v4); btmp = notEqual(v4, v4); res = dFdx(v4); res = dFdy(v4); res = dFdxFine(v4); res = dFdyFine(v4); res = dFdxCoarse(v4); res = dFdyCoarse(v4); res = fwidth(v4); res = fwidthFine(v4); res = fwidthCoarse(v4); //res = interpolateAtCentroid(v4); //res = interpolateAtSample(v4, 0); //res = interpolateAtOffset(v4, f16vec2(0.1hf)); } void main() { // Basic matrix tests. #if 0 f16mat2 m0 = test_mat2(v2, v2, v3.xy, v3.xy); f16mat3 m1 = test_mat3(v3, v3, v3, v4.xyz, v4.xyz, v4.yzw); #endif test_constants(); test_conversions(); test_builtins(); } spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/frag-coord.frag000066400000000000000000000001701400026215700237760ustar00rootroot00000000000000#version 450 layout(location = 0) out vec3 FragColor; void main() { FragColor = gl_FragCoord.xyz / gl_FragCoord.w; } native-16bit-types.fxconly.nofxc.sm62.native-16bit.frag000066400000000000000000000034631400026215700330520ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag#version 450 #extension GL_EXT_shader_explicit_arithmetic_types : require layout(location = 0) out f16vec4 Output; layout(location = 0) in f16vec4 Input; layout(location = 1) out i16vec4 OutputI; layout(location = 1) flat in i16vec4 InputI; layout(location = 2) out u16vec4 OutputU; layout(location = 2) flat in u16vec4 InputU; layout(set = 0, binding = 0) buffer Buf { float16_t foo0[4]; int16_t foo1[4]; uint16_t foo2[4]; f16vec4 foo3[4]; i16vec4 foo4[4]; u16vec4 foo5[4]; f16mat2x3 foo6[4]; layout(row_major) f16mat2x3 foo7[4]; }; void main() { int index = int(gl_FragCoord.x); Output = Input + float16_t(20.0); OutputI = InputI + int16_t(-40); OutputU = InputU + uint16_t(20); // Load 16-bit scalar. Output += foo0[index]; OutputI += foo1[index]; OutputU += foo2[index]; // Load 16-bit vector. Output += foo3[index]; OutputI += foo4[index]; OutputU += foo5[index]; // Load 16-bit vector from ColMajor matrix. Output += foo6[index][1].xyzz; // Load 16-bit vector from RowMajor matrix. Output += foo7[index][1].xyzz; // Load 16-bit matrix from ColMajor. f16mat2x3 m0 = foo6[index]; // Load 16-bit matrix from RowMajor. f16mat2x3 m1 = foo7[index]; // Store 16-bit scalar foo0[index] = Output.x; foo1[index] = OutputI.y; foo2[index] = OutputU.z; // Store 16-bit vector foo3[index] = Output; foo4[index] = OutputI; foo5[index] = OutputU; // Store 16-bit vector to ColMajor matrix. foo6[index][1] = Output.xyz; // Store 16-bit vector to RowMajor matrix. foo7[index][1] = Output.xyz; // Store 16-bit matrix to ColMajor. foo6[index] = f16mat2x3(Output.xyz, Output.wzy); // Store 16-bit matrix to RowMajor. foo7[index] = f16mat2x3(Output.xyz, Output.wzy); } spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/nonuniform-constructor.sm51.nonuniformresource.frag000066400000000000000000000005721400026215700332630ustar00rootroot00000000000000#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; layout(location = 1) flat in int vIndex; layout(set = 0, binding = 0) uniform texture2D uTex[]; layout(set = 1, binding = 0) uniform sampler Immut; void main() { FragColor = texture(nonuniformEXT(sampler2D(uTex[vIndex], Immut)), vUV); } spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/pixel-interlock-simple-callstack.sm51.fxconly.frag000066400000000000000000000007161400026215700325650ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(set = 0, binding = 0, std430) buffer SSBO0 { uint values0[]; }; layout(set = 0, binding = 1, std430) buffer SSBO1 { uint values1[]; }; void callee2() { values1[int(gl_FragCoord.x)] += 1; } void callee() { values0[int(gl_FragCoord.x)] += 1; callee2(); } void main() { beginInvocationInterlockARB(); callee(); endInvocationInterlockARB(); } spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/spec-constant.frag000066400000000000000000000045721400026215700245460ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(constant_id = 1) const float a = 1.0; layout(constant_id = 2) const float b = 2.0; layout(constant_id = 3) const int c = 3; layout(constant_id = 4) const int d = 4; layout(constant_id = 5) const uint e = 5u; layout(constant_id = 6) const uint f = 6u; layout(constant_id = 7) const bool g = false; layout(constant_id = 8) const bool h = true; // glslang doesn't seem to support partial spec constants or composites yet, so only test the basics. struct Foo { float elems[d + 2]; }; void main() { float t0 = a; float t1 = b; uint c0 = uint(c); // OpIAdd with different types. // FConvert, float-to-double. int c1 = -c; // SNegate int c2 = ~c; // OpNot int c3 = c + d; // OpIAdd int c4 = c - d; // OpISub int c5 = c * d; // OpIMul int c6 = c / d; // OpSDiv uint c7 = e / f; // OpUDiv int c8 = c % d; // OpSMod uint c9 = e % f; // OpUMod // TODO: OpSRem, any way to access this in GLSL? int c10 = c >> d; // OpShiftRightArithmetic uint c11 = e >> f; // OpShiftRightLogical int c12 = c << d; // OpShiftLeftLogical int c13 = c | d; // OpBitwiseOr int c14 = c ^ d; // OpBitwiseXor int c15 = c & d; // OpBitwiseAnd // VectorShuffle, CompositeExtract, CompositeInsert, not testable atm. bool c16 = g || h; // OpLogicalOr bool c17 = g && h; // OpLogicalAnd bool c18 = !g; // OpLogicalNot bool c19 = g == h; // OpLogicalEqual bool c20 = g != h; // OpLogicalNotEqual // OpSelect not testable atm. bool c21 = c == d; // OpIEqual bool c22 = c != d; // OpINotEqual bool c23 = c < d; // OpSLessThan bool c24 = e < f; // OpULessThan bool c25 = c > d; // OpSGreaterThan bool c26 = e > f; // OpUGreaterThan bool c27 = c <= d; // OpSLessThanEqual bool c28 = e <= f; // OpULessThanEqual bool c29 = c >= d; // OpSGreaterThanEqual bool c30 = e >= f; // OpUGreaterThanEqual // OpQuantizeToF16 not testable atm. int c31 = c8 + c3; int c32 = int(e); // OpIAdd with different types. bool c33 = bool(c); // int -> bool bool c34 = bool(e); // uint -> bool int c35 = int(g); // bool -> int uint c36 = uint(g); // bool -> uint float c37 = float(g); // bool -> float // Flexible sized arrays with spec constants and spec constant ops. float vec0[c + 3][8]; float vec1[c + 2]; vec0[0][0] = 10.0; vec1[0] = 20.0; Foo foo; foo.elems[c] = 10.0; FragColor = vec4(t0 + t1) + vec0[0][0] + vec1[0] + foo.elems[c]; } spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/ubo-offset-out-of-order.frag000066400000000000000000000003631400026215700263500ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 0) uniform UBO { layout(offset = 16) mat4 m; layout(offset = 0) vec4 v; }; layout(location = 0) in vec4 vColor; void main() { FragColor = m * vColor + v; } spirv-cross-2021.01.15/shaders-hlsl-no-opt/frag/variables.zero-initialize.frag000066400000000000000000000005221400026215700270410ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 vColor; layout(location = 0) out vec4 FragColor; int uninit_int; ivec4 uninit_vector; mat4 uninit_matrix; struct Foo { int a; }; Foo uninit_foo; void main() { int uninit_function_int; if (vColor.x > 10.0) uninit_function_int = 10; else uninit_function_int = 20; FragColor = vColor; } spirv-cross-2021.01.15/shaders-hlsl-no-opt/vert/000077500000000000000000000000001400026215700211555ustar00rootroot00000000000000flatten-matrix-input.flatten-matrix-vertex-input.vert000066400000000000000000000003671400026215700335100ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl-no-opt/vert#version 450 layout(location = 0) in mat4 m4; layout(location = 4) in mat3 m3; layout(location = 7) in mat2 m2; layout(location = 9) in vec4 v; void main() { gl_Position = m4 * v; gl_Position.xyz += m3 * v.xyz; gl_Position.xy += m2 * v.xy; } spirv-cross-2021.01.15/shaders-hlsl-no-opt/vert/pass-array-by-value.vert000066400000000000000000000011461400026215700256650ustar00rootroot00000000000000#version 310 es layout(location = 0) in int Index1; layout(location = 1) in int Index2; vec4 consume_constant_arrays2(const vec4 positions[4], const vec4 positions2[4]) { return positions[Index1] + positions2[Index2]; } vec4 consume_constant_arrays(const vec4 positions[4], const vec4 positions2[4]) { return consume_constant_arrays2(positions, positions2); } const vec4 LUT1[] = vec4[](vec4(0.0), vec4(1.0), vec4(2.0), vec4(3.0)); void main() { vec4 LUT2[4]; LUT2[0] = vec4(10.0); LUT2[1] = vec4(11.0); LUT2[2] = vec4(12.0); LUT2[3] = vec4(13.0); gl_Position = consume_constant_arrays(LUT1, LUT2); } spirv-cross-2021.01.15/shaders-hlsl/000077500000000000000000000000001400026215700167635ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl/asm/000077500000000000000000000000001400026215700175435ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl/asm/comp/000077500000000000000000000000001400026215700205015ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl/asm/comp/access-chain-invalidate.asm.comp000066400000000000000000000044671400026215700266120ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google Shaderc over Glslang; 7 ; Bound: 41 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "index" OpMemberName %SSBO 1 "array" OpName %_ "" OpDecorate %_arr_uint_uint_64 ArrayStride 4 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_64 = OpConstant %uint 64 %_arr_uint_uint_64 = OpTypeArray %uint %uint_64 %SSBO = OpTypeStruct %uint %_arr_uint_uint_64 %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %19 = OpLoad %uint %18 %20 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %19 %21 = OpLoad %uint %20 OpBranch %24 %24 = OpLabel %40 = OpPhi %uint %uint_0 %5 %35 %25 %31 = OpULessThan %bool %40 %uint_64 OpLoopMerge %26 %25 None OpBranchConditional %31 %25 %26 %25 = OpLabel %33 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %40 OpStore %33 %uint_0 %35 = OpIAdd %uint %40 %int_1 OpBranch %24 %26 = OpLabel %37 = OpLoad %uint %18 %39 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %37 OpStore %39 %21 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/comp/atomic-decrement.asm.comp000066400000000000000000000050431400026215700253620ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "main" %15 OpExecutionMode %3 LocalSize 4 1 1 OpName %3 "main" OpName %8 "u0" OpName %9 "u0_counters" OpMemberName %9 0 "c" OpName %11 "u0_counter" OpName %15 "vThreadID" OpName %19 "r0" OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 1 OpDecorate %11 Binding 1 OpDecorate %15 BuiltIn GlobalInvocationId %1 = OpTypeVoid %2 = OpTypeFunction %1 %5 = OpTypeInt 32 0 %6 = OpTypeImage %5 Buffer 0 0 0 2 R32ui %7 = OpTypePointer UniformConstant %6 %8 = OpVariable %7 UniformConstant %9 = OpTypeStruct %5 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpTypeVector %12 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpTypeFloat 32 %17 = OpTypeVector %16 4 %18 = OpTypePointer Function %17 %20 = OpTypePointer Uniform %5 %21 = OpConstant %5 0 %23 = OpConstant %5 1 %26 = OpTypePointer Function %16 %33 = OpConstant %12 0 %34 = OpConstant %5 2 %37 = OpTypePointer Input %12 %41 = OpTypeVector %5 4 %3 = OpFunction %1 None %2 %4 = OpLabel %19 = OpVariable %18 Function %22 = OpAccessChain %20 %11 %21 %24 = OpAtomicIDecrement %5 %22 %23 %21 %25 = OpBitcast %16 %24 %27 = OpInBoundsAccessChain %26 %19 %21 OpStore %27 %25 %28 = OpLoad %6 %8 %29 = OpInBoundsAccessChain %26 %19 %21 %30 = OpLoad %16 %29 %31 = OpBitcast %12 %30 %32 = OpIMul %5 %31 %23 %35 = OpShiftRightLogical %5 %33 %34 %36 = OpIAdd %5 %32 %35 %38 = OpInBoundsAccessChain %37 %15 %21 %39 = OpLoad %12 %38 %40 = OpBitcast %5 %39 %42 = OpCompositeConstruct %41 %40 %40 %40 %40 OpImageWrite %28 %36 %42 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/comp/atomic-increment.asm.comp000066400000000000000000000050431400026215700254000ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "main" %15 OpExecutionMode %3 LocalSize 4 1 1 OpName %3 "main" OpName %8 "u0" OpName %9 "u0_counters" OpMemberName %9 0 "c" OpName %11 "u0_counter" OpName %15 "vThreadID" OpName %19 "r0" OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 1 OpDecorate %11 Binding 1 OpDecorate %15 BuiltIn GlobalInvocationId %1 = OpTypeVoid %2 = OpTypeFunction %1 %5 = OpTypeInt 32 0 %6 = OpTypeImage %5 Buffer 0 0 0 2 R32ui %7 = OpTypePointer UniformConstant %6 %8 = OpVariable %7 UniformConstant %9 = OpTypeStruct %5 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpTypeVector %12 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpTypeFloat 32 %17 = OpTypeVector %16 4 %18 = OpTypePointer Function %17 %20 = OpTypePointer Uniform %5 %21 = OpConstant %5 0 %23 = OpConstant %5 1 %26 = OpTypePointer Function %16 %33 = OpConstant %12 0 %34 = OpConstant %5 2 %37 = OpTypePointer Input %12 %41 = OpTypeVector %5 4 %3 = OpFunction %1 None %2 %4 = OpLabel %19 = OpVariable %18 Function %22 = OpAccessChain %20 %11 %21 %24 = OpAtomicIIncrement %5 %22 %23 %21 %25 = OpBitcast %16 %24 %27 = OpInBoundsAccessChain %26 %19 %21 OpStore %27 %25 %28 = OpLoad %6 %8 %29 = OpInBoundsAccessChain %26 %19 %21 %30 = OpLoad %16 %29 %31 = OpBitcast %12 %30 %32 = OpIMul %5 %31 %23 %35 = OpShiftRightLogical %5 %33 %34 %36 = OpIAdd %5 %32 %35 %38 = OpInBoundsAccessChain %37 %15 %21 %39 = OpLoad %12 %38 %40 = OpBitcast %5 %39 %42 = OpCompositeConstruct %41 %40 %40 %40 %40 OpImageWrite %28 %36 %42 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/comp/bitcast_icmp.asm.comp000066400000000000000000000072541400026215700246110ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %inputs Restrict OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 OpDecorate %outputs Restrict %void = OpTypeVoid %main_func = OpTypeFunction %void %bool = OpTypeBool %bvec4 = OpTypeVector %bool 4 %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %uzero = OpConstant %uint 0 %uone = OpConstant %uint 1 %utrue = OpConstantComposite %uvec4 %uone %uone %uone %uone %ufalse = OpConstantComposite %uvec4 %uzero %uzero %uzero %uzero %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %result_slt = OpSLessThan %bvec4 %input0 %input1 %result_sle = OpSLessThanEqual %bvec4 %input0 %input1 %result_ult = OpULessThan %bvec4 %input0 %input1 %result_ule = OpULessThanEqual %bvec4 %input0 %input1 %result_sgt = OpSGreaterThan %bvec4 %input0 %input1 %result_sge = OpSGreaterThanEqual %bvec4 %input0 %input1 %result_ugt = OpUGreaterThan %bvec4 %input0 %input1 %result_uge = OpUGreaterThanEqual %bvec4 %input0 %input1 %int_slt = OpSelect %uvec4 %result_slt %utrue %ufalse OpStore %output_ptr_uvec4 %int_slt %int_sle = OpSelect %uvec4 %result_sle %utrue %ufalse OpStore %output_ptr_uvec4 %int_sle %int_ult = OpSelect %uvec4 %result_ult %utrue %ufalse OpStore %output_ptr_uvec4 %int_ult %int_ule = OpSelect %uvec4 %result_ule %utrue %ufalse OpStore %output_ptr_uvec4 %int_ule %int_sgt = OpSelect %uvec4 %result_sgt %utrue %ufalse OpStore %output_ptr_uvec4 %int_sgt %int_sge = OpSelect %uvec4 %result_sge %utrue %ufalse OpStore %output_ptr_uvec4 %int_sge %int_ugt = OpSelect %uvec4 %result_ugt %utrue %ufalse OpStore %output_ptr_uvec4 %int_ugt %int_uge = OpSelect %uvec4 %result_uge %utrue %ufalse OpStore %output_ptr_uvec4 %int_uge OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/comp/block-name-alias-global.asm.comp000066400000000000000000000120731400026215700265000ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 59 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Foo "A" OpMemberName %Foo 0 "a" OpMemberName %Foo 1 "b" OpName %A "A" OpMemberName %A 0 "Data" OpName %C1 "C1" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpName %Foo_0 "A" OpMemberName %Foo_0 0 "a" OpMemberName %Foo_0 1 "b" OpName %A_0 "A" OpMemberName %A_0 0 "Data" OpName %C2 "C2" OpName %B "B" OpMemberName %B 0 "Data" OpName %C3 "C3" OpName %B_0 "B" OpMemberName %B_0 0 "Data" OpName %C4 "C4" OpMemberDecorate %Foo 0 Offset 0 OpMemberDecorate %Foo 1 Offset 4 OpDecorate %_runtimearr_Foo ArrayStride 8 OpMemberDecorate %A 0 Offset 0 OpDecorate %A BufferBlock OpDecorate %C1 DescriptorSet 0 OpDecorate %C1 Binding 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %Foo_0 1 Offset 4 OpDecorate %_arr_Foo_0_uint_1024 ArrayStride 16 OpMemberDecorate %A_0 0 Offset 0 OpDecorate %A_0 Block OpDecorate %C2 DescriptorSet 0 OpDecorate %C2 Binding 2 OpDecorate %_runtimearr_Foo_0 ArrayStride 8 OpMemberDecorate %B 0 Offset 0 OpDecorate %B BufferBlock OpDecorate %C3 DescriptorSet 0 OpDecorate %C3 Binding 0 OpDecorate %_arr_Foo_0_uint_1024_0 ArrayStride 16 OpMemberDecorate %B_0 0 Offset 0 OpDecorate %B_0 Block OpDecorate %C4 DescriptorSet 0 OpDecorate %C4 Binding 3 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %Foo = OpTypeStruct %int %int %_runtimearr_Foo = OpTypeRuntimeArray %Foo %A = OpTypeStruct %_runtimearr_Foo %_ptr_Uniform_A = OpTypePointer Uniform %A %C1 = OpVariable %_ptr_Uniform_A Uniform %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %Foo_0 = OpTypeStruct %int %int %uint_1024 = OpConstant %uint 1024 %_arr_Foo_0_uint_1024 = OpTypeArray %Foo_0 %uint_1024 %A_0 = OpTypeStruct %_arr_Foo_0_uint_1024 %_ptr_Uniform_A_0 = OpTypePointer Uniform %A_0 %C2 = OpVariable %_ptr_Uniform_A_0 Uniform %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Uniform_Foo = OpTypePointer Uniform %Foo %_ptr_Uniform_int = OpTypePointer Uniform %int %int_1 = OpConstant %int 1 %_runtimearr_Foo_0 = OpTypeRuntimeArray %Foo %B = OpTypeStruct %_runtimearr_Foo_0 %_ptr_Uniform_B = OpTypePointer Uniform %B %C3 = OpVariable %_ptr_Uniform_B Uniform %_arr_Foo_0_uint_1024_0 = OpTypeArray %Foo_0 %uint_1024 %B_0 = OpTypeStruct %_arr_Foo_0_uint_1024_0 %_ptr_Uniform_B_0 = OpTypePointer Uniform %B_0 %C4 = OpVariable %_ptr_Uniform_B_0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %20 = OpLoad %uint %19 %27 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %28 = OpLoad %uint %27 %30 = OpAccessChain %_ptr_Uniform_Foo_0 %C2 %int_0 %28 %31 = OpLoad %Foo_0 %30 %33 = OpAccessChain %_ptr_Uniform_Foo %C1 %int_0 %20 %34 = OpCompositeExtract %int %31 0 %36 = OpAccessChain %_ptr_Uniform_int %33 %int_0 OpStore %36 %34 %37 = OpCompositeExtract %int %31 1 %39 = OpAccessChain %_ptr_Uniform_int %33 %int_1 OpStore %39 %37 %44 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %45 = OpLoad %uint %44 %50 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %51 = OpLoad %uint %50 %52 = OpAccessChain %_ptr_Uniform_Foo_0 %C4 %int_0 %51 %53 = OpLoad %Foo_0 %52 %54 = OpAccessChain %_ptr_Uniform_Foo %C3 %int_0 %45 %55 = OpCompositeExtract %int %53 0 %56 = OpAccessChain %_ptr_Uniform_int %54 %int_0 OpStore %56 %55 %57 = OpCompositeExtract %int %53 1 %58 = OpAccessChain %_ptr_Uniform_int %54 %int_1 OpStore %58 %57 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/comp/control-flow-hints.asm.comp000066400000000000000000000126501400026215700257140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 85 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %i "i" OpName %bar "bar" OpMemberName %bar 0 "@data" OpName %bar_0 "bar" OpName %foo "foo" OpName %i_0 "i" OpName %v "v" OpName %w "w" OpName %value "value" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %bar 0 Offset 0 OpDecorate %bar BufferBlock OpDecorate %bar_0 DescriptorSet 0 OpDecorate %bar_0 Binding 0 OpDecorate %foo DescriptorSet 0 OpDecorate %foo Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %bool = OpTypeBool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %bar = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_bar = OpTypePointer Uniform %bar %bar_0 = OpVariable %_ptr_Uniform_bar Uniform %foo = OpVariable %_ptr_Uniform_bar Uniform %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_1 = OpConstant %int 1 %int_15 = OpConstant %int 15 %_ptr_Function_float = OpTypePointer Function %float %int_10 = OpConstant %int 10 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %float_10 = OpConstant %float 10 %int_20 = OpConstant %int 20 %float_5 = OpConstant %float 5 %72 = OpConstantComposite %v4float %float_5 %float_5 %float_5 %float_5 %float_20 = OpConstant %float 20 %float_40 = OpConstant %float 40 %main = OpFunction %void None %3 %5 = OpLabel %84 = OpFunctionCall %void %_main_ OpReturn OpFunctionEnd %_main_ = OpFunction %void None %3 %7 = OpLabel %i = OpVariable %_ptr_Function_int Function %i_0 = OpVariable %_ptr_Function_int Function %v = OpVariable %_ptr_Function_float Function %w = OpVariable %_ptr_Function_float Function %value = OpVariable %_ptr_Function_float Function OpStore %i %int_0 OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 Unroll OpBranch %16 %16 = OpLabel %17 = OpLoad %int %i %20 = OpSLessThan %bool %17 %int_16 OpBranchConditional %20 %13 %14 %13 = OpLabel %27 = OpLoad %int %i %29 = OpLoad %int %i %31 = OpAccessChain %_ptr_Uniform_v4float %foo %int_0 %29 %32 = OpLoad %v4float %31 %33 = OpAccessChain %_ptr_Uniform_v4float %bar_0 %int_0 %27 OpStore %33 %32 OpBranch %15 %15 = OpLabel %34 = OpLoad %int %i %36 = OpIAdd %int %34 %int_1 OpStore %i %36 OpBranch %12 %14 = OpLabel OpStore %i_0 %int_0 OpBranch %38 %38 = OpLabel OpLoopMerge %40 %41 DontUnroll OpBranch %42 %42 = OpLabel %43 = OpLoad %int %i_0 %44 = OpSLessThan %bool %43 %int_16 OpBranchConditional %44 %39 %40 %39 = OpLabel %46 = OpLoad %int %i_0 %47 = OpISub %int %int_15 %46 %48 = OpLoad %int %i_0 %49 = OpAccessChain %_ptr_Uniform_v4float %foo %int_0 %48 %50 = OpLoad %v4float %49 %51 = OpAccessChain %_ptr_Uniform_v4float %bar_0 %int_0 %47 OpStore %51 %50 OpBranch %41 %41 = OpLabel %52 = OpLoad %int %i_0 %53 = OpIAdd %int %52 %int_1 OpStore %i_0 %53 OpBranch %38 %40 = OpLabel %60 = OpAccessChain %_ptr_Uniform_float %bar_0 %int_0 %int_10 %uint_0 %61 = OpLoad %float %60 OpStore %v %61 %63 = OpAccessChain %_ptr_Uniform_float %foo %int_0 %int_10 %uint_0 %64 = OpLoad %float %63 OpStore %w %64 %65 = OpLoad %float %v %67 = OpFOrdGreaterThan %bool %65 %float_10 OpSelectionMerge %69 DontFlatten OpBranchConditional %67 %68 %69 %68 = OpLabel %73 = OpAccessChain %_ptr_Uniform_v4float %foo %int_0 %int_20 OpStore %73 %72 OpBranch %69 %69 = OpLabel OpStore %value %float_20 %76 = OpLoad %float %w %78 = OpFOrdGreaterThan %bool %76 %float_40 OpSelectionMerge %80 Flatten OpBranchConditional %78 %79 %80 %79 = OpLabel OpStore %value %float_20 OpBranch %80 %80 = OpLabel %81 = OpLoad %float %value %82 = OpCompositeConstruct %v4float %81 %81 %81 %81 %83 = OpAccessChain %_ptr_Uniform_v4float %foo %int_0 %int_20 OpStore %83 %82 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/comp/global-parameter-name-alias.asm.comp000066400000000000000000000101621400026215700273630ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 61 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %id_1 OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 500 OpName %main "main" OpName %Load_u1_ "Load(u1;" OpName %size "size" OpName %_main_vu3_ "@main(vu3;" OpName %id "id" OpName %data "data" OpName %byteAddrTemp "byteAddrTemp" OpName %ssbo "ssbo" OpMemberName %ssbo 0 "@data" OpName %ssbo_0 "ssbo" OpName %param "param" OpName %id_0 "id" OpName %id_1 "id" OpName %param_0 "param" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %ssbo 0 NonWritable OpMemberDecorate %ssbo 0 Offset 0 OpDecorate %ssbo BufferBlock OpDecorate %ssbo_0 DescriptorSet 0 OpDecorate %ssbo_0 Binding 1 OpDecorate %id_1 BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %8 = OpTypeFunction %void %_ptr_Function_uint %v3uint = OpTypeVector %uint 3 %_ptr_Function_v3uint = OpTypePointer Function %v3uint %14 = OpTypeFunction %void %_ptr_Function_v3uint %v4uint = OpTypeVector %uint 4 %_ptr_Function_v4uint = OpTypePointer Function %v4uint %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_2 = OpConstant %int 2 %_runtimearr_uint = OpTypeRuntimeArray %uint %ssbo = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_ssbo = OpTypePointer Uniform %ssbo %ssbo_0 = OpVariable %_ptr_Uniform_ssbo Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %uint_4 = OpConstant %uint 4 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %id_1 = OpVariable %_ptr_Input_v3uint Input %main = OpFunction %void None %3 %5 = OpLabel %id_0 = OpVariable %_ptr_Function_v3uint Function %param_0 = OpVariable %_ptr_Function_v3uint Function %57 = OpLoad %v3uint %id_1 OpStore %id_0 %57 %59 = OpLoad %v3uint %id_0 OpStore %param_0 %59 %60 = OpFunctionCall %void %_main_vu3_ %param_0 OpReturn OpFunctionEnd %Load_u1_ = OpFunction %void None %8 %size = OpFunctionParameter %_ptr_Function_uint %11 = OpLabel %data = OpVariable %_ptr_Function_v4uint Function %byteAddrTemp = OpVariable %_ptr_Function_int Function %24 = OpLoad %uint %size %26 = OpShiftRightLogical %int %24 %int_2 OpStore %byteAddrTemp %26 %32 = OpLoad %int %byteAddrTemp %34 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %32 %35 = OpLoad %uint %34 %36 = OpLoad %int %byteAddrTemp %38 = OpIAdd %int %36 %int_1 %39 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpLoad %int %byteAddrTemp %42 = OpIAdd %int %41 %int_2 %43 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %42 %44 = OpLoad %uint %43 %45 = OpLoad %int %byteAddrTemp %47 = OpIAdd %int %45 %int_3 %48 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %47 %49 = OpLoad %uint %48 %50 = OpCompositeConstruct %v4uint %35 %40 %44 %49 OpStore %data %50 OpReturn OpFunctionEnd %_main_vu3_ = OpFunction %void None %14 %id = OpFunctionParameter %_ptr_Function_v3uint %17 = OpLabel %param = OpVariable %_ptr_Function_uint Function OpStore %param %uint_4 %53 = OpFunctionCall %void %Load_u1_ %param OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/comp/nmin-max-clamp.asm.comp000066400000000000000000000212161400026215700247600ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 139 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a1" OpMemberName %SSBO 1 "a2" OpMemberName %SSBO 2 "a3" OpMemberName %SSBO 3 "a4" OpMemberName %SSBO 4 "b1" OpMemberName %SSBO 5 "b2" OpMemberName %SSBO 6 "b3" OpMemberName %SSBO 7 "b4" OpMemberName %SSBO 8 "c1" OpMemberName %SSBO 9 "c2" OpMemberName %SSBO 10 "c3" OpMemberName %SSBO 11 "c4" OpName %_ "" OpName %i "i" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 8 OpMemberDecorate %SSBO 2 Offset 16 OpMemberDecorate %SSBO 3 Offset 32 OpMemberDecorate %SSBO 4 Offset 48 OpMemberDecorate %SSBO 5 Offset 56 OpMemberDecorate %SSBO 6 Offset 64 OpMemberDecorate %SSBO 7 Offset 80 OpMemberDecorate %SSBO 8 Offset 96 OpMemberDecorate %SSBO 9 Offset 104 OpMemberDecorate %SSBO 10 Offset 112 OpMemberDecorate %SSBO 11 Offset 128 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %SSBO = OpTypeStruct %float %v2float %v3float %v4float %float %v2float %v3float %v4float %float %v2float %v3float %v4float %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %_ptr_Uniform_float = OpTypePointer Uniform %float %int_8 = OpConstant %int 8 %int_1 = OpConstant %int 1 %int_5 = OpConstant %int 5 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %int_9 = OpConstant %int 9 %int_2 = OpConstant %int 2 %int_6 = OpConstant %int 6 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %int_10 = OpConstant %int 10 %int_3 = OpConstant %int 3 %int_7 = OpConstant %int 7 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_11 = OpConstant %int 11 %_ptr_Function_int = OpTypePointer Function %int %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %7 %35 = OpLabel %i = OpVariable %_ptr_Function_int Function %36 = OpAccessChain %_ptr_Uniform_float %_ %int_4 %37 = OpLoad %float %36 %38 = OpAccessChain %_ptr_Uniform_float %_ %int_8 %39 = OpLoad %float %38 %40 = OpExtInst %float %1 NMin %37 %39 %41 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %41 %40 %42 = OpAccessChain %_ptr_Uniform_v2float %_ %int_5 %43 = OpLoad %v2float %42 %44 = OpAccessChain %_ptr_Uniform_v2float %_ %int_9 %45 = OpLoad %v2float %44 %46 = OpExtInst %v2float %1 NMin %43 %45 %47 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 OpStore %47 %46 %48 = OpAccessChain %_ptr_Uniform_v3float %_ %int_6 %49 = OpLoad %v3float %48 %50 = OpAccessChain %_ptr_Uniform_v3float %_ %int_10 %51 = OpLoad %v3float %50 %52 = OpExtInst %v3float %1 NMin %49 %51 %53 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 OpStore %53 %52 %54 = OpAccessChain %_ptr_Uniform_v4float %_ %int_7 %55 = OpLoad %v4float %54 %56 = OpAccessChain %_ptr_Uniform_v4float %_ %int_11 %57 = OpLoad %v4float %56 %58 = OpExtInst %v4float %1 NMin %55 %57 %59 = OpAccessChain %_ptr_Uniform_v4float %_ %int_3 OpStore %59 %58 %60 = OpAccessChain %_ptr_Uniform_float %_ %int_4 %61 = OpLoad %float %60 %62 = OpAccessChain %_ptr_Uniform_float %_ %int_8 %63 = OpLoad %float %62 %64 = OpExtInst %float %1 NMax %61 %63 %65 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %65 %64 %66 = OpAccessChain %_ptr_Uniform_v2float %_ %int_5 %67 = OpLoad %v2float %66 %68 = OpAccessChain %_ptr_Uniform_v2float %_ %int_9 %69 = OpLoad %v2float %68 %70 = OpExtInst %v2float %1 NMax %67 %69 %71 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 OpStore %71 %70 %72 = OpAccessChain %_ptr_Uniform_v3float %_ %int_6 %73 = OpLoad %v3float %72 %74 = OpAccessChain %_ptr_Uniform_v3float %_ %int_10 %75 = OpLoad %v3float %74 %76 = OpExtInst %v3float %1 NMax %73 %75 %77 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 OpStore %77 %76 %78 = OpAccessChain %_ptr_Uniform_v4float %_ %int_7 %79 = OpLoad %v4float %78 %80 = OpAccessChain %_ptr_Uniform_v4float %_ %int_11 %81 = OpLoad %v4float %80 %82 = OpExtInst %v4float %1 NMax %79 %81 %83 = OpAccessChain %_ptr_Uniform_v4float %_ %int_3 OpStore %83 %82 %84 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %85 = OpLoad %float %84 %86 = OpAccessChain %_ptr_Uniform_float %_ %int_4 %87 = OpLoad %float %86 %88 = OpAccessChain %_ptr_Uniform_float %_ %int_8 %89 = OpLoad %float %88 %90 = OpExtInst %float %1 NClamp %85 %87 %89 %91 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %91 %90 %92 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 %93 = OpLoad %v2float %92 %94 = OpAccessChain %_ptr_Uniform_v2float %_ %int_5 %95 = OpLoad %v2float %94 %96 = OpAccessChain %_ptr_Uniform_v2float %_ %int_9 %97 = OpLoad %v2float %96 %98 = OpExtInst %v2float %1 NClamp %93 %95 %97 %99 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 OpStore %99 %98 %100 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 %101 = OpLoad %v3float %100 %102 = OpAccessChain %_ptr_Uniform_v3float %_ %int_6 %103 = OpLoad %v3float %102 %104 = OpAccessChain %_ptr_Uniform_v3float %_ %int_10 %105 = OpLoad %v3float %104 %106 = OpExtInst %v3float %1 NClamp %101 %103 %105 %107 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 OpStore %107 %106 %108 = OpAccessChain %_ptr_Uniform_v4float %_ %int_3 %109 = OpLoad %v4float %108 %110 = OpAccessChain %_ptr_Uniform_v4float %_ %int_7 %111 = OpLoad %v4float %110 %112 = OpAccessChain %_ptr_Uniform_v4float %_ %int_11 %113 = OpLoad %v4float %112 %114 = OpExtInst %v4float %1 NClamp %109 %111 %113 %115 = OpAccessChain %_ptr_Uniform_v4float %_ %int_3 OpStore %115 %114 OpStore %i %int_0 OpBranch %116 %116 = OpLabel OpLoopMerge %117 %118 None OpBranch %119 %119 = OpLabel %120 = OpLoad %int %i %121 = OpSLessThan %bool %120 %int_2 OpBranchConditional %121 %122 %117 %122 = OpLabel %123 = OpAccessChain %_ptr_Uniform_v2float %_ %int_5 %124 = OpLoad %v2float %123 %125 = OpAccessChain %_ptr_Uniform_v2float %_ %int_9 %126 = OpLoad %v2float %125 %127 = OpExtInst %v2float %1 NMin %124 %126 %128 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 OpStore %128 %127 OpBranch %118 %118 = OpLabel %129 = OpLoad %int %i %130 = OpIAdd %int %129 %int_1 OpStore %i %130 %131 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %132 = OpLoad %float %131 %133 = OpAccessChain %_ptr_Uniform_float %_ %int_5 %uint_0 %134 = OpLoad %float %133 %135 = OpAccessChain %_ptr_Uniform_float %_ %int_5 %uint_1 %136 = OpLoad %float %135 %137 = OpExtInst %float %1 NClamp %132 %134 %136 %138 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %138 %137 OpBranch %116 %117 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/000077500000000000000000000000001400026215700204625ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl/asm/frag/cbuffer-stripped.asm.frag000066400000000000000000000043101400026215700253440ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 34 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpMemberDecorate %UBO 0 RowMajor OpMemberDecorate %UBO 0 Offset 0 OpMemberDecorate %UBO 0 MatrixStride 16 OpMemberDecorate %UBO 1 Offset 64 OpDecorate %UBO Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %8 = OpTypeFunction %v2float %_ptr_Function_v2float = OpTypePointer Function %v2float %v4float = OpTypeVector %float 4 %mat2v4float = OpTypeMatrix %v4float 2 %UBO = OpTypeStruct %mat2v4float %v4float %_ptr_Uniform_UBO = OpTypePointer Uniform %UBO %_ = OpVariable %_ptr_Uniform_UBO Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_0 = OpConstant %int 0 %_ptr_Uniform_mat2v4float = OpTypePointer Uniform %mat2v4float %_ptr_Output_v2float = OpTypePointer Output %v2float %_entryPointOutput = OpVariable %_ptr_Output_v2float Output %main = OpFunction %void None %3 %5 = OpLabel %33 = OpFunctionCall %v2float %_main_ OpStore %_entryPointOutput %33 OpReturn OpFunctionEnd %_main_ = OpFunction %v2float None %8 %10 = OpLabel %a0 = OpVariable %_ptr_Function_v2float Function %21 = OpAccessChain %_ptr_Uniform_v4float %_ %int_1 %22 = OpLoad %v4float %21 %25 = OpAccessChain %_ptr_Uniform_mat2v4float %_ %int_0 %26 = OpLoad %mat2v4float %25 %27 = OpVectorTimesMatrix %v2float %22 %26 OpStore %a0 %27 %28 = OpLoad %v2float %a0 OpReturnValue %28 OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/combined-sampler-reuse.asm.frag000066400000000000000000000044421400026215700264500ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 36 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vUV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %uTex "uTex" OpName %uSampler "uSampler" OpName %vUV "vUV" OpDecorate %FragColor Location 0 OpDecorate %uTex DescriptorSet 0 OpDecorate %uTex Binding 1 OpDecorate %uSampler DescriptorSet 0 OpDecorate %uSampler Binding 0 OpDecorate %vUV Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %uTex = OpVariable %_ptr_UniformConstant_10 UniformConstant %14 = OpTypeSampler %_ptr_UniformConstant_14 = OpTypePointer UniformConstant %14 %uSampler = OpVariable %_ptr_UniformConstant_14 UniformConstant %18 = OpTypeSampledImage %10 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %int_1 = OpConstant %int 1 %32 = OpConstantComposite %v2int %int_1 %int_1 %main = OpFunction %void None %3 %5 = OpLabel %13 = OpLoad %10 %uTex %17 = OpLoad %14 %uSampler %19 = OpSampledImage %18 %13 %17 %23 = OpLoad %v2float %vUV %24 = OpImageSampleImplicitLod %v4float %19 %23 OpStore %FragColor %24 %28 = OpLoad %v2float %vUV %33 = OpImageSampleImplicitLod %v4float %19 %28 ConstOffset %32 %34 = OpLoad %v4float %FragColor %35 = OpFAdd %v4float %34 %33 OpStore %FragColor %35 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/empty-struct.asm.frag000066400000000000000000000041221400026215700245610ustar00rootroot00000000000000; SPIR-V ; Version: 1.2 ; Generator: Khronos; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %EntryPoint_Main "main" OpExecutionMode %EntryPoint_Main OriginUpperLeft OpSource Unknown 100 OpName %EmptyStructTest "EmptyStructTest" OpName %GetValue "GetValue" OpName %GetValue2 "GetValue" OpName %self "self" OpName %self2 "self" OpName %emptyStruct "emptyStruct" OpName %value "value" OpName %EntryPoint_Main "EntryPoint_Main" %EmptyStructTest = OpTypeStruct %_ptr_Function_EmptyStructTest = OpTypePointer Function %EmptyStructTest %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %5 = OpTypeFunction %float %_ptr_Function_EmptyStructTest %6 = OpTypeFunction %float %EmptyStructTest %void = OpTypeVoid %_ptr_Function_void = OpTypePointer Function %void %8 = OpTypeFunction %void %_ptr_Function_EmptyStructTest %9 = OpTypeFunction %void %float_0 = OpConstant %float 0 %GetValue = OpFunction %float None %5 %self = OpFunctionParameter %_ptr_Function_EmptyStructTest %13 = OpLabel OpReturnValue %float_0 OpFunctionEnd %GetValue2 = OpFunction %float None %6 %self2 = OpFunctionParameter %EmptyStructTest %14 = OpLabel OpReturnValue %float_0 OpFunctionEnd %EntryPoint_Main = OpFunction %void None %9 %37 = OpLabel %emptyStruct = OpVariable %_ptr_Function_EmptyStructTest Function %18 = OpVariable %_ptr_Function_EmptyStructTest Function %value = OpVariable %_ptr_Function_float Function %value2 = OpCompositeConstruct %EmptyStructTest %22 = OpFunctionCall %float %GetValue %emptyStruct %23 = OpFunctionCall %float %GetValue2 %value2 OpStore %value %22 OpStore %value %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/frem.asm.frag000066400000000000000000000030741400026215700230370ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 16 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vA %vB OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %vA "vA" OpName %vB "vB" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %vA RelaxedPrecision OpDecorate %vA Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %vB RelaxedPrecision OpDecorate %vB Location 1 OpDecorate %14 RelaxedPrecision OpDecorate %15 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %vA = OpVariable %_ptr_Input_v4float Input %vB = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %3 %5 = OpLabel %12 = OpLoad %v4float %vA %14 = OpLoad %v4float %vB %15 = OpFRem %v4float %12 %14 OpStore %FragColor %15 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/function-overload-alias.asm.frag000066400000000000000000000150611400026215700266320ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 76 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %foobar_vf4_ "foo" OpName %a "foo" OpName %foobar_vf3_ "foo" OpName %a_0 "foo" OpName %foobaz_vf4_ "foo" OpName %a_1 "foo" OpName %foobaz_vf2_ "foo" OpName %a_2 "foo" OpName %a_3 "foo" OpName %param "foo" OpName %b "foo" OpName %param_0 "foo" OpName %c "foo" OpName %param_1 "foo" OpName %d "foo" OpName %param_2 "foo" OpName %FragColor "FragColor" OpDecorate %foobar_vf4_ RelaxedPrecision OpDecorate %a RelaxedPrecision OpDecorate %foobar_vf3_ RelaxedPrecision OpDecorate %a_0 RelaxedPrecision OpDecorate %foobaz_vf4_ RelaxedPrecision OpDecorate %a_1 RelaxedPrecision OpDecorate %foobaz_vf2_ RelaxedPrecision OpDecorate %a_2 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %a_3 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %b RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %c RelaxedPrecision OpDecorate %62 RelaxedPrecision OpDecorate %d RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %69 RelaxedPrecision OpDecorate %70 RelaxedPrecision OpDecorate %71 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %74 RelaxedPrecision OpDecorate %75 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %9 = OpTypeFunction %v4float %_ptr_Function_v4float %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %15 = OpTypeFunction %v4float %_ptr_Function_v3float %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %24 = OpTypeFunction %v4float %_ptr_Function_v2float %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %53 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %57 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %64 = OpConstantComposite %v2float %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %a_3 = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %b = OpVariable %_ptr_Function_v4float Function %param_0 = OpVariable %_ptr_Function_v3float Function %c = OpVariable %_ptr_Function_v4float Function %param_1 = OpVariable %_ptr_Function_v4float Function %d = OpVariable %_ptr_Function_v4float Function %param_2 = OpVariable %_ptr_Function_v2float Function OpStore %param %53 %55 = OpFunctionCall %v4float %foobar_vf4_ %param OpStore %a_3 %55 OpStore %param_0 %57 %59 = OpFunctionCall %v4float %foobar_vf3_ %param_0 OpStore %b %59 OpStore %param_1 %53 %62 = OpFunctionCall %v4float %foobaz_vf4_ %param_1 OpStore %c %62 OpStore %param_2 %64 %66 = OpFunctionCall %v4float %foobaz_vf2_ %param_2 OpStore %d %66 %69 = OpLoad %v4float %a_3 %70 = OpLoad %v4float %b %71 = OpFAdd %v4float %69 %70 %72 = OpLoad %v4float %c %73 = OpFAdd %v4float %71 %72 %74 = OpLoad %v4float %d %75 = OpFAdd %v4float %73 %74 OpStore %FragColor %75 OpReturn OpFunctionEnd %foobar_vf4_ = OpFunction %v4float None %9 %a = OpFunctionParameter %_ptr_Function_v4float %12 = OpLabel %28 = OpLoad %v4float %a %30 = OpCompositeConstruct %v4float %float_1 %float_1 %float_1 %float_1 %31 = OpFAdd %v4float %28 %30 OpReturnValue %31 OpFunctionEnd %foobar_vf3_ = OpFunction %v4float None %15 %a_0 = OpFunctionParameter %_ptr_Function_v3float %18 = OpLabel %34 = OpLoad %v3float %a_0 %35 = OpVectorShuffle %v4float %34 %34 0 1 2 2 %36 = OpCompositeConstruct %v4float %float_1 %float_1 %float_1 %float_1 %37 = OpFAdd %v4float %35 %36 OpReturnValue %37 OpFunctionEnd %foobaz_vf4_ = OpFunction %v4float None %9 %a_1 = OpFunctionParameter %_ptr_Function_v4float %21 = OpLabel %40 = OpLoad %v4float %a_1 %42 = OpCompositeConstruct %v4float %float_2 %float_2 %float_2 %float_2 %43 = OpFAdd %v4float %40 %42 OpReturnValue %43 OpFunctionEnd %foobaz_vf2_ = OpFunction %v4float None %24 %a_2 = OpFunctionParameter %_ptr_Function_v2float %27 = OpLabel %46 = OpLoad %v2float %a_2 %47 = OpVectorShuffle %v4float %46 %46 0 1 0 1 %48 = OpCompositeConstruct %v4float %float_2 %float_2 %float_2 %float_2 %49 = OpFAdd %v4float %47 %48 OpReturnValue %49 OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/image-extract-reuse.asm.frag000066400000000000000000000030251400026215700257550ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 19 ; Schema: 0 OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %Size OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %Size "Size" OpName %uTexture "uTexture" OpDecorate %Size Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %_ptr_Output_v2int = OpTypePointer Output %v2int %Size = OpVariable %_ptr_Output_v2int Output %float = OpTypeFloat 32 %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %12 = OpTypeSampledImage %11 %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %uTexture = OpVariable %_ptr_UniformConstant_12 UniformConstant %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpLoad %12 %uTexture %17 = OpImage %11 %15 %18 = OpImageQuerySizeLod %v2int %17 %int_0 %19 = OpImageQuerySizeLod %v2int %17 %int_1 %20 = OpIAdd %v2int %18 %19 OpStore %Size %20 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/implicit-read-dep-phi.asm.frag000066400000000000000000000064051400026215700261560ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 60 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %v0 %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %phi "phi" OpName %i "i" OpName %v0 "v0" OpName %FragColor "FragColor" OpName %uImage "uImage" OpDecorate %v0 Location 0 OpDecorate %FragColor Location 0 OpDecorate %uImage DescriptorSet 0 OpDecorate %uImage Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %v0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %36 = OpTypeImage %float 2D 0 0 0 1 Unknown %37 = OpTypeSampledImage %36 %_ptr_UniformConstant_37 = OpTypePointer UniformConstant %37 %uImage = OpVariable %_ptr_UniformConstant_37 UniformConstant %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %float_2 = OpConstant %float 2 %int_1 = OpConstant %int 1 %float_1_vec = OpConstantComposite %v4float %float_1 %float_2 %float_1 %float_2 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %loop_header %loop_header = OpLabel %phi = OpPhi %float %float_1 %5 %phi_plus_2 %continue_block %tex_phi = OpPhi %v4float %float_1_vec %5 %texture_load_result %continue_block OpLoopMerge %merge_block %continue_block None OpBranch %loop_body %loop_body = OpLabel OpStore %FragColor %tex_phi %19 = OpLoad %int %i %22 = OpSLessThan %bool %19 %int_4 OpBranchConditional %22 %15 %merge_block %15 = OpLabel %26 = OpLoad %int %i %28 = OpAccessChain %_ptr_Input_float %v0 %26 %29 = OpLoad %float %28 %31 = OpFOrdGreaterThan %bool %29 %float_0 OpBranchConditional %31 %continue_block %merge_block %continue_block = OpLabel %40 = OpLoad %37 %uImage %43 = OpCompositeConstruct %v2float %phi %phi %texture_load_result = OpImageSampleExplicitLod %v4float %40 %43 Lod %float_0 %phi_plus_2 = OpFAdd %float %phi %float_2 %54 = OpLoad %int %i %56 = OpIAdd %int %54 %int_1 OpStore %i %56 OpBranch %loop_header %merge_block = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/inf-nan-constant.asm.frag000066400000000000000000000021471400026215700252630ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 14 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %FragColor = OpVariable %_ptr_Output_v3float Output %float_0x1p_128 = OpConstant %float 0x1p+128 %float_n0x1p_128 = OpConstant %float -0x1p+128 %float_0x1_8p_128 = OpConstant %float 0x1.8p+128 %13 = OpConstantComposite %v3float %float_0x1p_128 %float_n0x1p_128 %float_0x1_8p_128 %main = OpFunction %void None %3 %5 = OpLabel OpStore %FragColor %13 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/line-directive.line.asm.frag000066400000000000000000000144301400026215700257350ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google Shaderc over Glslang; 7 ; Bound: 83 ; Schema: 0 OpCapability Shader %2 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vColor OpExecutionMode %main OriginUpperLeft %1 = OpString "test.frag" OpSource GLSL 450 %1 "// OpModuleProcessed entry-point main // OpModuleProcessed client vulkan100 // OpModuleProcessed target-env vulkan1.0 // OpModuleProcessed entry-point main #line 1 #version 450 layout(location = 0) in float vColor; layout(location = 0) out float FragColor; void func() { FragColor = 1.0; FragColor = 2.0; if (vColor < 0.0) { FragColor = 3.0; } else { FragColor = 4.0; } for (int i = 0; i < 40 + vColor; i += int(vColor) + 5) { FragColor += 0.2; FragColor += 0.3; } switch (int(vColor)) { case 0: FragColor += 0.2; break; case 1: FragColor += 0.4; break; default: FragColor += 0.8; break; } do { FragColor += 10.0 + vColor; } while(FragColor < 100.0); } void main() { func(); } " OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %func_ "func(" OpName %FragColor "FragColor" OpName %vColor "vColor" OpName %i "i" OpDecorate %FragColor Location 0 OpDecorate %vColor Location 0 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %_ptr_Input_float = OpTypePointer Input %float %vColor = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %int = OpTypeInt 32 1 ; Should be ignored OpLine %1 5 0 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %float_40 = OpConstant %float 40 %float_0_200000003 = OpConstant %float 0.200000003 %float_0_300000012 = OpConstant %float 0.300000012 %int_5 = OpConstant %int 5 ; Should be ignored OpLine %1 5 0 %float_0_400000006 = OpConstant %float 0.400000006 %float_0_800000012 = OpConstant %float 0.800000012 %float_10 = OpConstant %float 10 %float_100 = OpConstant %float 100 %main = OpFunction %void None %4 OpLine %1 46 0 %6 = OpLabel OpLine %1 48 0 %82 = OpFunctionCall %void %func_ OpReturn OpFunctionEnd ; Should be ignored OpLine %1 5 0 %func_ = OpFunction %void None %4 OpLine %1 6 0 %8 = OpLabel %i = OpVariable %_ptr_Function_int Function OpLine %1 8 0 OpStore %FragColor %float_1 OpLine %1 9 0 OpStore %FragColor %float_2 OpLine %1 10 0 %16 = OpLoad %float %vColor %19 = OpFOrdLessThan %bool %16 %float_0 OpSelectionMerge %21 None OpBranchConditional %19 %20 %23 %20 = OpLabel OpLine %1 12 0 OpStore %FragColor %float_3 OpBranch %21 %23 = OpLabel OpLine %1 16 0 OpStore %FragColor %float_4 OpBranch %21 %21 = OpLabel OpLine %1 19 0 OpStore %i %int_0 OpBranch %29 %29 = OpLabel OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %34 = OpLoad %int %i %35 = OpConvertSToF %float %34 %37 = OpLoad %float %vColor %38 = OpFAdd %float %float_40 %37 %39 = OpFOrdLessThan %bool %35 %38 OpBranchConditional %39 %30 %31 %30 = OpLabel OpLine %1 21 0 %41 = OpLoad %float %FragColor %42 = OpFAdd %float %41 %float_0_200000003 OpStore %FragColor %42 OpLine %1 22 0 %44 = OpLoad %float %FragColor %45 = OpFAdd %float %44 %float_0_300000012 OpStore %FragColor %45 OpBranch %32 %32 = OpLabel OpLine %1 19 0 %46 = OpLoad %float %vColor %47 = OpConvertFToS %int %46 %49 = OpIAdd %int %47 %int_5 %50 = OpLoad %int %i %51 = OpIAdd %int %50 %49 OpStore %i %51 OpBranch %29 %31 = OpLabel OpLine %1 25 0 %52 = OpLoad %float %vColor %53 = OpConvertFToS %int %52 OpSelectionMerge %57 None OpSwitch %53 %56 0 %54 1 %55 %56 = OpLabel OpLine %1 36 0 %66 = OpLoad %float %FragColor %67 = OpFAdd %float %66 %float_0_800000012 OpStore %FragColor %67 OpLine %1 37 0 OpBranch %57 %54 = OpLabel OpLine %1 28 0 %58 = OpLoad %float %FragColor %59 = OpFAdd %float %58 %float_0_200000003 OpStore %FragColor %59 OpLine %1 29 0 OpBranch %57 %55 = OpLabel OpLine %1 32 0 %62 = OpLoad %float %FragColor %63 = OpFAdd %float %62 %float_0_400000006 OpStore %FragColor %63 OpLine %1 33 0 OpBranch %57 %57 = OpLabel OpBranch %70 OpLine %1 43 0 %70 = OpLabel OpLoopMerge %72 %73 None OpBranch %71 %71 = OpLabel OpLine %1 42 0 %75 = OpLoad %float %vColor %76 = OpFAdd %float %float_10 %75 %77 = OpLoad %float %FragColor %78 = OpFAdd %float %77 %76 OpStore %FragColor %78 OpBranch %73 %73 = OpLabel OpLine %1 43 0 %79 = OpLoad %float %FragColor %81 = OpFOrdLessThan %bool %79 %float_100 OpBranchConditional %81 %70 %72 %72 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/lut-promotion-initializer.asm.frag000066400000000000000000000210011400026215700272450ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 111 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %index OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %index "index" OpName %indexable "indexable" OpName %indexable_0 "indexable" OpName %indexable_1 "indexable" OpName %foo "foo" OpName %foobar "foobar" OpName %baz "baz" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %index RelaxedPrecision OpDecorate %index Flat OpDecorate %index Location 0 OpDecorate %20 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %foo RelaxedPrecision OpDecorate %61 RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %71 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %79 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision OpDecorate %foobar RelaxedPrecision OpDecorate %83 RelaxedPrecision OpDecorate %90 RelaxedPrecision OpDecorate %91 RelaxedPrecision OpDecorate %93 RelaxedPrecision OpDecorate %94 RelaxedPrecision OpDecorate %95 RelaxedPrecision OpDecorate %baz RelaxedPrecision OpDecorate %105 RelaxedPrecision OpDecorate %106 RelaxedPrecision OpDecorate %108 RelaxedPrecision OpDecorate %109 RelaxedPrecision OpDecorate %110 RelaxedPrecision OpDecorate %16 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %uint = OpTypeInt 32 0 %uint_16 = OpConstant %uint 16 %_arr_float_uint_16 = OpTypeArray %float %uint_16 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %16 = OpConstantComposite %_arr_float_uint_16 %float_1 %float_2 %float_3 %float_4 %float_1 %float_2 %float_3 %float_4 %float_1 %float_2 %float_3 %float_4 %float_1 %float_2 %float_3 %float_4 %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %index = OpVariable %_ptr_Input_int Input %_ptr_Function__arr_float_uint_16 = OpTypePointer Function %_arr_float_uint_16 %_ptr_Function_float = OpTypePointer Function %float %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %v4float = OpTypeVector %float 4 %uint_4 = OpConstant %uint 4 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %_ptr_Function__arr_v4float_uint_4 = OpTypePointer Function %_arr_v4float_uint_4 %float_0 = OpConstant %float 0 %54 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %55 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_8 = OpConstant %float 8 %57 = OpConstantComposite %v4float %float_8 %float_8 %float_8 %float_8 %float_5 = OpConstant %float 5 %59 = OpConstantComposite %v4float %float_5 %float_5 %float_5 %float_5 %60 = OpConstantComposite %_arr_v4float_uint_4 %54 %55 %57 %59 %int_30 = OpConstant %int 30 %int_3 = OpConstant %int 3 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %float_20 = OpConstant %float 20 %uint_2 = OpConstant %uint 2 %97 = OpConstantComposite %v4float %float_20 %float_20 %float_20 %float_20 %float_30 = OpConstant %float 30 %99 = OpConstantComposite %v4float %float_30 %float_30 %float_30 %float_30 %float_50 = OpConstant %float 50 %101 = OpConstantComposite %v4float %float_50 %float_50 %float_50 %float_50 %float_60 = OpConstant %float 60 %103 = OpConstantComposite %v4float %float_60 %float_60 %float_60 %float_60 %104 = OpConstantComposite %_arr_v4float_uint_4 %97 %99 %101 %103 %main = OpFunction %void None %3 %5 = OpLabel %indexable = OpVariable %_ptr_Function__arr_float_uint_16 Function %16 %indexable_0 = OpVariable %_ptr_Function__arr_float_uint_16 Function %16 %indexable_1 = OpVariable %_ptr_Function__arr_float_uint_16 Function %16 %foo = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %60 %foobar = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %60 %baz = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %60 %20 = OpLoad %int %index %24 = OpAccessChain %_ptr_Function_float %indexable %20 %25 = OpLoad %float %24 OpStore %FragColor %25 %26 = OpLoad %int %index %29 = OpSLessThan %bool %26 %int_10 OpSelectionMerge %31 None OpBranchConditional %29 %30 %40 %30 = OpLabel %32 = OpLoad %int %index %34 = OpBitwiseXor %int %32 %int_1 %36 = OpAccessChain %_ptr_Function_float %indexable_0 %34 %37 = OpLoad %float %36 %38 = OpLoad %float %FragColor %39 = OpFAdd %float %38 %37 OpStore %FragColor %39 OpBranch %31 %40 = OpLabel %41 = OpLoad %int %index %42 = OpBitwiseAnd %int %41 %int_1 %44 = OpAccessChain %_ptr_Function_float %indexable_1 %42 %45 = OpLoad %float %44 %46 = OpLoad %float %FragColor %47 = OpFAdd %float %46 %45 OpStore %FragColor %47 OpBranch %31 %31 = OpLabel %61 = OpLoad %int %index %63 = OpSGreaterThan %bool %61 %int_30 OpSelectionMerge %65 None OpBranchConditional %63 %64 %74 %64 = OpLabel %66 = OpLoad %int %index %68 = OpBitwiseAnd %int %66 %int_3 %70 = OpAccessChain %_ptr_Function_float %foo %68 %uint_1 %71 = OpLoad %float %70 %72 = OpLoad %float %FragColor %73 = OpFAdd %float %72 %71 OpStore %FragColor %73 OpBranch %65 %74 = OpLabel %75 = OpLoad %int %index %76 = OpBitwiseAnd %int %75 %int_1 %78 = OpAccessChain %_ptr_Function_float %foo %76 %uint_0 %79 = OpLoad %float %78 %80 = OpLoad %float %FragColor %81 = OpFAdd %float %80 %79 OpStore %FragColor %81 OpBranch %65 %65 = OpLabel %83 = OpLoad %int %index %84 = OpSGreaterThan %bool %83 %int_30 OpSelectionMerge %86 None OpBranchConditional %84 %85 %86 %85 = OpLabel %89 = OpAccessChain %_ptr_Function_float %foobar %int_1 %uint_2 OpStore %89 %float_20 OpBranch %86 %86 = OpLabel %90 = OpLoad %int %index %91 = OpBitwiseAnd %int %90 %int_3 %92 = OpAccessChain %_ptr_Function_float %foobar %91 %uint_2 %93 = OpLoad %float %92 %94 = OpLoad %float %FragColor %95 = OpFAdd %float %94 %93 OpStore %FragColor %95 OpStore %baz %104 %105 = OpLoad %int %index %106 = OpBitwiseAnd %int %105 %int_3 %107 = OpAccessChain %_ptr_Function_float %baz %106 %uint_2 %108 = OpLoad %float %107 %109 = OpLoad %float %FragColor %110 = OpFAdd %float %109 %108 OpStore %FragColor %110 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/pack-and-unpack-uint2.fxconly.nofxc.sm60.asm.frag000066400000000000000000000042271400026215700314640ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 34 ; Schema: 0 OpCapability Shader OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_ARB_gpu_shader_int64" OpName %main "main" OpName %packed "packed" OpName %unpacked "unpacked" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %uint_18 = OpConstant %uint 18 %uint_52 = OpConstant %uint 52 %13 = OpConstantComposite %v2uint %uint_18 %uint_52 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %uint_0 = OpConstant %uint 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_1 = OpConstant %uint 1 %float_1 = OpConstant %float 1 %main = OpFunction %void None %3 %5 = OpLabel %packed = OpVariable %_ptr_Function_ulong Function %unpacked = OpVariable %_ptr_Function_v2uint Function %14 = OpBitcast %ulong %13 OpStore %packed %14 %17 = OpLoad %ulong %packed %18 = OpBitcast %v2uint %17 OpStore %unpacked %18 %25 = OpAccessChain %_ptr_Function_uint %unpacked %uint_0 %26 = OpLoad %uint %25 %27 = OpConvertUToF %float %26 %29 = OpAccessChain %_ptr_Function_uint %unpacked %uint_1 %30 = OpLoad %uint %29 %31 = OpConvertUToF %float %30 %33 = OpCompositeConstruct %v4float %27 %31 %float_1 %float_1 OpStore %FragColor %33 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/pass-by-value.asm.frag000066400000000000000000000040131400026215700245700ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 32 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %add_value_f1_f1_ "add_value(f1;f1;" OpName %v "v" OpName %w "w" OpName %FragColor "FragColor" OpName %Registers "Registers" OpMemberName %Registers 0 "foo" OpName %registers "registers" OpDecorate %FragColor Location 0 OpMemberDecorate %Registers 0 Offset 0 OpDecorate %Registers Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %8 = OpTypeFunction %float %float %float %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %float_10 = OpConstant %float 10 %Registers = OpTypeStruct %float %_ptr_PushConstant_Registers = OpTypePointer PushConstant %Registers %registers = OpVariable %_ptr_PushConstant_Registers PushConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_PushConstant_float = OpTypePointer PushConstant %float %main = OpFunction %void None %3 %5 = OpLabel %29 = OpAccessChain %_ptr_PushConstant_float %registers %int_0 %30 = OpLoad %float %29 %31 = OpFunctionCall %float %add_value_f1_f1_ %float_10 %30 OpStore %FragColor %31 OpReturn OpFunctionEnd %add_value_f1_f1_ = OpFunction %float None %8 %v = OpFunctionParameter %float %w = OpFunctionParameter %float %12 = OpLabel %15 = OpFAdd %float %v %w OpReturnValue %15 OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/sample-and-compare.asm.frag000066400000000000000000000055611400026215700255560ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 32 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_TEXCOORD0 %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_2d_image "type.2d.image" OpName %g_Texture "g_Texture" OpName %type_sampler "type.sampler" OpName %g_Sampler "g_Sampler" OpName %g_CompareSampler "g_CompareSampler" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %g_Texture DescriptorSet 0 OpDecorate %g_Texture Binding 0 OpDecorate %g_Sampler DescriptorSet 0 OpDecorate %g_Sampler Binding 0 OpDecorate %g_CompareSampler DescriptorSet 0 OpDecorate %g_CompareSampler Binding 1 %float = OpTypeFloat 32 %float_0_5 = OpConstant %float 0.5 %float_0 = OpConstant %float 0 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Output_float = OpTypePointer Output %float %void = OpTypeVoid %19 = OpTypeFunction %void %type_sampled_image = OpTypeSampledImage %type_2d_image %v4float = OpTypeVector %float 4 %g_Texture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %g_CompareSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %19 %21 = OpLabel %22 = OpLoad %v2float %in_var_TEXCOORD0 %23 = OpLoad %type_2d_image %g_Texture %24 = OpLoad %type_sampler %g_Sampler %25 = OpSampledImage %type_sampled_image %23 %24 %26 = OpImageSampleImplicitLod %v4float %25 %22 None %27 = OpCompositeExtract %float %26 0 %28 = OpLoad %type_sampler %g_CompareSampler %29 = OpSampledImage %type_sampled_image %23 %28 %30 = OpImageSampleDrefExplicitLod %float %29 %22 %float_0_5 Lod %float_0 %31 = OpFAdd %float %27 %30 OpStore %out_var_SV_Target %31 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/single-function-private-lut.asm.frag000066400000000000000000000070071400026215700274640ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 54 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %o_color OpExecutionMode %main OriginUpperLeft OpSource GLSL 460 OpName %main "main" OpName %myType "myType" OpMemberName %myType 0 "data" OpName %myData "myData" OpName %uv "uv" OpName %gl_FragCoord "gl_FragCoord" OpName %index "index" OpName %elt "elt" OpName %o_color "o_color" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %o_color Location 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %myType = OpTypeStruct %float %uint = OpTypeInt 32 0 %uint_5 = OpConstant %uint 5 %_arr_myType_uint_5 = OpTypeArray %myType %uint_5 %_ptr_Private__arr_myType_uint_5 = OpTypePointer Private %_arr_myType_uint_5 %myData = OpVariable %_ptr_Private__arr_myType_uint_5 Private %float_0 = OpConstant %float 0 %18 = OpConstantComposite %myType %float_0 %float_1 = OpConstant %float 1 %20 = OpConstantComposite %myType %float_1 %21 = OpConstantComposite %_arr_myType_uint_5 %18 %20 %18 %20 %18 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %float_4 = OpConstant %float 4 %_ptr_Function_myType = OpTypePointer Function %myType %_ptr_Private_myType = OpTypePointer Private %myType %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_Output_v4float = OpTypePointer Output %v4float %o_color = OpVariable %_ptr_Output_v4float Output %36 = OpConstantComposite %v4float %float_0 %float_1 %float_0 %float_1 %37 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %main = OpFunction %void None %11 %38 = OpLabel %uv = OpVariable %_ptr_Function_v2float Function %index = OpVariable %_ptr_Function_int Function %elt = OpVariable %_ptr_Function_myType Function OpStore %myData %21 %39 = OpLoad %v4float %gl_FragCoord %40 = OpVectorShuffle %v2float %39 %39 0 1 OpStore %uv %40 %41 = OpAccessChain %_ptr_Function_float %uv %uint_0 %42 = OpLoad %float %41 %43 = OpFMod %float %42 %float_4 %44 = OpConvertFToS %int %43 OpStore %index %44 %45 = OpLoad %int %index %46 = OpAccessChain %_ptr_Private_myType %myData %45 %47 = OpLoad %myType %46 OpStore %elt %47 %48 = OpAccessChain %_ptr_Function_float %elt %int_0 %49 = OpLoad %float %48 %50 = OpFOrdGreaterThan %bool %49 %float_0 OpSelectionMerge %51 None OpBranchConditional %50 %52 %53 %52 = OpLabel OpStore %o_color %36 OpBranch %51 %53 = OpLabel OpStore %o_color %37 OpBranch %51 %51 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/srem.asm.frag000066400000000000000000000030661400026215700230550ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 23 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vA %vB OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %vA "vA" OpName %vB "vB" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %vA Flat OpDecorate %vA Location 0 OpDecorate %vB Flat OpDecorate %vB Location 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %_ptr_Input_v4int = OpTypePointer Input %v4int %vA = OpVariable %_ptr_Input_v4int Input %vB = OpVariable %_ptr_Input_v4int Input %main = OpFunction %void None %3 %5 = OpLabel %14 = OpLoad %v4int %vA %16 = OpLoad %v4int %vB %17 = OpLoad %v4int %vA %18 = OpLoad %v4int %vB %19 = OpSRem %v4int %17 %18 %20 = OpConvertSToF %v4float %19 OpStore %FragColor %20 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/storage-class-output-initializer.asm.frag000066400000000000000000000033231400026215700305310ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 25 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColors %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColors "FragColors" OpName %FragColor "FragColor" OpDecorate %FragColors Location 0 OpDecorate %FragColor Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_ptr_Output__arr_v4float_uint_2 = OpTypePointer Output %_arr_v4float_uint_2 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %17 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4 %float_10 = OpConstant %float 10 %19 = OpConstantComposite %v4float %float_10 %float_10 %float_10 %float_10 %20 = OpConstantComposite %_arr_v4float_uint_2 %17 %19 %_ptr_Output_v4float = OpTypePointer Output %v4float %float_5 = OpConstant %float 5 %24 = OpConstantComposite %v4float %float_5 %float_5 %float_5 %float_5 %FragColors = OpVariable %_ptr_Output__arr_v4float_uint_2 Output %20 %FragColor = OpVariable %_ptr_Output_v4float Output %24 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/texel-fetch-no-lod.asm.frag000066400000000000000000000035061400026215700255040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 26 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %uTexture "uTexture" OpName %gl_FragCoord "gl_FragCoord" OpDecorate %FragColor Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 0 OpDecorate %gl_FragCoord BuiltIn FragCoord %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %uTexture = OpVariable %_ptr_UniformConstant_11 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %int_0 = OpConstant %int 0 %main = OpFunction %void None %3 %5 = OpLabel %14 = OpLoad %11 %uTexture %18 = OpLoad %v4float %gl_FragCoord %19 = OpVectorShuffle %v2float %18 %18 0 1 %22 = OpConvertFToS %v2int %19 %24 = OpImage %10 %14 %25 = OpImageFetch %v4float %24 %22 OpStore %FragColor %25 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/texture-sampling-fp16.asm.frag000066400000000000000000000035621400026215700261720ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 25 ; Schema: 0 OpCapability Shader OpCapability StorageInputOutput16 OpCapability Float16 OpExtension "SPV_KHR_16bit_storage" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %UV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_shader_explicit_arithmetic_types_float16" OpName %main "main" OpName %FragColor "FragColor" OpName %uTexture "uTexture" OpName %UV "UV" OpDecorate %FragColor Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 0 OpDecorate %UV Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %half = OpTypeFloat 16 %float = OpTypeFloat 32 %v4half = OpTypeVector %half 4 %v4float = OpTypeVector %float 4 %_ptr_Output_v4half = OpTypePointer Output %v4half %FragColor = OpVariable %_ptr_Output_v4half Output %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %12 = OpTypeSampledImage %11 %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %uTexture = OpVariable %_ptr_UniformConstant_12 UniformConstant %v2half = OpTypeVector %half 2 %_ptr_Input_v2half = OpTypePointer Input %v2half %UV = OpVariable %_ptr_Input_v2half Input %main = OpFunction %void None %3 %5 = OpLabel %15 = OpLoad %12 %uTexture %19 = OpLoad %v2half %UV %23 = OpImageSampleImplicitLod %v4float %15 %19 %24 = OpFConvert %v4half %23 OpStore %FragColor %24 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/unknown-depth-state.asm.frag000066400000000000000000000056641400026215700260340ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 44 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vUV %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %sample_combined_ "sample_combined(" OpName %sample_separate_ "sample_separate(" OpName %uShadow "uShadow" OpName %vUV "vUV" OpName %uTexture "uTexture" OpName %uSampler "uSampler" OpName %FragColor "FragColor" OpDecorate %uShadow DescriptorSet 0 OpDecorate %uShadow Binding 0 OpDecorate %vUV Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 1 OpDecorate %uSampler DescriptorSet 0 OpDecorate %uSampler Binding 2 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeFunction %float %12 = OpTypeImage %float 2D 2 0 0 1 Unknown %13 = OpTypeSampledImage %12 %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %uShadow = OpVariable %_ptr_UniformConstant_13 UniformConstant %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %vUV = OpVariable %_ptr_Input_v3float Input %_ptr_UniformConstant_25 = OpTypePointer UniformConstant %12 %uTexture = OpVariable %_ptr_UniformConstant_25 UniformConstant %29 = OpTypeSampler %_ptr_UniformConstant_29 = OpTypePointer UniformConstant %29 %uSampler = OpVariable %_ptr_UniformConstant_29 UniformConstant %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %41 = OpFunctionCall %float %sample_combined_ %42 = OpFunctionCall %float %sample_separate_ %43 = OpFAdd %float %41 %42 OpStore %FragColor %43 OpReturn OpFunctionEnd %sample_combined_ = OpFunction %float None %7 %9 = OpLabel %16 = OpLoad %13 %uShadow %20 = OpLoad %v3float %vUV %21 = OpCompositeExtract %float %20 2 %22 = OpImageSampleDrefImplicitLod %float %16 %20 %21 OpReturnValue %22 OpFunctionEnd %sample_separate_ = OpFunction %float None %7 %11 = OpLabel %28 = OpLoad %12 %uTexture %32 = OpLoad %29 %uSampler %33 = OpSampledImage %13 %28 %32 %34 = OpLoad %v3float %vUV %35 = OpCompositeExtract %float %34 2 %36 = OpImageSampleDrefImplicitLod %float %33 %34 %35 OpReturnValue %36 OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/frag/unreachable.asm.frag000066400000000000000000000043361400026215700243610ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 47 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %counter %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %counter "counter" OpName %FragColor "FragColor" OpDecorate %counter Flat OpDecorate %counter Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %counter = OpVariable %_ptr_Input_int Input %int_10 = OpConstant %int 10 %bool = OpTypeBool %float_10 = OpConstant %float 10 %21 = OpConstantComposite %v4float %float_10 %float_10 %float_10 %float_10 %float_30 = OpConstant %float 30 %25 = OpConstantComposite %v4float %float_30 %float_30 %float_30 %float_30 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %false = OpConstantFalse %bool %44 = OpUndef %v4float %main = OpFunction %void None %3 %5 = OpLabel OpBranch %33 %33 = OpLabel %45 = OpPhi %v4float %44 %5 %44 %35 OpLoopMerge %34 %35 None OpBranch %36 %36 = OpLabel %37 = OpLoad %int %counter %38 = OpIEqual %bool %37 %int_10 OpSelectionMerge %39 None OpBranchConditional %38 %40 %41 %40 = OpLabel OpBranch %34 %41 = OpLabel OpBranch %34 %39 = OpLabel OpUnreachable %35 = OpLabel OpBranchConditional %false %33 %34 %34 = OpLabel %46 = OpPhi %v4float %21 %40 %25 %41 %44 %35 OpStore %FragColor %46 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/vert/000077500000000000000000000000001400026215700205235ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl/asm/vert/extract-transposed-matrix-from-struct.asm.vert000066400000000000000000000152511400026215700316270ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 79 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %VS "main" %PosL_1 %instanceID_1 %_entryPointOutput_Position %_entryPointOutput_Color OpSource HLSL 500 OpName %VS "VS" OpName %V2F "V2F" OpMemberName %V2F 0 "Position" OpMemberName %V2F 1 "Color" OpName %_VS_vf3_u1_ "@VS(vf3;u1;" OpName %PosL "PosL" OpName %instanceID "instanceID" OpName %InstanceData "InstanceData" OpMemberName %InstanceData 0 "MATRIX_MVP" OpMemberName %InstanceData 1 "Color" OpName %instData "instData" OpName %InstanceData_0 "InstanceData" OpMemberName %InstanceData_0 0 "MATRIX_MVP" OpMemberName %InstanceData_0 1 "Color" OpName %gInstanceData "gInstanceData" OpMemberName %gInstanceData 0 "@data" OpName %gInstanceData_0 "gInstanceData" OpName %v2f "v2f" OpName %PosL_0 "PosL" OpName %PosL_1 "PosL" OpName %instanceID_0 "instanceID" OpName %instanceID_1 "instanceID" OpName %flattenTemp "flattenTemp" OpName %param "param" OpName %param_0 "param" OpName %_entryPointOutput_Position "@entryPointOutput.Position" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpMemberDecorate %InstanceData_0 0 RowMajor OpMemberDecorate %InstanceData_0 0 Offset 0 OpMemberDecorate %InstanceData_0 0 MatrixStride 16 OpMemberDecorate %InstanceData_0 1 Offset 64 OpDecorate %_runtimearr_InstanceData_0 ArrayStride 80 OpMemberDecorate %gInstanceData 0 Offset 0 OpDecorate %gInstanceData Block OpDecorate %gInstanceData_0 DescriptorSet 1 OpDecorate %gInstanceData_0 Binding 0 OpDecorate %PosL_1 Location 0 OpDecorate %instanceID_1 BuiltIn InstanceIndex OpDecorate %_entryPointOutput_Position BuiltIn Position OpDecorate %_entryPointOutput_Color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %uint = OpTypeInt 32 0 %int_32 = OpConstant %uint 32 %_ptr_Function_uint = OpTypePointer Function %uint %v4float = OpTypeVector %float 4 %V2F = OpTypeStruct %v4float %v4float %13 = OpTypeFunction %V2F %_ptr_Function_v3float %_ptr_Function_uint %mat4v4float = OpTypeMatrix %v4float 4 %InstanceData = OpTypeStruct %mat4v4float %v4float %_ptr_Function_InstanceData = OpTypePointer Function %InstanceData %InstanceData_0 = OpTypeStruct %mat4v4float %v4float %_runtimearr_InstanceData_0 = OpTypeArray %InstanceData_0 %int_32 %gInstanceData = OpTypeStruct %_runtimearr_InstanceData_0 %_ptr_Uniform_gInstanceData = OpTypePointer Uniform %gInstanceData %gInstanceData_0 = OpVariable %_ptr_Uniform_gInstanceData Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_InstanceData_0 = OpTypePointer Uniform %InstanceData_0 %_ptr_Function_mat4v4float = OpTypePointer Function %mat4v4float %int_1 = OpConstant %int 1 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_V2F = OpTypePointer Function %V2F %float_1 = OpConstant %float 1 %_ptr_Input_v3float = OpTypePointer Input %v3float %PosL_1 = OpVariable %_ptr_Input_v3float Input %_ptr_Input_uint = OpTypePointer Input %uint %instanceID_1 = OpVariable %_ptr_Input_uint Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Position = OpVariable %_ptr_Output_v4float Output %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %VS = OpFunction %void None %3 %5 = OpLabel %PosL_0 = OpVariable %_ptr_Function_v3float Function %instanceID_0 = OpVariable %_ptr_Function_uint Function %flattenTemp = OpVariable %_ptr_Function_V2F Function %param = OpVariable %_ptr_Function_v3float Function %param_0 = OpVariable %_ptr_Function_uint Function %61 = OpLoad %v3float %PosL_1 OpStore %PosL_0 %61 %65 = OpLoad %uint %instanceID_1 OpStore %instanceID_0 %65 %68 = OpLoad %v3float %PosL_0 OpStore %param %68 %70 = OpLoad %uint %instanceID_0 OpStore %param_0 %70 %71 = OpFunctionCall %V2F %_VS_vf3_u1_ %param %param_0 OpStore %flattenTemp %71 %74 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0 %75 = OpLoad %v4float %74 OpStore %_entryPointOutput_Position %75 %77 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_1 %78 = OpLoad %v4float %77 OpStore %_entryPointOutput_Color %78 OpReturn OpFunctionEnd %_VS_vf3_u1_ = OpFunction %V2F None %13 %PosL = OpFunctionParameter %_ptr_Function_v3float %instanceID = OpFunctionParameter %_ptr_Function_uint %17 = OpLabel %instData = OpVariable %_ptr_Function_InstanceData Function %v2f = OpVariable %_ptr_Function_V2F Function %29 = OpLoad %uint %instanceID %31 = OpAccessChain %_ptr_Uniform_InstanceData_0 %gInstanceData_0 %int_0 %29 %32 = OpLoad %InstanceData_0 %31 %33 = OpCompositeExtract %mat4v4float %32 0 %35 = OpAccessChain %_ptr_Function_mat4v4float %instData %int_0 OpStore %35 %33 %36 = OpCompositeExtract %v4float %32 1 %39 = OpAccessChain %_ptr_Function_v4float %instData %int_1 OpStore %39 %36 %42 = OpAccessChain %_ptr_Function_mat4v4float %instData %int_0 %43 = OpLoad %mat4v4float %42 %44 = OpLoad %v3float %PosL %46 = OpCompositeExtract %float %44 0 %47 = OpCompositeExtract %float %44 1 %48 = OpCompositeExtract %float %44 2 %49 = OpCompositeConstruct %v4float %46 %47 %48 %float_1 %50 = OpMatrixTimesVector %v4float %43 %49 %51 = OpAccessChain %_ptr_Function_v4float %v2f %int_0 OpStore %51 %50 %52 = OpAccessChain %_ptr_Function_v4float %instData %int_1 %53 = OpLoad %v4float %52 %54 = OpAccessChain %_ptr_Function_v4float %v2f %int_1 OpStore %54 %53 %55 = OpLoad %V2F %v2f OpReturnValue %55 OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/vert/spec-constant-op-composite.asm.vert000066400000000000000000000072201400026215700274020ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 58 ; Schema: 0 OpCapability Shader OpCapability ClipDistance OpCapability CullDistance %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %52 %output OpSource GLSL 450 OpName %4 "main" OpName %9 "pos" OpName %50 "gl_PerVertex" OpMemberName %50 0 "gl_Position" OpMemberName %50 1 "gl_PointSize" OpMemberName %50 2 "gl_ClipDistance" OpMemberName %50 3 "gl_CullDistance" OpName %52 "" OpDecorate %13 SpecId 201 OpDecorate %24 SpecId 202 OpMemberDecorate %50 0 BuiltIn Position OpMemberDecorate %50 1 BuiltIn PointSize OpMemberDecorate %50 2 BuiltIn ClipDistance OpMemberDecorate %50 3 BuiltIn CullDistance OpDecorate %50 Block OpDecorate %57 SpecId 200 OpDecorate %output Flat OpDecorate %output Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Function %7 %10 = OpConstant %6 0 %11 = OpConstantComposite %7 %10 %10 %10 %10 %12 = OpTypeInt 32 1 %int_ptr = OpTypePointer Output %12 %13 = OpSpecConstant %12 -10 %14 = OpConstant %12 2 %15 = OpSpecConstantOp %12 IAdd %13 %14 %17 = OpTypeInt 32 0 %18 = OpConstant %17 1 %19 = OpTypePointer Function %6 %24 = OpSpecConstant %17 100 %25 = OpConstant %17 5 %26 = OpSpecConstantOp %17 UMod %24 %25 %28 = OpConstant %17 2 %33 = OpConstant %12 20 %34 = OpConstant %12 30 %35 = OpTypeVector %12 4 %36 = OpSpecConstantComposite %35 %33 %34 %15 %15 %40 = OpTypeVector %12 2 %41 = OpSpecConstantOp %40 VectorShuffle %36 %36 1 0 %foo = OpSpecConstantOp %12 CompositeExtract %36 1 %42 = OpTypeVector %6 2 %49 = OpTypeArray %6 %18 %50 = OpTypeStruct %7 %6 %49 %49 %51 = OpTypePointer Output %50 %52 = OpVariable %51 Output %output = OpVariable %int_ptr Output %53 = OpConstant %12 0 %55 = OpTypePointer Output %7 %57 = OpSpecConstant %6 3.14159 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %11 %16 = OpConvertSToF %6 %15 %20 = OpAccessChain %19 %9 %18 %21 = OpLoad %6 %20 %22 = OpFAdd %6 %21 %16 %23 = OpAccessChain %19 %9 %18 OpStore %23 %22 %27 = OpConvertUToF %6 %26 %29 = OpAccessChain %19 %9 %28 %30 = OpLoad %6 %29 %31 = OpFAdd %6 %30 %27 %32 = OpAccessChain %19 %9 %28 OpStore %32 %31 %37 = OpConvertSToF %7 %36 %38 = OpLoad %7 %9 %39 = OpFAdd %7 %38 %37 OpStore %9 %39 %43 = OpConvertSToF %42 %41 %44 = OpLoad %7 %9 %45 = OpVectorShuffle %42 %44 %44 0 1 %46 = OpFAdd %42 %45 %43 %47 = OpLoad %7 %9 %48 = OpVectorShuffle %7 %47 %46 4 5 2 3 OpStore %9 %48 %54 = OpLoad %7 %9 %56 = OpAccessChain %55 %52 %53 OpStore %56 %54 OpStore %output %foo OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/vert/uint-vertex-id-instance-id.asm.vert000066400000000000000000000051401400026215700272640ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 36 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %vid_1 %iid_1 %_entryPointOutput OpSource HLSL 500 OpName %main "main" OpName %_main_u1_u1_ "@main(u1;u1;" OpName %vid "vid" OpName %iid "iid" OpName %vid_0 "vid" OpName %vid_1 "vid" OpName %iid_0 "iid" OpName %iid_1 "iid" OpName %_entryPointOutput "@entryPointOutput" OpName %param "param" OpName %param_0 "param" OpDecorate %vid_1 BuiltIn VertexIndex OpDecorate %iid_1 BuiltIn InstanceIndex OpDecorate %_entryPointOutput BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %10 = OpTypeFunction %v4float %_ptr_Function_uint %_ptr_Function_uint %_ptr_Input_uint = OpTypePointer Input %uint %vid_1 = OpVariable %_ptr_Input_uint Input %iid_1 = OpVariable %_ptr_Input_uint Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %vid_0 = OpVariable %_ptr_Function_uint Function %iid_0 = OpVariable %_ptr_Function_uint Function %param = OpVariable %_ptr_Function_uint Function %param_0 = OpVariable %_ptr_Function_uint Function %25 = OpLoad %uint %vid_1 OpStore %vid_0 %25 %28 = OpLoad %uint %iid_1 OpStore %iid_0 %28 %32 = OpLoad %uint %vid_0 OpStore %param %32 %34 = OpLoad %uint %iid_0 OpStore %param_0 %34 %35 = OpFunctionCall %v4float %_main_u1_u1_ %param %param_0 OpStore %_entryPointOutput %35 OpReturn OpFunctionEnd %_main_u1_u1_ = OpFunction %v4float None %10 %vid = OpFunctionParameter %_ptr_Function_uint %iid = OpFunctionParameter %_ptr_Function_uint %14 = OpLabel %15 = OpLoad %uint %vid %16 = OpLoad %uint %iid %17 = OpIAdd %uint %15 %16 %18 = OpConvertUToF %float %17 %19 = OpCompositeConstruct %v4float %18 %18 %18 %18 OpReturnValue %19 OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/asm/vert/vertex-id-instance-id.asm.vert000066400000000000000000000044701400026215700263140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 26 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %gl_VertexID %gl_InstanceID OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %gl_VertexID "gl_VertexID" OpName %gl_InstanceID "gl_InstanceID" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_VertexID BuiltIn VertexIndex OpDecorate %gl_InstanceID BuiltIn InstanceIndex %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexID = OpVariable %_ptr_Input_int Input %gl_InstanceID = OpVariable %_ptr_Input_int Input %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %18 = OpLoad %int %gl_VertexID %20 = OpLoad %int %gl_InstanceID %21 = OpIAdd %int %18 %20 %22 = OpConvertSToF %float %21 %23 = OpCompositeConstruct %v4float %22 %22 %22 %22 %25 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %25 %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-hlsl/comp/000077500000000000000000000000001400026215700177215ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl/comp/access-chain-load-composite.comp000066400000000000000000000005241400026215700260400ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; struct Baz { float c; }; struct Bar { float d[2][4]; Baz baz[2]; }; struct Foo { mat2 a; vec2 b; Bar c[5]; }; layout(row_major, std430, set = 0, binding = 0) buffer SSBO { Foo foo; Foo foo2; }; void main() { Foo f = foo; f.a += 1.0; f.b += 2.0; f.c[3].d[1][1] += 5.0; foo2 = f; } spirv-cross-2021.01.15/shaders-hlsl/comp/access-chains.comp000066400000000000000000000007451400026215700233130ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; // TODO: Read structs, matrices and arrays. layout(std430, binding = 0) readonly buffer SSBO { vec4 a[3][2][4]; float b[3][2][4]; vec4 unsized[]; } ro; layout(std430, binding = 1) writeonly buffer SSBO1 { vec4 c[3][2][4]; float d[3][2][4]; vec4 unsized[]; } wo; void main() { wo.c[2][gl_GlobalInvocationID.x][1] = ro.a[1][gl_GlobalInvocationID.x][2]; wo.unsized[gl_GlobalInvocationID.x] = ro.unsized[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/shaders-hlsl/comp/access-chains.force-uav.comp000066400000000000000000000007451400026215700252010ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; // TODO: Read structs, matrices and arrays. layout(std430, binding = 0) readonly buffer SSBO { vec4 a[3][2][4]; float b[3][2][4]; vec4 unsized[]; } ro; layout(std430, binding = 1) writeonly buffer SSBO1 { vec4 c[3][2][4]; float d[3][2][4]; vec4 unsized[]; } wo; void main() { wo.c[2][gl_GlobalInvocationID.x][1] = ro.a[1][gl_GlobalInvocationID.x][2]; wo.unsized[gl_GlobalInvocationID.x] = ro.unsized[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/shaders-hlsl/comp/address-buffers.comp000066400000000000000000000005411400026215700236600ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 0, std430) readonly buffer ReadOnlyBuffer { vec4 ro; } ReadOnly; layout(binding = 1, std430) buffer ReadWriteBuffer { vec4 rw; } ReadWrite; layout(binding = 2, std430) buffer WriteOnlyBuffer { vec4 wo; } WriteOnly; void main() { WriteOnly.wo = ReadOnly.ro; ReadWrite.rw += 10.0; } spirv-cross-2021.01.15/shaders-hlsl/comp/atomic.comp000066400000000000000000000037031400026215700220600ustar00rootroot00000000000000#version 310 es #extension GL_OES_shader_image_atomic : require layout(local_size_x = 1) in; layout(r32ui, binding = 0) uniform highp uimage2D uImage; layout(r32i, binding = 1) uniform highp iimage2D iImage; layout(binding = 2, std430) buffer SSBO { uint u32; int i32; } ssbo; shared int int_atomic; shared uint uint_atomic; shared int int_atomic_array[1]; shared uint uint_atomic_array[1]; void main() { imageAtomicAdd(uImage, ivec2(1, 5), 1u); // Test that we do not invalidate OpImage variables which are loaded from UniformConstant // address space. imageStore(iImage, ivec2(1, 6), ivec4(imageAtomicAdd(uImage, ivec2(1, 5), 1u))); imageAtomicOr(uImage, ivec2(1, 5), 1u); imageAtomicXor(uImage, ivec2(1, 5), 1u); imageAtomicAnd(uImage, ivec2(1, 5), 1u); imageAtomicMin(uImage, ivec2(1, 5), 1u); imageAtomicMax(uImage, ivec2(1, 5), 1u); //imageAtomicExchange(uImage, ivec2(1, 5), 1u); imageAtomicCompSwap(uImage, ivec2(1, 5), 10u, 2u); imageAtomicAdd(iImage, ivec2(1, 6), 1); imageAtomicOr(iImage, ivec2(1, 6), 1); imageAtomicXor(iImage, ivec2(1, 6), 1); imageAtomicAnd(iImage, ivec2(1, 6), 1); imageAtomicMin(iImage, ivec2(1, 6), 1); imageAtomicMax(iImage, ivec2(1, 6), 1); //imageAtomicExchange(iImage, ivec2(1, 5), 1u); imageAtomicCompSwap(iImage, ivec2(1, 5), 10, 2); atomicAdd(ssbo.u32, 1u); atomicOr(ssbo.u32, 1u); atomicXor(ssbo.u32, 1u); atomicAnd(ssbo.u32, 1u); atomicMin(ssbo.u32, 1u); atomicMax(ssbo.u32, 1u); atomicExchange(ssbo.u32, 1u); atomicCompSwap(ssbo.u32, 10u, 2u); atomicAdd(ssbo.i32, 1); atomicOr(ssbo.i32, 1); atomicXor(ssbo.i32, 1); atomicAnd(ssbo.i32, 1); atomicMin(ssbo.i32, 1); atomicMax(ssbo.i32, 1); atomicExchange(ssbo.i32, 1); atomicCompSwap(ssbo.i32, 10, 2); atomicAdd(int_atomic, 10); atomicAdd(uint_atomic, 10u); atomicAdd(int_atomic_array[0], 10); atomicAdd(uint_atomic_array[0], 10u); } spirv-cross-2021.01.15/shaders-hlsl/comp/barriers.comp000066400000000000000000000016001400026215700224070ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4) in; void barrier_shared() { memoryBarrierShared(); } void full_barrier() { memoryBarrier(); } void image_barrier() { memoryBarrierImage(); } void buffer_barrier() { memoryBarrierBuffer(); } void group_barrier() { groupMemoryBarrier(); } void barrier_shared_exec() { memoryBarrierShared(); barrier(); } void full_barrier_exec() { memoryBarrier(); barrier(); } void image_barrier_exec() { memoryBarrierImage(); barrier(); } void buffer_barrier_exec() { memoryBarrierBuffer(); barrier(); } void group_barrier_exec() { groupMemoryBarrier(); barrier(); } void exec_barrier() { barrier(); } void main() { barrier_shared(); full_barrier(); image_barrier(); buffer_barrier(); group_barrier(); barrier_shared_exec(); full_barrier_exec(); image_barrier_exec(); buffer_barrier_exec(); group_barrier_exec(); exec_barrier(); } spirv-cross-2021.01.15/shaders-hlsl/comp/builtins.comp000066400000000000000000000004631400026215700224350ustar00rootroot00000000000000#version 310 es layout(local_size_x = 8, local_size_y = 4, local_size_z = 2) in; void main() { uvec3 local_id = gl_LocalInvocationID; uvec3 global_id = gl_GlobalInvocationID; uint local_index = gl_LocalInvocationIndex; uvec3 work_group_size = gl_WorkGroupSize; uvec3 work_group_id = gl_WorkGroupID; } spirv-cross-2021.01.15/shaders-hlsl/comp/composite-array-initialization.comp000066400000000000000000000010121400026215700267360ustar00rootroot00000000000000#version 450 layout(local_size_x = 2) in; struct Data { float a; float b; }; layout(std430, binding = 0) buffer SSBO { Data outdata[]; }; layout(constant_id = 0) const float X = 4.0; Data data[2] = Data[](Data(1.0, 2.0), Data(3.0, 4.0)); Data data2[2] = Data[](Data(X, 2.0), Data(3.0, 5.0)); Data combine(Data a, Data b) { return Data(a.a + b.a, a.b + b.b); } void main() { if (gl_LocalInvocationIndex == 0u) outdata[gl_WorkGroupID.x] = combine(data[gl_LocalInvocationID.x], data2[gl_LocalInvocationID.x]); } spirv-cross-2021.01.15/shaders-hlsl/comp/globallycoherent.comp000066400000000000000000000007151400026215700241410ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(r32f, binding = 0) uniform readonly image2D uImageIn; layout(r32f, binding = 1) uniform coherent writeonly image2D uImageOut; layout(set = 0, binding = 2) readonly buffer Foo { float foo; }; layout(set = 0, binding = 3) coherent writeonly buffer Bar { float bar; }; void main() { ivec2 coord = ivec2(9, 7); vec4 indata = imageLoad(uImageIn, coord); imageStore(uImageOut, coord, indata); bar = foo; } spirv-cross-2021.01.15/shaders-hlsl/comp/image.comp000066400000000000000000000072031400026215700216650ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(r32f, binding = 0) uniform readonly image2D uImageInF; layout(r32f, binding = 1) uniform writeonly image2D uImageOutF; layout(r32i, binding = 2) uniform readonly iimage2D uImageInI; layout(r32i, binding = 3) uniform writeonly iimage2D uImageOutI; layout(r32ui, binding = 4) uniform readonly uimage2D uImageInU; layout(r32ui, binding = 5) uniform writeonly uimage2D uImageOutU; layout(r32f, binding = 6) uniform readonly imageBuffer uImageInBuffer; layout(r32f, binding = 7) uniform writeonly imageBuffer uImageOutBuffer; layout(rg32f, binding = 8) uniform readonly image2D uImageInF2; layout(rg32f, binding = 9) uniform writeonly image2D uImageOutF2; layout(rg32i, binding = 10) uniform readonly iimage2D uImageInI2; layout(rg32i, binding = 11) uniform writeonly iimage2D uImageOutI2; layout(rg32ui, binding = 12) uniform readonly uimage2D uImageInU2; layout(rg32ui, binding = 13) uniform writeonly uimage2D uImageOutU2; layout(rg32f, binding = 14) uniform readonly imageBuffer uImageInBuffer2; layout(rg32f, binding = 15) uniform writeonly imageBuffer uImageOutBuffer2; layout(rgba32f, binding = 16) uniform readonly image2D uImageInF4; layout(rgba32f, binding = 17) uniform writeonly image2D uImageOutF4; layout(rgba32i, binding = 18) uniform readonly iimage2D uImageInI4; layout(rgba32i, binding = 19) uniform writeonly iimage2D uImageOutI4; layout(rgba32ui, binding = 20) uniform readonly uimage2D uImageInU4; layout(rgba32ui, binding = 21) uniform writeonly uimage2D uImageOutU4; layout(rgba32f, binding = 22) uniform readonly imageBuffer uImageInBuffer4; layout(rgba32f, binding = 23) uniform writeonly imageBuffer uImageOutBuffer4; layout(binding = 24) uniform writeonly image2D uImageNoFmtF; layout(binding = 25) uniform writeonly uimage2D uImageNoFmtU; layout(binding = 26) uniform writeonly iimage2D uImageNoFmtI; void main() { vec4 f = imageLoad(uImageInF, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutF, ivec2(gl_GlobalInvocationID.xy), f); ivec4 i = imageLoad(uImageInI, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutI, ivec2(gl_GlobalInvocationID.xy), i); uvec4 u = imageLoad(uImageInU, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutU, ivec2(gl_GlobalInvocationID.xy), u); vec4 b = imageLoad(uImageInBuffer, int(gl_GlobalInvocationID.x)); imageStore(uImageOutBuffer, int(gl_GlobalInvocationID.x), b); vec4 f2 = imageLoad(uImageInF2, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutF2, ivec2(gl_GlobalInvocationID.xy), f2); ivec4 i2 = imageLoad(uImageInI2, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutI2, ivec2(gl_GlobalInvocationID.xy), i2); uvec4 u2 = imageLoad(uImageInU2, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutU2, ivec2(gl_GlobalInvocationID.xy), u2); vec4 b2 = imageLoad(uImageInBuffer2, int(gl_GlobalInvocationID.x)); imageStore(uImageOutBuffer2, int(gl_GlobalInvocationID.x), b2); vec4 f4 = imageLoad(uImageInF4, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutF4, ivec2(gl_GlobalInvocationID.xy), f4); ivec4 i4 = imageLoad(uImageInI4, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutI4, ivec2(gl_GlobalInvocationID.xy), i4); uvec4 u4 = imageLoad(uImageInU4, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutU4, ivec2(gl_GlobalInvocationID.xy), u4); vec4 b4 = imageLoad(uImageInBuffer4, int(gl_GlobalInvocationID.x)); imageStore(uImageOutBuffer4, int(gl_GlobalInvocationID.x), b4); imageStore(uImageNoFmtF, ivec2(gl_GlobalInvocationID.xy), b2); imageStore(uImageNoFmtU, ivec2(gl_GlobalInvocationID.xy), u4); imageStore(uImageNoFmtI, ivec2(gl_GlobalInvocationID.xy), i4); } spirv-cross-2021.01.15/shaders-hlsl/comp/image.nonwritable-uav-texture.comp000066400000000000000000000072031400026215700264770ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(r32f, binding = 0) uniform readonly image2D uImageInF; layout(r32f, binding = 1) uniform writeonly image2D uImageOutF; layout(r32i, binding = 2) uniform readonly iimage2D uImageInI; layout(r32i, binding = 3) uniform writeonly iimage2D uImageOutI; layout(r32ui, binding = 4) uniform readonly uimage2D uImageInU; layout(r32ui, binding = 5) uniform writeonly uimage2D uImageOutU; layout(r32f, binding = 6) uniform readonly imageBuffer uImageInBuffer; layout(r32f, binding = 7) uniform writeonly imageBuffer uImageOutBuffer; layout(rg32f, binding = 8) uniform readonly image2D uImageInF2; layout(rg32f, binding = 9) uniform writeonly image2D uImageOutF2; layout(rg32i, binding = 10) uniform readonly iimage2D uImageInI2; layout(rg32i, binding = 11) uniform writeonly iimage2D uImageOutI2; layout(rg32ui, binding = 12) uniform readonly uimage2D uImageInU2; layout(rg32ui, binding = 13) uniform writeonly uimage2D uImageOutU2; layout(rg32f, binding = 14) uniform readonly imageBuffer uImageInBuffer2; layout(rg32f, binding = 15) uniform writeonly imageBuffer uImageOutBuffer2; layout(rgba32f, binding = 16) uniform readonly image2D uImageInF4; layout(rgba32f, binding = 17) uniform writeonly image2D uImageOutF4; layout(rgba32i, binding = 18) uniform readonly iimage2D uImageInI4; layout(rgba32i, binding = 19) uniform writeonly iimage2D uImageOutI4; layout(rgba32ui, binding = 20) uniform readonly uimage2D uImageInU4; layout(rgba32ui, binding = 21) uniform writeonly uimage2D uImageOutU4; layout(rgba32f, binding = 22) uniform readonly imageBuffer uImageInBuffer4; layout(rgba32f, binding = 23) uniform writeonly imageBuffer uImageOutBuffer4; layout(binding = 24) uniform writeonly image2D uImageNoFmtF; layout(binding = 25) uniform writeonly uimage2D uImageNoFmtU; layout(binding = 26) uniform writeonly iimage2D uImageNoFmtI; void main() { vec4 f = imageLoad(uImageInF, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutF, ivec2(gl_GlobalInvocationID.xy), f); ivec4 i = imageLoad(uImageInI, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutI, ivec2(gl_GlobalInvocationID.xy), i); uvec4 u = imageLoad(uImageInU, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutU, ivec2(gl_GlobalInvocationID.xy), u); vec4 b = imageLoad(uImageInBuffer, int(gl_GlobalInvocationID.x)); imageStore(uImageOutBuffer, int(gl_GlobalInvocationID.x), b); vec4 f2 = imageLoad(uImageInF2, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutF2, ivec2(gl_GlobalInvocationID.xy), f2); ivec4 i2 = imageLoad(uImageInI2, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutI2, ivec2(gl_GlobalInvocationID.xy), i2); uvec4 u2 = imageLoad(uImageInU2, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutU2, ivec2(gl_GlobalInvocationID.xy), u2); vec4 b2 = imageLoad(uImageInBuffer2, int(gl_GlobalInvocationID.x)); imageStore(uImageOutBuffer2, int(gl_GlobalInvocationID.x), b2); vec4 f4 = imageLoad(uImageInF4, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutF4, ivec2(gl_GlobalInvocationID.xy), f4); ivec4 i4 = imageLoad(uImageInI4, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutI4, ivec2(gl_GlobalInvocationID.xy), i4); uvec4 u4 = imageLoad(uImageInU4, ivec2(gl_GlobalInvocationID.xy)); imageStore(uImageOutU4, ivec2(gl_GlobalInvocationID.xy), u4); vec4 b4 = imageLoad(uImageInBuffer4, int(gl_GlobalInvocationID.x)); imageStore(uImageOutBuffer4, int(gl_GlobalInvocationID.x), b4); imageStore(uImageNoFmtF, ivec2(gl_GlobalInvocationID.xy), b2); imageStore(uImageNoFmtU, ivec2(gl_GlobalInvocationID.xy), u4); imageStore(uImageNoFmtI, ivec2(gl_GlobalInvocationID.xy), i4); } spirv-cross-2021.01.15/shaders-hlsl/comp/inverse.comp000066400000000000000000000005061400026215700222550ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std430, binding = 0) writeonly buffer MatrixOut { mat2 m2out; mat3 m3out; mat4 m4out; }; layout(std430, binding = 1) readonly buffer MatrixIn { mat2 m2in; mat3 m3in; mat4 m4in; }; void main() { m2out = inverse(m2in); m3out = inverse(m3in); m4out = inverse(m4in); } spirv-cross-2021.01.15/shaders-hlsl/comp/num-workgroups-alone.comp000066400000000000000000000002321400026215700247110ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { uvec3 outdata; }; void main() { outdata = gl_NumWorkGroups; } spirv-cross-2021.01.15/shaders-hlsl/comp/num-workgroups-with-builtins.comp000066400000000000000000000002531400026215700264200ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { uvec3 outdata; }; void main() { outdata = gl_NumWorkGroups + gl_WorkGroupID; } spirv-cross-2021.01.15/shaders-hlsl/comp/outer-product.comp000066400000000000000000000011241400026215700234130ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 0, std430) writeonly buffer SSBO { mat2 m22; mat2x3 m23; mat2x4 m24; mat3x2 m32; mat3 m33; mat3x4 m34; mat4x2 m42; mat4x3 m43; mat4 m44; }; layout(set = 0, binding = 1, std430) readonly buffer ReadSSBO { vec2 v2; vec3 v3; vec4 v4; }; void main() { m22 = outerProduct(v2, v2); m23 = outerProduct(v3, v2); m24 = outerProduct(v4, v2); m32 = outerProduct(v2, v3); m33 = outerProduct(v3, v3); m34 = outerProduct(v4, v3); m42 = outerProduct(v2, v4); m43 = outerProduct(v3, v4); m44 = outerProduct(v4, v4); } spirv-cross-2021.01.15/shaders-hlsl/comp/rmw-matrix.comp000066400000000000000000000003061400026215700227070ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float a; vec4 b; mat4 c; float a1; vec4 b1; mat4 c1; }; void main() { a *= a1; b *= b1; c *= c1; } spirv-cross-2021.01.15/shaders-hlsl/comp/rwbuffer-matrix.comp000066400000000000000000000037361400026215700237360ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std140, binding = 1) uniform UBO { int index0; int index1; }; layout(binding = 0, std430) buffer SSBO { layout(column_major) mat4 mcol; layout(row_major) mat4 mrow; layout(column_major) mat2 mcol2x2; layout(row_major) mat2 mrow2x2; layout(column_major) mat2x3 mcol2x3; layout(row_major) mat2x3 mrow2x3; layout(column_major) mat3x2 mcol3x2; layout(row_major) mat3x2 mrow3x2; }; void col_to_row() { // Load column-major, store row-major. mrow = mcol; mrow2x2 = mcol2x2; mrow2x3 = mcol2x3; mrow3x2 = mcol3x2; } void row_to_col() { // Load row-major, store column-major. mcol = mrow; mcol2x2 = mrow2x2; mcol2x3 = mrow2x3; mcol3x2 = mrow3x2; } void write_dynamic_index_row() { mrow[index0][index1] = 1.0; mrow2x2[index0][index1] = 2.0; mrow2x3[index0][index1] = 3.0; mrow3x2[index0][index1] = 4.0; mrow[index0] = vec4(1.0); mrow2x2[index0] = vec2(2.0); mrow2x3[index0] = vec3(3.0); mrow3x2[index0] = vec2(4.0); } void write_dynamic_index_col() { mcol[index0][index1] = 1.0; mcol2x2[index0][index1] = 2.0; mcol2x3[index0][index1] = 3.0; mcol3x2[index0][index1] = 4.0; mcol[index0] = vec4(1.0); mcol2x2[index0] = vec2(2.0); mcol2x3[index0] = vec3(3.0); mcol3x2[index0] = vec2(4.0); } void read_dynamic_index_row() { float a0 = mrow[index0][index1]; float a1 = mrow2x2[index0][index1]; float a2 = mrow2x3[index0][index1]; float a3 = mrow3x2[index0][index1]; vec4 v0 = mrow[index0]; vec2 v1 = mrow2x2[index0]; vec3 v2 = mrow2x3[index0]; vec2 v3 = mrow3x2[index0]; } void read_dynamic_index_col() { float a0 = mcol[index0][index1]; float a1 = mcol2x2[index0][index1]; float a2 = mcol2x3[index0][index1]; float a3 = mcol3x2[index0][index1]; vec4 v0 = mcol[index0]; vec2 v1 = mcol2x2[index0]; vec3 v2 = mcol2x3[index0]; vec2 v3 = mcol3x2[index0]; } void main() { row_to_col(); col_to_row(); write_dynamic_index_row(); write_dynamic_index_col(); read_dynamic_index_row(); read_dynamic_index_col(); } spirv-cross-2021.01.15/shaders-hlsl/comp/scalar-std450-distance-length-normalize.comp000066400000000000000000000003341400026215700301340ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std430, set = 0, binding = 0) buffer SSBO { float a; float b; float c; float d; float e; }; void main() { c = distance(a, b); d = length(a); e = normalize(a); } spirv-cross-2021.01.15/shaders-hlsl/comp/shared.comp000066400000000000000000000007751400026215700220600ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4) in; shared float sShared[gl_WorkGroupSize.x]; layout(std430, binding = 0) readonly buffer SSBO { float in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { float out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; float idata = in_data[ident]; sShared[gl_LocalInvocationIndex] = idata; memoryBarrierShared(); barrier(); out_data[ident] = sShared[gl_WorkGroupSize.x - gl_LocalInvocationIndex - 1u]; } spirv-cross-2021.01.15/shaders-hlsl/comp/spec-constant-op-member-array.comp000066400000000000000000000007761400026215700263710ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(constant_id = 0) const int a = 100; layout(constant_id = 1) const int b = 200; layout(constant_id = 2) const int c = 300; const int d = c + 50; layout(constant_id = 3) const int e = 400; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; layout(set = 1, binding = 0) buffer SSBO { A member_a; B member_b; int v[a]; int w[d]; }; void main() { w[gl_GlobalInvocationID.x] += v[gl_GlobalInvocationID.x] + e; } spirv-cross-2021.01.15/shaders-hlsl/comp/spec-constant-work-group-size.comp000066400000000000000000000007241400026215700264470ustar00rootroot00000000000000#version 450 layout(local_size_x_id = 10, local_size_y = 20) in; layout(constant_id = 0) const int a = 1; layout(constant_id = 1) const int b = 2; layout(set = 1, binding = 0) writeonly buffer SSBO { int v[]; }; void main() { int spec_const_array_size[b]; spec_const_array_size[0] = 10; spec_const_array_size[1] = 40; spec_const_array_size[a] = a; v[a + gl_WorkGroupSize.x + gl_WorkGroupSize.y + gl_GlobalInvocationID.x] = b + spec_const_array_size[1 - a]; } spirv-cross-2021.01.15/shaders-hlsl/comp/ssbo-array-length.comp000066400000000000000000000002351400026215700241420ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 1, std140) buffer SSBO { uint size; float v[]; }; void main() { size = v.length(); } spirv-cross-2021.01.15/shaders-hlsl/comp/ssbo-array.comp000066400000000000000000000006231400026215700226640ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO0 { vec4 a; } ssbo0; // Does not seem to work in glslang yet in HLSL output, disable for now. #if 0 layout(binding = 1, std430) buffer SSBO1 { vec4 b; } ssbo1[2]; layout(binding = 2, std430) buffer SSBO2 { vec4 c; } ssbo2[3][3]; #endif void main() { #if 0 ssbo1[1].b = ssbo0.a; ssbo2[1][2].c = ssbo0.a; #endif } spirv-cross-2021.01.15/shaders-hlsl/frag/000077500000000000000000000000001400026215700177025ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl/frag/array-lut-no-loop-variable.frag000066400000000000000000000003571400026215700256340ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 v0; void main() { float lut[5] = float[](1.0, 2.0, 3.0, 4.0, 5.0); for (int i = 0; i < 4; i++, FragColor += lut[i]) { } } spirv-cross-2021.01.15/shaders-hlsl/frag/basic-color-3comp.sm30.frag000066400000000000000000000002461400026215700245420ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 0) out vec3 FragColor; void main() { FragColor = vColor.xyz; } spirv-cross-2021.01.15/shaders-hlsl/frag/basic-color-3comp.sm50.frag000066400000000000000000000002461400026215700245440ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 0) out vec3 FragColor; void main() { FragColor = vColor.xyz; } spirv-cross-2021.01.15/shaders-hlsl/frag/basic.frag000066400000000000000000000004071400026215700216250ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; layout(binding = 0) uniform sampler2D uTex; layout(location = 0) out vec4 FragColor; void main() { FragColor = vColor * texture(uTex, vTex); } spirv-cross-2021.01.15/shaders-hlsl/frag/bit-conversions.frag000066400000000000000000000003541400026215700236710ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec2 value; layout(location = 0) out vec4 FragColor; void main() { int i = floatBitsToInt(value.x); FragColor = vec4(1.0, 0.0, intBitsToFloat(i), 1.0); } spirv-cross-2021.01.15/shaders-hlsl/frag/boolean-mix.frag000066400000000000000000000003011400026215700227470ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec2 x0; layout(location = 0) out vec2 FragColor; void main() { FragColor = x0.x > x0.y ? vec2(1.0, 0.0) : vec2(0.0, 1.0); } spirv-cross-2021.01.15/shaders-hlsl/frag/builtins.frag000066400000000000000000000003021400026215700223670ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; void main() { FragColor = gl_FragCoord + vColor; gl_FragDepth = 0.5; } spirv-cross-2021.01.15/shaders-hlsl/frag/bvec-operations.frag000066400000000000000000000005211400026215700236410ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec2 value; layout(location = 0) out vec4 FragColor; void main() { bvec2 bools1 = not(bvec2(value.x == 0.0, value.y == 0.0)); bvec2 bools2 = lessThanEqual(value, vec2(1.5, 0.5)); FragColor = vec4(1.0, 0.0, bools1.x ? 1.0 : 0.0, bools2.x ? 1.0 : 0.0); } spirv-cross-2021.01.15/shaders-hlsl/frag/clip-cull-distance.frag000066400000000000000000000003201400026215700242120ustar00rootroot00000000000000#version 450 in float gl_ClipDistance[2]; in float gl_CullDistance[1]; layout(location = 0) out float FragColor; void main() { FragColor = gl_ClipDistance[0] + gl_CullDistance[0] + gl_ClipDistance[1]; } spirv-cross-2021.01.15/shaders-hlsl/frag/combined-texture-sampler-parameter.frag000066400000000000000000000011311400026215700274340ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump sampler2D uSampler; layout(set = 0, binding = 1) uniform mediump sampler2DShadow uSamplerShadow; layout(location = 0) out float FragColor; vec4 samp2(sampler2D s) { return texture(s, vec2(1.0)) + texelFetch(s, ivec2(10), 0); } vec4 samp3(sampler2D s) { return samp2(s); } float samp4(mediump sampler2DShadow s) { return texture(s, vec3(1.0)); } float samp(sampler2D s0, mediump sampler2DShadow s1) { return samp3(s0).x + samp4(s1); } void main() { FragColor = samp(uSampler, uSamplerShadow); } spirv-cross-2021.01.15/shaders-hlsl/frag/combined-texture-sampler-shadow.frag000066400000000000000000000012651400026215700267510ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump samplerShadow uSampler; layout(set = 0, binding = 1) uniform mediump sampler uSampler1; layout(set = 0, binding = 2) uniform texture2D uDepth; layout(location = 0) out float FragColor; float samp2(texture2D t, mediump samplerShadow s) { return texture(sampler2DShadow(t, s), vec3(1.0)); } float samp3(texture2D t, mediump sampler s) { return texture(sampler2D(t, s), vec2(1.0)).x; } float samp(texture2D t, mediump samplerShadow s, mediump sampler s1) { float r0 = samp2(t, s); float r1 = samp3(t, s1); return r0 + r1; } void main() { FragColor = samp(uDepth, uSampler, uSampler1); } spirv-cross-2021.01.15/shaders-hlsl/frag/complex-expression-in-access-chain.frag000066400000000000000000000007651400026215700273420ustar00rootroot00000000000000#version 310 es precision mediump float; struct Foo { vec4 a; vec4 b; }; layout(binding = 0) buffer UBO { vec4 results[1024]; }; layout(binding = 1) uniform highp isampler2D Buf; layout(location = 0) flat in int vIn; layout(location = 1) flat in int vIn2; layout(location = 0) out vec4 FragColor; void main() { ivec4 coords = texelFetch(Buf, ivec2(gl_FragCoord.xy), 0); vec4 foo = results[coords.x % 16]; int c = vIn * vIn; int d = vIn2 * vIn2; FragColor = foo + foo + results[c + d]; } spirv-cross-2021.01.15/shaders-hlsl/frag/constant-composites.frag000066400000000000000000000005461400026215700245640ustar00rootroot00000000000000#version 310 es precision mediump float; float lut[4] = float[](1.0, 4.0, 3.0, 2.0); struct Foo { float a; float b; }; Foo foos[2] = Foo[](Foo(10.0, 20.0), Foo(30.0, 40.0)); layout(location = 0) out vec4 FragColor; layout(location = 0) flat in int line; void main() { FragColor = vec4(lut[line]); FragColor += foos[line].a * foos[1 - line].a; } spirv-cross-2021.01.15/shaders-hlsl/frag/control-dependent-in-branch.desktop.frag000066400000000000000000000014041400026215700274750ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) in vec4 vInput; void main() { FragColor = vInput; vec4 t = texture(uSampler, vInput.xy); vec4 d0 = dFdx(vInput); vec4 d1 = dFdy(vInput); vec4 d2 = fwidth(vInput); vec4 d3 = dFdxCoarse(vInput); vec4 d4 = dFdyCoarse(vInput); vec4 d5 = fwidthCoarse(vInput); vec4 d6 = dFdxFine(vInput); vec4 d7 = dFdyFine(vInput); vec4 d8 = fwidthFine(vInput); vec2 lod = textureQueryLod(uSampler, vInput.zw); if (vInput.y > 10.0) { FragColor += t; FragColor += d0; FragColor += d1; FragColor += d2; FragColor += d3; FragColor += d4; FragColor += d5; FragColor += d6; FragColor += d7; FragColor += d8; FragColor += lod.xyxy; } } spirv-cross-2021.01.15/shaders-hlsl/frag/demote-to-helper.frag000066400000000000000000000001371400026215700237160ustar00rootroot00000000000000#version 450 #extension GL_EXT_demote_to_helper_invocation : require void main() { demote; } spirv-cross-2021.01.15/shaders-hlsl/frag/depth-greater-than.frag000066400000000000000000000002021400026215700242200ustar00rootroot00000000000000#version 450 layout(early_fragment_tests) in; layout(depth_greater) out float gl_FragDepth; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/shaders-hlsl/frag/depth-less-than.frag000066400000000000000000000001771400026215700235500ustar00rootroot00000000000000#version 450 layout(early_fragment_tests) in; layout(depth_less) out float gl_FragDepth; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/shaders-hlsl/frag/dual-source-blending.frag000066400000000000000000000002731400026215700245500ustar00rootroot00000000000000#version 450 layout(location = 0, index = 0) out vec4 FragColor0; layout(location = 0, index = 1) out vec4 FragColor1; void main() { FragColor0 = vec4(1.0); FragColor1 = vec4(2.0); } spirv-cross-2021.01.15/shaders-hlsl/frag/early-fragment-test.frag000066400000000000000000000001001400026215700244240ustar00rootroot00000000000000#version 420 layout(early_fragment_tests) in; void main() { } spirv-cross-2021.01.15/shaders-hlsl/frag/for-loop-continue-control-flow.frag000066400000000000000000000002711400026215700265450ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(0.0); for (int i = 0; i < 3; (0 > 1) ? 1 : i ++) { int a = i; FragColor[a] += float(i); } } spirv-cross-2021.01.15/shaders-hlsl/frag/fp16-packing.frag000066400000000000000000000003751400026215700227360ustar00rootroot00000000000000#version 450 layout(location = 0) flat in uint FP16; layout(location = 1) flat in vec2 FP32; layout(location = 0) out vec2 FP32Out; layout(location = 1) out uint FP16Out; void main() { FP32Out = unpackHalf2x16(FP16); FP16Out = packHalf2x16(FP32); } spirv-cross-2021.01.15/shaders-hlsl/frag/front-facing.frag000066400000000000000000000003451400026215700231220ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in vec4 vB; void main() { if (gl_FrontFacing) FragColor = vA; else FragColor = vB; } spirv-cross-2021.01.15/shaders-hlsl/frag/image-query-selective.frag000066400000000000000000000024321400026215700247520ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform usampler1D uSampler1DUint; layout(binding = 0) uniform isampler1D uSampler1DInt; layout(binding = 0) uniform sampler1D uSampler1DFloat; layout(binding = 1) uniform sampler2D uSampler2D; layout(binding = 2) uniform isampler2DArray uSampler2DArray; layout(binding = 3) uniform sampler3D uSampler3D; layout(binding = 4) uniform samplerCube uSamplerCube; layout(binding = 5) uniform usamplerCubeArray uSamplerCubeArray; layout(binding = 6) uniform samplerBuffer uSamplerBuffer; layout(binding = 7) uniform isampler2DMS uSamplerMS; layout(binding = 8) uniform sampler2DMSArray uSamplerMSArray; void main() { int a = textureSize(uSampler1DUint, 0); a = textureSize(uSampler1DInt, 0); a = textureSize(uSampler1DFloat, 0); ivec3 c = textureSize(uSampler2DArray, 0); ivec3 d = textureSize(uSampler3D, 0); ivec2 e = textureSize(uSamplerCube, 0); ivec3 f = textureSize(uSamplerCubeArray, 0); int g = textureSize(uSamplerBuffer); ivec2 h = textureSize(uSamplerMS); ivec3 i = textureSize(uSamplerMSArray); int l1 = textureQueryLevels(uSampler2D); int l2 = textureQueryLevels(uSampler2DArray); int l3 = textureQueryLevels(uSampler3D); int l4 = textureQueryLevels(uSamplerCube); int s0 = textureSamples(uSamplerMS); int s1 = textureSamples(uSamplerMSArray); } spirv-cross-2021.01.15/shaders-hlsl/frag/image-query-uav.frag000066400000000000000000000010661400026215700235640ustar00rootroot00000000000000#version 450 layout(rgba32f, binding = 0) uniform writeonly image1D uImage1D; layout(rg32f, binding = 1) uniform writeonly image2D uImage2D; layout(r32f, binding = 2) uniform readonly image2DArray uImage2DArray; layout(rgba8, binding = 3) uniform writeonly image3D uImage3D; layout(rgba8_snorm, binding = 6) uniform writeonly imageBuffer uImageBuffer; // There is no RWTexture2DMS. void main() { int a = imageSize(uImage1D); ivec2 b = imageSize(uImage2D); ivec3 c = imageSize(uImage2DArray); ivec3 d = imageSize(uImage3D); int e = imageSize(uImageBuffer); } spirv-cross-2021.01.15/shaders-hlsl/frag/image-query-uav.nonwritable-uav-texture.frag000066400000000000000000000010661400026215700303760ustar00rootroot00000000000000#version 450 layout(rgba32f, binding = 0) uniform writeonly image1D uImage1D; layout(rg32f, binding = 1) uniform writeonly image2D uImage2D; layout(r32f, binding = 2) uniform readonly image2DArray uImage2DArray; layout(rgba8, binding = 3) uniform writeonly image3D uImage3D; layout(rgba8_snorm, binding = 6) uniform writeonly imageBuffer uImageBuffer; // There is no RWTexture2DMS. void main() { int a = imageSize(uImage1D); ivec2 b = imageSize(uImage2D); ivec3 c = imageSize(uImage2DArray); ivec3 d = imageSize(uImage3D); int e = imageSize(uImageBuffer); } spirv-cross-2021.01.15/shaders-hlsl/frag/image-query.frag000066400000000000000000000023301400026215700227660ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1D uSampler1D; layout(binding = 1) uniform sampler2D uSampler2D; layout(binding = 2) uniform sampler2DArray uSampler2DArray; layout(binding = 3) uniform sampler3D uSampler3D; layout(binding = 4) uniform samplerCube uSamplerCube; layout(binding = 5) uniform samplerCubeArray uSamplerCubeArray; layout(binding = 6) uniform samplerBuffer uSamplerBuffer; layout(binding = 7) uniform sampler2DMS uSamplerMS; layout(binding = 8) uniform sampler2DMSArray uSamplerMSArray; void main() { int a = textureSize(uSampler1D, 0); ivec2 b = textureSize(uSampler2D, 0); ivec3 c = textureSize(uSampler2DArray, 0); ivec3 d = textureSize(uSampler3D, 0); ivec2 e = textureSize(uSamplerCube, 0); ivec3 f = textureSize(uSamplerCubeArray, 0); int g = textureSize(uSamplerBuffer); ivec2 h = textureSize(uSamplerMS); ivec3 i = textureSize(uSamplerMSArray); int l0 = textureQueryLevels(uSampler1D); int l1 = textureQueryLevels(uSampler2D); int l2 = textureQueryLevels(uSampler2DArray); int l3 = textureQueryLevels(uSampler3D); int l4 = textureQueryLevels(uSamplerCube); int l5 = textureQueryLevels(uSamplerCubeArray); int s0 = textureSamples(uSamplerMS); int s1 = textureSamples(uSamplerMSArray); } spirv-cross-2021.01.15/shaders-hlsl/frag/input-attachment-ms.frag000066400000000000000000000007031400026215700244450ustar00rootroot00000000000000#version 450 layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInputMS uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform subpassInputMS uSubpass1; layout(location = 0) out vec4 FragColor; vec4 load_subpasses(mediump subpassInputMS uInput) { return subpassLoad(uInput, gl_SampleID); } void main() { FragColor = subpassLoad(uSubpass0, 1) + subpassLoad(uSubpass1, 2) + load_subpasses(uSubpass0); } spirv-cross-2021.01.15/shaders-hlsl/frag/input-attachment.frag000066400000000000000000000006751400026215700240400ustar00rootroot00000000000000#version 310 es precision mediump float; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec4 FragColor; vec4 load_subpasses(mediump subpassInput uInput) { return subpassLoad(uInput); } void main() { FragColor = subpassLoad(uSubpass0) + load_subpasses(uSubpass1); } spirv-cross-2021.01.15/shaders-hlsl/frag/io-block.frag000066400000000000000000000003371400026215700222450ustar00rootroot00000000000000#version 310 es #extension GL_EXT_shader_io_blocks : require precision mediump float; layout(location = 1) in VertexOut { vec4 a; vec4 b; }; layout(location = 0) out vec4 FragColor; void main() { FragColor = a + b; } spirv-cross-2021.01.15/shaders-hlsl/frag/legacy-tex-modifiers.sm30.frag000066400000000000000000000005601400026215700253460ustar00rootroot00000000000000#version 450 layout(location = 0) in vec2 vUV; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 0) uniform sampler2D uSampler; void main() { FragColor = textureProj(uSampler, vec3(vUV, 5.0)); FragColor += texture(uSampler, vUV, 3.0); FragColor += textureLod(uSampler, vUV, 2.0); FragColor += textureGrad(uSampler, vUV, vec2(4.0), vec2(5.0)); } spirv-cross-2021.01.15/shaders-hlsl/frag/lut-promotion.frag000066400000000000000000000021661400026215700234000ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out float FragColor; layout(location = 0) flat in int index; const float LUT[16] = float[]( 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0); void main() { // Try reading LUTs, both in branches and not branch. FragColor = LUT[index]; if (index < 10) FragColor += LUT[index ^ 1]; else FragColor += LUT[index & 1]; // Not declared as a LUT, but can be promoted to one. vec4 foo[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); if (index > 30) { FragColor += foo[index & 3].y; } else { FragColor += foo[index & 1].x; } // Not declared as a LUT, but this cannot be promoted, because we have a partial write. vec4 foobar[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); if (index > 30) { foobar[1].z = 20.0; } FragColor += foobar[index & 3].z; // Not declared as a LUT, but this cannot be promoted, because we have two complete writes. vec4 baz[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0)); FragColor += baz[index & 3].z; } spirv-cross-2021.01.15/shaders-hlsl/frag/matrix-input.frag000066400000000000000000000002201400026215700231760ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 1) in mat4 m; void main() { FragColor = m[0] + m[1] + m[2] + m[3]; } spirv-cross-2021.01.15/shaders-hlsl/frag/mod.frag000066400000000000000000000007721400026215700213300ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 a4; layout(location = 1) in vec3 a3; layout(location = 2) in vec2 a2; layout(location = 3) in float a1; layout(location = 4) in vec4 b4; layout(location = 5) in vec3 b3; layout(location = 6) in vec2 b2; layout(location = 7) in float b1; layout(location = 0) out vec4 FragColor; void main() { vec4 m0 = mod(a4, b4); vec3 m1 = mod(a3, b3); vec2 m2 = mod(a2, b2); float m3 = mod(a1, b1); FragColor = m0 + m1.xyzx + m2.xyxy + m3; } spirv-cross-2021.01.15/shaders-hlsl/frag/mrt.frag000066400000000000000000000004171400026215700213470ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 RT0; layout(location = 1) out vec4 RT1; layout(location = 2) out vec4 RT2; layout(location = 3) out vec4 RT3; void main() { RT0 = vec4(1.0); RT1 = vec4(2.0); RT2 = vec4(3.0); RT3 = vec4(4.0); } spirv-cross-2021.01.15/shaders-hlsl/frag/no-return.frag000066400000000000000000000000411400026215700224670ustar00rootroot00000000000000#version 310 es void main() { } spirv-cross-2021.01.15/shaders-hlsl/frag/no-return2.frag000066400000000000000000000001621400026215700225550ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vColor; void main() { vec4 v = vColor; } spirv-cross-2021.01.15/shaders-hlsl/frag/nonuniform-qualifier.nonuniformresource.sm51.frag000066400000000000000000000015201400026215700314370ustar00rootroot00000000000000#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(set = 0, binding = 0) uniform texture2D uSamplers[]; layout(set = 1, binding = 0) uniform sampler2D uCombinedSamplers[]; layout(set = 2, binding = 0) uniform sampler uSamps[]; layout(location = 0) flat in int vIndex; layout(location = 1) in vec2 vUV; layout(location = 0) out vec4 FragColor; layout(set = 3, binding = 0) uniform UBO { vec4 v[64]; } ubos[]; layout(set = 4, binding = 0) readonly buffer SSBO { vec4 v[]; } ssbos[]; void main() { int i = vIndex; FragColor = texture(sampler2D(uSamplers[nonuniformEXT(i + 10)], uSamps[nonuniformEXT(i + 40)]), vUV); FragColor = texture(uCombinedSamplers[nonuniformEXT(i + 10)], vUV); FragColor += ubos[nonuniformEXT(i + 20)].v[nonuniformEXT(i + 40)]; FragColor += ssbos[nonuniformEXT(i + 50)].v[nonuniformEXT(i + 60)]; } spirv-cross-2021.01.15/shaders-hlsl/frag/partial-write-preserve.frag000066400000000000000000000013341400026215700251610ustar00rootroot00000000000000#version 310 es precision mediump float; layout(std140, binding = 0) uniform UBO { int some_value; }; struct B { float a; float b; }; void partial_inout(inout vec4 x) { x.x = 10.0; } void partial_inout(inout B b) { b.b = 40.0; } // Make a complete write, but only conditionally ... void branchy_inout(inout vec4 v) { v.y = 20.0; if (some_value == 20) { v = vec4(50.0); } } void branchy_inout_2(out vec4 v) { if (some_value == 20) { v = vec4(50.0); } else { v = vec4(70.0); } v.y = 20.0; } void complete_inout(out vec4 x) { x = vec4(50.0); } void main() { vec4 a = vec4(10.0); partial_inout(a); complete_inout(a); branchy_inout(a); branchy_inout_2(a); B b = B(10.0, 20.0); partial_inout(b); } spirv-cross-2021.01.15/shaders-hlsl/frag/pixel-interlock-ordered.sm51.fxconly.frag000066400000000000000000000015271400026215700275500ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; layout(binding = 2, rgba8) uniform readonly image2D img3; layout(binding = 3) coherent buffer Buffer { int foo; uint bar; }; layout(binding = 4) buffer Buffer2 { uint quux; }; layout(binding = 5, rgba8) uniform writeonly image2D img4; layout(binding = 6) buffer Buffer3 { int baz; }; void main() { // Deliberately outside the critical section to test usage tracking. baz = 0; imageStore(img4, ivec2(1, 1), vec4(1.0, 0.0, 0.0, 1.0)); beginInvocationInterlockARB(); imageStore(img, ivec2(0, 0), imageLoad(img3, ivec2(0, 0))); imageAtomicAdd(img2, ivec2(0, 0), 1u); foo += 42; atomicAnd(bar, quux); endInvocationInterlockARB(); } spirv-cross-2021.01.15/shaders-hlsl/frag/point-coord-compat.frag000066400000000000000000000002011400026215700242520ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec2 FragColor; void main() { FragColor = gl_PointCoord; } spirv-cross-2021.01.15/shaders-hlsl/frag/query-lod.desktop.frag000066400000000000000000000003301400026215700241300ustar00rootroot00000000000000#version 450 layout(location = 0) in vec2 vTexCoord; layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; void main() { FragColor = textureQueryLod(uSampler, vTexCoord).xyxy; } spirv-cross-2021.01.15/shaders-hlsl/frag/readonly-coherent-ssbo.force-uav.frag000066400000000000000000000002411400026215700270140ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) coherent readonly buffer SSBO { vec4 a; }; layout(location = 0) out vec4 FragColor; void main() { FragColor = a; } spirv-cross-2021.01.15/shaders-hlsl/frag/readonly-coherent-ssbo.frag000066400000000000000000000002411400026215700251260ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) coherent readonly buffer SSBO { vec4 a; }; layout(location = 0) out vec4 FragColor; void main() { FragColor = a; } spirv-cross-2021.01.15/shaders-hlsl/frag/resources.frag000066400000000000000000000011331400026215700225530ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 3, std140) uniform CBuffer { vec4 a; } cbuf; layout(binding = 4) uniform sampler2D uSampledImage; layout(binding = 5) uniform mediump texture2D uTexture; layout(binding = 6) uniform mediump sampler uSampler; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTex; layout(std430, push_constant) uniform PushMe { vec4 d; } registers; void main() { vec4 c0 = texture(uSampledImage, vTex); vec4 c1 = texture(sampler2D(uTexture, uSampler), vTex); vec4 c2 = cbuf.a + registers.d; FragColor = c0 + c1 + c2; } spirv-cross-2021.01.15/shaders-hlsl/frag/row-major-layout-in-struct.frag000066400000000000000000000005071400026215700257230ustar00rootroot00000000000000#version 450 struct Foo { mat4 v; mat4 w; }; struct NonFoo { mat4 v; mat4 w; }; layout(std140, binding = 0) uniform UBO { layout(column_major) Foo foo; }; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vUV; void main() { NonFoo f; f.v = foo.v; f.w = foo.w; FragColor = f.v * (f.w * vUV); } spirv-cross-2021.01.15/shaders-hlsl/frag/sample-cmp-level-zero.frag000066400000000000000000000020211400026215700246560ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(binding = 0) uniform sampler2DShadow uSampler2D; layout(binding = 1) uniform sampler2DArrayShadow uSampler2DArray; layout(binding = 2) uniform samplerCubeShadow uSamplerCube; layout(binding = 3) uniform samplerCubeArrayShadow uSamplerCubeArray; layout(location = 0) in vec3 vUVRef; layout(location = 1) in vec4 vDirRef; void main() { float s0 = textureOffset(uSampler2D, vUVRef, ivec2(-1)); float s1 = textureOffset(uSampler2DArray, vDirRef, ivec2(-1)); float s2 = texture(uSamplerCube, vDirRef); float s3 = texture(uSamplerCubeArray, vDirRef, 0.5); float l0 = textureLodOffset(uSampler2D, vUVRef, 0.0, ivec2(-1)); float l1 = textureGradOffset(uSampler2DArray, vDirRef, vec2(0.0), vec2(0.0), ivec2(-1)); float l2 = textureGrad(uSamplerCube, vDirRef, vec3(0.0), vec3(0.0)); float p0 = textureProjOffset(uSampler2D, vDirRef, ivec2(+1)); float p1 = textureProjLodOffset(uSampler2D, vDirRef, 0.0, ivec2(+1)); FragColor = s0 + s1 + s2 + s3 + l0 + l1 + l2 + p0 + p1; } spirv-cross-2021.01.15/shaders-hlsl/frag/sample-mask-in-and-out.frag000066400000000000000000000002101400026215700247170ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0); gl_SampleMask[0] = gl_SampleMaskIn[0]; } spirv-cross-2021.01.15/shaders-hlsl/frag/sample-mask-in.frag000066400000000000000000000002341400026215700233600ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { if ((gl_SampleMaskIn[0] & (1 << gl_SampleID)) != 0) { FragColor = vec4(1.0); } } spirv-cross-2021.01.15/shaders-hlsl/frag/sample-mask-out.frag000066400000000000000000000001671400026215700235660ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0); gl_SampleMask[0] = 0; } spirv-cross-2021.01.15/shaders-hlsl/frag/sampler-array.frag000066400000000000000000000014411400026215700233220ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uCombined[4]; layout(binding = 4) uniform texture2D uTex[4]; layout(binding = 8) uniform sampler uSampler[4]; layout(binding = 12, rgba32f) uniform writeonly image2D uImage[8]; layout(location = 0) in vec2 vTex; layout(location = 1) flat in int vIndex; vec4 sample_in_function(sampler2D samp) { return texture(samp, vTex); } vec4 sample_in_function2(texture2D tex, sampler samp) { return texture(sampler2D(tex, samp), vTex); } void main() { vec4 color = texture(uCombined[vIndex], vTex); color += texture(sampler2D(uTex[vIndex], uSampler[vIndex]), vTex); color += sample_in_function(uCombined[vIndex + 1]); color += sample_in_function2(uTex[vIndex + 1], uSampler[vIndex + 1]); imageStore(uImage[vIndex], ivec2(gl_FragCoord.xy), color); } spirv-cross-2021.01.15/shaders-hlsl/frag/sampler-image-arrays.frag000066400000000000000000000015231400026215700245660ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) flat in vec2 vTex; layout(location = 1) flat in int vIndex; layout(binding = 0) uniform sampler2D uSampler[4]; layout(binding = 4) uniform sampler uSamplers[4]; layout(binding = 8) uniform texture2D uTextures[4]; vec4 sample_from_argument(sampler2D samplers[4]) { return texture(samplers[vIndex], vTex + 0.2); } vec4 sample_single_from_argument(sampler2D samp) { return texture(samp, vTex + 0.3); } vec4 sample_from_global() { return texture(uSampler[vIndex], vTex + 0.1); } void main() { FragColor = vec4(0.0); FragColor += texture(sampler2D(uTextures[2], uSamplers[1]), vTex); FragColor += texture(uSampler[vIndex], vTex); FragColor += sample_from_global(); FragColor += sample_from_argument(uSampler); FragColor += sample_single_from_argument(uSampler[3]); } spirv-cross-2021.01.15/shaders-hlsl/frag/scalar-refract-reflect.frag000066400000000000000000000005131400026215700250550ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(location = 0) in vec3 vRefract; void main() { FragColor = refract(vRefract.x, vRefract.y, vRefract.z); FragColor += reflect(vRefract.x, vRefract.y); FragColor += refract(vRefract.xy, vRefract.yz, vRefract.z).y; FragColor += reflect(vRefract.xy, vRefract.zy).y; } spirv-cross-2021.01.15/shaders-hlsl/frag/separate-combined-fake-overload.sm30.frag000066400000000000000000000006071400026215700274260ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uSamp; layout(binding = 1) uniform texture2D uT; layout(binding = 2) uniform sampler uS; vec4 samp(sampler2D uSamp) { return texture(uSamp, vec2(0.5)); } vec4 samp(texture2D T, sampler S) { return texture(sampler2D(T, S), vec2(0.5)); } void main() { FragColor = samp(uSamp) + samp(uT, uS); } spirv-cross-2021.01.15/shaders-hlsl/frag/spec-constant-block-size.frag000066400000000000000000000004371400026215700253700ustar00rootroot00000000000000#version 310 es precision mediump float; layout(constant_id = 10) const int Value = 2; layout(binding = 0) uniform SpecConstArray { vec4 samples[Value]; }; layout(location = 0) flat in int Index; layout(location = 0) out vec4 FragColor; void main() { FragColor = samples[Index]; } spirv-cross-2021.01.15/shaders-hlsl/frag/spec-constant-ternary.frag000066400000000000000000000002571400026215700250120ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(constant_id = 0) const uint s = 10u; const uint f = s > 20u ? 30u : 50u; void main() { FragColor = float(f); } spirv-cross-2021.01.15/shaders-hlsl/frag/switch-unsigned-case.frag000066400000000000000000000005461400026215700245740ustar00rootroot00000000000000#version 310 es precision mediump float; #define ENUM_0 0u #define ENUM_1 1u layout(set = 0, binding = 0) uniform Buff { uint TestVal; }; layout(location = 0) out vec4 fsout_Color; void main() { fsout_Color = vec4(1.0); switch (TestVal) { case ENUM_0: fsout_Color = vec4(0.1); break; case ENUM_1: fsout_Color = vec4(0.2); break; } } spirv-cross-2021.01.15/shaders-hlsl/frag/swizzle-scalar.frag000066400000000000000000000005431400026215700235170ustar00rootroot00000000000000#version 450 layout(location = 0) flat in float vFloat; layout(location = 1) flat in int vInt; layout(location = 0) out vec4 Float; layout(location = 1) out ivec4 Int; layout(location = 2) out vec4 Float2; layout(location = 3) out ivec4 Int2; void main() { Float = vec4(vFloat) * 2.0; Int = ivec4(vInt) * 2; Float2 = vec4(10.0); Int2 = ivec4(10); } spirv-cross-2021.01.15/shaders-hlsl/frag/tex-sampling-ms.frag000066400000000000000000000005511400026215700235710ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2DMS uTex; void main() { FragColor = texelFetch(uTex, ivec2(gl_FragCoord.xy), 0); FragColor += texelFetch(uTex, ivec2(gl_FragCoord.xy), 1); FragColor += texelFetch(uTex, ivec2(gl_FragCoord.xy), 2); FragColor += texelFetch(uTex, ivec2(gl_FragCoord.xy), 3); } spirv-cross-2021.01.15/shaders-hlsl/frag/tex-sampling.frag000066400000000000000000000064161400026215700231620ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1D tex1d; layout(binding = 1) uniform sampler2D tex2d; layout(binding = 2) uniform sampler3D tex3d; layout(binding = 3) uniform samplerCube texCube; layout(binding = 4) uniform sampler1DShadow tex1dShadow; layout(binding = 5) uniform sampler2DShadow tex2dShadow; layout(binding = 6) uniform samplerCubeShadow texCubeShadow; layout(binding = 7) uniform sampler1DArray tex1dArray; layout(binding = 8) uniform sampler2DArray tex2dArray; layout(binding = 9) uniform samplerCubeArray texCubeArray; layout(binding = 10) uniform samplerShadow samplerDepth; layout(binding = 11) uniform sampler samplerNonDepth; layout(binding = 12) uniform texture2D separateTex2d; layout(binding = 13) uniform texture2D separateTex2dDepth; layout(location = 0) in float texCoord1d; layout(location = 1) in vec2 texCoord2d; layout(location = 2) in vec3 texCoord3d; layout(location = 3) in vec4 texCoord4d; layout(location = 0) out vec4 FragColor; void main() { vec4 texcolor = texture(tex1d, texCoord1d); texcolor += textureOffset(tex1d, texCoord1d, 1); texcolor += textureLod(tex1d, texCoord1d, 2); texcolor += textureGrad(tex1d, texCoord1d, 1.0, 2.0); texcolor += textureProj(tex1d, vec2(texCoord1d, 2.0)); texcolor += texture(tex1d, texCoord1d, 1.0); texcolor += texture(tex2d, texCoord2d); texcolor += textureOffset(tex2d, texCoord2d, ivec2(1, 2)); texcolor += textureLod(tex2d, texCoord2d, 2); texcolor += textureGrad(tex2d, texCoord2d, vec2(1.0, 2.0), vec2(3.0, 4.0)); texcolor += textureProj(tex2d, vec3(texCoord2d, 2.0)); texcolor += texture(tex2d, texCoord2d, 1.0); texcolor += texture(tex3d, texCoord3d); texcolor += textureOffset(tex3d, texCoord3d, ivec3(1, 2, 3)); texcolor += textureLod(tex3d, texCoord3d, 2); texcolor += textureGrad(tex3d, texCoord3d, vec3(1.0, 2.0, 3.0), vec3(4.0, 5.0, 6.0)); texcolor += textureProj(tex3d, vec4(texCoord3d, 2.0)); texcolor += texture(tex3d, texCoord3d, 1.0); texcolor += texture(texCube, texCoord3d); texcolor += textureLod(texCube, texCoord3d, 2); texcolor += texture(texCube, texCoord3d, 1.0); texcolor.a += texture(tex1dShadow, vec3(texCoord1d, 0.0, 0.0)); texcolor.a += texture(tex2dShadow, vec3(texCoord2d, 0.0)); texcolor.a += texture(texCubeShadow, vec4(texCoord3d, 0.0)); texcolor += texture(tex1dArray, texCoord2d); texcolor += texture(tex2dArray, texCoord3d); texcolor += texture(texCubeArray, texCoord4d); texcolor += textureGather(tex2d, texCoord2d); texcolor += textureGather(tex2d, texCoord2d, 0); texcolor += textureGather(tex2d, texCoord2d, 1); texcolor += textureGather(tex2d, texCoord2d, 2); texcolor += textureGather(tex2d, texCoord2d, 3); texcolor += textureGatherOffset(tex2d, texCoord2d, ivec2(1, 1)); texcolor += textureGatherOffset(tex2d, texCoord2d, ivec2(1, 1), 0); texcolor += textureGatherOffset(tex2d, texCoord2d, ivec2(1, 1), 1); texcolor += textureGatherOffset(tex2d, texCoord2d, ivec2(1, 1), 2); texcolor += textureGatherOffset(tex2d, texCoord2d, ivec2(1, 1), 3); texcolor += texelFetch(tex2d, ivec2(1, 2), 0); texcolor += texture(sampler2D(separateTex2d, samplerNonDepth), texCoord2d); texcolor.a += texture(sampler2DShadow(separateTex2dDepth, samplerDepth), texCoord3d); FragColor = texcolor; } spirv-cross-2021.01.15/shaders-hlsl/frag/texel-fetch-offset.frag000066400000000000000000000004671400026215700242460ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uTexture; void main() { FragColor = texelFetchOffset(uTexture, ivec2(gl_FragCoord.xy), 0, ivec2(1, 1)); FragColor += texelFetchOffset(uTexture, ivec2(gl_FragCoord.xy), 0, ivec2(-1, 1)); } spirv-cross-2021.01.15/shaders-hlsl/frag/texture-proj-shadow.frag000066400000000000000000000012471400026215700245020ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1DShadow uShadow1D; layout(binding = 1) uniform sampler2DShadow uShadow2D; layout(binding = 2) uniform sampler1D uSampler1D; layout(binding = 3) uniform sampler2D uSampler2D; layout(binding = 4) uniform sampler3D uSampler3D; layout(location = 0) out float FragColor; layout(location = 0) in vec3 vClip3; layout(location = 1) in vec4 vClip4; layout(location = 2) in vec2 vClip2; void main() { FragColor = textureProj(uShadow1D, vClip4); FragColor = textureProj(uShadow2D, vClip4); FragColor = textureProj(uSampler1D, vClip2).x; FragColor = textureProj(uSampler2D, vClip3).x; FragColor = textureProj(uSampler3D, vClip4).x; } spirv-cross-2021.01.15/shaders-hlsl/frag/texture-size-combined-image-sampler.frag000066400000000000000000000003461400026215700275150ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform texture2D uTex; layout(set = 0, binding = 1) uniform sampler uSampler; layout(location = 0) out ivec2 FooOut; void main() { FooOut = textureSize(sampler2D(uTex, uSampler), 0); } spirv-cross-2021.01.15/shaders-hlsl/frag/unary-enclose.frag000066400000000000000000000003711400026215700233300ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vIn; layout(location = 1) flat in ivec4 vIn1; void main() { FragColor = +(-(-vIn)); ivec4 a = ~(~vIn1); bool b = false; b = !!b; } spirv-cross-2021.01.15/shaders-hlsl/frag/unorm-snorm-packing.frag000066400000000000000000000013421400026215700244510ustar00rootroot00000000000000#version 450 layout(location = 0) flat in uint SNORM8; layout(location = 1) flat in uint UNORM8; layout(location = 2) flat in uint SNORM16; layout(location = 3) flat in uint UNORM16; layout(location = 4) flat in vec4 FP32; layout(location = 0) out vec4 FP32Out; layout(location = 1) out uint UNORM8Out; layout(location = 2) out uint SNORM8Out; layout(location = 3) out uint UNORM16Out; layout(location = 4) out uint SNORM16Out; void main() { FP32Out = unpackUnorm4x8(UNORM8); FP32Out = unpackSnorm4x8(SNORM8); FP32Out.xy = unpackUnorm2x16(UNORM16); FP32Out.xy = unpackSnorm2x16(SNORM16); UNORM8Out = packUnorm4x8(FP32); SNORM8Out = packSnorm4x8(FP32); UNORM16Out = packUnorm2x16(FP32.xy); SNORM16Out = packSnorm2x16(FP32.zw); } spirv-cross-2021.01.15/shaders-hlsl/frag/various-glsl-ops.frag000066400000000000000000000007551400026215700240000ustar00rootroot00000000000000#version 450 layout(location = 0) in vec2 interpolant; layout(location = 0) out vec4 FragColor; void main() { vec4 color = vec4(0.0, 0.0, 0.0, interpolateAtOffset(interpolant, vec2(0.1, 0.1))); // glslang's HLSL parser currently fails here //color += vec4(0.0, 0.0, 0.0, interpolateAtSample(interpolant, gl_SampleID)); //color += vec4(0.0, 0.0, 0.0, interpolateAtCentroid(interpolant)); color += vec4(0.0, 0.0, 0.0, dFdxCoarse(interpolant.x)); FragColor = color; } spirv-cross-2021.01.15/shaders-hlsl/vert/000077500000000000000000000000001400026215700177435ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-hlsl/vert/basic.vert000066400000000000000000000004051400026215700217250ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { uniform mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders-hlsl/vert/clip-cull-distance.vert000066400000000000000000000003051400026215700243170ustar00rootroot00000000000000#version 450 out float gl_ClipDistance[2]; out float gl_CullDistance[1]; void main() { gl_Position = vec4(1.0); gl_ClipDistance[0] = 0.0; gl_ClipDistance[1] = 0.0; gl_CullDistance[0] = 4.0; } spirv-cross-2021.01.15/shaders-hlsl/vert/instancing.vert000066400000000000000000000001401400026215700227750ustar00rootroot00000000000000#version 310 es void main() { gl_Position = vec4(float(gl_VertexIndex + gl_InstanceIndex)); } spirv-cross-2021.01.15/shaders-hlsl/vert/locations.vert000066400000000000000000000021521400026215700226400ustar00rootroot00000000000000#version 310 es #extension GL_EXT_shader_io_blocks : require struct Foo { vec3 a; vec3 b; vec3 c; }; // This will lock to input location 2. layout(location = 2) in vec4 Input2; // This will lock to input location 4. layout(location = 4) in vec4 Input4; // This will pick first available, which is 0. layout(location = 0) in vec4 Input0; // Locks output 0. layout(location = 0) out float vLocation0; // Locks output 1. layout(location = 1) out float vLocation1; // Picks first available two locations, so, 2 and 3. layout(location = 2) out float vLocation2[2]; // Picks first available location, 4. layout(location = 4) out Foo vLocation4; // Picks first available location 9. layout(location = 9) out float vLocation9; // Locks location 7 and 8. layout(location = 7) out VertexOut { vec3 color; vec3 foo; } vout; void main() { gl_Position = vec4(1.0) + Input2 + Input4 + Input0; vLocation0 = 0.0; vLocation1 = 1.0; vLocation2[0] = 2.0; vLocation2[1] = 2.0; Foo foo; foo.a = vec3(1.0); foo.b = vec3(1.0); foo.c = vec3(1.0); vLocation4 = foo; vLocation9 = 9.0; vout.color = vec3(2.0); vout.foo = vec3(4.0); } spirv-cross-2021.01.15/shaders-hlsl/vert/matrix-attribute.vert000066400000000000000000000002071400026215700241510ustar00rootroot00000000000000#version 310 es layout(location = 0) in vec3 pos; layout(location = 1) in mat4 m; void main() { gl_Position = m * vec4(pos, 1.0); } spirv-cross-2021.01.15/shaders-hlsl/vert/matrix-output.vert000066400000000000000000000001521400026215700235050ustar00rootroot00000000000000#version 450 layout(location = 0) out mat4 m; void main() { gl_Position = vec4(1.0); m = mat4(1.0); } spirv-cross-2021.01.15/shaders-hlsl/vert/no-input.vert000066400000000000000000000000731400026215700224160ustar00rootroot00000000000000#version 310 es void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders-hlsl/vert/point-size-compat.vert000066400000000000000000000001201400026215700242200ustar00rootroot00000000000000#version 310 es void main() { gl_Position = vec4(1.0); gl_PointSize = 1.0; } spirv-cross-2021.01.15/shaders-hlsl/vert/qualifiers.vert000066400000000000000000000010711400026215700230100ustar00rootroot00000000000000#version 450 layout(location = 0) flat out float vFlat; layout(location = 1) centroid out float vCentroid; layout(location = 2) sample out float vSample; layout(location = 3) noperspective out float vNoperspective; layout(location = 4) out Block { flat float vFlat; centroid float vCentroid; sample float vSample; noperspective float vNoperspective; } vout; void main() { gl_Position = vec4(1.0); vFlat = 0.0; vCentroid = 1.0; vSample = 2.0; vNoperspective = 3.0; vout.vFlat = 0.0; vout.vCentroid = 1.0; vout.vSample = 2.0; vout.vNoperspective = 3.0; } spirv-cross-2021.01.15/shaders-hlsl/vert/read-from-row-major-array.vert000066400000000000000000000013741400026215700255550ustar00rootroot00000000000000#version 310 es layout(location = 0) in highp vec4 a_position; layout(location = 0) out mediump float v_vtxResult; layout(set = 0, binding = 0, std140, row_major) uniform Block { highp mat2x3 var[3][4]; }; mediump float compare_float (highp float a, highp float b) { return abs(a - b) < 0.05 ? 1.0 : 0.0; } mediump float compare_vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z); } mediump float compare_mat2x3 (highp mat2x3 a, highp mat2x3 b){ return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1]); } void main (void) { gl_Position = a_position; mediump float result = 1.0; result *= compare_mat2x3(var[0][0], mat2x3(2.0, 6.0, -6.0, 0.0, 5.0, 5.0)); v_vtxResult = result; } spirv-cross-2021.01.15/shaders-hlsl/vert/return-array.vert000066400000000000000000000004631400026215700233030ustar00rootroot00000000000000#version 310 es layout(location = 0) in vec4 vInput0; layout(location = 1) in vec4 vInput1; vec4[2] test() { return vec4[](vec4(10.0), vec4(20.0)); } vec4[2] test2() { vec4 foobar[2]; foobar[0] = vInput0; foobar[1] = vInput1; return foobar; } void main() { gl_Position = test()[0] + test2()[1]; } spirv-cross-2021.01.15/shaders-hlsl/vert/sampler-buffers.vert000066400000000000000000000007321400026215700237440ustar00rootroot00000000000000#version 450 layout(binding = 1) uniform samplerBuffer uFloatSampler; layout(binding = 2) uniform isamplerBuffer uIntSampler; layout(binding = 3) uniform usamplerBuffer uUintSampler; vec4 sample_from_function(samplerBuffer s0, isamplerBuffer s1, usamplerBuffer s2) { return texelFetch(s0, 20) + intBitsToFloat(texelFetch(s1, 40)) + uintBitsToFloat(texelFetch(s2, 60)); } void main() { gl_Position = sample_from_function(uFloatSampler, uIntSampler, uUintSampler); } spirv-cross-2021.01.15/shaders-hlsl/vert/struct-composite-decl.vert000066400000000000000000000005061400026215700250770ustar00rootroot00000000000000#version 310 es layout(location = 0) in vec4 a; layout(location = 1) in vec4 b; layout(location = 2) in vec4 c; layout(location = 3) in vec4 d; struct VOut { vec4 a; vec4 b; vec4 c; vec4 d; }; layout(location = 0) out VOut vout; void emit_result(VOut v) { vout = v; } void main() { emit_result(VOut(a, b, c, d)); } spirv-cross-2021.01.15/shaders-hlsl/vert/texture_buffer.vert000066400000000000000000000003231400026215700236740ustar00rootroot00000000000000#version 450 layout(binding = 4) uniform samplerBuffer uSamp; layout(rgba32f, binding = 5) uniform readonly imageBuffer uSampo; void main() { gl_Position = texelFetch(uSamp, 10) + imageLoad(uSampo, 100); } spirv-cross-2021.01.15/shaders-msl-no-opt/000077500000000000000000000000001400026215700200265ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/000077500000000000000000000000001400026215700206065ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/000077500000000000000000000000001400026215700215445ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/aliased-struct-divergent-member-name.asm.comp000066400000000000000000000060021400026215700322750ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 37 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %T "T" OpMemberName %T 0 "a" OpName %v "v" OpName %T_0 "T" OpMemberName %T_0 0 "b" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "foo" OpName %_ "" OpName %T_1 "T" OpMemberName %T_1 0 "c" OpName %SSBO2 "SSBO2" OpMemberName %SSBO2 0 "bar" OpName %__0 "" OpMemberDecorate %T_0 0 Offset 0 OpDecorate %_runtimearr_T_0 ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpMemberDecorate %T_1 0 Offset 0 OpDecorate %_runtimearr_T_1 ArrayStride 16 OpMemberDecorate %SSBO2 0 Offset 0 OpDecorate %SSBO2 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %T = OpTypeStruct %float %_ptr_Function_T = OpTypePointer Function %T %float_40 = OpConstant %float 40 %11 = OpConstantComposite %T %float_40 %T_0 = OpTypeStruct %float %_runtimearr_T_0 = OpTypeRuntimeArray %T_0 %SSBO1 = OpTypeStruct %_runtimearr_T_0 %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %_ptr_Uniform_T_0 = OpTypePointer Uniform %T_0 %_ptr_Uniform_float = OpTypePointer Uniform %float %T_1 = OpTypeStruct %float %_runtimearr_T_1 = OpTypeRuntimeArray %T_1 %SSBO2 = OpTypeStruct %_runtimearr_T_1 %_ptr_Uniform_SSBO2 = OpTypePointer Uniform %SSBO2 %__0 = OpVariable %_ptr_Uniform_SSBO2 Uniform %int_30 = OpConstant %int 30 %_ptr_Uniform_T_1 = OpTypePointer Uniform %T_1 %main = OpFunction %void None %3 %5 = OpLabel %v = OpVariable %_ptr_Function_T Function OpStore %v %11 %20 = OpLoad %T %v %22 = OpAccessChain %_ptr_Uniform_T_0 %_ %int_0 %int_10 %23 = OpCompositeExtract %float %20 0 %25 = OpAccessChain %_ptr_Uniform_float %22 %int_0 OpStore %25 %23 %32 = OpLoad %T %v %34 = OpAccessChain %_ptr_Uniform_T_1 %__0 %int_0 %int_30 %35 = OpCompositeExtract %float %32 0 %36 = OpAccessChain %_ptr_Uniform_float %34 %int_0 OpStore %36 %35 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/arithmetic-conversion-signs.asm.comp000066400000000000000000000114771400026215700306520ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 76 ; Schema: 0 OpCapability Shader OpCapability Int16 OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_shader_explicit_arithmetic_types_int16" OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "s32" OpMemberName %SSBO 1 "u32" OpMemberName %SSBO 2 "s16" OpMemberName %SSBO 3 "u16" OpMemberName %SSBO 4 "f32" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpMemberDecorate %SSBO 2 Offset 8 OpMemberDecorate %SSBO 3 Offset 10 OpMemberDecorate %SSBO 4 Offset 12 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %short = OpTypeInt 16 1 %ushort = OpTypeInt 16 0 %float = OpTypeFloat 32 %SSBO = OpTypeStruct %int %uint %short %ushort %float %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %_ptr_Uniform_int = OpTypePointer Uniform %int %_ptr_Uniform_short = OpTypePointer Uniform %short %int_1 = OpConstant %int 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_3 = OpConstant %int 3 %_ptr_Uniform_ushort = OpTypePointer Uniform %ushort %int_4 = OpConstant %int 4 %_ptr_Uniform_float = OpTypePointer Uniform %float %main = OpFunction %void None %3 %5 = OpLabel %ptr_s32 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %ptr_u32 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %ptr_s16 = OpAccessChain %_ptr_Uniform_short %_ %int_2 %ptr_u16 = OpAccessChain %_ptr_Uniform_ushort %_ %int_3 %ptr_f32 = OpAccessChain %_ptr_Uniform_float %_ %int_4 %s32 = OpLoad %int %ptr_s32 %u32 = OpLoad %uint %ptr_u32 %s16 = OpLoad %short %ptr_s16 %u16 = OpLoad %ushort %ptr_u16 %f32 = OpLoad %float %ptr_f32 ; Sign-extend %s16_to_s32_signed = OpSConvert %int %s16 OpStore %ptr_s32 %s16_to_s32_signed %s16_to_u32_signed = OpSConvert %uint %s16 OpStore %ptr_u32 %s16_to_u32_signed %u16_to_s32_signed = OpSConvert %int %u16 OpStore %ptr_s32 %u16_to_s32_signed %u16_to_u32_signed = OpSConvert %uint %u16 OpStore %ptr_u32 %u16_to_u32_signed ; Zero-extend ; Result must be unsigned for OpUConvert. ;%s16_to_s32_unsigned = OpUConvert %int %s16 ;OpStore %ptr_s32 %s16_to_s32_unsigned %s16_to_u32_unsigned = OpUConvert %uint %s16 OpStore %ptr_u32 %s16_to_u32_unsigned ;%u16_to_s32_unsigned = OpUConvert %int %u16 ;OpStore %ptr_s32 %u16_to_s32_unsigned %u16_to_u32_unsigned = OpUConvert %uint %u16 OpStore %ptr_u32 %u16_to_u32_unsigned ; Truncate (SConvert == UConvert) %s32_to_s16_signed = OpSConvert %short %s32 OpStore %ptr_s16 %s32_to_s16_signed %s32_to_u16_signed = OpSConvert %ushort %s32 OpStore %ptr_u16 %s32_to_u16_signed %u32_to_s16_signed = OpSConvert %short %u32 OpStore %ptr_s16 %u32_to_s16_signed %u32_to_u16_signed = OpSConvert %ushort %u32 OpStore %ptr_u16 %u32_to_u16_signed ;%s32_to_s16_unsigned = OpUConvert %short %s32 ;OpStore %ptr_s16 %s32_to_s16_unsigned %s32_to_u16_unsigned = OpUConvert %ushort %s32 OpStore %ptr_u16 %s32_to_u16_unsigned ;%u32_to_s16_unsigned = OpUConvert %short %u32 ;OpStore %ptr_s16 %u32_to_s16_unsigned %u32_to_u16_unsigned = OpUConvert %ushort %u32 OpStore %ptr_u16 %u32_to_u16_unsigned ; SToF %s16_to_f32_signed = OpConvertSToF %float %s16 OpStore %ptr_f32 %s16_to_f32_signed %u16_to_f32_signed = OpConvertSToF %float %u16 OpStore %ptr_f32 %u16_to_f32_signed %s16_to_f32_unsigned = OpConvertUToF %float %s16 OpStore %ptr_f32 %s16_to_f32_unsigned %u16_to_f32_unsigned = OpConvertUToF %float %u16 OpStore %ptr_f32 %u16_to_f32_unsigned ; FToS %f32_to_s16_signed = OpConvertFToS %short %f32 OpStore %ptr_s16 %f32_to_s16_signed %f32_to_u16_signed = OpConvertFToS %ushort %f32 OpStore %ptr_u16 %f32_to_u16_signed ; FToU %f32_to_u16_unsigned = OpConvertFToU %ushort %f32 OpStore %ptr_u16 %f32_to_u16_unsigned ; Result must be unsigned for FToU, so don't bother testing that. OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/atomic-load-store.asm.comp000066400000000000000000000035361400026215700265350ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 23 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %c "c" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a" OpMemberName %SSBO 1 "b" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %SSBO = OpTypeStruct %uint %uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_0 = OpConstant %int 0 %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %c = OpVariable %_ptr_Function_uint Function %15 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %16 = OpAtomicLoad %uint %15 %int_1 %int_0 OpStore %c %16 %18 = OpLoad %uint %c %19 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 OpAtomicStore %19 %int_1 %int_0 %18 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/atomic-result-temporary.asm.comp000066400000000000000000000045461400026215700300240ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "count" OpMemberName %SSBO 1 "data" OpName %_ "" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO = OpTypeStruct %uint %_runtimearr_uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %uint_1024 = OpConstant %uint 1024 %bool = OpTypeBool %int_1 = OpConstant %int 1 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %_ptr_Input_uint = OpTypePointer Input %uint %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %19 = OpAtomicIAdd %uint %16 %uint_1 %uint_0 %uint_1 %23 = OpULessThan %bool %19 %uint_1024 OpSelectionMerge %25 None OpBranchConditional %23 %24 %25 %24 = OpLabel %32 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %33 = OpLoad %uint %32 %34 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %19 OpStore %34 %33 OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/bitcast-fp16-fp32.asm.comp000066400000000000000000000047531400026215700261670ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 33 ; Schema: 0 OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_shader_explicit_arithmetic_types" OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a" OpMemberName %SSBO 1 "b" OpMemberName %SSBO 2 "c" OpMemberName %SSBO 3 "d" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpMemberDecorate %SSBO 2 Offset 8 OpMemberDecorate %SSBO 3 Offset 12 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %half = OpTypeFloat 16 %v2half = OpTypeVector %half 2 %float = OpTypeFloat 32 %SSBO = OpTypeStruct %v2half %float %float %v2half %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_v2half = OpTypePointer Uniform %v2half %uint = OpTypeInt 32 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %int_3 = OpConstant %int 3 %int_2 = OpConstant %int 2 %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Uniform_v2half %_ %int_0 %17 = OpLoad %v2half %16 %20 = OpBitcast %float %17 %22 = OpAccessChain %_ptr_Uniform_float %_ %int_1 OpStore %22 %20 %25 = OpAccessChain %_ptr_Uniform_float %_ %int_2 %26 = OpLoad %float %25 %28 = OpBitcast %v2half %26 %29 = OpAccessChain %_ptr_Uniform_v2half %_ %int_3 OpStore %29 %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/bitfield-signed-operations.asm.comp000066400000000000000000000077351400026215700304310ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 26 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "ints" OpMemberName %SSBO 1 "uints" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 16 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %uint = OpTypeInt 32 0 %v4uint = OpTypeVector %uint 4 %int_1 = OpConstant %int 1 %uint_11 = OpConstant %uint 11 %SSBO = OpTypeStruct %v4int %v4uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_v4int = OpTypePointer Uniform %v4int %_ptr_Uniform_v4uint = OpTypePointer Uniform %v4uint %main = OpFunction %void None %3 %5 = OpLabel %ints_ptr = OpAccessChain %_ptr_Uniform_v4int %_ %int_0 %uints_ptr = OpAccessChain %_ptr_Uniform_v4uint %_ %int_1 %ints = OpLoad %v4int %ints_ptr %uints = OpLoad %v4uint %uints_ptr %ints_alt = OpVectorShuffle %v4int %ints %ints 3 2 1 0 %uints_alt = OpVectorShuffle %v4uint %uints %uints 3 2 1 0 %int_to_int_popcount = OpBitCount %v4int %ints %int_to_uint_popcount = OpBitCount %v4uint %ints %uint_to_int_popcount = OpBitCount %v4int %uints %uint_to_uint_popcount = OpBitCount %v4uint %uints ; BitReverse must have matching types w.r.t. sign, yay. %int_to_int_reverse = OpBitReverse %v4int %ints ;%int_to_uint_reverse = OpBitReverse %v4uint %ints ;%uint_to_int_reverse = OpBitReverse %v4int %uints %uint_to_uint_reverse = OpBitReverse %v4uint %uints ; Base and Result must match. %int_to_int_sbit = OpBitFieldSExtract %v4int %ints %int_1 %uint_11 ;%int_to_uint_sbit = OpBitFieldSExtract %v4uint %ints %offset %count ;%uint_to_int_sbit = OpBitFieldSExtract %v4int %uints %offset %count %uint_to_uint_sbit = OpBitFieldSExtract %v4uint %uints %uint_11 %int_1 ; Base and Result must match. %int_to_int_ubit = OpBitFieldUExtract %v4int %ints %int_1 %uint_11 ;%int_to_uint_ubit = OpBitFieldUExtract %v4uint %ints %offset %count ;%uint_to_int_ubit = OpBitFieldUExtract %v4int %uints %offset %count %uint_to_uint_ubit = OpBitFieldUExtract %v4uint %uints %uint_11 %int_1 %int_to_int_insert = OpBitFieldInsert %v4int %ints %ints_alt %int_1 %uint_11 %uint_to_uint_insert = OpBitFieldInsert %v4uint %uints %uints_alt %uint_11 %int_1 OpStore %ints_ptr %int_to_int_popcount OpStore %uints_ptr %int_to_uint_popcount OpStore %ints_ptr %uint_to_int_popcount OpStore %uints_ptr %uint_to_uint_popcount OpStore %ints_ptr %int_to_int_reverse ;OpStore %uints_ptr %int_to_uint_reverse ;OpStore %ints_ptr %uint_to_int_reverse OpStore %uints_ptr %uint_to_uint_reverse OpStore %ints_ptr %int_to_int_sbit ;OpStore %uints_ptr %int_to_uint_sbit ;OpStore %ints_ptr %uint_to_int_sbit OpStore %uints_ptr %uint_to_uint_sbit OpStore %ints_ptr %int_to_int_ubit ;OpStore %uints_ptr %int_to_uint_ubit ;OpStore %ints_ptr %uint_to_int_ubit OpStore %uints_ptr %uint_to_uint_ubit OpStore %ints_ptr %int_to_int_insert OpStore %uints_ptr %uint_to_uint_insert OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/bitscan.asm.comp000066400000000000000000000052741400026215700246360ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "u" OpMemberName %SSBO 1 "i" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 16 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %SSBO = OpTypeStruct %uvec4 %ivec4 %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_uvec4 = OpTypePointer Uniform %uvec4 %int_1 = OpConstant %int 1 %_ptr_Uniform_ivec4 = OpTypePointer Uniform %ivec4 %main = OpFunction %void None %3 %5 = OpLabel %uptr = OpAccessChain %_ptr_Uniform_uvec4 %_ %int_0 %iptr = OpAccessChain %_ptr_Uniform_ivec4 %_ %int_1 %uvalue = OpLoad %uvec4 %uptr %ivalue = OpLoad %ivec4 %iptr %lsb_uint_to_uint = OpExtInst %uvec4 %1 FindILsb %uvalue %lsb_uint_to_int = OpExtInst %ivec4 %1 FindILsb %uvalue %lsb_int_to_uint = OpExtInst %uvec4 %1 FindILsb %ivalue %lsb_int_to_int = OpExtInst %ivec4 %1 FindILsb %ivalue %umsb_uint_to_uint = OpExtInst %uvec4 %1 FindUMsb %uvalue %umsb_uint_to_int = OpExtInst %ivec4 %1 FindUMsb %uvalue %umsb_int_to_uint = OpExtInst %uvec4 %1 FindUMsb %ivalue %umsb_int_to_int = OpExtInst %ivec4 %1 FindUMsb %ivalue %smsb_uint_to_uint = OpExtInst %uvec4 %1 FindSMsb %uvalue %smsb_uint_to_int = OpExtInst %ivec4 %1 FindSMsb %uvalue %smsb_int_to_uint = OpExtInst %uvec4 %1 FindSMsb %ivalue %smsb_int_to_int = OpExtInst %ivec4 %1 FindSMsb %ivalue OpStore %uptr %lsb_uint_to_uint OpStore %iptr %lsb_uint_to_int OpStore %uptr %lsb_int_to_uint OpStore %iptr %lsb_int_to_int OpStore %uptr %umsb_uint_to_uint OpStore %iptr %umsb_uint_to_int OpStore %uptr %umsb_int_to_uint OpStore %iptr %umsb_int_to_int OpStore %uptr %smsb_uint_to_uint OpStore %iptr %smsb_uint_to_int OpStore %uptr %smsb_int_to_uint OpStore %iptr %smsb_int_to_int OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/composite-construct-buffer-struct.asm.comp000066400000000000000000000041601400026215700320210ustar00rootroot00000000000000 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %Block "Block" OpName %SSBO "SSBO" OpName %SSBO_Var "ssbo" OpName %UBO_Var "ubo" OpDecorate %SSBO_Var Binding 0 OpDecorate %SSBO_Var DescriptorSet 0 OpDecorate %UBO_Var Binding 1 OpDecorate %UBO_Var DescriptorSet 0 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %Block 0 Offset 0 OpMemberDecorate %Block 1 Offset 16 OpDecorate %BlockArray ArrayStride 32 OpDecorate %arr_uvec2_2 ArrayStride 8 OpDecorate %SSBO Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uvec2 = OpTypeVector %uint 2 %arr_uvec2_2 = OpTypeArray %uvec2 %uint_2 %arr_uvec2_2_ptr = OpTypePointer StorageBuffer %arr_uvec2_2 %arr_uvec2_2_ptr_const = OpTypePointer Uniform %arr_uvec2_2 %arr_uvec2_2_ptr_func = OpTypePointer Function %arr_uvec2_2 %arr_uvec2_2_ptr_workgroup = OpTypePointer Workgroup %arr_uvec2_2 %wg = OpVariable %arr_uvec2_2_ptr_workgroup Workgroup %Block = OpTypeStruct %arr_uvec2_2 %arr_uvec2_2 %Block_ptr = OpTypePointer StorageBuffer %Block %BlockArray = OpTypeArray %Block %uint_3 %SSBO = OpTypeStruct %BlockArray %SSBO_Ptr = OpTypePointer StorageBuffer %SSBO %SSBO_Var = OpVariable %SSBO_Ptr StorageBuffer %UBO_Ptr = OpTypePointer Uniform %SSBO %UBO_Var = OpVariable %UBO_Ptr Uniform %void = OpTypeVoid %func_type = OpTypeFunction %void %main = OpFunction %void None %func_type %25 = OpLabel %func = OpVariable %arr_uvec2_2_ptr_func Function ; Copy device array to temporary. %ptr = OpAccessChain %Block_ptr %SSBO_Var %uint_0 %uint_0 %ptr_arr_1 = OpAccessChain %arr_uvec2_2_ptr %SSBO_Var %uint_0 %uint_0 %uint_1 %loaded_array = OpLoad %arr_uvec2_2 %ptr_arr_1 %constructed = OpCompositeConstruct %Block %loaded_array %loaded_array OpStore %ptr %constructed OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/constant-composite-undef.asm.comp000066400000000000000000000030601400026215700301320ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Block "Block" OpMemberName %Block 0 "f" OpName %block "block" OpMemberDecorate %Block 0 Offset 0 OpDecorate %Block BufferBlock OpDecorate %block DescriptorSet 0 OpDecorate %block Binding 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Block = OpTypeStruct %v4float %_ptr_Uniform_Block = OpTypePointer Uniform %Block %block = OpVariable %_ptr_Uniform_Block Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_0_100000001 = OpConstant %float 0.100000001 %float_0_200000003 = OpConstant %float 0.200000003 %float_0_300000012 = OpConstant %float 0.300000012 %15 = OpUndef %float %16 = OpConstantComposite %v4float %float_0_100000001 %float_0_200000003 %float_0_300000012 %15 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %main = OpFunction %void None %6 %18 = OpLabel %19 = OpAccessChain %_ptr_Uniform_v4float %block %int_0 OpStore %19 %16 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/copy-logical-2.spv14.asm.comp000066400000000000000000000056231400026215700267060ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 48 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %ssbo OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %B1 "B1" OpName %A "A" OpName %C "C" OpName %B2 "B2" OpMemberName %A 0 "a" OpMemberName %A 1 "b1" OpMemberName %A 2 "b1_array" OpMemberName %C 0 "c" OpMemberName %C 1 "b2" OpMemberName %C 2 "b2_array" OpMemberName %B1 0 "elem1" OpMemberName %B2 0 "elem2" OpMemberName %SSBO 0 "a_block" OpMemberName %SSBO 1 "c_block" OpDecorate %B1Array ArrayStride 16 OpDecorate %B2Array ArrayStride 16 OpMemberDecorate %B1 0 Offset 0 OpMemberDecorate %A 0 Offset 0 OpMemberDecorate %A 1 Offset 16 OpMemberDecorate %A 2 Offset 32 OpMemberDecorate %A 3 Offset 96 OpMemberDecorate %B2 0 Offset 0 OpMemberDecorate %C 0 Offset 0 OpMemberDecorate %C 1 Offset 16 OpMemberDecorate %C 2 Offset 32 OpMemberDecorate %C 3 Offset 96 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 112 OpMemberDecorate %A0 0 Offset 0 OpMemberDecorate %C0 0 Offset 0 OpMemberDecorate %A0 0 RowMajor OpMemberDecorate %A0 0 MatrixStride 8 OpMemberDecorate %C0 0 ColMajor OpMemberDecorate %C0 0 MatrixStride 16 OpDecorate %SSBO Block OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %m2float = OpTypeMatrix %v2float 2 %A0 = OpTypeStruct %m2float %C0 = OpTypeStruct %m2float %B2 = OpTypeStruct %v4float %B2Array = OpTypeArray %B2 %uint_4 %C = OpTypeStruct %v4float %B2 %B2Array %C0 %B1 = OpTypeStruct %v4float %B1Array = OpTypeArray %B1 %uint_4 %A = OpTypeStruct %v4float %B1 %B1Array %A0 %SSBO = OpTypeStruct %A %C %_ptr_Uniform_SSBO = OpTypePointer StorageBuffer %SSBO %ssbo = OpVariable %_ptr_Uniform_SSBO StorageBuffer %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Uniform_C = OpTypePointer StorageBuffer %C %int_0 = OpConstant %int 0 %_ptr_Uniform_A = OpTypePointer StorageBuffer %A %main = OpFunction %void None %3 %5 = OpLabel %22 = OpAccessChain %_ptr_Uniform_C %ssbo %int_1 %39 = OpAccessChain %_ptr_Uniform_A %ssbo %int_0 %23 = OpLoad %C %22 %24 = OpCopyLogical %A %23 OpStore %39 %24 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/copy-logical.spv14.asm.comp000066400000000000000000000046771400026215700265570ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 48 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %ssbo OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %B1 "B1" OpName %A "A" OpName %C "C" OpName %B2 "B2" OpMemberName %A 0 "a" OpMemberName %A 1 "b1" OpMemberName %A 2 "b1_array" OpMemberName %C 0 "c" OpMemberName %C 1 "b2" OpMemberName %C 2 "b2_array" OpMemberName %B1 0 "elem1" OpMemberName %B2 0 "elem2" OpMemberName %SSBO 0 "a_block" OpMemberName %SSBO 1 "c_block" OpDecorate %B1Array ArrayStride 16 OpDecorate %B2Array ArrayStride 16 OpMemberDecorate %B1 0 Offset 0 OpMemberDecorate %A 0 Offset 0 OpMemberDecorate %A 1 Offset 16 OpMemberDecorate %A 2 Offset 32 OpMemberDecorate %B2 0 Offset 0 OpMemberDecorate %C 0 Offset 0 OpMemberDecorate %C 1 Offset 16 OpMemberDecorate %C 2 Offset 32 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 96 OpDecorate %SSBO Block OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %v4float = OpTypeVector %float 4 %B2 = OpTypeStruct %v4float %B2Array = OpTypeArray %B2 %uint_4 %C = OpTypeStruct %v4float %B2 %B2Array %B1 = OpTypeStruct %v4float %B1Array = OpTypeArray %B1 %uint_4 %A = OpTypeStruct %v4float %B1 %B1Array %SSBO = OpTypeStruct %A %C %_ptr_Uniform_SSBO = OpTypePointer StorageBuffer %SSBO %ssbo = OpVariable %_ptr_Uniform_SSBO StorageBuffer %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Uniform_C = OpTypePointer StorageBuffer %C %int_0 = OpConstant %int 0 %_ptr_Uniform_A = OpTypePointer StorageBuffer %A %main = OpFunction %void None %3 %5 = OpLabel %22 = OpAccessChain %_ptr_Uniform_C %ssbo %int_1 %39 = OpAccessChain %_ptr_Uniform_A %ssbo %int_0 %23 = OpLoad %C %22 %24 = OpCopyLogical %A %23 OpStore %39 %24 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/device-array-load-temporary.asm.comp000066400000000000000000000040621400026215700305150ustar00rootroot00000000000000 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %Block "Block" OpName %SSBO "SSBO" OpName %SSBO_Var "ssbo" OpName %UBO_Var "ubo" OpDecorate %SSBO_Var Binding 0 OpDecorate %SSBO_Var DescriptorSet 0 OpDecorate %UBO_Var Binding 1 OpDecorate %UBO_Var DescriptorSet 0 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %Block 0 Offset 0 OpMemberDecorate %Block 1 Offset 16 OpDecorate %BlockArray ArrayStride 32 OpDecorate %arr_uvec2_2 ArrayStride 8 OpDecorate %SSBO Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uvec2 = OpTypeVector %uint 2 %arr_uvec2_2 = OpTypeArray %uvec2 %uint_2 %arr_uvec2_2_ptr = OpTypePointer StorageBuffer %arr_uvec2_2 %arr_uvec2_2_ptr_const = OpTypePointer Uniform %arr_uvec2_2 %arr_uvec2_2_ptr_func = OpTypePointer Function %arr_uvec2_2 %arr_uvec2_2_ptr_workgroup = OpTypePointer Workgroup %arr_uvec2_2 %wg = OpVariable %arr_uvec2_2_ptr_workgroup Workgroup %Block = OpTypeStruct %arr_uvec2_2 %arr_uvec2_2 %BlockArray = OpTypeArray %Block %uint_3 %SSBO = OpTypeStruct %BlockArray %SSBO_Ptr = OpTypePointer StorageBuffer %SSBO %SSBO_Var = OpVariable %SSBO_Ptr StorageBuffer %UBO_Ptr = OpTypePointer Uniform %SSBO %UBO_Var = OpVariable %UBO_Ptr Uniform %void = OpTypeVoid %func_type = OpTypeFunction %void %main = OpFunction %void None %func_type %25 = OpLabel %func = OpVariable %arr_uvec2_2_ptr_func Function ; Copy device array to temporary. %ptr_arr_0 = OpAccessChain %arr_uvec2_2_ptr %SSBO_Var %uint_0 %uint_0 %uint_0 %ptr_arr_1 = OpAccessChain %arr_uvec2_2_ptr %SSBO_Var %uint_0 %uint_0 %uint_1 %loaded_array = OpLoad %arr_uvec2_2 %ptr_arr_1 OpStore %ptr_arr_0 %loaded_array OpStore %ptr_arr_0 %loaded_array OpReturn OpFunctionEnd device-array-load-temporary.force-native-array.asm.comp000066400000000000000000000040621400026215700341330ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %Block "Block" OpName %SSBO "SSBO" OpName %SSBO_Var "ssbo" OpName %UBO_Var "ubo" OpDecorate %SSBO_Var Binding 0 OpDecorate %SSBO_Var DescriptorSet 0 OpDecorate %UBO_Var Binding 1 OpDecorate %UBO_Var DescriptorSet 0 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %Block 0 Offset 0 OpMemberDecorate %Block 1 Offset 16 OpDecorate %BlockArray ArrayStride 32 OpDecorate %arr_uvec2_2 ArrayStride 8 OpDecorate %SSBO Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uvec2 = OpTypeVector %uint 2 %arr_uvec2_2 = OpTypeArray %uvec2 %uint_2 %arr_uvec2_2_ptr = OpTypePointer StorageBuffer %arr_uvec2_2 %arr_uvec2_2_ptr_const = OpTypePointer Uniform %arr_uvec2_2 %arr_uvec2_2_ptr_func = OpTypePointer Function %arr_uvec2_2 %arr_uvec2_2_ptr_workgroup = OpTypePointer Workgroup %arr_uvec2_2 %wg = OpVariable %arr_uvec2_2_ptr_workgroup Workgroup %Block = OpTypeStruct %arr_uvec2_2 %arr_uvec2_2 %BlockArray = OpTypeArray %Block %uint_3 %SSBO = OpTypeStruct %BlockArray %SSBO_Ptr = OpTypePointer StorageBuffer %SSBO %SSBO_Var = OpVariable %SSBO_Ptr StorageBuffer %UBO_Ptr = OpTypePointer Uniform %SSBO %UBO_Var = OpVariable %UBO_Ptr Uniform %void = OpTypeVoid %func_type = OpTypeFunction %void %main = OpFunction %void None %func_type %25 = OpLabel %func = OpVariable %arr_uvec2_2_ptr_func Function ; Copy device array to temporary. %ptr_arr_0 = OpAccessChain %arr_uvec2_2_ptr %SSBO_Var %uint_0 %uint_0 %uint_0 %ptr_arr_1 = OpAccessChain %arr_uvec2_2_ptr %SSBO_Var %uint_0 %uint_0 %uint_1 %loaded_array = OpLoad %arr_uvec2_2 %ptr_arr_1 OpStore %ptr_arr_0 %loaded_array OpStore %ptr_arr_0 %loaded_array OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/device-constant-array-load-store.asm.comp000066400000000000000000000056311400026215700314610ustar00rootroot00000000000000 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %Block "Block" OpName %SSBO "SSBO" OpName %SSBO_Var "ssbo" OpName %UBO_Var "ubo" OpDecorate %SSBO_Var Binding 0 OpDecorate %SSBO_Var DescriptorSet 0 OpDecorate %UBO_Var Binding 1 OpDecorate %UBO_Var DescriptorSet 0 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %Block 0 Offset 0 OpMemberDecorate %Block 1 Offset 16 OpDecorate %BlockArray ArrayStride 32 OpDecorate %arr_uvec2_2 ArrayStride 8 OpDecorate %SSBO Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uvec2 = OpTypeVector %uint 2 %arr_uvec2_2 = OpTypeArray %uvec2 %uint_2 %arr_uvec2_2_ptr = OpTypePointer StorageBuffer %arr_uvec2_2 %arr_uvec2_2_ptr_const = OpTypePointer Uniform %arr_uvec2_2 %arr_uvec2_2_ptr_func = OpTypePointer Function %arr_uvec2_2 %arr_uvec2_2_ptr_workgroup = OpTypePointer Workgroup %arr_uvec2_2 %wg = OpVariable %arr_uvec2_2_ptr_workgroup Workgroup %Block = OpTypeStruct %arr_uvec2_2 %arr_uvec2_2 %BlockArray = OpTypeArray %Block %uint_3 %SSBO = OpTypeStruct %BlockArray %SSBO_Ptr = OpTypePointer StorageBuffer %SSBO %SSBO_Var = OpVariable %SSBO_Ptr StorageBuffer %UBO_Ptr = OpTypePointer Uniform %SSBO %UBO_Var = OpVariable %UBO_Ptr Uniform %void = OpTypeVoid %func_type = OpTypeFunction %void %main = OpFunction %void None %func_type %25 = OpLabel %func = OpVariable %arr_uvec2_2_ptr_func Function ; DeviceToDevice %ptr_arr_0 = OpAccessChain %arr_uvec2_2_ptr %SSBO_Var %uint_0 %uint_0 %uint_0 %ptr_arr_1 = OpAccessChain %arr_uvec2_2_ptr %SSBO_Var %uint_0 %uint_0 %uint_1 %loaded_array = OpLoad %arr_uvec2_2 %ptr_arr_1 OpStore %ptr_arr_0 %loaded_array ; ConstantToDevice %ptr_arr_1_const = OpAccessChain %arr_uvec2_2_ptr_const %UBO_Var %uint_0 %uint_0 %uint_1 %loaded_array_const = OpLoad %arr_uvec2_2 %ptr_arr_1_const OpStore %ptr_arr_0 %loaded_array_const ; StackToDevice %loaded_array_func = OpLoad %arr_uvec2_2 %func OpStore %ptr_arr_0 %loaded_array_func ; ThreadGroupToDevice %loaded_array_workgroup = OpLoad %arr_uvec2_2 %wg OpStore %ptr_arr_0 %loaded_array_workgroup ; DeviceToThreadGroup %loaded_array_2 = OpLoad %arr_uvec2_2 %ptr_arr_1 OpStore %wg %loaded_array_2 ; DeviceToStack %loaded_array_3 = OpLoad %arr_uvec2_2 %ptr_arr_1 OpStore %func %loaded_array_3 ; ConstantToThreadGroup %loaded_array_const_2 = OpLoad %arr_uvec2_2 %ptr_arr_1_const OpStore %wg %loaded_array_const_2 ; ConstantToStack %loaded_array_const_3 = OpLoad %arr_uvec2_2 %ptr_arr_1_const OpStore %func %loaded_array_const_3 OpReturn OpFunctionEnd device-constant-array-load-store.force-native-array.asm.comp000066400000000000000000000056311400026215700350770ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %Block "Block" OpName %SSBO "SSBO" OpName %SSBO_Var "ssbo" OpName %UBO_Var "ubo" OpDecorate %SSBO_Var Binding 0 OpDecorate %SSBO_Var DescriptorSet 0 OpDecorate %UBO_Var Binding 1 OpDecorate %UBO_Var DescriptorSet 0 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %Block 0 Offset 0 OpMemberDecorate %Block 1 Offset 16 OpDecorate %BlockArray ArrayStride 32 OpDecorate %arr_uvec2_2 ArrayStride 8 OpDecorate %SSBO Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uvec2 = OpTypeVector %uint 2 %arr_uvec2_2 = OpTypeArray %uvec2 %uint_2 %arr_uvec2_2_ptr = OpTypePointer StorageBuffer %arr_uvec2_2 %arr_uvec2_2_ptr_const = OpTypePointer Uniform %arr_uvec2_2 %arr_uvec2_2_ptr_func = OpTypePointer Function %arr_uvec2_2 %arr_uvec2_2_ptr_workgroup = OpTypePointer Workgroup %arr_uvec2_2 %wg = OpVariable %arr_uvec2_2_ptr_workgroup Workgroup %Block = OpTypeStruct %arr_uvec2_2 %arr_uvec2_2 %BlockArray = OpTypeArray %Block %uint_3 %SSBO = OpTypeStruct %BlockArray %SSBO_Ptr = OpTypePointer StorageBuffer %SSBO %SSBO_Var = OpVariable %SSBO_Ptr StorageBuffer %UBO_Ptr = OpTypePointer Uniform %SSBO %UBO_Var = OpVariable %UBO_Ptr Uniform %void = OpTypeVoid %func_type = OpTypeFunction %void %main = OpFunction %void None %func_type %25 = OpLabel %func = OpVariable %arr_uvec2_2_ptr_func Function ; DeviceToDevice %ptr_arr_0 = OpAccessChain %arr_uvec2_2_ptr %SSBO_Var %uint_0 %uint_0 %uint_0 %ptr_arr_1 = OpAccessChain %arr_uvec2_2_ptr %SSBO_Var %uint_0 %uint_0 %uint_1 %loaded_array = OpLoad %arr_uvec2_2 %ptr_arr_1 OpStore %ptr_arr_0 %loaded_array ; ConstantToDevice %ptr_arr_1_const = OpAccessChain %arr_uvec2_2_ptr_const %UBO_Var %uint_0 %uint_0 %uint_1 %loaded_array_const = OpLoad %arr_uvec2_2 %ptr_arr_1_const OpStore %ptr_arr_0 %loaded_array_const ; StackToDevice %loaded_array_func = OpLoad %arr_uvec2_2 %func OpStore %ptr_arr_0 %loaded_array_func ; ThreadGroupToDevice %loaded_array_workgroup = OpLoad %arr_uvec2_2 %wg OpStore %ptr_arr_0 %loaded_array_workgroup ; DeviceToThreadGroup %loaded_array_2 = OpLoad %arr_uvec2_2 %ptr_arr_1 OpStore %wg %loaded_array_2 ; DeviceToStack %loaded_array_3 = OpLoad %arr_uvec2_2 %ptr_arr_1 OpStore %func %loaded_array_3 ; ConstantToThreadGroup %loaded_array_const_2 = OpLoad %arr_uvec2_2 %ptr_arr_1_const OpStore %wg %loaded_array_const_2 ; ConstantToStack %loaded_array_const_3 = OpLoad %arr_uvec2_2 %ptr_arr_1_const OpStore %func %loaded_array_const_3 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/glsl-signed-operations.asm.comp000066400000000000000000000124761400026215700276060ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 26 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "ints" OpMemberName %SSBO 1 "uints" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 16 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %uint = OpTypeInt 32 0 %v4uint = OpTypeVector %uint 4 %SSBO = OpTypeStruct %v4int %v4uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_v4int = OpTypePointer Uniform %v4int %int_1 = OpConstant %int 1 %_ptr_Uniform_v4uint = OpTypePointer Uniform %v4uint %main = OpFunction %void None %3 %5 = OpLabel %ints_ptr = OpAccessChain %_ptr_Uniform_v4int %_ %int_0 %uints_ptr = OpAccessChain %_ptr_Uniform_v4uint %_ %int_1 %ints = OpLoad %v4int %ints_ptr %uints = OpLoad %v4uint %uints_ptr %int_to_int_sabs = OpExtInst %v4int %1 SAbs %ints %int_to_uint_sabs = OpExtInst %v4uint %1 SAbs %ints %uint_to_int_sabs = OpExtInst %v4int %1 SAbs %uints %uint_to_uint_sabs = OpExtInst %v4uint %1 SAbs %uints %int_to_int_ssign = OpExtInst %v4int %1 SSign %ints %int_to_uint_ssign = OpExtInst %v4uint %1 SSign %ints %uint_to_int_ssign = OpExtInst %v4int %1 SSign %uints %uint_to_uint_ssign = OpExtInst %v4uint %1 SSign %uints %int_to_int_smsb = OpExtInst %v4int %1 FindSMsb %uints %int_to_uint_smsb = OpExtInst %v4uint %1 FindSMsb %uints %uint_to_int_umsb = OpExtInst %v4int %1 FindUMsb %ints %uint_to_uint_umsb = OpExtInst %v4uint %1 FindUMsb %ints %int_to_int_smin = OpExtInst %v4int %1 SMin %ints %ints %int_to_uint_smin = OpExtInst %v4uint %1 SMin %ints %uints %uint_to_int_smin = OpExtInst %v4int %1 SMin %uints %uints %uint_to_uint_smin = OpExtInst %v4uint %1 SMin %uints %ints %int_to_int_umin = OpExtInst %v4int %1 UMin %ints %uints %int_to_uint_umin = OpExtInst %v4uint %1 UMin %ints %uints %uint_to_int_umin = OpExtInst %v4int %1 UMin %uints %ints %uint_to_uint_umin = OpExtInst %v4uint %1 UMin %uints %ints %int_to_int_smax = OpExtInst %v4int %1 SMax %ints %ints %int_to_uint_smax = OpExtInst %v4uint %1 SMax %ints %ints %uint_to_int_smax = OpExtInst %v4int %1 SMax %uints %ints %uint_to_uint_smax = OpExtInst %v4uint %1 SMax %uints %ints %int_to_int_umax = OpExtInst %v4int %1 UMax %ints %uints %int_to_uint_umax = OpExtInst %v4uint %1 UMax %ints %ints %uint_to_int_umax = OpExtInst %v4int %1 UMax %uints %ints %uint_to_uint_umax = OpExtInst %v4uint %1 UMax %uints %ints %int_to_int_sclamp = OpExtInst %v4int %1 SClamp %uints %uints %uints %int_to_uint_sclamp = OpExtInst %v4uint %1 SClamp %uints %uints %uints %uint_to_int_uclamp = OpExtInst %v4int %1 UClamp %ints %ints %ints %uint_to_uint_uclamp = OpExtInst %v4uint %1 UClamp %ints %ints %ints OpStore %ints_ptr %int_to_int_sabs OpStore %uints_ptr %int_to_uint_sabs OpStore %ints_ptr %uint_to_int_sabs OpStore %uints_ptr %uint_to_uint_sabs OpStore %ints_ptr %int_to_int_ssign OpStore %uints_ptr %int_to_uint_ssign OpStore %ints_ptr %uint_to_int_ssign OpStore %uints_ptr %uint_to_uint_ssign OpStore %ints_ptr %int_to_int_smsb OpStore %uints_ptr %int_to_uint_smsb OpStore %ints_ptr %uint_to_int_umsb OpStore %uints_ptr %uint_to_uint_umsb OpStore %ints_ptr %int_to_int_smin OpStore %uints_ptr %int_to_uint_smin OpStore %ints_ptr %uint_to_int_smin OpStore %uints_ptr %uint_to_uint_smin OpStore %ints_ptr %int_to_int_umin OpStore %uints_ptr %int_to_uint_umin OpStore %ints_ptr %uint_to_int_umin OpStore %uints_ptr %uint_to_uint_umin OpStore %ints_ptr %int_to_int_smax OpStore %uints_ptr %int_to_uint_smax OpStore %ints_ptr %uint_to_int_smax OpStore %uints_ptr %uint_to_uint_smax OpStore %ints_ptr %int_to_int_umax OpStore %uints_ptr %int_to_uint_umax OpStore %ints_ptr %uint_to_int_umax OpStore %uints_ptr %uint_to_uint_umax OpStore %ints_ptr %int_to_int_sclamp OpStore %uints_ptr %int_to_uint_sclamp OpStore %ints_ptr %uint_to_int_uclamp OpStore %uints_ptr %uint_to_uint_uclamp OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/glsl.std450.frexp-modf-struct.asm.comp000066400000000000000000000041771400026215700305670ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %ResTypeMod = OpTypeStruct %float %float %_ptr_Function_ResTypeMod = OpTypePointer Function %ResTypeMod %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_20 = OpConstant %float 20 %int_1 = OpConstant %int 1 %_ptr_Function_float = OpTypePointer Function %float %ResTypeFrexp = OpTypeStruct %float %int %_ptr_Function_ResTypeFrexp = OpTypePointer Function %ResTypeFrexp %float_40 = OpConstant %float 40 %_ptr_Function_int = OpTypePointer Function %int %SSBO = OpTypeStruct %float %int %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_int = OpTypePointer Uniform %int %main = OpFunction %void None %3 %5 = OpLabel %modres = OpExtInst %ResTypeMod %1 ModfStruct %float_20 %frexpres = OpExtInst %ResTypeFrexp %1 FrexpStruct %float_40 %modres_f = OpCompositeExtract %float %modres 0 %modres_i = OpCompositeExtract %float %modres 1 %frexpres_f = OpCompositeExtract %float %frexpres 0 %frexpres_i = OpCompositeExtract %int %frexpres 1 %float_ptr = OpAccessChain %_ptr_Uniform_float %_ %int_0 %int_ptr = OpAccessChain %_ptr_Uniform_int %_ %int_1 OpStore %float_ptr %modres_f OpStore %float_ptr %modres_i OpStore %float_ptr %frexpres_f OpStore %int_ptr %frexpres_i OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/storage-buffer-basic.invalid.asm.comp000066400000000000000000000050121400026215700306200ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Codeplay; 0 ; Bound: 31 ; Schema: 0 OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %22 "main" %gl_WorkGroupID OpSource OpenCL_C 120 OpDecorate %15 SpecId 0 ;OpDecorate %16 SpecId 1 OpDecorate %17 SpecId 2 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_4 0 Offset 0 OpDecorate %_struct_4 Block OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize OpDecorate %20 DescriptorSet 0 OpDecorate %20 Binding 0 OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %size1 = OpConstant %uint 1 %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_runtimearr_float = OpTypeArray %float %size1 ; Runtime arrays do not work yet in MSL. %_struct_4 = OpTypeStruct %_runtimearr_float %_ptr_StorageBuffer__struct_4 = OpTypePointer StorageBuffer %_struct_4 %void = OpTypeVoid %8 = OpTypeFunction %void %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Private_v3uint = OpTypePointer Private %v3uint %uint_0 = OpConstant %uint 0 %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %15 = OpSpecConstant %uint 1 %16 = OpConstant %uint 2 %17 = OpSpecConstant %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %15 %16 %17 %19 = OpVariable %_ptr_Private_v3uint Private %gl_WorkGroupSize %20 = OpVariable %_ptr_StorageBuffer__struct_4 StorageBuffer %21 = OpVariable %_ptr_StorageBuffer__struct_4 StorageBuffer %22 = OpFunction %void None %8 %23 = OpLabel %24 = OpAccessChain %_ptr_Input_uint %gl_WorkGroupID %uint_0 %25 = OpLoad %uint %24 %26 = OpAccessChain %_ptr_StorageBuffer_float %21 %uint_0 %25 %27 = OpLoad %float %26 %28 = OpAccessChain %_ptr_StorageBuffer_float %20 %uint_0 %25 %29 = OpLoad %float %28 %30 = OpFAdd %float %27 %29 OpStore %28 %30 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/storage-buffer-pointer-argument.asm.comp000066400000000000000000000051571400026215700314240ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 30 ; Schema: 0 OpCapability Shader OpCapability VariablePointersStorageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %copy_out_f1_f1_ "copy_out(f1;f1;" OpName %A "A" OpName %B "B" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a" OpName %_ "" OpName %SSBORead "SSBORead" OpMemberName %SSBORead 0 "b" OpName %__0 "" OpMemberDecorate %SSBO 0 NonReadable OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpMemberDecorate %SSBORead 0 NonWritable OpMemberDecorate %SSBORead 0 Offset 0 OpDecorate %SSBORead Block OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %8 = OpTypeFunction %void %_ptr_StorageBuffer_float %_ptr_StorageBuffer_float %SSBO = OpTypeStruct %float %_ptr_StorageBuffer_SSBO = OpTypePointer StorageBuffer %SSBO %_ = OpVariable %_ptr_StorageBuffer_SSBO StorageBuffer %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %SSBORead = OpTypeStruct %float %_ptr_StorageBuffer_SSBORead = OpTypePointer StorageBuffer %SSBORead %__0 = OpVariable %_ptr_StorageBuffer_SSBORead StorageBuffer %main = OpFunction %void None %3 %5 = OpLabel %param = OpVariable %_ptr_Function_float Function %param_0 = OpVariable %_ptr_Function_float Function %25 = OpAccessChain %_ptr_StorageBuffer_float %_ %int_0 %26 = OpAccessChain %_ptr_StorageBuffer_float %__0 %int_0 %27 = OpFunctionCall %void %copy_out_f1_f1_ %25 %26 OpReturn OpFunctionEnd %copy_out_f1_f1_ = OpFunction %void None %8 %A = OpFunctionParameter %_ptr_StorageBuffer_float %B = OpFunctionParameter %_ptr_StorageBuffer_float %12 = OpLabel %13 = OpLoad %float %B OpStore %A %13 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/comp/variable-pointers.asm.comp000066400000000000000000000152321400026215700266340ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 89 ; Schema: 0 OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %foo "foo" OpMemberName %foo 0 "a" OpMemberName %foo 1 "b" OpMemberName %foo 2 "c" OpName %bar "bar" OpMemberName %bar 0 "d" OpName %baz "baz" OpMemberName %baz 0 "e" OpName %buf "buf" OpName %buf2 "buf2" OpName %cb "cb" OpName %tgsm "tgsm" OpName %sbuf "sbuf" OpName %sbuf2 "sbuf2" OpName %stgsm "stgsm" OpName %select_buffer "select_buffer" OpName %select_buffer_null "select_buffer_null" OpName %select_tgsm "select_tgsm" OpName %cur "cur" OpMemberDecorate %foo 0 Offset 0 OpMemberDecorate %foo 1 Offset 512 OpMemberDecorate %foo 2 Offset 520 OpMemberDecorate %bar 0 Offset 0 OpMemberDecorate %baz 0 Offset 0 OpDecorate %foo Block OpDecorate %bar Block OpDecorate %baz Block OpDecorate %buf DescriptorSet 0 OpDecorate %buf Binding 0 OpDecorate %cb DescriptorSet 0 OpDecorate %cb Binding 3 OpDecorate %buf2 DescriptorSet 0 OpDecorate %buf2 Binding 4 OpDecorate %_ptr_Workgroup_int ArrayStride 4 OpDecorate %_ptr_StorageBuffer_int ArrayStride 4 OpDecorate %_arr_int_uint_128 ArrayStride 4 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId %void = OpTypeVoid %22 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_128 = OpConstant %uint 128 %_arr_int_uint_128 = OpTypeArray %int %uint_128 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %foo = OpTypeStruct %_arr_int_uint_128 %uint %v2float %_ptr_StorageBuffer_foo = OpTypePointer StorageBuffer %foo %buf = OpVariable %_ptr_StorageBuffer_foo StorageBuffer %bar = OpTypeStruct %int %_ptr_Uniform_bar = OpTypePointer Uniform %bar %cb = OpVariable %_ptr_Uniform_bar Uniform %baz = OpTypeStruct %_arr_int_uint_128 %_ptr_StorageBuffer_baz = OpTypePointer StorageBuffer %baz %buf2 = OpVariable %_ptr_StorageBuffer_baz StorageBuffer %_ptr_Workgroup__arr_int_uint_128 = OpTypePointer Workgroup %_arr_int_uint_128 %tgsm = OpVariable %_ptr_Workgroup__arr_int_uint_128 Workgroup %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %_ptr_Private__ptr_StorageBuffer_int = OpTypePointer Private %_ptr_StorageBuffer_int %sbuf = OpVariable %_ptr_Private__ptr_StorageBuffer_int Private %sbuf2 = OpVariable %_ptr_Private__ptr_StorageBuffer_int Private %_ptr_Workgroup_int = OpTypePointer Workgroup %int %_ptr_Private__ptr_Workgroup_int = OpTypePointer Private %_ptr_Workgroup_int %stgsm = OpVariable %_ptr_Private__ptr_Workgroup_int Private %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %_ptr_Uniform_int = OpTypePointer Uniform %int %44 = OpTypeFunction %_ptr_StorageBuffer_int %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %47 = OpConstantNull %_ptr_StorageBuffer_int %48 = OpTypeFunction %_ptr_Workgroup_int %49 = OpConstantNull %_ptr_Workgroup_int %_ptr_Function__ptr_Workgroup_int = OpTypePointer Function %_ptr_Workgroup_int %select_buffer = OpFunction %_ptr_StorageBuffer_int None %44 %51 = OpLabel %52 = OpAccessChain %_ptr_Uniform_int %cb %uint_0 %53 = OpLoad %int %52 %54 = OpINotEqual %bool %53 %int_0 %55 = OpAccessChain %_ptr_StorageBuffer_int %buf %uint_0 %uint_0 %56 = OpAccessChain %_ptr_StorageBuffer_int %buf2 %uint_0 %uint_0 %57 = OpSelect %_ptr_StorageBuffer_int %54 %55 %56 OpReturnValue %57 OpFunctionEnd %select_buffer_null = OpFunction %_ptr_StorageBuffer_int None %44 %58 = OpLabel %59 = OpAccessChain %_ptr_Uniform_int %cb %uint_0 %60 = OpLoad %int %59 %61 = OpINotEqual %bool %60 %int_0 %62 = OpAccessChain %_ptr_StorageBuffer_int %buf %uint_0 %uint_0 %63 = OpSelect %_ptr_StorageBuffer_int %61 %62 %47 OpReturnValue %63 OpFunctionEnd %select_tgsm = OpFunction %_ptr_Workgroup_int None %48 %64 = OpLabel %65 = OpAccessChain %_ptr_Uniform_int %cb %uint_0 %66 = OpLoad %int %65 %67 = OpINotEqual %bool %66 %int_0 %68 = OpAccessChain %_ptr_Workgroup_int %tgsm %uint_0 %69 = OpSelect %_ptr_Workgroup_int %67 %68 %49 OpReturnValue %69 OpFunctionEnd %main = OpFunction %void None %22 %70 = OpLabel %cur = OpVariable %_ptr_Function__ptr_Workgroup_int Function %71 = OpFunctionCall %_ptr_StorageBuffer_int %select_buffer OpStore %sbuf %71 %72 = OpFunctionCall %_ptr_StorageBuffer_int %select_buffer_null OpStore %sbuf2 %72 %73 = OpFunctionCall %_ptr_Workgroup_int %select_tgsm OpStore %stgsm %73 %74 = OpAccessChain %_ptr_StorageBuffer_int %buf %uint_0 %uint_0 %75 = OpLoad %_ptr_Workgroup_int %stgsm %76 = OpCopyObject %_ptr_Workgroup_int %75 OpStore %cur %76 OpBranch %77 %77 = OpLabel %78 = OpPhi %_ptr_StorageBuffer_int %74 %70 %79 %80 %81 = OpLoad %_ptr_Workgroup_int %cur %82 = OpLoad %int %78 %83 = OpINotEqual %bool %82 %int_0 OpLoopMerge %85 %80 None OpBranchConditional %83 %84 %85 %84 = OpLabel %86 = OpLoad %int %81 %87 = OpIAdd %int %82 %86 OpStore %78 %87 OpStore %81 %87 OpBranch %80 %80 = OpLabel %79 = OpPtrAccessChain %_ptr_StorageBuffer_int %78 %uint_1 %88 = OpPtrAccessChain %_ptr_Workgroup_int %81 %uint_1 OpStore %cur %88 OpBranch %77 %85 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/000077500000000000000000000000001400026215700215255ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/component-insert-packed-expression.asm.frag000066400000000000000000000057021400026215700320770ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %frag "main" %gl_FragCoord %out_var_SV_Target OpExecutionMode %frag OriginUpperLeft OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "_BorderWidths" OpName %_Globals "$Globals" OpName %out_var_SV_Target "out.var.SV_Target" OpName %frag "frag" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %out_var_SV_Target Location 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpDecorate %_arr_float_uint_4 ArrayStride 16 OpMemberDecorate %type__Globals 0 Offset 0 OpDecorate %type__Globals Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int_2 = OpConstant %int 2 %uint = OpTypeInt 32 0 %float_1 = OpConstant %float 1 %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %type__Globals = OpTypeStruct %_arr_float_uint_4 %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %21 = OpTypeFunction %void %v2float = OpTypeVector %float 2 %_ptr_Uniform_float = OpTypePointer Uniform %float %bool = OpTypeBool %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %frag = OpFunction %void None %21 %25 = OpLabel %26 = OpLoad %v4float %gl_FragCoord %27 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_0 %28 = OpLoad %float %27 %29 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_1 %30 = OpLoad %float %29 %31 = OpCompositeConstruct %v2float %28 %30 %32 = OpCompositeExtract %float %26 0 %33 = OpFOrdGreaterThan %bool %32 %float_0 OpSelectionMerge %34 None OpBranchConditional %33 %35 %34 %35 = OpLabel %36 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_2 %37 = OpLoad %float %36 %38 = OpCompositeInsert %v2float %37 %31 0 OpBranch %34 %34 = OpLabel %39 = OpPhi %v2float %31 %25 %38 %35 %40 = OpCompositeExtract %float %39 0 %41 = OpCompositeExtract %float %39 1 %42 = OpCompositeConstruct %v4float %40 %41 %float_0 %float_1 OpStore %out_var_SV_Target %42 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/empty-struct-in-struct.asm.frag000066400000000000000000000046141400026215700275600ustar00rootroot00000000000000; SPIR-V ; Version: 1.2 ; Generator: Khronos; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %EntryPoint_Main "main" OpExecutionMode %EntryPoint_Main OriginUpperLeft OpSource Unknown 100 OpName %EmptyStructTest "EmptyStructTest" OpName %EmptyStruct2Test "EmptyStruct2Test" OpName %GetValue "GetValue" OpName %GetValue2 "GetValue" OpName %self "self" OpName %self2 "self" OpName %emptyStruct "emptyStruct" OpName %value "value" OpName %EntryPoint_Main "EntryPoint_Main" %EmptyStructTest = OpTypeStruct %EmptyStruct2Test = OpTypeStruct %EmptyStructTest %_ptr_Function_EmptyStruct2Test = OpTypePointer Function %EmptyStruct2Test %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %5 = OpTypeFunction %float %_ptr_Function_EmptyStruct2Test %6 = OpTypeFunction %float %EmptyStruct2Test %void = OpTypeVoid %_ptr_Function_void = OpTypePointer Function %void %8 = OpTypeFunction %void %_ptr_Function_EmptyStruct2Test %9 = OpTypeFunction %void %float_0 = OpConstant %float 0 %value4 = OpConstantNull %EmptyStruct2Test %GetValue = OpFunction %float None %5 %self = OpFunctionParameter %_ptr_Function_EmptyStruct2Test %13 = OpLabel OpReturnValue %float_0 OpFunctionEnd %GetValue2 = OpFunction %float None %6 %self2 = OpFunctionParameter %EmptyStruct2Test %14 = OpLabel OpReturnValue %float_0 OpFunctionEnd %EntryPoint_Main = OpFunction %void None %9 %37 = OpLabel %emptyStruct = OpVariable %_ptr_Function_EmptyStruct2Test Function %18 = OpVariable %_ptr_Function_EmptyStruct2Test Function %value = OpVariable %_ptr_Function_float Function %value2 = OpCompositeConstruct %EmptyStructTest %value3 = OpCompositeConstruct %EmptyStruct2Test %value2 %22 = OpFunctionCall %float %GetValue %emptyStruct %23 = OpFunctionCall %float %GetValue2 %value3 %24 = OpFunctionCall %float %GetValue2 %value4 OpStore %value %22 OpStore %value %23 OpStore %value %24 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/fixup-entry-point-identifier.nomain.asm.frag000066400000000000000000000017561400026215700321770ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 12 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %foo "_5ma@@in" %FragColor OpExecutionMode %foo OriginUpperLeft OpSource GLSL 450 OpName %foo "FOO" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %11 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %foo = OpFunction %void None %3 %5 = OpLabel OpStore %FragColor %11 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/image-fetch-uint-coord.asm.frag000066400000000000000000000035171400026215700274050ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 29 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_TEXCOORD0 %out_var_SV_Target0 OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_2d_image "type.2d.image" OpName %Tex "Tex" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %main "main" OpDecorate %in_var_TEXCOORD0 Flat OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %Tex DescriptorSet 0 OpDecorate %Tex Binding 0 %int = OpTypeInt 32 1 %int_2 = OpConstant %int 2 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %16 = OpTypeFunction %void %Tex = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v3uint Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %16 %19 = OpLabel %20 = OpLoad %v3uint %in_var_TEXCOORD0 %21 = OpCompositeExtract %uint %20 2 %27 = OpLoad %type_2d_image %Tex %28 = OpImageFetch %v4float %27 %20 Lod %21 OpStore %out_var_SV_Target0 %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/image-gather.asm.frag000066400000000000000000000067671400026215700255170ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Google spiregg; 0 ; Bound: 36 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_user_type" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %psMain "main" %gl_FragCoord %in_var_TEXCOORD0 %out_var_SV_Target0 OpExecutionMode %psMain OriginUpperLeft OpSource HLSL 500 OpName %type_2d_image "type.2d.image" OpName %g_texture "g_texture" OpName %type_sampler "type.sampler" OpName %g_sampler "g_sampler" OpName %g_comp "g_comp" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %psMain "psMain" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_Position" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_texture DescriptorSet 0 OpDecorate %g_texture Binding 0 OpDecorate %g_sampler DescriptorSet 0 OpDecorate %g_sampler Binding 0 OpDecorate %g_comp DescriptorSet 0 OpDecorate %g_comp Binding 1 OpDecorateString %g_texture UserTypeGOOGLE "texture2d" %float = OpTypeFloat 32 %float_0_5 = OpConstant %float 0.5 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %v2int = OpTypeVector %int 2 %16 = OpConstantComposite %v2int %int_0 %int_0 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %25 = OpTypeFunction %void %type_sampled_image = OpTypeSampledImage %type_2d_image %g_texture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %g_comp = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %psMain = OpFunction %void None %25 %26 = OpLabel %27 = OpLoad %v2float %in_var_TEXCOORD0 %28 = OpLoad %type_2d_image %g_texture %29 = OpLoad %type_sampler %g_comp %30 = OpSampledImage %type_sampled_image %28 %29 %32 = OpLoad %type_sampler %g_sampler %33 = OpSampledImage %type_sampled_image %28 %32 %31 = OpImageGather %v4float %33 %27 %int_1 ConstOffset %16 %34 = OpImageGather %v4float %33 %27 %int_0 ConstOffset %16 %35 = OpFMul %v4float %34 %31 OpStore %out_var_SV_Target0 %35 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/image-type-normal-comparison-usage.asm.frag000066400000000000000000000067221400026215700317550ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_TEXCOORD0 %out_var_SV_Target0 OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_2d_image "type.2d.image" OpName %ShadowMap "ShadowMap" OpName %type_sampler "type.sampler" OpName %SampleNormal "SampleNormal" OpName %SampleShadow "SampleShadow" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %main "main" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %ShadowMap DescriptorSet 0 OpDecorate %ShadowMap Binding 0 OpDecorate %SampleNormal DescriptorSet 0 OpDecorate %SampleNormal Binding 0 OpDecorate %SampleShadow DescriptorSet 0 OpDecorate %SampleShadow Binding 1 %float = OpTypeFloat 32 %float_0_5 = OpConstant %float 0.5 %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %21 = OpTypeFunction %void %bool = OpTypeBool %type_sampled_image = OpTypeSampledImage %type_2d_image %ShadowMap = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %SampleNormal = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %SampleShadow = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %21 %23 = OpLabel %24 = OpLoad %v2float %in_var_TEXCOORD0 %25 = OpCompositeExtract %float %24 0 %26 = OpFOrdGreaterThan %bool %25 %float_0_5 OpSelectionMerge %27 None OpBranchConditional %26 %28 %29 %28 = OpLabel %30 = OpLoad %type_2d_image %ShadowMap %31 = OpLoad %type_sampler %SampleNormal %32 = OpSampledImage %type_sampled_image %30 %31 %33 = OpImageSampleImplicitLod %v4float %32 %24 None %34 = OpCompositeExtract %float %33 0 %35 = OpFOrdLessThanEqual %bool %34 %float_0_5 %36 = OpSelect %float %35 %float_1 %float_0 OpBranch %27 %29 = OpLabel %37 = OpLoad %type_2d_image %ShadowMap %38 = OpLoad %type_sampler %SampleShadow %39 = OpSampledImage %type_sampled_image %37 %38 %40 = OpImageSampleDrefExplicitLod %float %39 %24 %float_0_5 Lod %float_0 OpBranch %27 %27 = OpLabel %41 = OpPhi %float %36 %28 %40 %29 %42 = OpCompositeConstruct %v4float %41 %41 %41 %float_1 OpStore %out_var_SV_Target0 %42 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/input-attachment-unused-frag-coord.asm.frag000066400000000000000000000063571400026215700317670ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 35 ; Schema: 0 OpCapability Shader OpCapability InputAttachment %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %load_subpasses_IP1_ "load_subpasses(IP1;" OpName %uInput "uInput" OpName %FragColor "FragColor" OpName %uSubpass0 "uSubpass0" OpName %uSubpass1 "uSubpass1" OpName %gl_FragCoord "gl_FragCoord" OpDecorate %load_subpasses_IP1_ RelaxedPrecision OpDecorate %uInput RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %uSubpass0 RelaxedPrecision OpDecorate %uSubpass0 DescriptorSet 0 OpDecorate %uSubpass0 Binding 0 OpDecorate %uSubpass0 InputAttachmentIndex 0 OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %uSubpass1 RelaxedPrecision OpDecorate %uSubpass1 DescriptorSet 0 OpDecorate %uSubpass1 Binding 1 OpDecorate %uSubpass1 InputAttachmentIndex 1 OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %gl_FragCoord BuiltIn FragCoord %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float SubpassData 0 0 0 2 Unknown %_ptr_UniformConstant_7 = OpTypePointer UniformConstant %7 %v4float = OpTypeVector %float 4 %10 = OpTypeFunction %v4float %_ptr_UniformConstant_7 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %v2int = OpTypeVector %int 2 %18 = OpConstantComposite %v2int %int_0 %int_0 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %uSubpass0 = OpVariable %_ptr_UniformConstant_7 UniformConstant %uSubpass1 = OpVariable %_ptr_UniformConstant_7 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %3 %5 = OpLabel %25 = OpLoad %7 %uSubpass0 %26 = OpImageRead %v4float %25 %18 %28 = OpFunctionCall %v4float %load_subpasses_IP1_ %uSubpass1 %29 = OpFAdd %v4float %26 %28 ;%32 = OpLoad %v4float %gl_FragCoord ;%33 = OpVectorShuffle %v4float %32 %32 0 1 0 1 ;%34 = OpFAdd %v4float %29 %33 OpStore %FragColor %29 OpReturn OpFunctionEnd %load_subpasses_IP1_ = OpFunction %v4float None %10 %uInput = OpFunctionParameter %_ptr_UniformConstant_7 %13 = OpLabel %14 = OpLoad %7 %uInput %19 = OpImageRead %v4float %14 %18 OpReturnValue %19 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/modf-frexp-scalar-access-chain-output.asm.frag000066400000000000000000000026371400026215700323440ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 17 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %col "col" %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0_150000006 = OpConstant %float 0.150000006 %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %v2int = OpTypeVector %int 2 %_ptr_Function_v2int = OpTypePointer Function %v2int %_ptr_Function_int = OpTypePointer Function %int %main = OpFunction %void None %3 %5 = OpLabel %col = OpVariable %_ptr_Function_v3float Function %icol = OpVariable %_ptr_Function_v2int Function %ptr_x = OpAccessChain %_ptr_Function_float %col %int_0 %ptr_y = OpAccessChain %_ptr_Function_int %icol %int_1 %16 = OpExtInst %float %1 Modf %float_0_150000006 %ptr_x %17 = OpExtInst %float %1 Frexp %float_0_150000006 %ptr_y OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/only-initializer-frag-depth.asm.frag000066400000000000000000000016431400026215700304720ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 10 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragDepth OpExecutionMode %main OriginUpperLeft OpExecutionMode %main DepthReplacing OpSource GLSL 450 OpName %main "main" OpName %gl_FragDepth "gl_FragDepth" OpDecorate %gl_FragDepth BuiltIn FragDepth %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %float_0_5 = OpConstant %float 0.5 %gl_FragDepth = OpVariable %_ptr_Output_float Output %float_0_5 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/phi.zero-initialize.asm.frag000066400000000000000000000052031400026215700270420ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 40 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vColor %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %vColor "vColor" OpName %uninit_function_int "uninit_function_int" OpName %FragColor "FragColor" OpName %uninit_int "uninit_int" OpName %uninit_vector "uninit_vector" OpName %uninit_matrix "uninit_matrix" OpName %Foo "Foo" OpMemberName %Foo 0 "a" OpName %uninit_foo "uninit_foo" OpDecorate %vColor Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %vColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_10 = OpConstant %float 10 %bool = OpTypeBool %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_10 = OpConstant %int 10 %int_20 = OpConstant %int 20 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Private_int = OpTypePointer Private %int %uninit_int = OpUndef %int %v4int = OpTypeVector %int 4 %_ptr_Private_v4int = OpTypePointer Private %v4int %uninit_vector = OpUndef %v4int %mat4v4float = OpTypeMatrix %v4float 4 %_ptr_Private_mat4v4float = OpTypePointer Private %mat4v4float %uninit_matrix = OpUndef %mat4v4float %Foo = OpTypeStruct %int %_ptr_Private_Foo = OpTypePointer Private %Foo %uninit_foo = OpUndef %Foo %main = OpFunction %void None %3 %5 = OpLabel %uninit_function_int = OpVariable %_ptr_Function_int Function %13 = OpAccessChain %_ptr_Input_float %vColor %uint_0 %14 = OpLoad %float %13 %17 = OpFOrdGreaterThan %bool %14 %float_10 OpSelectionMerge %19 None OpBranchConditional %17 %18 %24 %18 = OpLabel OpBranch %19 %24 = OpLabel OpBranch %19 %19 = OpLabel %27 = OpPhi %int %int_10 %18 %int_20 %24 %28 = OpLoad %v4float %vColor OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/pixel-interlock-callstack.msl2.asm.frag000066400000000000000000000072021400026215700310720ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpSource GLSL 450 OpSourceExtension "GL_ARB_fragment_shader_interlock" OpName %main "main" OpName %callee2_ "callee2(" OpName %callee_ "callee(" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "values1" OpName %_ "" OpName %gl_FragCoord "gl_FragCoord" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "values0" OpName %__0 "" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_runtimearr_uint_0 ArrayStride 4 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO1 = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_runtimearr_uint_0 = OpTypeRuntimeArray %uint %SSBO0 = OpTypeStruct %_runtimearr_uint_0 %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %__0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %44 = OpFunctionCall %void %callee_ OpReturn OpFunctionEnd %callee2_ = OpFunction %void None %3 %7 = OpLabel %23 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %24 = OpLoad %float %23 %25 = OpConvertFToS %int %24 %28 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 %29 = OpLoad %uint %28 %30 = OpIAdd %uint %29 %uint_1 %31 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 OpStore %31 %30 OpReturn OpFunctionEnd %callee_ = OpFunction %void None %3 %9 = OpLabel %36 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %37 = OpLoad %float %36 %38 = OpConvertFToS %int %37 %39 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpIAdd %uint %40 %uint_1 %42 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 OpStore %42 %41 OpBeginInvocationInterlockEXT %43 = OpFunctionCall %void %callee2_ OpEndInvocationInterlockEXT OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/pixel-interlock-control-flow.msl2.asm.frag000066400000000000000000000112201400026215700315510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpSource GLSL 450 OpSourceExtension "GL_ARB_fragment_shader_interlock" OpName %main "main" OpName %callee2_ "callee2(" OpName %callee_ "callee(" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "values1" OpName %_ "" OpName %gl_FragCoord "gl_FragCoord" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "values0" OpName %__0 "" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_runtimearr_uint_0 ArrayStride 4 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 OpMemberDecorate %SSBO2 0 Offset 0 OpDecorate %SSBO2 BufferBlock OpDecorate %ssbo2 DescriptorSet 0 OpDecorate %ssbo2 Binding 2 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO1 = OpTypeStruct %_runtimearr_uint %SSBO2 = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ptr_Uniform_SSBO2 = OpTypePointer Uniform %SSBO2 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %ssbo2 = OpVariable %_ptr_Uniform_SSBO2 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_4 = OpConstant %uint 4 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %bool = OpTypeBool %true = OpConstantTrue %bool %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_runtimearr_uint_0 = OpTypeRuntimeArray %uint %SSBO0 = OpTypeStruct %_runtimearr_uint_0 %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %__0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %44 = OpFunctionCall %void %callee_ %callee3_res = OpFunctionCall %void %callee3_ OpReturn OpFunctionEnd %callee3_ = OpFunction %void None %3 %calle3_block = OpLabel %frag_coord_x_ptr = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %frag_coord_x = OpLoad %float %frag_coord_x_ptr %frag_coord_int = OpConvertFToS %int %frag_coord_x %ssbo_ptr = OpAccessChain %_ptr_Uniform_uint %ssbo2 %int_0 %frag_coord_int OpStore %ssbo_ptr %uint_4 OpReturn OpFunctionEnd %callee2_ = OpFunction %void None %3 %7 = OpLabel %23 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %24 = OpLoad %float %23 %25 = OpConvertFToS %int %24 %28 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 %29 = OpLoad %uint %28 %30 = OpIAdd %uint %29 %uint_1 %31 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 OpStore %31 %30 OpReturn OpFunctionEnd %callee_ = OpFunction %void None %3 %9 = OpLabel %36 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %37 = OpLoad %float %36 %38 = OpConvertFToS %int %37 %39 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpIAdd %uint %40 %uint_1 %42 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 OpStore %42 %41 %43 = OpFunctionCall %void %callee2_ OpSelectionMerge %merged_block None OpBranchConditional %true %dummy_block %merged_block %dummy_block = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpBranch %merged_block %merged_block = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/pixel-interlock-split-functions.msl2.asm.frag000066400000000000000000000077011400026215700322760ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpSource GLSL 450 OpSourceExtension "GL_ARB_fragment_shader_interlock" OpName %main "main" OpName %callee2_ "callee2(" OpName %callee_ "callee(" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "values1" OpName %_ "" OpName %gl_FragCoord "gl_FragCoord" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "values0" OpName %__0 "" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_runtimearr_uint_0 ArrayStride 4 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO1 = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_runtimearr_uint_0 = OpTypeRuntimeArray %uint %SSBO0 = OpTypeStruct %_runtimearr_uint_0 %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %__0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %44 = OpFunctionCall %void %callee_ %call3res = OpFunctionCall %void %callee3_ %call4res = OpFunctionCall %void %callee4_ OpReturn OpFunctionEnd %callee3_ = OpFunction %void None %3 %begin3 = OpLabel OpBeginInvocationInterlockEXT OpReturn OpFunctionEnd %callee4_ = OpFunction %void None %3 %begin4 = OpLabel OpEndInvocationInterlockEXT OpReturn OpFunctionEnd %callee2_ = OpFunction %void None %3 %7 = OpLabel %23 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %24 = OpLoad %float %23 %25 = OpConvertFToS %int %24 %28 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 %29 = OpLoad %uint %28 %30 = OpIAdd %uint %29 %uint_1 %31 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 OpStore %31 %30 OpReturn OpFunctionEnd %callee_ = OpFunction %void None %3 %9 = OpLabel %36 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %37 = OpLoad %float %36 %38 = OpConvertFToS %int %37 %39 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpIAdd %uint %40 %uint_1 %42 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 OpStore %42 %41 %43 = OpFunctionCall %void %callee2_ OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/private-initializer-direct-store.asm.frag000066400000000000000000000022211400026215700315370ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 17 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %b "b" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %float_10 = OpConstant %float 10 %float_20 = OpConstant %float 20 %b = OpVariable %_ptr_Private_float Private %float_10 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel OpStore %b %float_20 %15 = OpLoad %float %b %16 = OpFAdd %float %15 %15 OpStore %FragColor %16 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/reserved-function-identifier.asm.frag000066400000000000000000000043741400026215700307370ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 37 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %ACOS_f1_ "mat3" OpName %a "a" OpName %ACOS_i1_ "gl_Foo" OpName %a_0 "a" OpName %FragColor "FragColor" OpName %param "param" OpName %param_0 "param" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %8 = OpTypeFunction %float %_ptr_Function_float %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %14 = OpTypeFunction %float %_ptr_Function_int %float_1 = OpConstant %float 1 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %float_2 = OpConstant %float 2 %int_4 = OpConstant %int 4 %main = OpFunction %void None %3 %5 = OpLabel %param = OpVariable %_ptr_Function_float Function %param_0 = OpVariable %_ptr_Function_int Function OpStore %param %float_2 %32 = OpFunctionCall %float %ACOS_f1_ %param OpStore %param_0 %int_4 %35 = OpFunctionCall %float %ACOS_i1_ %param_0 %36 = OpFAdd %float %32 %35 OpStore %FragColor %36 OpReturn OpFunctionEnd %ACOS_f1_ = OpFunction %float None %8 %a = OpFunctionParameter %_ptr_Function_float %11 = OpLabel %18 = OpLoad %float %a %20 = OpFAdd %float %18 %float_1 OpReturnValue %20 OpFunctionEnd %ACOS_i1_ = OpFunction %float None %14 %a_0 = OpFunctionParameter %_ptr_Function_int %17 = OpLabel %23 = OpLoad %int %a_0 %24 = OpConvertSToF %float %23 %25 = OpFAdd %float %24 %float_1 OpReturnValue %25 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/subgroup-arithmetic-cast.msl21.asm.frag000066400000000000000000000056311400026215700310340ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 78 ; Schema: 0 OpCapability Shader OpCapability GroupNonUniform OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %index %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_KHR_shader_subgroup_arithmetic" OpSourceExtension "GL_KHR_shader_subgroup_basic" OpSourceExtension "GL_KHR_shader_subgroup_clustered" OpName %main "main" OpName %index "index" OpName %FragColor "FragColor" OpDecorate %index Flat OpDecorate %index Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %index = OpVariable %_ptr_Input_int Input %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %_ptr_Output_uint = OpTypePointer Output %uint %FragColor = OpVariable %_ptr_Output_uint Output %main = OpFunction %void None %3 %5 = OpLabel %i = OpLoad %int %index %u = OpBitcast %uint %i %res0 = OpGroupNonUniformSMin %uint %uint_3 Reduce %i %res1 = OpGroupNonUniformSMax %uint %uint_3 Reduce %u %res2 = OpGroupNonUniformUMin %uint %uint_3 Reduce %i %res3 = OpGroupNonUniformUMax %uint %uint_3 Reduce %u ;%res4 = OpGroupNonUniformSMax %uint %uint_3 InclusiveScan %i ;%res5 = OpGroupNonUniformSMin %uint %uint_3 InclusiveScan %u ;%res6 = OpGroupNonUniformUMax %uint %uint_3 ExclusiveScan %i ;%res7 = OpGroupNonUniformUMin %uint %uint_3 ExclusiveScan %u %res8 = OpGroupNonUniformSMin %uint %uint_3 ClusteredReduce %i %uint_4 %res9 = OpGroupNonUniformSMax %uint %uint_3 ClusteredReduce %u %uint_4 %res10 = OpGroupNonUniformUMin %uint %uint_3 ClusteredReduce %i %uint_4 %res11 = OpGroupNonUniformUMax %uint %uint_3 ClusteredReduce %u %uint_4 OpStore %FragColor %res0 OpStore %FragColor %res1 OpStore %FragColor %res2 OpStore %FragColor %res3 ;OpStore %FragColor %res4 ;OpStore %FragColor %res5 ;OpStore %FragColor %res6 ;OpStore %FragColor %res7 OpStore %FragColor %res8 OpStore %FragColor %res9 OpStore %FragColor %res10 OpStore %FragColor %res11 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/switch-block-case-fallthrough.asm.invalid.frag000066400000000000000000000057031400026215700324160ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vIndex %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %vIndex "vIndex" OpName %FragColor "FragColor" OpName %i "i" OpName %j "j" OpDecorate %vIndex Flat OpDecorate %vIndex Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %_ptr_Input_int = OpTypePointer Input %int %vIndex = OpVariable %_ptr_Input_int Input %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Function_int = OpTypePointer Function %int %main = OpFunction %void None %3 %header = OpLabel %i = OpVariable %_ptr_Function_int Function %int_0 %j = OpVariable %_ptr_Function_int Function %9 = OpLoad %int %vIndex OpSelectionMerge %switch_merge None OpSwitch %9 %default_case 100 %default_case 0 %case_0 1 %case_1 11 %case_1 2 %case_2 3 %case_3 4 %case_4 5 %case_5 %case_0 = OpLabel OpBranch %default_case %default_case = OpLabel %default_case_phi = OpPhi %int %int_2 %header %int_3 %case_0 ; Test what happens when a case block dominates access to a variable. OpStore %j %default_case_phi OpBranch %case_1 %case_1 = OpLabel ; Test phi nodes between case labels. %case_1_phi = OpPhi %int %int_0 %default_case %int_1 %header OpStore %j %case_1_phi OpBranch %case_2 %case_2 = OpLabel OpBranch %switch_merge %case_3 = OpLabel ; Conditionally branch to another case block. This is really dumb, but it is apparently legal. %case_3_cond = OpSGreaterThan %bool %9 %int_3 OpBranchConditional %case_3_cond %case_4 %switch_merge %case_4 = OpLabel ; When emitted from case 3, we should *not* see fallthrough behavior. OpBranch %case_5 %case_5 = OpLabel OpStore %i %int_0 OpBranch %switch_merge %switch_merge = OpLabel %26 = OpLoad %int %i %27 = OpConvertSToF %float %26 %28 = OpCompositeConstruct %v4float %27 %27 %27 %27 OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/texture-access.swizzle.asm.frag000066400000000000000000000411151400026215700276140ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 247 ; Schema: 0 OpCapability Shader OpCapability Sampled1D OpCapability SampledCubeArray OpCapability SampledBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %c "c" OpName %tex1d "tex1d" OpName %tex2d "tex2d" OpName %tex3d "tex3d" OpName %texCube "texCube" OpName %tex2dArray "tex2dArray" OpName %texCubeArray "texCubeArray" OpName %depth2d "depth2d" OpName %depthCube "depthCube" OpName %depth2dArray "depth2dArray" OpName %depthCubeArray "depthCubeArray" OpName %texBuffer "texBuffer" OpName %tex1dSamp "tex1dSamp" OpName %tex2dSamp "tex2dSamp" OpName %tex3dSamp "tex3dSamp" OpName %texCubeSamp "texCubeSamp" OpName %tex2dArraySamp "tex2dArraySamp" OpName %texCubeArraySamp "texCubeArraySamp" OpName %depth2dSamp "depth2dSamp" OpName %depthCubeSamp "depthCubeSamp" OpName %depth2dArraySamp "depth2dArraySamp" OpName %depthCubeArraySamp "depthCubeArraySamp" OpDecorate %tex1d DescriptorSet 0 OpDecorate %tex1d Binding 0 OpDecorate %tex2d DescriptorSet 0 OpDecorate %tex2d Binding 1 OpDecorate %tex3d DescriptorSet 0 OpDecorate %tex3d Binding 2 OpDecorate %texCube DescriptorSet 0 OpDecorate %texCube Binding 3 OpDecorate %tex2dArray DescriptorSet 0 OpDecorate %tex2dArray Binding 4 OpDecorate %texCubeArray DescriptorSet 0 OpDecorate %texCubeArray Binding 5 OpDecorate %depth2d DescriptorSet 0 OpDecorate %depth2d Binding 7 OpDecorate %depthCube DescriptorSet 0 OpDecorate %depthCube Binding 8 OpDecorate %depth2dArray DescriptorSet 0 OpDecorate %depth2dArray Binding 9 OpDecorate %depthCubeArray DescriptorSet 0 OpDecorate %depthCubeArray Binding 10 OpDecorate %texBuffer DescriptorSet 0 OpDecorate %texBuffer Binding 6 OpDecorate %tex1dSamp DescriptorSet 1 OpDecorate %tex1dSamp Binding 0 OpDecorate %tex2dSamp DescriptorSet 1 OpDecorate %tex2dSamp Binding 1 OpDecorate %tex3dSamp DescriptorSet 1 OpDecorate %tex3dSamp Binding 2 OpDecorate %texCubeSamp DescriptorSet 1 OpDecorate %texCubeSamp Binding 3 OpDecorate %tex2dArraySamp DescriptorSet 1 OpDecorate %tex2dArraySamp Binding 4 OpDecorate %texCubeArraySamp DescriptorSet 1 OpDecorate %texCubeArraySamp Binding 5 OpDecorate %depth2dSamp DescriptorSet 1 OpDecorate %depth2dSamp Binding 7 OpDecorate %depthCubeSamp DescriptorSet 1 OpDecorate %depthCubeSamp Binding 8 OpDecorate %depth2dArraySamp DescriptorSet 1 OpDecorate %depth2dArraySamp Binding 9 OpDecorate %depthCubeArraySamp DescriptorSet 1 OpDecorate %depthCubeArraySamp Binding 10 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %10 = OpTypeImage %float 1D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %12 = OpTypeSampler %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %tex1d = OpVariable %_ptr_UniformConstant_10 UniformConstant %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %tex1dSamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %float_0 = OpConstant %float 0 %17 = OpTypeImage %float 2D 0 0 0 1 Unknown %18 = OpTypeSampledImage %17 %_ptr_UniformConstant_17 = OpTypePointer UniformConstant %17 %tex2d = OpVariable %_ptr_UniformConstant_17 UniformConstant %tex2dSamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpConstantComposite %v2float %float_0 %float_0 %25 = OpTypeImage %float 3D 0 0 0 1 Unknown %26 = OpTypeSampledImage %25 %_ptr_UniformConstant_25 = OpTypePointer UniformConstant %25 %tex3d = OpVariable %_ptr_UniformConstant_25 UniformConstant %tex3dSamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %v3float = OpTypeVector %float 3 %31 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %33 = OpTypeImage %float Cube 0 0 0 1 Unknown %34 = OpTypeSampledImage %33 %_ptr_UniformConstant_33 = OpTypePointer UniformConstant %33 %texCube = OpVariable %_ptr_UniformConstant_33 UniformConstant %texCubeSamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %39 = OpTypeImage %float 2D 0 1 0 1 Unknown %40 = OpTypeSampledImage %39 %_ptr_UniformConstant_39 = OpTypePointer UniformConstant %39 %tex2dArray = OpVariable %_ptr_UniformConstant_39 UniformConstant %tex2dArraySamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %45 = OpTypeImage %float Cube 0 1 0 1 Unknown %46 = OpTypeSampledImage %45 %_ptr_UniformConstant_45 = OpTypePointer UniformConstant %45 %texCubeArray = OpVariable %_ptr_UniformConstant_45 UniformConstant %texCubeArraySamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %50 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %52 = OpTypeImage %float 2D 1 0 0 1 Unknown %53 = OpTypeSampledImage %52 %_ptr_UniformConstant_52 = OpTypePointer UniformConstant %52 %depth2d = OpVariable %_ptr_UniformConstant_52 UniformConstant %depth2dSamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %float_1 = OpConstant %float 1 %58 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %65 = OpTypeImage %float Cube 1 0 0 1 Unknown %66 = OpTypeSampledImage %65 %_ptr_UniformConstant_65 = OpTypePointer UniformConstant %65 %depthCube = OpVariable %_ptr_UniformConstant_65 UniformConstant %depthCubeSamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %70 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1 %74 = OpTypeImage %float 2D 1 1 0 1 Unknown %75 = OpTypeSampledImage %74 %_ptr_UniformConstant_74 = OpTypePointer UniformConstant %74 %depth2dArray = OpVariable %_ptr_UniformConstant_74 UniformConstant %depth2dArraySamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %82 = OpTypeImage %float Cube 1 1 0 1 Unknown %83 = OpTypeSampledImage %82 %_ptr_UniformConstant_82 = OpTypePointer UniformConstant %82 %depthCubeArray = OpVariable %_ptr_UniformConstant_82 UniformConstant %depthCubeArraySamp = OpVariable %_ptr_UniformConstant_12 UniformConstant %97 = OpConstantComposite %v2float %float_0 %float_1 %98 = OpConstantComposite %v4float %float_0 %float_0 %float_1 %float_1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %v2int = OpTypeVector %int 2 %138 = OpConstantComposite %v2int %int_0 %int_0 %v3int = OpTypeVector %int 3 %143 = OpConstantComposite %v3int %int_0 %int_0 %int_0 %149 = OpTypeImage %float Buffer 0 0 0 1 Unknown %_ptr_UniformConstant_149 = OpTypePointer UniformConstant %149 %texBuffer = OpVariable %_ptr_UniformConstant_149 UniformConstant %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %main = OpFunction %void None %3 %5 = OpLabel %c = OpVariable %_ptr_Function_v4float Function %13 = OpLoad %10 %tex1d %14 = OpLoad %12 %tex1dSamp %15 = OpSampledImage %11 %13 %14 %16 = OpImageSampleImplicitLod %v4float %15 %float_0 OpStore %c %16 %19 = OpLoad %17 %tex2d %20 = OpLoad %12 %tex2dSamp %21 = OpSampledImage %18 %19 %20 %24 = OpImageSampleImplicitLod %v4float %21 %23 OpStore %c %24 %27 = OpLoad %25 %tex3d %28 = OpLoad %12 %tex3dSamp %29 = OpSampledImage %26 %27 %28 %32 = OpImageSampleImplicitLod %v4float %29 %31 OpStore %c %32 %35 = OpLoad %33 %texCube %36 = OpLoad %12 %texCubeSamp %37 = OpSampledImage %34 %35 %36 %38 = OpImageSampleImplicitLod %v4float %37 %31 OpStore %c %38 %41 = OpLoad %39 %tex2dArray %42 = OpLoad %12 %tex2dArraySamp %43 = OpSampledImage %40 %41 %42 %44 = OpImageSampleImplicitLod %v4float %43 %31 OpStore %c %44 %47 = OpLoad %45 %texCubeArray %48 = OpLoad %12 %texCubeArraySamp %49 = OpSampledImage %46 %47 %48 %51 = OpImageSampleImplicitLod %v4float %49 %50 OpStore %c %51 %54 = OpLoad %52 %depth2d %55 = OpLoad %12 %depth2dSamp %56 = OpSampledImage %53 %54 %55 %59 = OpCompositeExtract %float %58 2 %60 = OpImageSampleDrefImplicitLod %float %56 %58 %59 %64 = OpAccessChain %_ptr_Function_float %c %uint_0 OpStore %64 %60 %67 = OpLoad %65 %depthCube %68 = OpLoad %12 %depthCubeSamp %69 = OpSampledImage %66 %67 %68 %71 = OpCompositeExtract %float %70 3 %72 = OpImageSampleDrefImplicitLod %float %69 %70 %71 %73 = OpAccessChain %_ptr_Function_float %c %uint_0 OpStore %73 %72 %76 = OpLoad %74 %depth2dArray %77 = OpLoad %12 %depth2dArraySamp %78 = OpSampledImage %75 %76 %77 %79 = OpCompositeExtract %float %70 3 %80 = OpImageSampleDrefImplicitLod %float %78 %70 %79 %81 = OpAccessChain %_ptr_Function_float %c %uint_0 OpStore %81 %80 %84 = OpLoad %82 %depthCubeArray %85 = OpLoad %12 %depthCubeArraySamp %86 = OpSampledImage %83 %84 %85 %87 = OpImageSampleDrefImplicitLod %float %86 %50 %float_1 %88 = OpAccessChain %_ptr_Function_float %c %uint_0 OpStore %88 %87 %89 = OpLoad %10 %tex1d %90 = OpLoad %12 %tex1dSamp %91 = OpSampledImage %11 %89 %90 %92 = OpImageSampleProjImplicitLod %v4float %91 %97 OpStore %c %92 %93 = OpLoad %17 %tex2d %94 = OpLoad %12 %tex2dSamp %95 = OpSampledImage %18 %93 %94 %96 = OpImageSampleProjImplicitLod %v4float %95 %58 OpStore %c %96 %99 = OpLoad %25 %tex3d %100 = OpLoad %12 %tex3dSamp %101 = OpSampledImage %26 %99 %100 %102 = OpImageSampleProjImplicitLod %v4float %101 %70 OpStore %c %102 %103 = OpLoad %52 %depth2d %104 = OpLoad %12 %depth2dSamp %105 = OpSampledImage %53 %103 %104 %106 = OpCompositeExtract %float %98 2 %107 = OpCompositeExtract %float %98 3 %108 = OpCompositeInsert %v4float %107 %98 2 %109 = OpImageSampleProjDrefImplicitLod %float %105 %108 %106 %110 = OpAccessChain %_ptr_Function_float %c %uint_0 OpStore %110 %109 %111 = OpLoad %10 %tex1d %112 = OpLoad %12 %tex1dSamp %113 = OpSampledImage %11 %111 %112 %114 = OpImageSampleExplicitLod %v4float %113 %float_0 Lod %float_0 OpStore %c %114 %115 = OpLoad %17 %tex2d %116 = OpLoad %12 %tex2dSamp %117 = OpSampledImage %18 %115 %116 %118 = OpImageSampleExplicitLod %v4float %117 %23 Lod %float_0 OpStore %c %118 %119 = OpLoad %25 %tex3d %120 = OpLoad %12 %tex3dSamp %121 = OpSampledImage %26 %119 %120 %122 = OpImageSampleExplicitLod %v4float %121 %31 Lod %float_0 OpStore %c %122 %123 = OpLoad %33 %texCube %124 = OpLoad %12 %texCubeSamp %125 = OpSampledImage %34 %123 %124 %126 = OpImageSampleExplicitLod %v4float %125 %31 Lod %float_0 OpStore %c %126 %127 = OpLoad %39 %tex2dArray %128 = OpLoad %12 %tex2dArraySamp %129 = OpSampledImage %40 %127 %128 %130 = OpImageSampleExplicitLod %v4float %129 %31 Lod %float_0 OpStore %c %130 %131 = OpLoad %45 %texCubeArray %132 = OpLoad %12 %texCubeArraySamp %133 = OpSampledImage %46 %131 %132 %134 = OpImageSampleExplicitLod %v4float %133 %50 Lod %float_0 OpStore %c %134 %135 = OpLoad %52 %depth2d %136 = OpLoad %12 %depth2dSamp %137 = OpSampledImage %53 %135 %136 %139 = OpCompositeExtract %float %58 2 %140 = OpImageSampleDrefExplicitLod %float %137 %58 %139 Lod %float_0 %141 = OpAccessChain %_ptr_Function_float %c %uint_0 OpStore %141 %140 %142 = OpLoad %10 %tex1d %144 = OpLoad %12 %tex1dSamp %145 = OpSampledImage %11 %142 %144 %146 = OpImageSampleProjExplicitLod %v4float %145 %97 Lod %float_0 OpStore %c %146 %147 = OpLoad %17 %tex2d %148 = OpLoad %12 %tex2dSamp %150 = OpSampledImage %18 %147 %148 %151 = OpImageSampleProjExplicitLod %v4float %150 %58 Lod %float_0 OpStore %c %151 %152 = OpLoad %25 %tex3d %153 = OpLoad %12 %tex3dSamp %154 = OpSampledImage %26 %152 %153 %155 = OpImageSampleProjExplicitLod %v4float %154 %70 Lod %float_0 OpStore %c %155 %156 = OpLoad %52 %depth2d %157 = OpLoad %12 %depth2dSamp %158 = OpSampledImage %53 %156 %157 %159 = OpCompositeExtract %float %98 2 %160 = OpCompositeExtract %float %98 3 %161 = OpCompositeInsert %v4float %160 %98 2 %162 = OpImageSampleProjDrefExplicitLod %float %158 %161 %159 Lod %float_0 %163 = OpAccessChain %_ptr_Function_float %c %uint_0 OpStore %163 %162 %164 = OpLoad %10 %tex1d %165 = OpImageFetch %v4float %164 %int_0 Lod %int_0 OpStore %c %165 %166 = OpLoad %17 %tex2d %167 = OpImageFetch %v4float %166 %138 Lod %int_0 OpStore %c %167 %168 = OpLoad %25 %tex3d %169 = OpImageFetch %v4float %168 %143 Lod %int_0 OpStore %c %169 %170 = OpLoad %39 %tex2dArray %171 = OpImageFetch %v4float %170 %143 Lod %int_0 OpStore %c %171 %172 = OpLoad %149 %texBuffer %173 = OpImageFetch %v4float %172 %int_0 OpStore %c %173 %174 = OpLoad %17 %tex2d %175 = OpLoad %12 %tex2dSamp %176 = OpSampledImage %18 %174 %175 %177 = OpImageGather %v4float %176 %23 %int_0 OpStore %c %177 %178 = OpLoad %33 %texCube %179 = OpLoad %12 %texCubeSamp %180 = OpSampledImage %34 %178 %179 %181 = OpImageGather %v4float %180 %31 %int_1 OpStore %c %181 %182 = OpLoad %39 %tex2dArray %183 = OpLoad %12 %tex2dArraySamp %184 = OpSampledImage %40 %182 %183 %185 = OpImageGather %v4float %184 %31 %int_2 OpStore %c %185 %186 = OpLoad %45 %texCubeArray %187 = OpLoad %12 %texCubeArraySamp %188 = OpSampledImage %46 %186 %187 %189 = OpImageGather %v4float %188 %50 %int_3 OpStore %c %189 %190 = OpLoad %52 %depth2d %191 = OpLoad %12 %depth2dSamp %192 = OpSampledImage %53 %190 %191 %193 = OpImageDrefGather %v4float %192 %23 %float_1 OpStore %c %193 %194 = OpLoad %65 %depthCube %195 = OpLoad %12 %depthCubeSamp %196 = OpSampledImage %66 %194 %195 %197 = OpImageDrefGather %v4float %196 %31 %float_1 OpStore %c %197 %198 = OpLoad %74 %depth2dArray %199 = OpLoad %12 %depth2dArraySamp %200 = OpSampledImage %75 %198 %199 %201 = OpImageDrefGather %v4float %200 %31 %float_1 OpStore %c %201 %202 = OpLoad %82 %depthCubeArray %203 = OpLoad %12 %depthCubeArraySamp %204 = OpSampledImage %83 %202 %203 %205 = OpImageDrefGather %v4float %204 %50 %float_1 OpStore %c %205 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/frag/vector-shuffle-undef-index.asm.frag000066400000000000000000000031661400026215700303130ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vFloat OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %vFloat "vFloat" OpName %undef "undef" OpDecorate %FragColor Location 0 OpDecorate %vFloat Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %vFloat = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %_ptr_Private_v4float = OpTypePointer Private %v4float %undef = OpUndef %v4float %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_Private_float = OpTypePointer Private %float %uint_3 = OpConstant %uint 3 %_ptr_Input_float = OpTypePointer Input %float %main = OpFunction %void None %3 %5 = OpLabel %13 = OpLoad %v4float %vFloat %26 = OpVectorShuffle %v4float %13 %undef 4 1 0xffffffff 3 %27 = OpVectorShuffle %v4float %13 %13 2 1 0xffffffff 3 %28 = OpFAdd %v4float %26 %27 OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/000077500000000000000000000000001400026215700222225ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/composite-extract-row-major.asm.comp000066400000000000000000000035211400026215700312470ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 21 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBORow "SSBORow" OpMemberName %SSBORow 0 "v" OpMemberName %SSBORow 1 "row_major0" OpName %_ "" OpMemberDecorate %SSBORow 0 Offset 0 OpMemberDecorate %SSBORow 1 RowMajor OpMemberDecorate %SSBORow 1 Offset 16 OpMemberDecorate %SSBORow 1 MatrixStride 16 OpDecorate %SSBORow BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %SSBORow = OpTypeStruct %float %mat4v4float %_ptr_Uniform_SSBORow = OpTypePointer Uniform %SSBORow %_ = OpVariable %_ptr_Uniform_SSBORow Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %main = OpFunction %void None %3 %5 = OpLabel %row_ptr = OpAccessChain %_ptr_Uniform_v4float %_ %int_1 %int_1 %vec = OpLoad %v4float %row_ptr %float_val = OpCompositeExtract %float %vec 2 %20 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %20 %float_val OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding-2.asm.comp000066400000000000000000000045401400026215700307410ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 23 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_scalar_block_layout" OpName %main "main" OpName %SSBOScalar "SSBOScalar" OpMemberName %SSBOScalar 0 "a" OpMemberName %SSBOScalar 1 "b" OpMemberName %SSBOScalar 2 "c" OpName %_ "" OpMemberDecorate %SSBOScalar 0 Offset 0 OpMemberDecorate %SSBOScalar 1 RowMajor OpMemberDecorate %SSBOScalar 1 Offset 16 OpMemberDecorate %SSBOScalar 1 MatrixStride 16 OpMemberDecorate %SSBOScalar 2 RowMajor OpMemberDecorate %SSBOScalar 2 Offset 64 OpMemberDecorate %SSBOScalar 2 MatrixStride 16 OpDecorate %SSBOScalar BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %mat3v3float = OpTypeMatrix %v3float 3 %SSBOScalar = OpTypeStruct %v3float %mat3v3float %mat3v3float %_ptr_Uniform_SSBOScalar = OpTypePointer Uniform %SSBOScalar %_ = OpVariable %_ptr_Uniform_SSBOScalar Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %_ptr_Uniform_mat3v3float = OpTypePointer Uniform %mat3v3float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %main = OpFunction %void None %3 %5 = OpLabel %b_ptr = OpAccessChain %_ptr_Uniform_mat3v3float %_ %int_1 %c_ptr = OpAccessChain %_ptr_Uniform_mat3v3float %_ %int_2 %b = OpLoad %mat3v3float %b_ptr %c = OpLoad %mat3v3float %c_ptr OpStore %b_ptr %c %19 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 %20 = OpLoad %v3float %19 %21 = OpMatrixTimesVector %v3float %b %20 %22 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 OpStore %22 %21 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding-3.asm.comp000066400000000000000000000036011400026215700307370ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 22 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_scalar_block_layout" OpName %main "main" OpName %SSBOScalar "SSBOScalar" OpMemberName %SSBOScalar 0 "a" OpMemberName %SSBOScalar 1 "b" OpMemberName %SSBOScalar 2 "c" OpName %_ "" OpMemberDecorate %SSBOScalar 0 Offset 0 OpMemberDecorate %SSBOScalar 1 Offset 12 OpMemberDecorate %SSBOScalar 2 Offset 24 OpDecorate %SSBOScalar BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %SSBOScalar = OpTypeStruct %v3float %v3float %v3float %_ptr_Uniform_SSBOScalar = OpTypePointer Uniform %SSBOScalar %_ = OpVariable %_ptr_Uniform_SSBOScalar Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %int_2 = OpConstant %int 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpAccessChain %_ptr_Uniform_v3float %_ %int_1 %16 = OpLoad %v3float %15 %18 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 %19 = OpLoad %v3float %18 OpStore %18 %16 %20 = OpFMul %v3float %16 %19 %21 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 OpStore %21 %20 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding-4.asm.comp000066400000000000000000000051251400026215700307430ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_scalar_block_layout" OpName %main "main" OpName %SSBOScalar "SSBOScalar" OpMemberName %SSBOScalar 0 "a" OpMemberName %SSBOScalar 1 "b" OpMemberName %SSBOScalar 2 "c" OpName %_ "" OpDecorate %_arr_v2float_uint_16 ArrayStride 16 OpDecorate %_arr_v2float_uint_16_0 ArrayStride 16 OpDecorate %_arr_float_uint_16 ArrayStride 16 OpMemberDecorate %SSBOScalar 0 Offset 0 OpMemberDecorate %SSBOScalar 1 Offset 256 OpMemberDecorate %SSBOScalar 2 Offset 512 OpDecorate %SSBOScalar BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_16 = OpConstant %uint 16 %_arr_v2float_uint_16 = OpTypeArray %v2float %uint_16 %_arr_v2float_uint_16_0 = OpTypeArray %v2float %uint_16 %_arr_float_uint_16 = OpTypeArray %float %uint_16 %SSBOScalar = OpTypeStruct %_arr_v2float_uint_16 %_arr_v2float_uint_16_0 %_arr_float_uint_16 %_ptr_Uniform_SSBOScalar = OpTypePointer Uniform %SSBOScalar %_ = OpVariable %_ptr_Uniform_SSBOScalar Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %int_2 = OpConstant %int 2 %float_10 = OpConstant %float 10.0 %float_11 = OpConstant %float 11.0 %float_const = OpConstantComposite %v2float %float_10 %float_11 %_ptr_Uniform_float = OpTypePointer Uniform %float %main = OpFunction %void None %3 %5 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 %int_10 %22 = OpLoad %v2float %21 %25 = OpAccessChain %_ptr_Uniform_float %_ %int_2 %int_10 %26 = OpLoad %float %25 OpStore %21 %float_const %27 = OpVectorTimesScalar %v2float %22 %26 %28 = OpAccessChain %_ptr_Uniform_v2float %_ %int_0 %int_10 OpStore %28 %27 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding-5.asm.comp000066400000000000000000000042711400026215700307450ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_scalar_block_layout" OpName %main "main" OpName %SSBOScalar "SSBOScalar" OpMemberName %SSBOScalar 0 "a" OpMemberName %SSBOScalar 1 "b" OpMemberName %SSBOScalar 2 "c" OpName %_ "" OpMemberDecorate %SSBOScalar 0 Offset 0 OpMemberDecorate %SSBOScalar 1 Offset 8 OpMemberDecorate %SSBOScalar 2 Offset 20 OpDecorate %SSBOScalar BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %SSBOScalar = OpTypeStruct %v2float %v3float %v3float %_ptr_Uniform_SSBOScalar = OpTypePointer Uniform %SSBOScalar %_ = OpVariable %_ptr_Uniform_SSBOScalar Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %int_2 = OpConstant %int 2 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %float_1 = OpConstant %float 1 %27 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Uniform_v3float %_ %int_1 %17 = OpLoad %v3float %16 %18 = OpVectorShuffle %v2float %17 %17 0 1 %20 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 %21 = OpLoad %v3float %20 %22 = OpVectorShuffle %v2float %21 %21 1 2 OpStore %16 %27 %23 = OpFMul %v2float %18 %22 %25 = OpAccessChain %_ptr_Uniform_v2float %_ %int_0 OpStore %25 %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/load-packed-no-forwarding.asm.comp000066400000000000000000000045401400026215700306020ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 23 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_scalar_block_layout" OpName %main "main" OpName %SSBOScalar "SSBOScalar" OpMemberName %SSBOScalar 0 "a" OpMemberName %SSBOScalar 1 "b" OpMemberName %SSBOScalar 2 "c" OpName %_ "" OpMemberDecorate %SSBOScalar 0 Offset 0 OpMemberDecorate %SSBOScalar 1 RowMajor OpMemberDecorate %SSBOScalar 1 Offset 12 OpMemberDecorate %SSBOScalar 1 MatrixStride 12 OpMemberDecorate %SSBOScalar 2 RowMajor OpMemberDecorate %SSBOScalar 2 Offset 48 OpMemberDecorate %SSBOScalar 2 MatrixStride 12 OpDecorate %SSBOScalar BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %mat3v3float = OpTypeMatrix %v3float 3 %SSBOScalar = OpTypeStruct %v3float %mat3v3float %mat3v3float %_ptr_Uniform_SSBOScalar = OpTypePointer Uniform %SSBOScalar %_ = OpVariable %_ptr_Uniform_SSBOScalar Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %_ptr_Uniform_mat3v3float = OpTypePointer Uniform %mat3v3float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %main = OpFunction %void None %3 %5 = OpLabel %b_ptr = OpAccessChain %_ptr_Uniform_mat3v3float %_ %int_1 %c_ptr = OpAccessChain %_ptr_Uniform_mat3v3float %_ %int_2 %b = OpLoad %mat3v3float %b_ptr %c = OpLoad %mat3v3float %c_ptr OpStore %b_ptr %c %19 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 %20 = OpLoad %v3float %19 %21 = OpMatrixTimesVector %v3float %b %20 %22 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 OpStore %22 %21 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/packed-vector-extract-insert.asm.comp000066400000000000000000000045041400026215700313650ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_scalar_block_layout" OpName %main "main" OpName %SSBOScalar "SSBOScalar" OpMemberName %SSBOScalar 0 "a" OpMemberName %SSBOScalar 1 "b" OpMemberName %SSBOScalar 2 "c" OpMemberName %SSBOScalar 3 "d" OpName %_ "" OpMemberDecorate %SSBOScalar 0 Offset 0 OpMemberDecorate %SSBOScalar 1 Offset 8 OpMemberDecorate %SSBOScalar 2 Offset 20 OpMemberDecorate %SSBOScalar 3 Offset 32 OpDecorate %SSBOScalar BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %SSBOScalar = OpTypeStruct %v2float %v3float %v3float %v3float %_ptr_Uniform_SSBOScalar = OpTypePointer Uniform %SSBOScalar %_ = OpVariable %_ptr_Uniform_SSBOScalar Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %int_2 = OpConstant %int 2 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %float_2 = OpConstant %float 2.0 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %main = OpFunction %void None %3 %5 = OpLabel %v3_ptr = OpAccessChain %_ptr_Uniform_v3float %_ %int_1 %v3 = OpLoad %v3float %v3_ptr %v3_mod = OpCompositeInsert %v3float %float_2 %v3 2 %v2 = OpVectorShuffle %v2float %v3 %v3 0 1 %v1 = OpCompositeExtract %float %v3 2 %v2_mul = OpVectorTimesScalar %v2float %v2 %v1 %v2_ptr = OpAccessChain %_ptr_Uniform_v2float %_ %int_0 OpStore %v2_ptr %v2_mul OpStore %v3_ptr %v3_mod OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/row-major-split-access-chain.asm.comp000066400000000000000000000035411400026215700312510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 21 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBORow "SSBORow" OpMemberName %SSBORow 0 "v" OpMemberName %SSBORow 1 "row_major0" OpName %_ "" OpMemberDecorate %SSBORow 0 Offset 0 OpMemberDecorate %SSBORow 1 RowMajor OpMemberDecorate %SSBORow 1 Offset 16 OpMemberDecorate %SSBORow 1 MatrixStride 16 OpDecorate %SSBORow BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %SSBORow = OpTypeStruct %float %mat4v4float %_ptr_Uniform_SSBORow = OpTypePointer Uniform %SSBORow %_ = OpVariable %_ptr_Uniform_SSBORow Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %main = OpFunction %void None %3 %5 = OpLabel %row_ptr = OpAccessChain %_ptr_Uniform_v4float %_ %int_1 %int_1 %float_ptr = OpAccessChain %_ptr_Uniform_float %row_ptr %uint_2 %19 = OpLoad %float %float_ptr %20 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %20 %19 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-array-float2.asm.frag000066400000000000000000000043211400026215700274100ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 29 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpDecorate %_arr_v2float_uint_2 ArrayStride 16 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 1 Offset 24 OpDecorate %type_Foo Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_arr_v2float_uint_2 = OpTypeArray %v2float %uint_2 %type_Foo = OpTypeStruct %_arr_v2float_uint_2 %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v2float = OpTypePointer Output %v2float %void = OpTypeVoid %16 = OpTypeFunction %void %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v2float Output %main = OpFunction %void None %16 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %int_0 %21 = OpLoad %v2float %20 %22 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %int_1 %23 = OpLoad %v2float %22 %24 = OpFAdd %v2float %21 %23 %25 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %26 = OpLoad %float %25 %27 = OpCompositeConstruct %v2float %26 %26 %28 = OpFAdd %v2float %24 %27 OpStore %out_var_SV_Target %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-array-float3-one-element.asm.frag000066400000000000000000000041051400026215700316170ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 26 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpDecorate %_arr_v3float_uint_1 ArrayStride 16 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 1 Offset 12 OpDecorate %type_Foo Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_arr_v3float_uint_1 = OpTypeArray %v3float %uint_1 %type_Foo = OpTypeStruct %_arr_v3float_uint_1 %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v3float = OpTypePointer Output %v3float %void = OpTypeVoid %16 = OpTypeFunction %void %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v3float Output %main = OpFunction %void None %16 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %int_0 %21 = OpLoad %v3float %20 %22 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %23 = OpLoad %float %22 %24 = OpCompositeConstruct %v3float %23 %23 %23 %25 = OpFAdd %v3float %21 %24 OpStore %out_var_SV_Target %25 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-array-float3.asm.frag000066400000000000000000000043251400026215700274150ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 29 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpDecorate %_arr_v3float_uint_2 ArrayStride 16 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 1 Offset 28 OpDecorate %type_Foo Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_arr_v3float_uint_2 = OpTypeArray %v3float %uint_2 %type_Foo = OpTypeStruct %_arr_v3float_uint_2 %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v3float = OpTypePointer Output %v3float %void = OpTypeVoid %16 = OpTypeFunction %void %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v3float Output %main = OpFunction %void None %16 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %int_0 %21 = OpLoad %v3float %20 %22 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %int_1 %23 = OpLoad %v3float %22 %24 = OpFAdd %v3float %21 %23 %25 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %26 = OpLoad %float %25 %27 = OpCompositeConstruct %v3float %26 %26 %26 %28 = OpFAdd %v3float %24 %27 OpStore %out_var_SV_Target %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-float2x2-col-major.invalid.asm.frag000066400000000000000000000044231400026215700320570ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 30 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 0 MatrixStride 16 OpMemberDecorate %type_Foo 0 ColMajor OpMemberDecorate %type_Foo 1 Offset 24 OpDecorate %type_Foo Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat2v2float = OpTypeMatrix %v2float 2 %type_Foo = OpTypeStruct %mat2v2float %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v2float = OpTypePointer Output %v2float %void = OpTypeVoid %17 = OpTypeFunction %void %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v2float Output %main = OpFunction %void None %17 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %uint_0 %22 = OpLoad %v2float %21 %23 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %uint_1 %24 = OpLoad %v2float %23 %25 = OpFAdd %v2float %22 %24 %26 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %27 = OpLoad %float %26 %28 = OpCompositeConstruct %v2float %27 %27 %29 = OpFAdd %v2float %25 %28 OpStore %out_var_SV_Target %29 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-float2x2-row-major.asm.frag000066400000000000000000000044231400026215700304640ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 30 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 0 MatrixStride 16 OpMemberDecorate %type_Foo 0 RowMajor OpMemberDecorate %type_Foo 1 Offset 24 OpDecorate %type_Foo Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat2v2float = OpTypeMatrix %v2float 2 %type_Foo = OpTypeStruct %mat2v2float %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v2float = OpTypePointer Output %v2float %void = OpTypeVoid %17 = OpTypeFunction %void %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v2float Output %main = OpFunction %void None %17 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %uint_0 %22 = OpLoad %v2float %21 %23 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %uint_1 %24 = OpLoad %v2float %23 %25 = OpFAdd %v2float %22 %24 %26 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %27 = OpLoad %float %26 %28 = OpCompositeConstruct %v2float %27 %27 %29 = OpFAdd %v2float %25 %28 OpStore %out_var_SV_Target %29 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-float2x3-col-major.invalid.asm.frag000066400000000000000000000044271400026215700320640ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 30 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 0 MatrixStride 16 OpMemberDecorate %type_Foo 0 ColMajor OpMemberDecorate %type_Foo 1 Offset 28 OpDecorate %type_Foo Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %mat2v3float = OpTypeMatrix %v3float 2 %type_Foo = OpTypeStruct %mat2v3float %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v3float = OpTypePointer Output %v3float %void = OpTypeVoid %17 = OpTypeFunction %void %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v3float Output %main = OpFunction %void None %17 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %uint_0 %22 = OpLoad %v3float %21 %23 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %uint_1 %24 = OpLoad %v3float %23 %25 = OpFAdd %v3float %22 %24 %26 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %27 = OpLoad %float %26 %28 = OpCompositeConstruct %v3float %27 %27 %27 %29 = OpFAdd %v3float %25 %28 OpStore %out_var_SV_Target %29 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-float2x3-row-major.asm.frag000066400000000000000000000044271400026215700304710ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 30 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 0 MatrixStride 16 OpMemberDecorate %type_Foo 0 RowMajor OpMemberDecorate %type_Foo 1 Offset 40 OpDecorate %type_Foo Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %mat2v3float = OpTypeMatrix %v3float 2 %type_Foo = OpTypeStruct %mat2v3float %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v3float = OpTypePointer Output %v3float %void = OpTypeVoid %17 = OpTypeFunction %void %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v3float Output %main = OpFunction %void None %17 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %uint_0 %22 = OpLoad %v3float %21 %23 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %uint_1 %24 = OpLoad %v3float %23 %25 = OpFAdd %v3float %22 %24 %26 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %27 = OpLoad %float %26 %28 = OpCompositeConstruct %v3float %27 %27 %27 %29 = OpFAdd %v3float %25 %28 OpStore %out_var_SV_Target %29 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-float3x2-col-major.invalid.asm.frag000066400000000000000000000044231400026215700320600ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 30 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 0 MatrixStride 16 OpMemberDecorate %type_Foo 0 ColMajor OpMemberDecorate %type_Foo 1 Offset 40 OpDecorate %type_Foo Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat3v2float = OpTypeMatrix %v2float 3 %type_Foo = OpTypeStruct %mat3v2float %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v2float = OpTypePointer Output %v2float %void = OpTypeVoid %17 = OpTypeFunction %void %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v2float Output %main = OpFunction %void None %17 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %uint_0 %22 = OpLoad %v2float %21 %23 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %uint_1 %24 = OpLoad %v2float %23 %25 = OpFAdd %v2float %22 %24 %26 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %27 = OpLoad %float %26 %28 = OpCompositeConstruct %v2float %27 %27 %29 = OpFAdd %v2float %25 %28 OpStore %out_var_SV_Target %29 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-float3x2-row-major.asm.frag000066400000000000000000000044231400026215700304650ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 30 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 0 MatrixStride 16 OpMemberDecorate %type_Foo 0 RowMajor OpMemberDecorate %type_Foo 1 Offset 28 OpDecorate %type_Foo Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat3v2float = OpTypeMatrix %v2float 3 %type_Foo = OpTypeStruct %mat3v2float %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v2float = OpTypePointer Output %v2float %void = OpTypeVoid %17 = OpTypeFunction %void %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v2float Output %main = OpFunction %void None %17 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %uint_0 %22 = OpLoad %v2float %21 %23 = OpAccessChain %_ptr_Uniform_v2float %Foo %int_0 %uint_1 %24 = OpLoad %v2float %23 %25 = OpFAdd %v2float %22 %24 %26 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %27 = OpLoad %float %26 %28 = OpCompositeConstruct %v2float %27 %27 %29 = OpFAdd %v2float %25 %28 OpStore %out_var_SV_Target %29 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-float3x3-col-major.invalid.asm.frag000066400000000000000000000044271400026215700320650ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 30 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 0 MatrixStride 16 OpMemberDecorate %type_Foo 0 ColMajor OpMemberDecorate %type_Foo 1 Offset 44 OpDecorate %type_Foo Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %mat3v3float = OpTypeMatrix %v3float 3 %type_Foo = OpTypeStruct %mat3v3float %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v3float = OpTypePointer Output %v3float %void = OpTypeVoid %17 = OpTypeFunction %void %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v3float Output %main = OpFunction %void None %17 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %uint_0 %22 = OpLoad %v3float %21 %23 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %uint_1 %24 = OpLoad %v3float %23 %25 = OpFAdd %v3float %22 %24 %26 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %27 = OpLoad %float %26 %28 = OpCompositeConstruct %v3float %27 %27 %27 %29 = OpFAdd %v3float %25 %28 OpStore %out_var_SV_Target %29 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/packing/scalar-float3x3-row-major.asm.frag000066400000000000000000000044271400026215700304720ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 30 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_Foo "type.Foo" OpMemberName %type_Foo 0 "a" OpMemberName %type_Foo 1 "b" OpName %Foo "Foo" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Foo DescriptorSet 0 OpDecorate %Foo Binding 0 OpMemberDecorate %type_Foo 0 Offset 0 OpMemberDecorate %type_Foo 0 MatrixStride 16 OpMemberDecorate %type_Foo 0 RowMajor OpMemberDecorate %type_Foo 1 Offset 44 OpDecorate %type_Foo Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %mat3v3float = OpTypeMatrix %v3float 3 %type_Foo = OpTypeStruct %mat3v3float %float %_ptr_Uniform_type_Foo = OpTypePointer Uniform %type_Foo %_ptr_Output_v3float = OpTypePointer Output %v3float %void = OpTypeVoid %17 = OpTypeFunction %void %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_float = OpTypePointer Uniform %float %Foo = OpVariable %_ptr_Uniform_type_Foo Uniform %out_var_SV_Target = OpVariable %_ptr_Output_v3float Output %main = OpFunction %void None %17 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %uint_0 %22 = OpLoad %v3float %21 %23 = OpAccessChain %_ptr_Uniform_v3float %Foo %int_0 %uint_1 %24 = OpLoad %v3float %23 %25 = OpFAdd %v3float %22 %24 %26 = OpAccessChain %_ptr_Uniform_float %Foo %int_1 %27 = OpLoad %float %26 %28 = OpCompositeConstruct %v3float %27 %27 %27 %29 = OpFAdd %v3float %25 %28 OpStore %out_var_SV_Target %29 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/temporary.zero-initialize.asm.frag000066400000000000000000000067461400026215700274020ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 65 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vA %vB OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %vA "vA" OpName %vB "vB" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %vA RelaxedPrecision OpDecorate %vA Flat OpDecorate %vA Location 0 OpDecorate %25 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %vB RelaxedPrecision OpDecorate %vB Flat OpDecorate %vB Location 1 OpDecorate %38 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %51 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %64 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %60 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %11 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_int = OpTypePointer Input %int %vA = OpVariable %_ptr_Input_int Input %bool = OpTypeBool %int_20 = OpConstant %int 20 %int_50 = OpConstant %int 50 %vB = OpVariable %_ptr_Input_int Input %int_40 = OpConstant %int 40 %int_60 = OpConstant %int 60 %int_10 = OpConstant %int 10 %float_1 = OpConstant %float 1 %63 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %main = OpFunction %void None %3 %5 = OpLabel OpStore %FragColor %11 OpBranch %17 %17 = OpLabel %60 = OpPhi %int %int_0 %5 %58 %20 %57 = OpPhi %int %int_0 %5 %56 %20 %25 = OpLoad %int %vA %27 = OpSLessThan %bool %57 %25 OpLoopMerge %19 %20 None OpBranchConditional %27 %18 %19 %18 = OpLabel %30 = OpIAdd %int %25 %57 %32 = OpIEqual %bool %30 %int_20 OpSelectionMerge %34 None OpBranchConditional %32 %33 %36 %33 = OpLabel OpBranch %34 %36 = OpLabel %38 = OpLoad %int %vB %40 = OpIAdd %int %38 %57 %42 = OpIEqual %bool %40 %int_40 %64 = OpSelect %int %42 %int_60 %60 OpBranch %34 %34 = OpLabel %58 = OpPhi %int %int_50 %33 %64 %36 %49 = OpIAdd %int %58 %int_10 %51 = OpLoad %v4float %FragColor %53 = OpFAdd %v4float %51 %63 OpStore %FragColor %53 OpBranch %20 %20 = OpLabel %56 = OpIAdd %int %57 %49 OpBranch %17 %19 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc/000077500000000000000000000000001400026215700215445ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc/array-control-point-initializer.asm.tesc000066400000000000000000000072461400026215700314600ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 48 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_out %gl_InvocationID %foo OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpName %gl_InvocationID "gl_InvocationID" OpName %foo "foo" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %foo Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %22 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %uint_3 = OpConstant %uint 3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %_arr__arr_float_uint_3_uint_4 = OpTypeArray %_arr_float_uint_3 %uint_4 %_ptr_Output__arr__arr_float_uint_3_uint_4 = OpTypePointer Output %_arr__arr_float_uint_3_uint_4 %foo_zero = OpConstantNull %_arr__arr_float_uint_3_uint_4 %foo = OpVariable %_ptr_Output__arr__arr_float_uint_3_uint_4 Output %foo_zero %_ptr_Output_float = OpTypePointer Output %float %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %float_2 = OpConstant %float 2 %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Output_v4float %gl_out %19 %int_0 OpStore %24 %22 %30 = OpLoad %int %gl_InvocationID %31 = OpLoad %int %gl_InvocationID %32 = OpConvertSToF %float %31 %34 = OpAccessChain %_ptr_Output_float %foo %30 %int_0 OpStore %34 %32 %35 = OpLoad %int %gl_InvocationID %37 = OpLoad %int %gl_InvocationID %38 = OpConvertSToF %float %37 %39 = OpFAdd %float %38 %float_1 %40 = OpAccessChain %_ptr_Output_float %foo %35 %int_1 OpStore %40 %39 %41 = OpLoad %int %gl_InvocationID %43 = OpLoad %int %gl_InvocationID %44 = OpConvertSToF %float %43 %46 = OpFAdd %float %44 %float_2 %47 = OpAccessChain %_ptr_Output_float %foo %41 %int_2 OpStore %47 %46 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc/block-control-point-initializer.asm.tesc000066400000000000000000000063321400026215700314270ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 35 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_out %gl_InvocationID %verts OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpName %gl_InvocationID "gl_InvocationID" OpName %Verts "Verts" OpMemberName %Verts 0 "a" OpMemberName %Verts 1 "b" OpName %verts "verts" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %Verts Block OpDecorate %verts Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 ;%gl_out_zero = OpConstantNull %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output ;%gl_out_zero %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %22 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %v2float = OpTypeVector %float 2 %Verts = OpTypeStruct %float %v2float %_arr_Verts_uint_4 = OpTypeArray %Verts %uint_4 %_ptr_Output__arr_Verts_uint_4 = OpTypePointer Output %_arr_Verts_uint_4 %verts_zero = OpConstantNull %_arr_Verts_uint_4 %verts = OpVariable %_ptr_Output__arr_Verts_uint_4 Output %verts_zero %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Output_v4float %gl_out %19 %int_0 OpStore %24 %22 %30 = OpLoad %int %gl_InvocationID %31 = OpLoad %int %gl_InvocationID %32 = OpConvertSToF %float %31 %34 = OpAccessChain %_ptr_Output_float %verts %30 %int_0 OpStore %34 %32 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc/builtin-control-point-initializer.asm.tesc000066400000000000000000000055741400026215700320120ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 35 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_out %gl_InvocationID %verts OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpName %gl_out "gl_out" OpName %gl_InvocationID "gl_InvocationID" OpName %Verts "Verts" OpMemberName %Verts 0 "a" OpMemberName %Verts 1 "b" OpName %verts "verts" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %Verts Block OpDecorate %verts Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %gl_PerVertex = OpTypeStruct %v4float %float %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out_zero = OpConstantNull %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %gl_out_zero %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %22 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %v2float = OpTypeVector %float 2 %Verts = OpTypeStruct %float %v2float %_arr_Verts_uint_4 = OpTypeArray %Verts %uint_4 %_ptr_Output__arr_Verts_uint_4 = OpTypePointer Output %_arr_Verts_uint_4 %verts_zero = OpConstantNull %_arr_Verts_uint_4 %verts = OpVariable %_ptr_Output__arr_Verts_uint_4 Output %verts_zero %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Output_v4float %gl_out %19 %int_0 OpStore %24 %22 %30 = OpLoad %int %gl_InvocationID %31 = OpLoad %int %gl_InvocationID %32 = OpConvertSToF %float %31 %34 = OpAccessChain %_ptr_Output_float %verts %30 %int_0 OpStore %34 %32 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc/composite-control-point-initializer.asm.tesc000066400000000000000000000061721400026215700323410ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 35 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_out %gl_InvocationID %foo OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpName %gl_InvocationID "gl_InvocationID" OpName %Foo "Foo" OpMemberName %Foo 0 "a" OpMemberName %Foo 1 "b" OpMemberName %Foo 2 "c" OpName %foo "foo" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %foo Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %22 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %v2float = OpTypeVector %float 2 %Foo = OpTypeStruct %float %v2float %v4float %_arr_Foo_uint_4 = OpTypeArray %Foo %uint_4 %_ptr_Output__arr_Foo_uint_4 = OpTypePointer Output %_arr_Foo_uint_4 %foo_zero = OpConstantNull %_arr_Foo_uint_4 %foo = OpVariable %_ptr_Output__arr_Foo_uint_4 Output %foo_zero %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Output_v4float %gl_out %19 %int_0 OpStore %24 %22 %30 = OpLoad %int %gl_InvocationID %31 = OpLoad %int %gl_InvocationID %32 = OpConvertSToF %float %31 %34 = OpAccessChain %_ptr_Output_float %foo %30 %int_0 OpStore %34 %32 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc/plain-control-point-initializer.asm.tesc000066400000000000000000000056011400026215700314360ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 33 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_out %gl_InvocationID %v OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpName %gl_InvocationID "gl_InvocationID" OpName %v "v" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %v Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %22 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %v_zero = OpConstantNull %_arr_float_uint_4 %v = OpVariable %_ptr_Output__arr_float_uint_4 Output %v_zero %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Output_v4float %gl_out %19 %int_0 OpStore %24 %22 %28 = OpLoad %int %gl_InvocationID %29 = OpLoad %int %gl_InvocationID %30 = OpConvertSToF %float %29 %32 = OpAccessChain %_ptr_Output_float %v %28 OpStore %32 %30 OpReturn OpFunctionEnd tess-fixed-input-array-builtin-array.invalid.asm.tesc000066400000000000000000000307671400026215700336720ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 162 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %hs_main "main" %p_pos %p_1 %i_1 %_entryPointOutput_pos %_entryPointOutput %_patchConstantOutput_EdgeTess %_patchConstantOutput_InsideTess OpExecutionMode %hs_main OutputVertices 3 OpExecutionMode %hs_main Triangles OpExecutionMode %hs_main SpacingFractionalOdd OpExecutionMode %hs_main VertexOrderCw OpSource HLSL 500 OpName %hs_main "hs_main" OpName %VertexOutput "VertexOutput" OpMemberName %VertexOutput 0 "pos" OpMemberName %VertexOutput 1 "uv" OpName %HSOut "HSOut" OpMemberName %HSOut 0 "pos" OpMemberName %HSOut 1 "uv" OpName %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ "@hs_main(struct-VertexOutput-vf4-vf21[3];u1;" OpName %p "p" OpName %i "i" OpName %HSConstantOut "HSConstantOut" OpMemberName %HSConstantOut 0 "EdgeTess" OpMemberName %HSConstantOut 1 "InsideTess" OpName %PatchHS_struct_VertexOutput_vf4_vf21_3__ "PatchHS(struct-VertexOutput-vf4-vf21[3];" OpName %patch "patch" OpName %output "output" OpName %p_0 "p" OpName %p_pos "p.pos" OpName %VertexOutput_0 "VertexOutput" OpMemberName %VertexOutput_0 0 "uv" OpName %p_1 "p" OpName %i_0 "i" OpName %i_1 "i" OpName %flattenTemp "flattenTemp" OpName %param "param" OpName %param_0 "param" OpName %_entryPointOutput_pos "@entryPointOutput.pos" OpName %HSOut_0 "HSOut" OpMemberName %HSOut_0 0 "uv" OpName %_entryPointOutput "@entryPointOutput" OpName %_patchConstantResult "@patchConstantResult" OpName %param_1 "param" OpName %_patchConstantOutput_EdgeTess "@patchConstantOutput.EdgeTess" OpName %_patchConstantOutput_InsideTess "@patchConstantOutput.InsideTess" OpName %output_0 "output" OpDecorate %p_pos BuiltIn Position OpDecorate %p_1 Location 0 OpDecorate %i_1 BuiltIn InvocationId OpDecorate %_entryPointOutput_pos BuiltIn Position OpDecorate %_entryPointOutput Location 0 OpDecorate %_patchConstantOutput_EdgeTess Patch OpDecorate %_patchConstantOutput_EdgeTess BuiltIn TessLevelOuter OpDecorate %_patchConstantOutput_InsideTess Patch OpDecorate %_patchConstantOutput_InsideTess BuiltIn TessLevelInner %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %VertexOutput = OpTypeStruct %v4float %v2float %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_VertexOutput_uint_3 = OpTypeArray %VertexOutput %uint_3 %_ptr_Function__arr_VertexOutput_uint_3 = OpTypePointer Function %_arr_VertexOutput_uint_3 %_ptr_Function_uint = OpTypePointer Function %uint %HSOut = OpTypeStruct %v4float %v2float %16 = OpTypeFunction %HSOut %_ptr_Function__arr_VertexOutput_uint_3 %_ptr_Function_uint %_arr_float_uint_3 = OpTypeArray %float %uint_3 %HSConstantOut = OpTypeStruct %_arr_float_uint_3 %float %23 = OpTypeFunction %HSConstantOut %_ptr_Function__arr_VertexOutput_uint_3 %_ptr_Function_HSOut = OpTypePointer Function %HSOut %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %int_1 = OpConstant %int 1 %_ptr_Function_v2float = OpTypePointer Function %v2float %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %p_pos = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %VertexOutput_0 = OpTypeStruct %v2float %_arr_VertexOutput_0_uint_3 = OpTypeArray %VertexOutput_0 %uint_3 %_ptr_Input__arr_VertexOutput_0_uint_3 = OpTypePointer Input %_arr_VertexOutput_0_uint_3 %p_1 = OpVariable %_ptr_Input__arr_VertexOutput_0_uint_3 Input %_ptr_Input_v2float = OpTypePointer Input %v2float %int_2 = OpConstant %int 2 %_ptr_Input_uint = OpTypePointer Input %uint %i_1 = OpVariable %_ptr_Input_uint Input %_ptr_Output__arr_v4float_uint_3 = OpTypePointer Output %_arr_v4float_uint_3 %_entryPointOutput_pos = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %_ptr_Output_v4float = OpTypePointer Output %v4float %HSOut_0 = OpTypeStruct %v2float %_arr_HSOut_0_uint_3 = OpTypeArray %HSOut_0 %uint_3 %_ptr_Output__arr_HSOut_0_uint_3 = OpTypePointer Output %_arr_HSOut_0_uint_3 %_entryPointOutput = OpVariable %_ptr_Output__arr_HSOut_0_uint_3 Output %_ptr_Output_v2float = OpTypePointer Output %v2float %uint_2 = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %_ptr_Function_HSConstantOut = OpTypePointer Function %HSConstantOut %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %_patchConstantOutput_EdgeTess = OpVariable %_ptr_Output__arr_float_uint_4 Output %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_float = OpTypePointer Output %float %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %_patchConstantOutput_InsideTess = OpVariable %_ptr_Output__arr_float_uint_2 Output %float_1 = OpConstant %float 1 %hs_main = OpFunction %void None %3 %5 = OpLabel %p_0 = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %i_0 = OpVariable %_ptr_Function_uint Function %flattenTemp = OpVariable %_ptr_Function_HSOut Function %param = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %param_0 = OpVariable %_ptr_Function_uint Function %_patchConstantResult = OpVariable %_ptr_Function_HSConstantOut Function %param_1 = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %50 = OpAccessChain %_ptr_Input_v4float %p_pos %int_0 %51 = OpLoad %v4float %50 %52 = OpAccessChain %_ptr_Function_v4float %p_0 %int_0 %int_0 OpStore %52 %51 %58 = OpAccessChain %_ptr_Input_v2float %p_1 %int_0 %int_0 %59 = OpLoad %v2float %58 %60 = OpAccessChain %_ptr_Function_v2float %p_0 %int_0 %int_1 OpStore %60 %59 %61 = OpAccessChain %_ptr_Input_v4float %p_pos %int_1 %62 = OpLoad %v4float %61 %63 = OpAccessChain %_ptr_Function_v4float %p_0 %int_1 %int_0 OpStore %63 %62 %64 = OpAccessChain %_ptr_Input_v2float %p_1 %int_1 %int_0 %65 = OpLoad %v2float %64 %66 = OpAccessChain %_ptr_Function_v2float %p_0 %int_1 %int_1 OpStore %66 %65 %68 = OpAccessChain %_ptr_Input_v4float %p_pos %int_2 %69 = OpLoad %v4float %68 %70 = OpAccessChain %_ptr_Function_v4float %p_0 %int_2 %int_0 OpStore %70 %69 %71 = OpAccessChain %_ptr_Input_v2float %p_1 %int_2 %int_0 %72 = OpLoad %v2float %71 %73 = OpAccessChain %_ptr_Function_v2float %p_0 %int_2 %int_1 OpStore %73 %72 %77 = OpLoad %uint %i_1 OpStore %i_0 %77 %80 = OpLoad %_arr_VertexOutput_uint_3 %p_0 OpStore %param %80 %82 = OpLoad %uint %i_0 OpStore %param_0 %82 %83 = OpFunctionCall %HSOut %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ %param %param_0 OpStore %flattenTemp %83 %86 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0 %87 = OpLoad %v4float %86 %94 = OpLoad %uint %i_1 %89 = OpAccessChain %_ptr_Output_v4float %_entryPointOutput_pos %94 OpStore %89 %87 %95 = OpAccessChain %_ptr_Function_v2float %flattenTemp %int_1 %96 = OpLoad %v2float %95 %98 = OpAccessChain %_ptr_Output_v2float %_entryPointOutput %94 %int_0 OpStore %98 %96 OpControlBarrier %uint_2 %uint_1 %uint_0 %102 = OpLoad %uint %i_1 %104 = OpIEqual %bool %102 %int_0 OpSelectionMerge %106 None OpBranchConditional %104 %105 %106 %105 = OpLabel %110 = OpLoad %_arr_VertexOutput_uint_3 %p_0 OpStore %param_1 %110 %111 = OpFunctionCall %HSConstantOut %PatchHS_struct_VertexOutput_vf4_vf21_3__ %param_1 OpStore %_patchConstantResult %111 %117 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_0 %118 = OpLoad %float %117 %120 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_0 OpStore %120 %118 %121 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_1 %122 = OpLoad %float %121 %123 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_1 OpStore %123 %122 %124 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_2 %125 = OpLoad %float %124 %126 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_2 OpStore %126 %125 %130 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_1 %131 = OpLoad %float %130 %132 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_InsideTess %int_0 OpStore %132 %131 OpBranch %106 %106 = OpLabel OpReturn OpFunctionEnd %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ = OpFunction %HSOut None %16 %p = OpFunctionParameter %_ptr_Function__arr_VertexOutput_uint_3 %i = OpFunctionParameter %_ptr_Function_uint %20 = OpLabel %output = OpVariable %_ptr_Function_HSOut Function %31 = OpLoad %uint %i %33 = OpAccessChain %_ptr_Function_v4float %p %31 %int_0 %34 = OpLoad %v4float %33 %35 = OpAccessChain %_ptr_Function_v4float %output %int_0 OpStore %35 %34 %37 = OpLoad %uint %i %39 = OpAccessChain %_ptr_Function_v2float %p %37 %int_1 %40 = OpLoad %v2float %39 %41 = OpAccessChain %_ptr_Function_v2float %output %int_1 OpStore %41 %40 %42 = OpLoad %HSOut %output OpReturnValue %42 OpFunctionEnd %PatchHS_struct_VertexOutput_vf4_vf21_3__ = OpFunction %HSConstantOut None %23 %patch = OpFunctionParameter %_ptr_Function__arr_VertexOutput_uint_3 %26 = OpLabel %output_0 = OpVariable %_ptr_Function_HSConstantOut Function %135 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %136 = OpLoad %v2float %135 %137 = OpCompositeConstruct %v2float %float_1 %float_1 %138 = OpFAdd %v2float %137 %136 %139 = OpCompositeExtract %float %138 0 %140 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_0 OpStore %140 %139 %141 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %142 = OpLoad %v2float %141 %143 = OpCompositeConstruct %v2float %float_1 %float_1 %144 = OpFAdd %v2float %143 %142 %145 = OpCompositeExtract %float %144 0 %146 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_1 OpStore %146 %145 %147 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %148 = OpLoad %v2float %147 %149 = OpCompositeConstruct %v2float %float_1 %float_1 %150 = OpFAdd %v2float %149 %148 %151 = OpCompositeExtract %float %150 0 %152 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_2 OpStore %152 %151 %153 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %154 = OpLoad %v2float %153 %155 = OpCompositeConstruct %v2float %float_1 %float_1 %156 = OpFAdd %v2float %155 %154 %157 = OpCompositeExtract %float %156 0 %158 = OpAccessChain %_ptr_Function_float %output_0 %int_1 OpStore %158 %157 %159 = OpLoad %HSConstantOut %output_0 OpReturnValue %159 OpFunctionEnd tess-fixed-input-array-builtin-array.invalid.multi-patch.asm.tesc000066400000000000000000000307671400026215700361200ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 162 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %hs_main "main" %p_pos %p_1 %i_1 %_entryPointOutput_pos %_entryPointOutput %_patchConstantOutput_EdgeTess %_patchConstantOutput_InsideTess OpExecutionMode %hs_main OutputVertices 3 OpExecutionMode %hs_main Triangles OpExecutionMode %hs_main SpacingFractionalOdd OpExecutionMode %hs_main VertexOrderCw OpSource HLSL 500 OpName %hs_main "hs_main" OpName %VertexOutput "VertexOutput" OpMemberName %VertexOutput 0 "pos" OpMemberName %VertexOutput 1 "uv" OpName %HSOut "HSOut" OpMemberName %HSOut 0 "pos" OpMemberName %HSOut 1 "uv" OpName %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ "@hs_main(struct-VertexOutput-vf4-vf21[3];u1;" OpName %p "p" OpName %i "i" OpName %HSConstantOut "HSConstantOut" OpMemberName %HSConstantOut 0 "EdgeTess" OpMemberName %HSConstantOut 1 "InsideTess" OpName %PatchHS_struct_VertexOutput_vf4_vf21_3__ "PatchHS(struct-VertexOutput-vf4-vf21[3];" OpName %patch "patch" OpName %output "output" OpName %p_0 "p" OpName %p_pos "p.pos" OpName %VertexOutput_0 "VertexOutput" OpMemberName %VertexOutput_0 0 "uv" OpName %p_1 "p" OpName %i_0 "i" OpName %i_1 "i" OpName %flattenTemp "flattenTemp" OpName %param "param" OpName %param_0 "param" OpName %_entryPointOutput_pos "@entryPointOutput.pos" OpName %HSOut_0 "HSOut" OpMemberName %HSOut_0 0 "uv" OpName %_entryPointOutput "@entryPointOutput" OpName %_patchConstantResult "@patchConstantResult" OpName %param_1 "param" OpName %_patchConstantOutput_EdgeTess "@patchConstantOutput.EdgeTess" OpName %_patchConstantOutput_InsideTess "@patchConstantOutput.InsideTess" OpName %output_0 "output" OpDecorate %p_pos BuiltIn Position OpDecorate %p_1 Location 0 OpDecorate %i_1 BuiltIn InvocationId OpDecorate %_entryPointOutput_pos BuiltIn Position OpDecorate %_entryPointOutput Location 0 OpDecorate %_patchConstantOutput_EdgeTess Patch OpDecorate %_patchConstantOutput_EdgeTess BuiltIn TessLevelOuter OpDecorate %_patchConstantOutput_InsideTess Patch OpDecorate %_patchConstantOutput_InsideTess BuiltIn TessLevelInner %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %VertexOutput = OpTypeStruct %v4float %v2float %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_VertexOutput_uint_3 = OpTypeArray %VertexOutput %uint_3 %_ptr_Function__arr_VertexOutput_uint_3 = OpTypePointer Function %_arr_VertexOutput_uint_3 %_ptr_Function_uint = OpTypePointer Function %uint %HSOut = OpTypeStruct %v4float %v2float %16 = OpTypeFunction %HSOut %_ptr_Function__arr_VertexOutput_uint_3 %_ptr_Function_uint %_arr_float_uint_3 = OpTypeArray %float %uint_3 %HSConstantOut = OpTypeStruct %_arr_float_uint_3 %float %23 = OpTypeFunction %HSConstantOut %_ptr_Function__arr_VertexOutput_uint_3 %_ptr_Function_HSOut = OpTypePointer Function %HSOut %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %int_1 = OpConstant %int 1 %_ptr_Function_v2float = OpTypePointer Function %v2float %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %p_pos = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %VertexOutput_0 = OpTypeStruct %v2float %_arr_VertexOutput_0_uint_3 = OpTypeArray %VertexOutput_0 %uint_3 %_ptr_Input__arr_VertexOutput_0_uint_3 = OpTypePointer Input %_arr_VertexOutput_0_uint_3 %p_1 = OpVariable %_ptr_Input__arr_VertexOutput_0_uint_3 Input %_ptr_Input_v2float = OpTypePointer Input %v2float %int_2 = OpConstant %int 2 %_ptr_Input_uint = OpTypePointer Input %uint %i_1 = OpVariable %_ptr_Input_uint Input %_ptr_Output__arr_v4float_uint_3 = OpTypePointer Output %_arr_v4float_uint_3 %_entryPointOutput_pos = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %_ptr_Output_v4float = OpTypePointer Output %v4float %HSOut_0 = OpTypeStruct %v2float %_arr_HSOut_0_uint_3 = OpTypeArray %HSOut_0 %uint_3 %_ptr_Output__arr_HSOut_0_uint_3 = OpTypePointer Output %_arr_HSOut_0_uint_3 %_entryPointOutput = OpVariable %_ptr_Output__arr_HSOut_0_uint_3 Output %_ptr_Output_v2float = OpTypePointer Output %v2float %uint_2 = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %_ptr_Function_HSConstantOut = OpTypePointer Function %HSConstantOut %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %_patchConstantOutput_EdgeTess = OpVariable %_ptr_Output__arr_float_uint_4 Output %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_float = OpTypePointer Output %float %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %_patchConstantOutput_InsideTess = OpVariable %_ptr_Output__arr_float_uint_2 Output %float_1 = OpConstant %float 1 %hs_main = OpFunction %void None %3 %5 = OpLabel %p_0 = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %i_0 = OpVariable %_ptr_Function_uint Function %flattenTemp = OpVariable %_ptr_Function_HSOut Function %param = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %param_0 = OpVariable %_ptr_Function_uint Function %_patchConstantResult = OpVariable %_ptr_Function_HSConstantOut Function %param_1 = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %50 = OpAccessChain %_ptr_Input_v4float %p_pos %int_0 %51 = OpLoad %v4float %50 %52 = OpAccessChain %_ptr_Function_v4float %p_0 %int_0 %int_0 OpStore %52 %51 %58 = OpAccessChain %_ptr_Input_v2float %p_1 %int_0 %int_0 %59 = OpLoad %v2float %58 %60 = OpAccessChain %_ptr_Function_v2float %p_0 %int_0 %int_1 OpStore %60 %59 %61 = OpAccessChain %_ptr_Input_v4float %p_pos %int_1 %62 = OpLoad %v4float %61 %63 = OpAccessChain %_ptr_Function_v4float %p_0 %int_1 %int_0 OpStore %63 %62 %64 = OpAccessChain %_ptr_Input_v2float %p_1 %int_1 %int_0 %65 = OpLoad %v2float %64 %66 = OpAccessChain %_ptr_Function_v2float %p_0 %int_1 %int_1 OpStore %66 %65 %68 = OpAccessChain %_ptr_Input_v4float %p_pos %int_2 %69 = OpLoad %v4float %68 %70 = OpAccessChain %_ptr_Function_v4float %p_0 %int_2 %int_0 OpStore %70 %69 %71 = OpAccessChain %_ptr_Input_v2float %p_1 %int_2 %int_0 %72 = OpLoad %v2float %71 %73 = OpAccessChain %_ptr_Function_v2float %p_0 %int_2 %int_1 OpStore %73 %72 %77 = OpLoad %uint %i_1 OpStore %i_0 %77 %80 = OpLoad %_arr_VertexOutput_uint_3 %p_0 OpStore %param %80 %82 = OpLoad %uint %i_0 OpStore %param_0 %82 %83 = OpFunctionCall %HSOut %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ %param %param_0 OpStore %flattenTemp %83 %86 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0 %87 = OpLoad %v4float %86 %94 = OpLoad %uint %i_1 %89 = OpAccessChain %_ptr_Output_v4float %_entryPointOutput_pos %94 OpStore %89 %87 %95 = OpAccessChain %_ptr_Function_v2float %flattenTemp %int_1 %96 = OpLoad %v2float %95 %98 = OpAccessChain %_ptr_Output_v2float %_entryPointOutput %94 %int_0 OpStore %98 %96 OpControlBarrier %uint_2 %uint_1 %uint_0 %102 = OpLoad %uint %i_1 %104 = OpIEqual %bool %102 %int_0 OpSelectionMerge %106 None OpBranchConditional %104 %105 %106 %105 = OpLabel %110 = OpLoad %_arr_VertexOutput_uint_3 %p_0 OpStore %param_1 %110 %111 = OpFunctionCall %HSConstantOut %PatchHS_struct_VertexOutput_vf4_vf21_3__ %param_1 OpStore %_patchConstantResult %111 %117 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_0 %118 = OpLoad %float %117 %120 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_0 OpStore %120 %118 %121 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_1 %122 = OpLoad %float %121 %123 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_1 OpStore %123 %122 %124 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_2 %125 = OpLoad %float %124 %126 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_2 OpStore %126 %125 %130 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_1 %131 = OpLoad %float %130 %132 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_InsideTess %int_0 OpStore %132 %131 OpBranch %106 %106 = OpLabel OpReturn OpFunctionEnd %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ = OpFunction %HSOut None %16 %p = OpFunctionParameter %_ptr_Function__arr_VertexOutput_uint_3 %i = OpFunctionParameter %_ptr_Function_uint %20 = OpLabel %output = OpVariable %_ptr_Function_HSOut Function %31 = OpLoad %uint %i %33 = OpAccessChain %_ptr_Function_v4float %p %31 %int_0 %34 = OpLoad %v4float %33 %35 = OpAccessChain %_ptr_Function_v4float %output %int_0 OpStore %35 %34 %37 = OpLoad %uint %i %39 = OpAccessChain %_ptr_Function_v2float %p %37 %int_1 %40 = OpLoad %v2float %39 %41 = OpAccessChain %_ptr_Function_v2float %output %int_1 OpStore %41 %40 %42 = OpLoad %HSOut %output OpReturnValue %42 OpFunctionEnd %PatchHS_struct_VertexOutput_vf4_vf21_3__ = OpFunction %HSConstantOut None %23 %patch = OpFunctionParameter %_ptr_Function__arr_VertexOutput_uint_3 %26 = OpLabel %output_0 = OpVariable %_ptr_Function_HSConstantOut Function %135 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %136 = OpLoad %v2float %135 %137 = OpCompositeConstruct %v2float %float_1 %float_1 %138 = OpFAdd %v2float %137 %136 %139 = OpCompositeExtract %float %138 0 %140 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_0 OpStore %140 %139 %141 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %142 = OpLoad %v2float %141 %143 = OpCompositeConstruct %v2float %float_1 %float_1 %144 = OpFAdd %v2float %143 %142 %145 = OpCompositeExtract %float %144 0 %146 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_1 OpStore %146 %145 %147 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %148 = OpLoad %v2float %147 %149 = OpCompositeConstruct %v2float %float_1 %float_1 %150 = OpFAdd %v2float %149 %148 %151 = OpCompositeExtract %float %150 0 %152 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_2 OpStore %152 %151 %153 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %154 = OpLoad %v2float %153 %155 = OpCompositeConstruct %v2float %float_1 %float_1 %156 = OpFAdd %v2float %155 %154 %157 = OpCompositeExtract %float %156 0 %158 = OpAccessChain %_ptr_Function_float %output_0 %int_1 OpStore %158 %157 %159 = OpLoad %HSConstantOut %output_0 OpReturnValue %159 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc/tess-level-initializer-quad.asm.tesc000066400000000000000000000103451400026215700305420ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 47 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_out %gl_InvocationID %gl_TessLevelInner %gl_TessLevelOuter OpExecutionMode %main OutputVertices 4 OpExecutionMode %main Quads OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpName %gl_InvocationID "gl_InvocationID" OpName %gl_TessLevelInner "gl_TessLevelInner" OpName %gl_TessLevelOuter "gl_TessLevelOuter" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %gl_TessLevelInner Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %22 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %inner_zero = OpConstantNull %_arr_float_uint_2 %gl_TessLevelInner = OpVariable %_ptr_Output__arr_float_uint_2 Output %inner_zero %_ptr_Output_float = OpTypePointer Output %float %int_1 = OpConstant %int 1 %float_2 = OpConstant %float 2 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %outer_zero = OpConstantNull %_arr_float_uint_4 %gl_TessLevelOuter = OpVariable %_ptr_Output__arr_float_uint_4 Output %outer_zero %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %int_2 = OpConstant %int 2 %float_5 = OpConstant %float 5 %int_3 = OpConstant %int 3 %float_6 = OpConstant %float 6 %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Output_v4float %gl_out %19 %int_0 OpStore %24 %22 %30 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_0 OpStore %30 %float_1 %33 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_1 OpStore %33 %float_2 %38 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_0 OpStore %38 %float_3 %40 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_1 OpStore %40 %float_4 %43 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_2 OpStore %43 %float_5 %46 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_3 OpStore %46 %float_6 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/tesc/tess-level-initializer-triangle.asm.tesc000066400000000000000000000103511400026215700314120ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 47 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_out %gl_InvocationID %gl_TessLevelInner %gl_TessLevelOuter OpExecutionMode %main OutputVertices 4 OpExecutionMode %main Triangles OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpName %gl_InvocationID "gl_InvocationID" OpName %gl_TessLevelInner "gl_TessLevelInner" OpName %gl_TessLevelOuter "gl_TessLevelOuter" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %gl_TessLevelInner Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %22 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %inner_zero = OpConstantNull %_arr_float_uint_2 %gl_TessLevelInner = OpVariable %_ptr_Output__arr_float_uint_2 Output %inner_zero %_ptr_Output_float = OpTypePointer Output %float %int_1 = OpConstant %int 1 %float_2 = OpConstant %float 2 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %outer_zero = OpConstantNull %_arr_float_uint_4 %gl_TessLevelOuter = OpVariable %_ptr_Output__arr_float_uint_4 Output %outer_zero %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %int_2 = OpConstant %int 2 %float_5 = OpConstant %float 5 %int_3 = OpConstant %int 3 %float_6 = OpConstant %float 6 %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Output_v4float %gl_out %19 %int_0 OpStore %24 %22 %30 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_0 OpStore %30 %float_1 %33 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_1 OpStore %33 %float_2 %38 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_0 OpStore %38 %float_3 %40 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_1 OpStore %40 %float_4 %43 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_2 OpStore %43 %float_5 %46 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_3 OpStore %46 %float_6 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/vert/000077500000000000000000000000001400026215700215665ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/asm/vert/block-struct-initializer.asm.vert000066400000000000000000000022771400026215700302140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 13 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %foo %gl_Position OpSource GLSL 450 OpName %main "main" OpName %Vert "Vert" OpMemberName %Vert 0 "a" OpMemberName %Vert 1 "b" OpName %_ "" OpName %Foo "Foo" OpMemberName %Foo 0 "c" OpMemberName %Foo 1 "d" OpName %foo "foo" OpDecorate %Vert Block OpDecorate %_ Location 0 OpDecorate %foo Location 2 OpDecorate %gl_Position BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Vert = OpTypeStruct %float %float %vec4 = OpTypeVector %float 4 %ptr_Output_vec4 = OpTypePointer Output %vec4 %_ptr_Output_Vert = OpTypePointer Output %Vert %zero_vert = OpConstantNull %Vert %_ = OpVariable %_ptr_Output_Vert Output %zero_vert %gl_Position = OpVariable %ptr_Output_vec4 Output %Foo = OpTypeStruct %float %float %_ptr_Output_Foo = OpTypePointer Output %Foo %zero_foo = OpConstantNull %Foo %blank = OpConstantNull %vec4 %foo = OpVariable %_ptr_Output_Foo Output %zero_foo %main = OpFunction %void None %3 %5 = OpLabel OpStore %gl_Position %blank OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/vert/builtin-output-initializer.asm.vert000066400000000000000000000030311400026215700305710ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpName %_ "" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %gl_PerVertex = OpTypeStruct %v4float %float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %zero = OpConstantNull %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %zero %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %17 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/vert/composite-extract-physical-type-id.asm.vert000066400000000000000000000055601400026215700321120ustar00rootroot00000000000000 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %VSMain "main" %gl_VertexIndex %gl_Position OpSource HLSL 600 OpName %type_Float2Array "type.Float2Array" OpMemberName %type_Float2Array 0 "arr" OpName %Float2Array "Float2Array" OpName %VSMain "VSMain" OpName %param_var_i "param.var.i" OpName %src_VSMain "src.VSMain" OpName %i "i" OpName %bb_entry "bb.entry" OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpDecorate %gl_Position BuiltIn Position OpDecorate %Float2Array DescriptorSet 0 OpDecorate %Float2Array Binding 0 OpDecorate %_arr_v2float_uint_3 ArrayStride 16 OpMemberDecorate %type_Float2Array 0 Offset 0 OpDecorate %type_Float2Array Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %v2float = OpTypeVector %float 2 %_arr_v2float_uint_3 = OpTypeArray %v2float %uint_3 %type_Float2Array = OpTypeStruct %_arr_v2float_uint_3 %_ptr_Uniform_type_Float2Array = OpTypePointer Uniform %type_Float2Array %_ptr_Input_uint = OpTypePointer Input %uint %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %20 = OpTypeFunction %void %_ptr_Function_uint = OpTypePointer Function %uint %27 = OpTypeFunction %v4float %_ptr_Function_uint %_ptr_Uniform__arr_v2float_uint_3 = OpTypePointer Uniform %_arr_v2float_uint_3 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %Float2Array = OpVariable %_ptr_Uniform_type_Float2Array Uniform %gl_VertexIndex = OpVariable %_ptr_Input_uint Input %gl_Position = OpVariable %_ptr_Output_v4float Output %VSMain = OpFunction %void None %20 %21 = OpLabel %param_var_i = OpVariable %_ptr_Function_uint Function %24 = OpLoad %uint %gl_VertexIndex OpStore %param_var_i %24 %25 = OpFunctionCall %v4float %src_VSMain %param_var_i OpStore %gl_Position %25 OpReturn OpFunctionEnd %src_VSMain = OpFunction %v4float None %27 %i = OpFunctionParameter %_ptr_Function_uint %bb_entry = OpLabel %30 = OpLoad %uint %i %32 = OpAccessChain %_ptr_Uniform__arr_v2float_uint_3 %Float2Array %int_0 %34 = OpAccessChain %_ptr_Uniform_v2float %32 %30 %35 = OpLoad %v2float %34 %36 = OpCompositeExtract %float %35 0 %37 = OpCompositeExtract %float %35 1 %38 = OpCompositeConstruct %v4float %36 %37 %float_0 %float_1 OpReturnValue %38 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/vert/duplicate-view-index.asm.vert000066400000000000000000000053441400026215700273040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 23 ; Schema: 0 OpCapability Shader OpCapability MultiView OpExtension "SPV_KHR_multiview" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %gl_ViewIndex OpEntryPoint Vertex %main2 "main2" %_ %gl_ViewIndex2 OpSource GLSL 450 OpSourceExtension "GL_EXT_multiview" OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %gl_ViewIndex "gl_ViewIndex" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_ViewIndex BuiltIn ViewIndex OpDecorate %gl_ViewIndex2 BuiltIn ViewIndex %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_int = OpTypePointer Input %int %gl_ViewIndex = OpVariable %_ptr_Input_int Input %gl_ViewIndex2 = OpVariable %_ptr_Input_int Input %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %18 = OpLoad %int %gl_ViewIndex %19 = OpConvertSToF %float %18 %20 = OpCompositeConstruct %v4float %19 %19 %19 %19 %22 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %22 %20 OpReturn OpFunctionEnd %main2 = OpFunction %void None %3 %100 = OpLabel %101 = OpLoad %int %gl_ViewIndex2 %102 = OpConvertSToF %float %101 %103 = OpCompositeConstruct %v4float %102 %102 %102 %102 %104 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %104 %103 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/vert/empty-struct-composite.asm.vert000066400000000000000000000022461400026215700277330ustar00rootroot00000000000000; SPIR-V ; Version: 1.1 ; Generator: Google rspirv; 0 ; Bound: 17 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %2 "main" OpName %Test "Test" OpName %t "t" OpName %retvar "retvar" OpName %main "main" OpName %retvar_0 "retvar" %void = OpTypeVoid %6 = OpTypeFunction %void %Test = OpTypeStruct %_ptr_Function_Test = OpTypePointer Function %Test %_ptr_Function_void = OpTypePointer Function %void %2 = OpFunction %void None %6 %7 = OpLabel %t = OpVariable %_ptr_Function_Test Function %retvar = OpVariable %_ptr_Function_void Function OpBranch %4 %4 = OpLabel %13 = OpCompositeConstruct %Test OpStore %t %13 OpReturn OpFunctionEnd %main = OpFunction %void None %6 %15 = OpLabel %retvar_0 = OpVariable %_ptr_Function_void Function OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/asm/vert/op-load-forced-temporary-array.asm.frag000066400000000000000000000042751400026215700311450ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 39 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %vs_main "main" %gl_Position OpSource HLSL 600 OpName %vs_main "vs_main" OpDecorate %gl_Position BuiltIn Position %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int_1 = OpConstant %int 1 %float_3 = OpConstant %float 3 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %15 = OpTypeFunction %void %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Function__arr_float_uint_2 = OpTypePointer Function %_arr_float_uint_2 %_ptr_Function_float = OpTypePointer Function %float %bool = OpTypeBool %gl_Position = OpVariable %_ptr_Output_v4float Output %21 = OpUndef %float %vs_main = OpFunction %void None %15 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_float_uint_2 Function OpBranch %24 %24 = OpLabel %25 = OpPhi %int %int_0 %22 %26 %27 %28 = OpSLessThan %bool %25 %int_2 OpLoopMerge %29 %27 None OpBranchConditional %28 %27 %29 %27 = OpLabel %30 = OpAccessChain %_ptr_Function_float %23 %25 OpStore %30 %float_0 %26 = OpIAdd %int %25 %int_1 OpBranch %24 %29 = OpLabel %31 = OpLoad %_arr_float_uint_2 %23 %32 = OpBitcast %uint %float_3 %33 = OpINotEqual %bool %32 %uint_0 OpSelectionMerge %34 None OpBranchConditional %33 %35 %34 %35 = OpLabel %36 = OpCompositeExtract %float %31 0 OpBranch %34 %34 = OpLabel %37 = OpPhi %float %21 %29 %36 %35 %38 = OpCompositeConstruct %v4float %float_0 %float_0 %float_0 %37 OpStore %gl_Position %38 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/comp/000077500000000000000000000000001400026215700207645ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/comp/array-copy-threadgroup-memory.comp000066400000000000000000000006321400026215700275630ustar00rootroot00000000000000#version 450 layout(local_size_x = 8) in; shared float shared_group[8][8]; shared float shared_group_alt[8][8]; void main() { float blob[8]; for (int i = 0; i < 8; i++) blob[i] = float(i); shared_group[gl_LocalInvocationIndex] = blob; barrier(); float copied_blob[8] = shared_group[gl_LocalInvocationIndex ^ 1u]; shared_group_alt[gl_LocalInvocationIndex] = shared_group[gl_LocalInvocationIndex]; } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/basic.dynamic-buffer.msl2.invalid.comp000066400000000000000000000006531400026215700301240ustar00rootroot00000000000000#version 450 layout(local_size_x = 3, local_size_y = 3, local_size_z = 2) in; layout(set = 0, binding = 0) uniform Foo { int a; int b; }; layout(set = 0, binding = 1) uniform Bar { int c; int d; }; layout(set = 1, binding = 2) buffer Baz { int e; int f; } baz[3][3][2]; void main() { uvec3 coords = gl_GlobalInvocationID; baz[coords.x][coords.y][coords.z].e = a + c; baz[coords.x][coords.y][coords.z].f = b * d; } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/bitcast-16bit-1.invalid.comp000066400000000000000000000010721400026215700260030ustar00rootroot00000000000000#version 450 core #extension GL_AMD_gpu_shader_half_float : require #extension GL_AMD_gpu_shader_int16 : require layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO0 { i16vec4 inputs[]; }; layout(binding = 1, std430) buffer SSBO1 { ivec4 outputs[]; }; void main() { uint ident = gl_GlobalInvocationID.x; f16vec2 a = int16BitsToFloat16(inputs[ident].xy); outputs[ident].x = int(packFloat2x16(a + f16vec2(1, 1))); outputs[ident].y = packInt2x16(inputs[ident].zw); outputs[ident].z = int(packUint2x16(u16vec2(inputs[ident].xy))); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/bitcast-16bit-2.invalid.comp000066400000000000000000000011071400026215700260030ustar00rootroot00000000000000#version 450 core #extension GL_AMD_gpu_shader_half_float : require #extension GL_AMD_gpu_shader_int16 : require layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO0 { ivec4 inputs[]; }; layout(binding = 1, std430) buffer SSBO1 { i16vec4 outputs[]; }; layout(binding = 2) uniform UBO { f16vec4 const0; }; void main() { uint ident = gl_GlobalInvocationID.x; outputs[ident].xy = unpackInt2x16(inputs[ident].x) + float16BitsToInt16(const0.xy); outputs[ident].zw = i16vec2(unpackUint2x16(uint(inputs[ident].y)) - float16BitsToUint16(const0.zw)); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/bitfield.comp000066400000000000000000000007211400026215700234260ustar00rootroot00000000000000#version 310 es void main() { int signed_value = 0; uint unsigned_value = 0u; int s = bitfieldExtract(signed_value, 5, 20); uint u = bitfieldExtract(unsigned_value, 6, 21); s = bitfieldInsert(s, 40, 5, 4); u = bitfieldInsert(u, 60u, 5, 4); u = bitfieldReverse(u); s = bitfieldReverse(s); int v0 = bitCount(u); int v1 = bitCount(s); int v2 = findMSB(u); int v3 = findMSB(s); int v4 = findLSB(u); int v5 = findLSB(s); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/glsl.std450.comp000066400000000000000000000046651400026215700236420ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO { float res; int ires; uint ures; vec4 f32; ivec4 s32; uvec4 u32; mat2 m2; mat3 m3; mat4 m4; }; void main() { float tmp; vec2 v2; vec3 v3; vec4 v4; int itmp; res = round(f32.x); res = roundEven(f32.x); res = trunc(f32.x); res = abs(f32.x); ires = abs(s32.x); res = sign(f32.x); ires = sign(s32.x); res = floor(f32.x); res = ceil(f32.x); res = fract(f32.x); res = radians(f32.x); res = degrees(f32.x); res = sin(f32.x); res = cos(f32.x); res = tan(f32.x); res = asin(f32.x); res = acos(f32.x); res = atan(f32.x); res = sinh(f32.x); res = cosh(f32.x); res = tanh(f32.x); res = asinh(f32.x); res = acosh(f32.x); res = atanh(f32.x); res = atan(f32.x, f32.y); res = pow(f32.x, f32.y); res = exp(f32.x); res = log(f32.x); res = exp2(f32.x); res = log2(f32.x); res = sqrt(f32.x); res = inversesqrt(f32.x); res = length(f32.x); res = distance(f32.x, f32.y); res = normalize(f32.x); res = faceforward(f32.x, f32.y, f32.z); res = reflect(f32.x, f32.y); res = refract(f32.x, f32.y, f32.z); res = length(f32.xy); res = distance(f32.xy, f32.zw); v2 = normalize(f32.xy); v2 = faceforward(f32.xy, f32.yz, f32.zw); v2 = reflect(f32.xy, f32.zw); v2 = refract(f32.xy, f32.yz, f32.w); v3 = cross(f32.xyz, f32.yzw); res = determinant(m2); res = determinant(m3); res = determinant(m4); m2 = inverse(m2); m3 = inverse(m3); m4 = inverse(m4); res = modf(f32.x, tmp); // ModfStruct res = min(f32.x, f32.y); ures = min(u32.x, u32.y); ires = min(s32.x, s32.y); res = max(f32.x, f32.y); ures = max(u32.x, u32.y); ires = max(s32.x, s32.y); res = clamp(f32.x, f32.y, f32.z); ures = clamp(u32.x, u32.y, u32.z); ires = clamp(s32.x, s32.y, s32.z); res = mix(f32.x, f32.y, f32.z); res = step(f32.x, f32.y); res = smoothstep(f32.x, f32.y, f32.z); res = fma(f32.x, f32.y, f32.z); res = frexp(f32.x, itmp); // FrexpStruct res = ldexp(f32.x, itmp); ures = packSnorm4x8(f32); ures = packUnorm4x8(f32); ures = packSnorm2x16(f32.xy); ures = packUnorm2x16(f32.xy); ures = packHalf2x16(f32.xy); // packDouble2x32 v2 = unpackSnorm2x16(u32.x); v2 = unpackUnorm2x16(u32.x); v2 = unpackHalf2x16(u32.x); v4 = unpackSnorm4x8(u32.x); v4 = unpackUnorm4x8(u32.x); // unpackDouble2x32 s32 = findLSB(s32); s32 = findLSB(u32); s32 = findMSB(s32); s32 = findMSB(u32); // interpolateAtSample // interpolateAtOffset // NMin, NMax, NClamp } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/illegal-struct-name.asm.comp000066400000000000000000000046201400026215700262760ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 31 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Foo "Foo" OpMemberName %Foo 0 "abs" OpName %f "f" OpName %Foo_0 "Foo" OpMemberName %Foo_0 0 "abs" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "foo" OpMemberName %SSBO 1 "foo2" OpName %_ "" OpName %linear "abs" OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Foo = OpTypeStruct %float %_ptr_Function_Foo = OpTypePointer Function %Foo %Foo_0 = OpTypeStruct %float %SSBO = OpTypeStruct %Foo_0 %Foo_0 %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Function_int = OpTypePointer Function %int %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %main = OpFunction %void None %3 %5 = OpLabel %f = OpVariable %_ptr_Function_Foo Function %linear = OpVariable %_ptr_Function_int Function %17 = OpAccessChain %_ptr_Uniform_Foo_0 %_ %int_0 %18 = OpLoad %Foo_0 %17 %19 = OpCompositeExtract %float %18 0 %21 = OpAccessChain %_ptr_Function_float %f %int_0 OpStore %21 %19 OpStore %linear %int_10 %26 = OpLoad %Foo %f %27 = OpAccessChain %_ptr_Uniform_Foo_0 %_ %int_1 %28 = OpCompositeExtract %float %26 0 %30 = OpAccessChain %_ptr_Uniform_float %27 %int_0 OpStore %30 %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/comp/int64.invalid.msl22.comp000066400000000000000000000017021400026215700251730ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require layout(local_size_x = 1) in; struct M0 { int64_t v; i64vec2 b[2]; uint64_t c; uint64_t d[5]; }; struct SSBO0_Type { i64vec4 a; M0 m0; }; struct SSBO1_Type { u64vec4 b; M0 m0; }; struct SSBO2_Type { int64_t a[4]; i64vec2 b[4]; }; struct SSBO3_Type { int64_t a[4]; i64vec2 b[4]; }; layout(set = 0, binding = 0, std430) buffer SSBO { int s32; uint u32; }; void main() { SSBO0_Type ssbo_0; SSBO1_Type ssbo_1; SSBO2_Type ssbo_2; SSBO3_Type ssbo_3; ssbo_0.a += i64vec4(10, 20, 30, 40); ssbo_1.b += u64vec4(999999999999999999ul, 8888888888888888ul, 77777777777777777ul, 6666666666666666ul); ssbo_0.a += 20; ssbo_0.a = abs(ssbo_0.a + i64vec4(ssbo_1.b)); ssbo_0.a++; ssbo_1.b++; ssbo_0.a--; ssbo_1.b--; ssbo_2.a[0] += 1l; ssbo_3.a[0] += 2l; s32 = int(ssbo_0.a.x + ssbo_1.b.y + ssbo_2.a[1] + ssbo_3.a[2]); u32 = uint(ssbo_0.a.y + ssbo_1.b.z + ssbo_2.a[0] + ssbo_3.a[1]); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/loop.comp000066400000000000000000000026201400026215700226150ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 idat = in_data[ident]; int k = 0; uint i = 0u; if (idat.y == 20.0) { do { k = k * 2; i++; } while (i < ident); } switch (k) { case 10: for (;;) { i++; if (i > 10u) break; } break; default: for (;;) { i += 2u; if (i > 20u) break; } break; } while (k < 10) { idat *= 2.0; k++; } for (uint i = 0u; i < 16u; i++, k++) for (uint j = 0u; j < 30u; j++) idat = mvp * idat; k = 0; for (;;) { k++; if (k > 10) { k += 2; } else { k += 3; continue; } k += 10; } k = 0; do { k++; } while (k > 10); int l = 0; for (;; l++) { if (l == 5) { continue; } idat += 1.0; } out_data[ident] = idat; } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/return.comp000066400000000000000000000007451400026215700231710ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; if (ident == 2u) { out_data[ident] = vec4(20.0); } else if (ident == 4u) { out_data[ident] = vec4(10.0); return; } for (int i = 0; i < 20; i++) { if (i == 10) break; return; } out_data[ident] = vec4(10.0); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/std140-array-load-composite-construct.comp000066400000000000000000000003041400026215700307330ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std140, binding = 0) buffer SSBO { float a[16]; vec4 b[16]; }; void main() { b[gl_GlobalInvocationID.x] = vec4(a[gl_GlobalInvocationID.x]); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/struct-packing-scalar.nocompat.invalid.vk.comp000066400000000000000000000034201400026215700317270ustar00rootroot00000000000000#version 310 es #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; struct S0 { vec2 a[1]; float b; }; struct S1 { vec3 a; float b; }; struct S2 { vec3 a[1]; float b; }; struct S3 { vec2 a; float b; }; struct S4 { vec2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; // glslang seems to miscompile this atm into ArrayStride of 16 even in scalar layout. //S4 m3s[8]; }; layout(binding = 2, scalar) restrict buffer SSBO2 { float m0; mat2 m1; layout(row_major) mat3x2 m2; } ssbo_scalar2; layout(binding = 1, scalar) restrict buffer SSBO1 { Content content; Content content1[2]; Content content2; layout(column_major) mat2 m0; layout(column_major) mat2 m1; layout(column_major) mat2x3 m2[4]; layout(column_major) mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_scalar; layout(binding = 0, std140) restrict buffer SSBO0 { Content content; Content content1[2]; Content content2; layout(column_major) mat2 m0; layout(column_major) mat2 m1; layout(column_major) mat2x3 m2[4]; layout(column_major) mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_140; void main() { ssbo_scalar.content = ssbo_140.content; ssbo_scalar.content.m1.a = ssbo_scalar.m2[1] * ssbo_scalar.content.m0.a[0]; // test packed matrix access ssbo_scalar.m0 = ssbo_scalar2.m1; ssbo_scalar2.m1 = ssbo_scalar.m4; ssbo_scalar2.m2 = ssbo_scalar.m3; } subgroups.nocompat.invalid.vk.msl12.emulate-subgroup.comp000066400000000000000000000010541400026215700337350ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/comp#version 450 #extension GL_KHR_shader_subgroup_basic : require layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float FragColor; }; // Reduced test for emulated functionality. void main() { // basic FragColor = float(gl_NumSubgroups); FragColor = float(gl_SubgroupID); FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/subgroups.nocompat.invalid.vk.msl21.comp000066400000000000000000000121621400026215700305170ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_vote : require #extension GL_KHR_shader_subgroup_shuffle : require #extension GL_KHR_shader_subgroup_shuffle_relative : require #extension GL_KHR_shader_subgroup_arithmetic : require #extension GL_KHR_shader_subgroup_clustered : require #extension GL_KHR_shader_subgroup_quad : require layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float FragColor; }; void main() { // basic FragColor = float(gl_NumSubgroups); FragColor = float(gl_SubgroupID); FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); // ballot FragColor = float(gl_SubgroupEqMask); FragColor = float(gl_SubgroupGeMask); FragColor = float(gl_SubgroupGtMask); FragColor = float(gl_SubgroupLeMask); FragColor = float(gl_SubgroupLtMask); vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); bvec2 broadcasted_bool = subgroupBroadcast(bvec2(true), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); bvec4 first_bool = subgroupBroadcastFirst(bvec4(false)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); // shuffle uint shuffled = subgroupShuffle(10u, 8u); bool shuffled_bool = subgroupShuffle(true, 9u); uint shuffled_xor = subgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = subgroupShuffleXor(false, 9u); // shuffle relative uint shuffled_up = subgroupShuffleUp(20u, 4u); bool shuffled_up_bool = subgroupShuffleUp(true, 4u); uint shuffled_down = subgroupShuffleDown(20u, 4u); bool shuffled_down_bool = subgroupShuffleDown(false, 4u); // vote bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal = subgroupAllEqual(0); has_equal = subgroupAllEqual(true); has_equal = subgroupAllEqual(vec3(0.0, 1.0, 2.0)); has_equal = subgroupAllEqual(bvec4(true, true, false, true)); // arithmetic vec4 added = subgroupAdd(vec4(20.0)); ivec4 iadded = subgroupAdd(ivec4(20)); vec4 multiplied = subgroupMul(vec4(20.0)); ivec4 imultiplied = subgroupMul(ivec4(20)); vec4 lo = subgroupMin(vec4(20.0)); vec4 hi = subgroupMax(vec4(20.0)); ivec4 slo = subgroupMin(ivec4(20)); ivec4 shi = subgroupMax(ivec4(20)); uvec4 ulo = subgroupMin(uvec4(20)); uvec4 uhi = subgroupMax(uvec4(20)); uvec4 anded = subgroupAnd(ballot_value); uvec4 ored = subgroupOr(ballot_value); uvec4 xored = subgroupXor(ballot_value); added = subgroupInclusiveAdd(added); iadded = subgroupInclusiveAdd(iadded); multiplied = subgroupInclusiveMul(multiplied); imultiplied = subgroupInclusiveMul(imultiplied); //lo = subgroupInclusiveMin(lo); // FIXME: Unsupported by Metal //hi = subgroupInclusiveMax(hi); //slo = subgroupInclusiveMin(slo); //shi = subgroupInclusiveMax(shi); //ulo = subgroupInclusiveMin(ulo); //uhi = subgroupInclusiveMax(uhi); //anded = subgroupInclusiveAnd(anded); //ored = subgroupInclusiveOr(ored); //xored = subgroupInclusiveXor(ored); //added = subgroupExclusiveAdd(lo); added = subgroupExclusiveAdd(multiplied); multiplied = subgroupExclusiveMul(multiplied); iadded = subgroupExclusiveAdd(imultiplied); imultiplied = subgroupExclusiveMul(imultiplied); //lo = subgroupExclusiveMin(lo); // FIXME: Unsupported by Metal //hi = subgroupExclusiveMax(hi); //ulo = subgroupExclusiveMin(ulo); //uhi = subgroupExclusiveMax(uhi); //slo = subgroupExclusiveMin(slo); //shi = subgroupExclusiveMax(shi); //anded = subgroupExclusiveAnd(anded); //ored = subgroupExclusiveOr(ored); //xored = subgroupExclusiveXor(ored); // clustered added = subgroupClusteredAdd(added, 4u); multiplied = subgroupClusteredMul(multiplied, 4u); iadded = subgroupClusteredAdd(iadded, 4u); imultiplied = subgroupClusteredMul(imultiplied, 4u); lo = subgroupClusteredMin(lo, 4u); hi = subgroupClusteredMax(hi, 4u); ulo = subgroupClusteredMin(ulo, 4u); uhi = subgroupClusteredMax(uhi, 4u); slo = subgroupClusteredMin(slo, 4u); shi = subgroupClusteredMax(shi, 4u); anded = subgroupClusteredAnd(anded, 4u); ored = subgroupClusteredOr(ored, 4u); xored = subgroupClusteredXor(xored, 4u); // quad vec4 swap_horiz = subgroupQuadSwapHorizontal(vec4(20.0)); bvec4 swap_horiz_bool = subgroupQuadSwapHorizontal(bvec4(true)); vec4 swap_vertical = subgroupQuadSwapVertical(vec4(20.0)); bvec4 swap_vertical_bool = subgroupQuadSwapVertical(bvec4(true)); vec4 swap_diagonal = subgroupQuadSwapDiagonal(vec4(20.0)); bvec4 swap_diagonal_bool = subgroupQuadSwapDiagonal(bvec4(true)); vec4 quad_broadcast = subgroupQuadBroadcast(vec4(20.0), 3u); bvec4 quad_broadcast_bool = subgroupQuadBroadcast(bvec4(true), 3u); } subgroups.nocompat.invalid.vk.msl21.fixed-subgroup.comp000066400000000000000000000121621400026215700334020ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/comp#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_vote : require #extension GL_KHR_shader_subgroup_shuffle : require #extension GL_KHR_shader_subgroup_shuffle_relative : require #extension GL_KHR_shader_subgroup_arithmetic : require #extension GL_KHR_shader_subgroup_clustered : require #extension GL_KHR_shader_subgroup_quad : require layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float FragColor; }; void main() { // basic FragColor = float(gl_NumSubgroups); FragColor = float(gl_SubgroupID); FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); // ballot FragColor = float(gl_SubgroupEqMask); FragColor = float(gl_SubgroupGeMask); FragColor = float(gl_SubgroupGtMask); FragColor = float(gl_SubgroupLeMask); FragColor = float(gl_SubgroupLtMask); vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); bvec2 broadcasted_bool = subgroupBroadcast(bvec2(true), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); bvec4 first_bool = subgroupBroadcastFirst(bvec4(false)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); // shuffle uint shuffled = subgroupShuffle(10u, 8u); bool shuffled_bool = subgroupShuffle(true, 9u); uint shuffled_xor = subgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = subgroupShuffleXor(false, 9u); // shuffle relative uint shuffled_up = subgroupShuffleUp(20u, 4u); bool shuffled_up_bool = subgroupShuffleUp(true, 4u); uint shuffled_down = subgroupShuffleDown(20u, 4u); bool shuffled_down_bool = subgroupShuffleDown(false, 4u); // vote bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal = subgroupAllEqual(0); has_equal = subgroupAllEqual(true); has_equal = subgroupAllEqual(vec3(0.0, 1.0, 2.0)); has_equal = subgroupAllEqual(bvec4(true, true, false, true)); // arithmetic vec4 added = subgroupAdd(vec4(20.0)); ivec4 iadded = subgroupAdd(ivec4(20)); vec4 multiplied = subgroupMul(vec4(20.0)); ivec4 imultiplied = subgroupMul(ivec4(20)); vec4 lo = subgroupMin(vec4(20.0)); vec4 hi = subgroupMax(vec4(20.0)); ivec4 slo = subgroupMin(ivec4(20)); ivec4 shi = subgroupMax(ivec4(20)); uvec4 ulo = subgroupMin(uvec4(20)); uvec4 uhi = subgroupMax(uvec4(20)); uvec4 anded = subgroupAnd(ballot_value); uvec4 ored = subgroupOr(ballot_value); uvec4 xored = subgroupXor(ballot_value); added = subgroupInclusiveAdd(added); iadded = subgroupInclusiveAdd(iadded); multiplied = subgroupInclusiveMul(multiplied); imultiplied = subgroupInclusiveMul(imultiplied); //lo = subgroupInclusiveMin(lo); // FIXME: Unsupported by Metal //hi = subgroupInclusiveMax(hi); //slo = subgroupInclusiveMin(slo); //shi = subgroupInclusiveMax(shi); //ulo = subgroupInclusiveMin(ulo); //uhi = subgroupInclusiveMax(uhi); //anded = subgroupInclusiveAnd(anded); //ored = subgroupInclusiveOr(ored); //xored = subgroupInclusiveXor(ored); //added = subgroupExclusiveAdd(lo); added = subgroupExclusiveAdd(multiplied); multiplied = subgroupExclusiveMul(multiplied); iadded = subgroupExclusiveAdd(imultiplied); imultiplied = subgroupExclusiveMul(imultiplied); //lo = subgroupExclusiveMin(lo); // FIXME: Unsupported by Metal //hi = subgroupExclusiveMax(hi); //ulo = subgroupExclusiveMin(ulo); //uhi = subgroupExclusiveMax(uhi); //slo = subgroupExclusiveMin(slo); //shi = subgroupExclusiveMax(shi); //anded = subgroupExclusiveAnd(anded); //ored = subgroupExclusiveOr(ored); //xored = subgroupExclusiveXor(ored); // clustered added = subgroupClusteredAdd(added, 4u); multiplied = subgroupClusteredMul(multiplied, 4u); iadded = subgroupClusteredAdd(iadded, 4u); imultiplied = subgroupClusteredMul(imultiplied, 4u); lo = subgroupClusteredMin(lo, 4u); hi = subgroupClusteredMax(hi, 4u); ulo = subgroupClusteredMin(ulo, 4u); uhi = subgroupClusteredMax(uhi, 4u); slo = subgroupClusteredMin(slo, 4u); shi = subgroupClusteredMax(shi, 4u); anded = subgroupClusteredAnd(anded, 4u); ored = subgroupClusteredOr(ored, 4u); xored = subgroupClusteredXor(xored, 4u); // quad vec4 swap_horiz = subgroupQuadSwapHorizontal(vec4(20.0)); bvec4 swap_horiz_bool = subgroupQuadSwapHorizontal(bvec4(true)); vec4 swap_vertical = subgroupQuadSwapVertical(vec4(20.0)); bvec4 swap_vertical_bool = subgroupQuadSwapVertical(bvec4(true)); vec4 swap_diagonal = subgroupQuadSwapDiagonal(vec4(20.0)); bvec4 swap_diagonal_bool = subgroupQuadSwapDiagonal(bvec4(true)); vec4 quad_broadcast = subgroupQuadBroadcast(vec4(20.0), 3u); bvec4 quad_broadcast_bool = subgroupQuadBroadcast(bvec4(true), 3u); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/subgroups.nocompat.invalid.vk.msl21.ios.comp000066400000000000000000000031731400026215700313120ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_shuffle : require #extension GL_KHR_shader_subgroup_shuffle_relative : require #extension GL_KHR_shader_subgroup_quad : require layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float FragColor; }; // Reduced test for functionality exposed on iOS. void main() { // basic FragColor = float(gl_NumSubgroups); FragColor = float(gl_SubgroupID); FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); // shuffle uint shuffled = subgroupShuffle(10u, 8u); bool shuffled_bool = subgroupShuffle(true, 9u); uint shuffled_xor = subgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = subgroupShuffleXor(false, 9u); // shuffle relative uint shuffled_up = subgroupShuffleUp(20u, 4u); bool shuffled_up_bool = subgroupShuffleUp(true, 4u); uint shuffled_down = subgroupShuffleDown(20u, 4u); bool shuffled_down_bool = subgroupShuffleDown(false, 4u); // quad vec4 swap_horiz = subgroupQuadSwapHorizontal(vec4(20.0)); bvec4 swap_horiz_bool = subgroupQuadSwapHorizontal(bvec4(true)); vec4 swap_vertical = subgroupQuadSwapVertical(vec4(20.0)); bvec4 swap_vertical_bool = subgroupQuadSwapVertical(bvec4(true)); vec4 swap_diagonal = subgroupQuadSwapDiagonal(vec4(20.0)); bvec4 swap_diagonal_bool = subgroupQuadSwapDiagonal(bvec4(true)); vec4 quad_broadcast = subgroupQuadBroadcast(vec4(20.0), 3u); bvec4 quad_broadcast_bool = subgroupQuadBroadcast(bvec4(true), 3u); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/subgroups.nocompat.invalid.vk.msl22.ios.comp000066400000000000000000000056351400026215700313200ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_vote : require #extension GL_KHR_shader_subgroup_shuffle : require #extension GL_KHR_shader_subgroup_shuffle_relative : require #extension GL_KHR_shader_subgroup_quad : require layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float FragColor; }; // Reduced test for functionality exposed on iOS. void main() { // basic FragColor = float(gl_NumSubgroups); FragColor = float(gl_SubgroupID); FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); // ballot FragColor = float(gl_SubgroupEqMask); FragColor = float(gl_SubgroupGeMask); FragColor = float(gl_SubgroupGtMask); FragColor = float(gl_SubgroupLeMask); FragColor = float(gl_SubgroupLtMask); vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); bvec2 broadcasted_bool = subgroupBroadcast(bvec2(true), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); bvec4 first_bool = subgroupBroadcastFirst(bvec4(false)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); // shuffle uint shuffled = subgroupShuffle(10u, 8u); bool shuffled_bool = subgroupShuffle(true, 9u); uint shuffled_xor = subgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = subgroupShuffleXor(false, 9u); // shuffle relative uint shuffled_up = subgroupShuffleUp(20u, 4u); bool shuffled_up_bool = subgroupShuffleUp(true, 4u); uint shuffled_down = subgroupShuffleDown(20u, 4u); bool shuffled_down_bool = subgroupShuffleDown(false, 4u); // vote bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal = subgroupAllEqual(0); has_equal = subgroupAllEqual(true); has_equal = subgroupAllEqual(vec3(0.0, 1.0, 2.0)); has_equal = subgroupAllEqual(bvec4(true, true, false, true)); // quad vec4 swap_horiz = subgroupQuadSwapHorizontal(vec4(20.0)); bvec4 swap_horiz_bool = subgroupQuadSwapHorizontal(bvec4(true)); vec4 swap_vertical = subgroupQuadSwapVertical(vec4(20.0)); bvec4 swap_vertical_bool = subgroupQuadSwapVertical(bvec4(true)); vec4 swap_diagonal = subgroupQuadSwapDiagonal(vec4(20.0)); bvec4 swap_diagonal_bool = subgroupQuadSwapDiagonal(bvec4(true)); vec4 quad_broadcast = subgroupQuadBroadcast(vec4(20.0), 3u); bvec4 quad_broadcast_bool = subgroupQuadBroadcast(bvec4(true), 3u); } spirv-cross-2021.01.15/shaders-msl-no-opt/comp/subgroups.nocompat.invalid.vk.msl23.ios.simd.comp000066400000000000000000000121621400026215700322450ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_vote : require #extension GL_KHR_shader_subgroup_shuffle : require #extension GL_KHR_shader_subgroup_shuffle_relative : require #extension GL_KHR_shader_subgroup_arithmetic : require #extension GL_KHR_shader_subgroup_clustered : require #extension GL_KHR_shader_subgroup_quad : require layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float FragColor; }; void main() { // basic FragColor = float(gl_NumSubgroups); FragColor = float(gl_SubgroupID); FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); // ballot FragColor = float(gl_SubgroupEqMask); FragColor = float(gl_SubgroupGeMask); FragColor = float(gl_SubgroupGtMask); FragColor = float(gl_SubgroupLeMask); FragColor = float(gl_SubgroupLtMask); vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); bvec2 broadcasted_bool = subgroupBroadcast(bvec2(true), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); bvec4 first_bool = subgroupBroadcastFirst(bvec4(false)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); // shuffle uint shuffled = subgroupShuffle(10u, 8u); bool shuffled_bool = subgroupShuffle(true, 9u); uint shuffled_xor = subgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = subgroupShuffleXor(false, 9u); // shuffle relative uint shuffled_up = subgroupShuffleUp(20u, 4u); bool shuffled_up_bool = subgroupShuffleUp(true, 4u); uint shuffled_down = subgroupShuffleDown(20u, 4u); bool shuffled_down_bool = subgroupShuffleDown(false, 4u); // vote bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal = subgroupAllEqual(0); has_equal = subgroupAllEqual(true); has_equal = subgroupAllEqual(vec3(0.0, 1.0, 2.0)); has_equal = subgroupAllEqual(bvec4(true, true, false, true)); // arithmetic vec4 added = subgroupAdd(vec4(20.0)); ivec4 iadded = subgroupAdd(ivec4(20)); vec4 multiplied = subgroupMul(vec4(20.0)); ivec4 imultiplied = subgroupMul(ivec4(20)); vec4 lo = subgroupMin(vec4(20.0)); vec4 hi = subgroupMax(vec4(20.0)); ivec4 slo = subgroupMin(ivec4(20)); ivec4 shi = subgroupMax(ivec4(20)); uvec4 ulo = subgroupMin(uvec4(20)); uvec4 uhi = subgroupMax(uvec4(20)); uvec4 anded = subgroupAnd(ballot_value); uvec4 ored = subgroupOr(ballot_value); uvec4 xored = subgroupXor(ballot_value); added = subgroupInclusiveAdd(added); iadded = subgroupInclusiveAdd(iadded); multiplied = subgroupInclusiveMul(multiplied); imultiplied = subgroupInclusiveMul(imultiplied); //lo = subgroupInclusiveMin(lo); // FIXME: Unsupported by Metal //hi = subgroupInclusiveMax(hi); //slo = subgroupInclusiveMin(slo); //shi = subgroupInclusiveMax(shi); //ulo = subgroupInclusiveMin(ulo); //uhi = subgroupInclusiveMax(uhi); //anded = subgroupInclusiveAnd(anded); //ored = subgroupInclusiveOr(ored); //xored = subgroupInclusiveXor(ored); //added = subgroupExclusiveAdd(lo); added = subgroupExclusiveAdd(multiplied); multiplied = subgroupExclusiveMul(multiplied); iadded = subgroupExclusiveAdd(imultiplied); imultiplied = subgroupExclusiveMul(imultiplied); //lo = subgroupExclusiveMin(lo); // FIXME: Unsupported by Metal //hi = subgroupExclusiveMax(hi); //ulo = subgroupExclusiveMin(ulo); //uhi = subgroupExclusiveMax(uhi); //slo = subgroupExclusiveMin(slo); //shi = subgroupExclusiveMax(shi); //anded = subgroupExclusiveAnd(anded); //ored = subgroupExclusiveOr(ored); //xored = subgroupExclusiveXor(ored); // clustered added = subgroupClusteredAdd(added, 4u); multiplied = subgroupClusteredMul(multiplied, 4u); iadded = subgroupClusteredAdd(iadded, 4u); imultiplied = subgroupClusteredMul(imultiplied, 4u); lo = subgroupClusteredMin(lo, 4u); hi = subgroupClusteredMax(hi, 4u); ulo = subgroupClusteredMin(ulo, 4u); uhi = subgroupClusteredMax(uhi, 4u); slo = subgroupClusteredMin(slo, 4u); shi = subgroupClusteredMax(shi, 4u); anded = subgroupClusteredAnd(anded, 4u); ored = subgroupClusteredOr(ored, 4u); xored = subgroupClusteredXor(xored, 4u); // quad vec4 swap_horiz = subgroupQuadSwapHorizontal(vec4(20.0)); bvec4 swap_horiz_bool = subgroupQuadSwapHorizontal(bvec4(true)); vec4 swap_vertical = subgroupQuadSwapVertical(vec4(20.0)); bvec4 swap_vertical_bool = subgroupQuadSwapVertical(bvec4(true)); vec4 swap_diagonal = subgroupQuadSwapDiagonal(vec4(20.0)); bvec4 swap_diagonal_bool = subgroupQuadSwapDiagonal(bvec4(true)); vec4 quad_broadcast = subgroupQuadBroadcast(vec4(20.0), 3u); bvec4 quad_broadcast_bool = subgroupQuadBroadcast(bvec4(true), 3u); } spirv-cross-2021.01.15/shaders-msl-no-opt/components/000077500000000000000000000000001400026215700222135ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/components/fragment-input-component.frag000066400000000000000000000003141400026215700300120ustar00rootroot00000000000000#version 450 layout(location = 0, component = 3) in float Foo1; layout(location = 0, component = 0) in vec3 Foo3; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(Foo3, Foo1); } spirv-cross-2021.01.15/shaders-msl-no-opt/components/fragment-output-component.frag000066400000000000000000000004201400026215700302110ustar00rootroot00000000000000#version 450 layout(location = 0, component = 0) out float FragColor0; layout(location = 0, component = 1) out vec2 FragColor1; layout(location = 0, component = 3) out float FragColor3; void main() { FragColor0 = 1.0; FragColor1 = vec2(2.0, 3.0); FragColor3 = 4.0; } spirv-cross-2021.01.15/shaders-msl-no-opt/components/fragment-output-component.pad-fragment.frag000066400000000000000000000003031400026215700325550ustar00rootroot00000000000000#version 450 layout(location = 0, component = 0) out float FragColor0; layout(location = 0, component = 1) out vec2 FragColor1; void main() { FragColor0 = 1.0; FragColor1 = vec2(2.0, 3.0); } spirv-cross-2021.01.15/shaders-msl-no-opt/components/vertex-input-component.vert000066400000000000000000000003341400026215700275670ustar00rootroot00000000000000#version 450 layout(location = 0, component = 0) in vec3 Foo3; layout(location = 0, component = 3) in float Foo1; layout(location = 0) out vec3 Foo; void main() { gl_Position = vec4(Foo3, Foo1); Foo = Foo3 + Foo1; } spirv-cross-2021.01.15/shaders-msl-no-opt/components/vertex-output-component.vert000066400000000000000000000003211400026215700277640ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 vFoo; layout(location = 0) out vec3 Foo3; layout(location = 0, component = 3) out float Foo1; void main() { gl_Position = vFoo; Foo3 = vFoo.xyz; Foo1 = vFoo.w; } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/000077500000000000000000000000001400026215700207455ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag/16bit-constants.invalid.frag000066400000000000000000000004361400026215700261750ustar00rootroot00000000000000#version 450 core #extension GL_AMD_gpu_shader_int16 : require #extension GL_AMD_gpu_shader_half_float : require layout(location = 0) out float16_t foo; layout(location = 1) out int16_t bar; layout(location = 2) out uint16_t baz; void main() { foo = 1.0hf; bar = 2s; baz = 3us; } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/demote-to-helper.vk.nocompat.msl21.invalid.frag000066400000000000000000000002511400026215700315760ustar00rootroot00000000000000#version 450 #extension GL_EXT_demote_to_helper_invocation : require void main() { //demote; // FIXME: Not implemented for MSL bool helper = helperInvocationEXT(); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/depth-image-gather.asm.frag000066400000000000000000000067651400026215700260370ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Google spiregg; 0 ; Bound: 36 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_user_type" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %psMain "main" %gl_FragCoord %in_var_TEXCOORD0 %out_var_SV_Target0 OpExecutionMode %psMain OriginUpperLeft OpSource HLSL 500 OpName %type_2d_image "type.2d.image" OpName %g_depthTexture "g_depthTexture" OpName %type_sampler "type.sampler" OpName %g_sampler "g_sampler" OpName %g_comp "g_comp" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %psMain "psMain" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_Position" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_depthTexture DescriptorSet 0 OpDecorate %g_depthTexture Binding 0 OpDecorate %g_sampler DescriptorSet 0 OpDecorate %g_sampler Binding 0 OpDecorate %g_comp DescriptorSet 0 OpDecorate %g_comp Binding 1 OpDecorateString %g_depthTexture UserTypeGOOGLE "texture2d" %float = OpTypeFloat 32 %float_0_5 = OpConstant %float 0.5 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %v2int = OpTypeVector %int 2 %16 = OpConstantComposite %v2int %int_0 %int_0 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %25 = OpTypeFunction %void %type_sampled_image = OpTypeSampledImage %type_2d_image %g_depthTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %g_comp = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %psMain = OpFunction %void None %25 %26 = OpLabel %27 = OpLoad %v2float %in_var_TEXCOORD0 %28 = OpLoad %type_2d_image %g_depthTexture %29 = OpLoad %type_sampler %g_comp %30 = OpSampledImage %type_sampled_image %28 %29 %31 = OpImageDrefGather %v4float %30 %27 %float_0_5 None %32 = OpLoad %type_sampler %g_sampler %33 = OpSampledImage %type_sampled_image %28 %32 %34 = OpImageGather %v4float %33 %27 %int_0 ConstOffset %16 %35 = OpFMul %v4float %31 %34 OpStore %out_var_SV_Target0 %35 OpReturn OpFunctionEnd force-active-resources.msl2.argument..force-active.discrete.frag000066400000000000000000000006701400026215700350330ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 layout(location = 0) in vec2 vUV; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 0) uniform sampler2D uTexture1; layout(set = 0, binding = 1) uniform sampler2D uTexture2; layout(set = 2, binding = 0) uniform sampler2D uTextureDiscrete1; layout(set = 2, binding = 1) uniform sampler2D uTextureDiscrete2; void main() { FragColor = texture(uTexture2, vUV); FragColor += texture(uTextureDiscrete2, vUV); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/fp16.desktop.invalid.frag000066400000000000000000000062331400026215700254630ustar00rootroot00000000000000#version 450 #extension GL_AMD_gpu_shader_half_float : require layout(location = 0) in float16_t v1; layout(location = 1) in f16vec2 v2; layout(location = 2) in f16vec3 v3; layout(location = 3) in f16vec4 v4; layout(location = 0) out float o1; layout(location = 1) out vec2 o2; layout(location = 2) out vec3 o3; layout(location = 3) out vec4 o4; f16mat2 test_mat2(f16vec2 a, f16vec2 b, f16vec2 c, f16vec2 d) { return f16mat2(a, b) * f16mat2(c, d); } f16mat3 test_mat3(f16vec3 a, f16vec3 b, f16vec3 c, f16vec3 d, f16vec3 e, f16vec3 f) { return f16mat3(a, b, c) * f16mat3(d, e, f); } void test_constants() { float16_t a = 1.0hf; float16_t b = 1.5hf; float16_t c = -1.5hf; // Negatives float16_t d = (0.0hf / 0.0hf); // NaN float16_t e = (1.0hf / 0.0hf); // +Inf float16_t f = (-1.0hf / 0.0hf); // -Inf float16_t g = 1014.0hf; // Large. float16_t h = 0.000001hf; // Denormal } float16_t test_result() { return 1.0hf; } void test_conversions() { float16_t one = test_result(); int a = int(one); uint b = uint(one); bool c = bool(one); float d = float(one); //double e = double(one); float16_t a2 = float16_t(a); float16_t b2 = float16_t(b); float16_t c2 = float16_t(c); float16_t d2 = float16_t(d); //float16_t e2 = float16_t(e); } void test_builtins() { f16vec4 res; res = radians(v4); res = degrees(v4); res = sin(v4); res = cos(v4); res = tan(v4); res = asin(v4); res = atan(v4, v3.xyzz); res = atan(v4); res = sinh(v4); res = cosh(v4); res = tanh(v4); res = asinh(v4); res = acosh(v4); res = atanh(v4); res = pow(v4, v4); res = exp(v4); res = log(v4); res = exp2(v4); res = log2(v4); res = sqrt(v4); res = inversesqrt(v4); res = abs(v4); res = sign(v4); res = floor(v4); res = trunc(v4); res = round(v4); res = roundEven(v4); res = ceil(v4); res = fract(v4); res = mod(v4, v4); f16vec4 tmp; res = modf(v4, tmp); res = min(v4, v4); res = max(v4, v4); res = clamp(v4, v4, v4); res = mix(v4, v4, v4); res = mix(v4, v4, lessThan(v4, v4)); res = step(v4, v4); res = smoothstep(v4, v4, v4); bvec4 btmp = isnan(v4); btmp = isinf(v4); res = fma(v4, v4, v4); ivec4 itmp; res = frexp(v4, itmp); res = ldexp(res, itmp); uint pack0 = packFloat2x16(v4.xy); uint pack1 = packFloat2x16(v4.zw); res = f16vec4(unpackFloat2x16(pack0), unpackFloat2x16(pack1)); float16_t t0 = length(v4); t0 = distance(v4, v4); t0 = dot(v4, v4); f16vec3 res3 = cross(v3, v3); res = normalize(v4); res = faceforward(v4, v4, v4); res = reflect(v4, v4); res = refract(v4, v4, v1); btmp = lessThan(v4, v4); btmp = lessThanEqual(v4, v4); btmp = greaterThan(v4, v4); btmp = greaterThanEqual(v4, v4); btmp = equal(v4, v4); btmp = notEqual(v4, v4); res = dFdx(v4); res = dFdy(v4); res = dFdxFine(v4); res = dFdyFine(v4); res = dFdxCoarse(v4); res = dFdyCoarse(v4); res = fwidth(v4); res = fwidthFine(v4); res = fwidthCoarse(v4); //res = interpolateAtCentroid(v4); //res = interpolateAtSample(v4, 0); //res = interpolateAtOffset(v4, f16vec2(0.1hf)); } void main() { // Basic matrix tests. f16mat2 m0 = test_mat2(v2, v2, v3.xy, v3.xy); f16mat3 m1 = test_mat3(v3, v3, v3, v4.xyz, v4.xyz, v4.yzw); test_constants(); test_conversions(); test_builtins(); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/image-gather.frag000066400000000000000000000005711400026215700241430ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 0) uniform sampler2D uSamp; layout(set = 0, binding = 1) uniform sampler2DShadow uSampShadow; layout(location = 0) in vec3 vUV; void main() { FragColor = textureGather(uSamp, vUV.xy, 0); FragColor += textureGather(uSamp, vUV.xy, 1); FragColor += textureGather(uSampShadow, vUV.xy, vUV.z); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/in_block_assign.frag000066400000000000000000000002731400026215700247340ustar00rootroot00000000000000#version 450 struct VOUT { vec4 a; }; layout(location = 0) in VOUT Clip; layout(location = 0) out vec4 FragColor; void main() { VOUT tmp = Clip; tmp.a += 1.0; FragColor = tmp.a; } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/min-max-clamp.invalid.asm.frag000066400000000000000000000264501400026215700264610ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 205 ; Schema: 0 OpCapability Shader OpCapability Float16 OpExtension "SPV_AMD_gpu_shader_half_float" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %v1 %v2 %v3 %v4 %h1 %h2 %h3 %h4 OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_AMD_gpu_shader_half_float" OpName %main "main" OpName %res "res" OpName %res2 "res2" OpName %res3 "res3" OpName %res4 "res4" OpName %hres "hres" OpName %hres2 "hres2" OpName %hres3 "hres3" OpName %hres4 "hres4" OpName %v1 "v1" OpName %v2 "v2" OpName %v3 "v3" OpName %v4 "v4" OpName %h1 "h1" OpName %h2 "h2" OpName %h3 "h3" OpName %h4 "h4" OpDecorate %v1 Location 0 OpDecorate %v2 Location 1 OpDecorate %v3 Location 2 OpDecorate %v4 Location 3 OpDecorate %h1 Location 4 OpDecorate %h2 Location 5 OpDecorate %h3 Location 6 OpDecorate %h4 Location 7 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %half = OpTypeFloat 16 %v2half = OpTypeVector %half 2 %v3half = OpTypeVector %half 3 %v4half = OpTypeVector %half 4 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Function_v3float = OpTypePointer Function %v3float %_ptr_Input_v3float = OpTypePointer Input %v3float %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Function_half = OpTypePointer Function %half %_ptr_Input_half = OpTypePointer Input %half %_ptr_Function_v2half = OpTypePointer Function %v2half %_ptr_Input_v2half = OpTypePointer Input %v2half %_ptr_Function_v3half = OpTypePointer Function %v3half %_ptr_Input_v3half = OpTypePointer Input %v3half %_ptr_Function_v4half = OpTypePointer Function %v4half %_ptr_Input_v4half = OpTypePointer Input %v4half %v1 = OpVariable %_ptr_Input_float Input %v2 = OpVariable %_ptr_Input_v2float Input %v3 = OpVariable %_ptr_Input_v3float Input %v4 = OpVariable %_ptr_Input_v4float Input %h1 = OpVariable %_ptr_Input_half Input %h2 = OpVariable %_ptr_Input_v2half Input %h3 = OpVariable %_ptr_Input_v3half Input %h4 = OpVariable %_ptr_Input_v4half Input %main = OpFunction %void None %3 %5 = OpLabel %res = OpVariable %_ptr_Function_float Function %46 = OpLoad %float %v1 %47 = OpLoad %float %v1 %48 = OpExtInst %float %1 FMin %46 %47 OpStore %res %48 %49 = OpLoad %float %v1 %50 = OpLoad %float %v1 %51 = OpExtInst %float %1 FMax %49 %50 OpStore %res %51 %52 = OpLoad %float %v1 %53 = OpLoad %float %v1 %54 = OpLoad %float %v1 %55 = OpExtInst %float %1 FClamp %52 %53 %54 OpStore %res %55 %56 = OpLoad %float %v1 %57 = OpLoad %float %v1 %58 = OpExtInst %float %1 NMin %56 %57 OpStore %res %58 %59 = OpLoad %float %v1 %60 = OpLoad %float %v1 %61 = OpExtInst %float %1 NMax %59 %60 OpStore %res %61 %62 = OpLoad %float %v1 %63 = OpLoad %float %v1 %64 = OpLoad %float %v1 %65 = OpExtInst %float %1 NClamp %62 %63 %64 OpStore %res %65 %res2 = OpVariable %_ptr_Function_v2float Function %66 = OpLoad %v2float %v2 %67 = OpLoad %v2float %v2 %68 = OpExtInst %v2float %1 FMin %66 %67 OpStore %res2 %68 %69 = OpLoad %v2float %v2 %70 = OpLoad %v2float %v2 %71 = OpExtInst %v2float %1 FMax %69 %70 OpStore %res2 %71 %72 = OpLoad %v2float %v2 %73 = OpLoad %v2float %v2 %74 = OpLoad %v2float %v2 %75 = OpExtInst %v2float %1 FClamp %72 %73 %74 OpStore %res2 %75 %76 = OpLoad %v2float %v2 %77 = OpLoad %v2float %v2 %78 = OpExtInst %v2float %1 NMin %76 %77 OpStore %res2 %78 %79 = OpLoad %v2float %v2 %80 = OpLoad %v2float %v2 %81 = OpExtInst %v2float %1 NMax %79 %80 OpStore %res2 %81 %82 = OpLoad %v2float %v2 %83 = OpLoad %v2float %v2 %84 = OpLoad %v2float %v2 %85 = OpExtInst %v2float %1 NClamp %82 %83 %84 OpStore %res2 %85 %res3 = OpVariable %_ptr_Function_v3float Function %86 = OpLoad %v3float %v3 %87 = OpLoad %v3float %v3 %88 = OpExtInst %v3float %1 FMin %86 %87 OpStore %res3 %88 %89 = OpLoad %v3float %v3 %90 = OpLoad %v3float %v3 %91 = OpExtInst %v3float %1 FMax %89 %90 OpStore %res3 %91 %92 = OpLoad %v3float %v3 %93 = OpLoad %v3float %v3 %94 = OpLoad %v3float %v3 %95 = OpExtInst %v3float %1 FClamp %92 %93 %94 OpStore %res3 %95 %96 = OpLoad %v3float %v3 %97 = OpLoad %v3float %v3 %98 = OpExtInst %v3float %1 NMin %96 %97 OpStore %res3 %98 %99 = OpLoad %v3float %v3 %100 = OpLoad %v3float %v3 %101 = OpExtInst %v3float %1 NMax %99 %100 OpStore %res3 %101 %102 = OpLoad %v3float %v3 %103 = OpLoad %v3float %v3 %104 = OpLoad %v3float %v3 %105 = OpExtInst %v3float %1 NClamp %102 %103 %104 OpStore %res3 %105 %res4 = OpVariable %_ptr_Function_v4float Function %106 = OpLoad %v4float %v4 %107 = OpLoad %v4float %v4 %108 = OpExtInst %v4float %1 FMin %106 %107 OpStore %res4 %108 %109 = OpLoad %v4float %v4 %110 = OpLoad %v4float %v4 %111 = OpExtInst %v4float %1 FMax %109 %110 OpStore %res4 %111 %112 = OpLoad %v4float %v4 %113 = OpLoad %v4float %v4 %114 = OpLoad %v4float %v4 %115 = OpExtInst %v4float %1 FClamp %112 %113 %114 OpStore %res4 %115 %116 = OpLoad %v4float %v4 %117 = OpLoad %v4float %v4 %118 = OpExtInst %v4float %1 NMin %116 %117 OpStore %res4 %118 %119 = OpLoad %v4float %v4 %120 = OpLoad %v4float %v4 %121 = OpExtInst %v4float %1 NMax %119 %120 OpStore %res4 %121 %122 = OpLoad %v4float %v4 %123 = OpLoad %v4float %v4 %124 = OpLoad %v4float %v4 %125 = OpExtInst %v4float %1 NClamp %122 %123 %124 OpStore %res4 %125 %hres = OpVariable %_ptr_Function_half Function %126 = OpLoad %half %h1 %127 = OpLoad %half %h1 %128 = OpExtInst %half %1 FMin %126 %127 OpStore %hres %128 %129 = OpLoad %half %h1 %130 = OpLoad %half %h1 %131 = OpExtInst %half %1 FMax %129 %130 OpStore %hres %131 %132 = OpLoad %half %h1 %133 = OpLoad %half %h1 %134 = OpLoad %half %h1 %135 = OpExtInst %half %1 FClamp %132 %133 %134 OpStore %hres %135 %136 = OpLoad %half %h1 %137 = OpLoad %half %h1 %138 = OpExtInst %half %1 NMin %136 %137 OpStore %hres %138 %139 = OpLoad %half %h1 %140 = OpLoad %half %h1 %141 = OpExtInst %half %1 NMax %139 %140 OpStore %hres %141 %142 = OpLoad %half %h1 %143 = OpLoad %half %h1 %144 = OpLoad %half %h1 %145 = OpExtInst %half %1 NClamp %142 %143 %144 OpStore %hres %145 %hres2 = OpVariable %_ptr_Function_v2half Function %146 = OpLoad %v2half %h2 %147 = OpLoad %v2half %h2 %148 = OpExtInst %v2half %1 FMin %146 %147 OpStore %hres2 %148 %149 = OpLoad %v2half %h2 %150 = OpLoad %v2half %h2 %151 = OpExtInst %v2half %1 FMax %149 %150 OpStore %hres2 %151 %152 = OpLoad %v2half %h2 %153 = OpLoad %v2half %h2 %154 = OpLoad %v2half %h2 %155 = OpExtInst %v2half %1 FClamp %152 %153 %154 OpStore %hres2 %155 %156 = OpLoad %v2half %h2 %157 = OpLoad %v2half %h2 %158 = OpExtInst %v2half %1 NMin %156 %157 OpStore %hres2 %158 %159 = OpLoad %v2half %h2 %160 = OpLoad %v2half %h2 %161 = OpExtInst %v2half %1 NMax %159 %160 OpStore %hres2 %161 %162 = OpLoad %v2half %h2 %163 = OpLoad %v2half %h2 %164 = OpLoad %v2half %h2 %165 = OpExtInst %v2half %1 NClamp %162 %163 %164 OpStore %hres2 %165 %hres3 = OpVariable %_ptr_Function_v3half Function %166 = OpLoad %v3half %h3 %167 = OpLoad %v3half %h3 %168 = OpExtInst %v3half %1 FMin %166 %167 OpStore %hres3 %168 %169 = OpLoad %v3half %h3 %170 = OpLoad %v3half %h3 %171 = OpExtInst %v3half %1 FMax %169 %170 OpStore %hres3 %171 %172 = OpLoad %v3half %h3 %173 = OpLoad %v3half %h3 %174 = OpLoad %v3half %h3 %175 = OpExtInst %v3half %1 FClamp %172 %173 %174 OpStore %hres3 %175 %176 = OpLoad %v3half %h3 %177 = OpLoad %v3half %h3 %178 = OpExtInst %v3half %1 NMin %176 %177 OpStore %hres3 %178 %179 = OpLoad %v3half %h3 %180 = OpLoad %v3half %h3 %181 = OpExtInst %v3half %1 NMax %179 %180 OpStore %hres3 %181 %182 = OpLoad %v3half %h3 %183 = OpLoad %v3half %h3 %184 = OpLoad %v3half %h3 %185 = OpExtInst %v3half %1 NClamp %182 %183 %184 OpStore %hres3 %185 %hres4 = OpVariable %_ptr_Function_v4half Function %186 = OpLoad %v4half %h4 %187 = OpLoad %v4half %h4 %188 = OpExtInst %v4half %1 FMin %186 %187 OpStore %hres4 %188 %189 = OpLoad %v4half %h4 %190 = OpLoad %v4half %h4 %191 = OpExtInst %v4half %1 FMax %189 %190 OpStore %hres4 %191 %192 = OpLoad %v4half %h4 %193 = OpLoad %v4half %h4 %194 = OpLoad %v4half %h4 %195 = OpExtInst %v4half %1 FClamp %192 %193 %194 OpStore %hres4 %195 %196 = OpLoad %v4half %h4 %197 = OpLoad %v4half %h4 %198 = OpExtInst %v4half %1 NMin %196 %197 OpStore %hres4 %198 %199 = OpLoad %v4half %h4 %200 = OpLoad %v4half %h4 %201 = OpExtInst %v4half %1 NMax %199 %200 OpStore %hres4 %201 %202 = OpLoad %v4half %h4 %203 = OpLoad %v4half %h4 %204 = OpLoad %v4half %h4 %205 = OpExtInst %v4half %1 NClamp %202 %203 %204 OpStore %hres4 %205 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl-no-opt/frag/nonuniform-constructor.msl2.frag000066400000000000000000000005741400026215700272450ustar00rootroot00000000000000#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; layout(location = 1) flat in int vIndex; layout(set = 0, binding = 0) uniform texture2D uTex[10]; layout(set = 1, binding = 0) uniform sampler Immut; void main() { FragColor = texture(nonuniformEXT(sampler2D(uTex[vIndex], Immut)), vUV); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/pixel-interlock-simple-callstack.msl2.frag000066400000000000000000000007161400026215700310250ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(set = 0, binding = 0, std430) buffer SSBO0 { uint values0[]; }; layout(set = 0, binding = 1, std430) buffer SSBO1 { uint values1[]; }; void callee2() { values1[int(gl_FragCoord.x)] += 1; } void callee() { values0[int(gl_FragCoord.x)] += 1; callee2(); } void main() { beginInvocationInterlockARB(); callee(); endInvocationInterlockARB(); } scalar-block-layout-ubo-std430.vk.nocompat.invalid.frag000066400000000000000000000006071400026215700330670ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 #extension GL_EXT_scalar_block_layout : require layout(std430, binding = 0) uniform UBO { float a[1]; vec2 b[2]; }; layout(std430, binding = 1) uniform UBOEnhancedLayout { float c[1]; vec2 d[2]; layout(offset = 10000) float e; }; layout(location = 0) flat in int vIndex; layout(location = 0) out float FragColor; void main() { FragColor = a[vIndex] + c[vIndex] + e; } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/shadow-compare-global-alias.invalid.frag000066400000000000000000000014231400026215700304710ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(binding = 0) uniform sampler2DShadow uSampler; layout(location = 0) in vec3 vUV; layout(binding = 1) uniform texture2D uTex; layout(binding = 2) uniform samplerShadow uSamp; float Samp(vec3 uv) { return texture(sampler2DShadow(uTex, uSamp), uv); } float Samp2(vec3 uv) { return texture(uSampler, vUV); } float Samp3(texture2D uT, samplerShadow uS, vec3 uv) { return texture(sampler2DShadow(uT, uS), vUV); } float Samp4(sampler2DShadow uS, vec3 uv) { return texture(uS, vUV); } void main() { FragColor = texture(uSampler, vUV); FragColor += texture(sampler2DShadow(uTex, uSamp), vUV); FragColor += Samp(vUV); FragColor += Samp2(vUV); FragColor += Samp3(uTex, uSamp, vUV); FragColor += Samp4(uSampler, vUV); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/subgroups.nocompat.invalid.vk.msl22.frag000066400000000000000000000117301400026215700304620ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_vote : require #extension GL_KHR_shader_subgroup_shuffle : require #extension GL_KHR_shader_subgroup_shuffle_relative : require #extension GL_KHR_shader_subgroup_arithmetic : require #extension GL_KHR_shader_subgroup_clustered : require #extension GL_KHR_shader_subgroup_quad : require layout(location = 0) out float FragColor; void main() { // basic FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); // ballot FragColor = float(gl_SubgroupEqMask); FragColor = float(gl_SubgroupGeMask); FragColor = float(gl_SubgroupGtMask); FragColor = float(gl_SubgroupLeMask); FragColor = float(gl_SubgroupLtMask); vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); bvec2 broadcasted_bool = subgroupBroadcast(bvec2(true), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); bvec4 first_bool = subgroupBroadcastFirst(bvec4(false)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); // shuffle uint shuffled = subgroupShuffle(10u, 8u); bool shuffled_bool = subgroupShuffle(true, 9u); uint shuffled_xor = subgroupShuffleXor(30u, 8u); bool shuffled_xor_bool = subgroupShuffleXor(false, 9u); // shuffle relative uint shuffled_up = subgroupShuffleUp(20u, 4u); bool shuffled_up_bool = subgroupShuffleUp(true, 4u); uint shuffled_down = subgroupShuffleDown(20u, 4u); bool shuffled_down_bool = subgroupShuffleDown(false, 4u); // vote bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal = subgroupAllEqual(0); has_equal = subgroupAllEqual(true); has_equal = subgroupAllEqual(vec3(0.0, 1.0, 2.0)); has_equal = subgroupAllEqual(bvec4(true, true, false, true)); // arithmetic vec4 added = subgroupAdd(vec4(20.0)); ivec4 iadded = subgroupAdd(ivec4(20)); vec4 multiplied = subgroupMul(vec4(20.0)); ivec4 imultiplied = subgroupMul(ivec4(20)); vec4 lo = subgroupMin(vec4(20.0)); vec4 hi = subgroupMax(vec4(20.0)); ivec4 slo = subgroupMin(ivec4(20)); ivec4 shi = subgroupMax(ivec4(20)); uvec4 ulo = subgroupMin(uvec4(20)); uvec4 uhi = subgroupMax(uvec4(20)); uvec4 anded = subgroupAnd(ballot_value); uvec4 ored = subgroupOr(ballot_value); uvec4 xored = subgroupXor(ballot_value); added = subgroupInclusiveAdd(added); iadded = subgroupInclusiveAdd(iadded); multiplied = subgroupInclusiveMul(multiplied); imultiplied = subgroupInclusiveMul(imultiplied); //lo = subgroupInclusiveMin(lo); // FIXME: Unsupported by Metal //hi = subgroupInclusiveMax(hi); //slo = subgroupInclusiveMin(slo); //shi = subgroupInclusiveMax(shi); //ulo = subgroupInclusiveMin(ulo); //uhi = subgroupInclusiveMax(uhi); //anded = subgroupInclusiveAnd(anded); //ored = subgroupInclusiveOr(ored); //xored = subgroupInclusiveXor(ored); //added = subgroupExclusiveAdd(lo); added = subgroupExclusiveAdd(multiplied); multiplied = subgroupExclusiveMul(multiplied); iadded = subgroupExclusiveAdd(imultiplied); imultiplied = subgroupExclusiveMul(imultiplied); //lo = subgroupExclusiveMin(lo); // FIXME: Unsupported by Metal //hi = subgroupExclusiveMax(hi); //ulo = subgroupExclusiveMin(ulo); //uhi = subgroupExclusiveMax(uhi); //slo = subgroupExclusiveMin(slo); //shi = subgroupExclusiveMax(shi); //anded = subgroupExclusiveAnd(anded); //ored = subgroupExclusiveOr(ored); //xored = subgroupExclusiveXor(ored); // clustered added = subgroupClusteredAdd(added, 4u); multiplied = subgroupClusteredMul(multiplied, 4u); iadded = subgroupClusteredAdd(iadded, 4u); imultiplied = subgroupClusteredMul(imultiplied, 4u); lo = subgroupClusteredMin(lo, 4u); hi = subgroupClusteredMax(hi, 4u); ulo = subgroupClusteredMin(ulo, 4u); uhi = subgroupClusteredMax(uhi, 4u); slo = subgroupClusteredMin(slo, 4u); shi = subgroupClusteredMax(shi, 4u); anded = subgroupClusteredAnd(anded, 4u); ored = subgroupClusteredOr(ored, 4u); xored = subgroupClusteredXor(xored, 4u); // quad vec4 swap_horiz = subgroupQuadSwapHorizontal(vec4(20.0)); bvec4 swap_horiz_bool = subgroupQuadSwapHorizontal(bvec4(true)); vec4 swap_vertical = subgroupQuadSwapVertical(vec4(20.0)); bvec4 swap_vertical_bool = subgroupQuadSwapVertical(bvec4(true)); vec4 swap_diagonal = subgroupQuadSwapDiagonal(vec4(20.0)); bvec4 swap_diagonal_bool = subgroupQuadSwapDiagonal(bvec4(true)); vec4 quad_broadcast = subgroupQuadBroadcast(vec4(20.0), 3u); bvec4 quad_broadcast_bool = subgroupQuadBroadcast(bvec4(true), 3u); } subpass-input-attachment-index-fallback.msl20.ios.framebuffer-fetch.frag000066400000000000000000000002671400026215700364400ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 layout(binding = 4, input_attachment_index = 1) uniform subpassInput uInput; layout(location = 1) out vec4 FragColor; void main() { FragColor = subpassLoad(uInput); } subpass-input-attachment-index-fallback.msl23.framebuffer-fetch.frag000066400000000000000000000002671400026215700356520ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 layout(binding = 4, input_attachment_index = 1) uniform subpassInput uInput; layout(location = 1) out vec4 FragColor; void main() { FragColor = subpassLoad(uInput); } subpass-input-function-argument.framebuffer-fetch.ios.frag000066400000000000000000000005711400026215700341550ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 layout(set = 0, input_attachment_index = 0, binding = 0) uniform subpassInput uSub; layout(location = 0) out vec4 FragColor; vec4 samp3(subpassInput uS) { return subpassLoad(uS); } vec4 samp2(subpassInput uS) { return subpassLoad(uS) + samp3(uS); } vec4 samp() { return subpassLoad(uSub) + samp3(uSub); } void main() { FragColor = samp() + samp2(uSub); } subpass-input-function-argument.framebuffer-fetch.msl23.frag000066400000000000000000000005711400026215700343230ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 layout(set = 0, input_attachment_index = 0, binding = 0) uniform subpassInput uSub; layout(location = 0) out vec4 FragColor; vec4 samp3(subpassInput uS) { return subpassLoad(uS); } vec4 samp2(subpassInput uS) { return subpassLoad(uS) + samp3(uS); } vec4 samp() { return subpassLoad(uSub) + samp3(uSub); } void main() { FragColor = samp() + samp2(uSub); } subpass-input.decoration-binding.framebuffer-fetch.msl23.argument.frag000066400000000000000000000005321400026215700362340ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 layout(set = 0, binding = 10, input_attachment_index = 1) uniform subpassInput uSub; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 9) uniform texture2D uTex; layout(set = 0, binding = 8) uniform sampler uSampler; void main() { FragColor = subpassLoad(uSub) + texture(sampler2D(uTex, uSampler), vec2(0.5)); } subpass-input.decoration-binding.framebuffer-fetch.msl23.frag000066400000000000000000000005321400026215700344130ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 layout(set = 0, binding = 10, input_attachment_index = 1) uniform subpassInput uSub; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 9) uniform texture2D uTex; layout(set = 0, binding = 8) uniform sampler uSampler; void main() { FragColor = subpassLoad(uSub) + texture(sampler2D(uTex, uSampler), vec2(0.5)); } subpass-input.decoration-binding.ios.framebuffer-fetch.msl2.argument.frag000066400000000000000000000005321400026215700367420ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 layout(set = 0, binding = 10, input_attachment_index = 1) uniform subpassInput uSub; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 9) uniform texture2D uTex; layout(set = 0, binding = 8) uniform sampler uSampler; void main() { FragColor = subpassLoad(uSub) + texture(sampler2D(uTex, uSampler), vec2(0.5)); } subpass-input.decoration-binding.ios.framebuffer-fetch.msl2.frag000066400000000000000000000005321400026215700351210ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 layout(set = 0, binding = 10, input_attachment_index = 1) uniform subpassInput uSub; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 9) uniform texture2D uTex; layout(set = 0, binding = 8) uniform sampler uSampler; void main() { FragColor = subpassLoad(uSub) + texture(sampler2D(uTex, uSampler), vec2(0.5)); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/texture-access-int.swizzle.frag000066400000000000000000000035331400026215700270470ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform isampler1D tex1d; layout(binding = 1) uniform isampler2D tex2d; layout(binding = 2) uniform isampler3D tex3d; layout(binding = 3) uniform isamplerCube texCube; layout(binding = 4) uniform isampler2DArray tex2dArray; layout(binding = 5) uniform isamplerCubeArray texCubeArray; layout(binding = 6) uniform isamplerBuffer texBuffer; void main() { // OpImageSampleImplicitLod vec4 c = texture(tex1d, 0.0); c = texture(tex2d, vec2(0.0, 0.0)); c = texture(tex3d, vec3(0.0, 0.0, 0.0)); c = texture(texCube, vec3(0.0, 0.0, 0.0)); c = texture(tex2dArray, vec3(0.0, 0.0, 0.0)); c = texture(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0)); // OpImageSampleProjImplicitLod c = textureProj(tex1d, vec2(0.0, 1.0)); c = textureProj(tex2d, vec3(0.0, 0.0, 1.0)); c = textureProj(tex3d, vec4(0.0, 0.0, 0.0, 1.0)); // OpImageSampleExplicitLod c = textureLod(tex1d, 0.0, 0.0); c = textureLod(tex2d, vec2(0.0, 0.0), 0.0); c = textureLod(tex3d, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(texCube, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(tex2dArray, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 0.0); // OpImageSampleProjExplicitLod c = textureProjLod(tex1d, vec2(0.0, 1.0), 0.0); c = textureProjLod(tex2d, vec3(0.0, 0.0, 1.0), 0.0); c = textureProjLod(tex3d, vec4(0.0, 0.0, 0.0, 1.0), 0.0); // OpImageFetch c = texelFetch(tex1d, 0, 0); c = texelFetch(tex2d, ivec2(0, 0), 0); c = texelFetch(tex3d, ivec3(0, 0, 0), 0); c = texelFetch(tex2dArray, ivec3(0, 0, 0), 0); // Show that this transformation doesn't apply to Buffer images. c = texelFetch(texBuffer, 0); // OpImageGather c = textureGather(tex2d, vec2(0.0, 0.0), 0); c = textureGather(texCube, vec3(0.0, 0.0, 0.0), 1); c = textureGather(tex2dArray, vec3(0.0, 0.0, 0.0), 2); c = textureGather(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 3); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/texture-access-leaf.swizzle.frag000066400000000000000000000056261400026215700271710ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1D tex1d; layout(binding = 1) uniform sampler2D tex2d; layout(binding = 2) uniform sampler3D tex3d; layout(binding = 3) uniform samplerCube texCube; layout(binding = 4) uniform sampler2DArray tex2dArray; layout(binding = 5) uniform samplerCubeArray texCubeArray; layout(binding = 6) uniform samplerBuffer texBuffer; layout(binding = 7) uniform sampler2DShadow depth2d; layout(binding = 8) uniform samplerCubeShadow depthCube; layout(binding = 9) uniform sampler2DArrayShadow depth2dArray; layout(binding = 10) uniform samplerCubeArrayShadow depthCubeArray; vec4 doSwizzle() { // OpImageSampleImplicitLod vec4 c = texture(tex1d, 0.0); c = texture(tex2d, vec2(0.0, 0.0)); c = texture(tex3d, vec3(0.0, 0.0, 0.0)); c = texture(texCube, vec3(0.0, 0.0, 0.0)); c = texture(tex2dArray, vec3(0.0, 0.0, 0.0)); c = texture(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0)); // OpImageSampleDrefImplicitLod c.r = texture(depth2d, vec3(0.0, 0.0, 1.0)); c.r = texture(depthCube, vec4(0.0, 0.0, 0.0, 1.0)); c.r = texture(depth2dArray, vec4(0.0, 0.0, 0.0, 1.0)); c.r = texture(depthCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 1.0); // OpImageSampleProjImplicitLod c = textureProj(tex1d, vec2(0.0, 1.0)); c = textureProj(tex2d, vec3(0.0, 0.0, 1.0)); c = textureProj(tex3d, vec4(0.0, 0.0, 0.0, 1.0)); // OpImageSampleProjDrefImplicitLod c.r = textureProj(depth2d, vec4(0.0, 0.0, 1.0, 1.0)); // OpImageSampleExplicitLod c = textureLod(tex1d, 0.0, 0.0); c = textureLod(tex2d, vec2(0.0, 0.0), 0.0); c = textureLod(tex3d, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(texCube, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(tex2dArray, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 0.0); // OpImageSampleDrefExplicitLod c.r = textureLod(depth2d, vec3(0.0, 0.0, 1.0), 0.0); // OpImageSampleProjExplicitLod c = textureProjLod(tex1d, vec2(0.0, 1.0), 0.0); c = textureProjLod(tex2d, vec3(0.0, 0.0, 1.0), 0.0); c = textureProjLod(tex3d, vec4(0.0, 0.0, 0.0, 1.0), 0.0); // OpImageSampleProjDrefExplicitLod c.r = textureProjLod(depth2d, vec4(0.0, 0.0, 1.0, 1.0), 0.0); // OpImageFetch c = texelFetch(tex1d, 0, 0); c = texelFetch(tex2d, ivec2(0, 0), 0); c = texelFetch(tex3d, ivec3(0, 0, 0), 0); c = texelFetch(tex2dArray, ivec3(0, 0, 0), 0); // Show that this transformation doesn't apply to Buffer images. c = texelFetch(texBuffer, 0); // OpImageGather c = textureGather(tex2d, vec2(0.0, 0.0), 0); c = textureGather(texCube, vec3(0.0, 0.0, 0.0), 1); c = textureGather(tex2dArray, vec3(0.0, 0.0, 0.0), 2); c = textureGather(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 3); // OpImageDrefGather c = textureGather(depth2d, vec2(0.0, 0.0), 1.0); c = textureGather(depthCube, vec3(0.0, 0.0, 0.0), 1.0); c = textureGather(depth2dArray, vec3(0.0, 0.0, 0.0), 1.0); c = textureGather(depthCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 1.0); return c; } void main() { vec4 c = doSwizzle(); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/texture-access-uint.swizzle.frag000066400000000000000000000035331400026215700272340ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform usampler1D tex1d; layout(binding = 1) uniform usampler2D tex2d; layout(binding = 2) uniform usampler3D tex3d; layout(binding = 3) uniform usamplerCube texCube; layout(binding = 4) uniform usampler2DArray tex2dArray; layout(binding = 5) uniform usamplerCubeArray texCubeArray; layout(binding = 6) uniform usamplerBuffer texBuffer; void main() { // OpImageSampleImplicitLod vec4 c = texture(tex1d, 0.0); c = texture(tex2d, vec2(0.0, 0.0)); c = texture(tex3d, vec3(0.0, 0.0, 0.0)); c = texture(texCube, vec3(0.0, 0.0, 0.0)); c = texture(tex2dArray, vec3(0.0, 0.0, 0.0)); c = texture(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0)); // OpImageSampleProjImplicitLod c = textureProj(tex1d, vec2(0.0, 1.0)); c = textureProj(tex2d, vec3(0.0, 0.0, 1.0)); c = textureProj(tex3d, vec4(0.0, 0.0, 0.0, 1.0)); // OpImageSampleExplicitLod c = textureLod(tex1d, 0.0, 0.0); c = textureLod(tex2d, vec2(0.0, 0.0), 0.0); c = textureLod(tex3d, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(texCube, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(tex2dArray, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 0.0); // OpImageSampleProjExplicitLod c = textureProjLod(tex1d, vec2(0.0, 1.0), 0.0); c = textureProjLod(tex2d, vec3(0.0, 0.0, 1.0), 0.0); c = textureProjLod(tex3d, vec4(0.0, 0.0, 0.0, 1.0), 0.0); // OpImageFetch c = texelFetch(tex1d, 0, 0); c = texelFetch(tex2d, ivec2(0, 0), 0); c = texelFetch(tex3d, ivec3(0, 0, 0), 0); c = texelFetch(tex2dArray, ivec3(0, 0, 0), 0); // Show that this transformation doesn't apply to Buffer images. c = texelFetch(texBuffer, 0); // OpImageGather c = textureGather(tex2d, vec2(0.0, 0.0), 0); c = textureGather(texCube, vec3(0.0, 0.0, 0.0), 1); c = textureGather(tex2dArray, vec3(0.0, 0.0, 0.0), 2); c = textureGather(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 3); } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/texture-access.swizzle.frag000066400000000000000000000055351400026215700262630ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1D tex1d; layout(binding = 1) uniform sampler2D tex2d; layout(binding = 2) uniform sampler3D tex3d; layout(binding = 3) uniform samplerCube texCube; layout(binding = 4) uniform sampler2DArray tex2dArray; layout(binding = 5) uniform samplerCubeArray texCubeArray; layout(binding = 6) uniform samplerBuffer texBuffer; layout(binding = 7) uniform sampler2DShadow depth2d; layout(binding = 8) uniform samplerCubeShadow depthCube; layout(binding = 9) uniform sampler2DArrayShadow depth2dArray; layout(binding = 10) uniform samplerCubeArrayShadow depthCubeArray; void main() { // OpImageSampleImplicitLod vec4 c = texture(tex1d, 0.0); c = texture(tex2d, vec2(0.0, 0.0)); c = texture(tex3d, vec3(0.0, 0.0, 0.0)); c = texture(texCube, vec3(0.0, 0.0, 0.0)); c = texture(tex2dArray, vec3(0.0, 0.0, 0.0)); c = texture(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0)); // OpImageSampleDrefImplicitLod c.r = texture(depth2d, vec3(0.0, 0.0, 1.0)); c.r = texture(depthCube, vec4(0.0, 0.0, 0.0, 1.0)); c.r = texture(depth2dArray, vec4(0.0, 0.0, 0.0, 1.0)); c.r = texture(depthCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 1.0); // OpImageSampleProjImplicitLod c = textureProj(tex1d, vec2(0.0, 1.0)); c = textureProj(tex2d, vec3(0.0, 0.0, 1.0)); c = textureProj(tex3d, vec4(0.0, 0.0, 0.0, 1.0)); // OpImageSampleProjDrefImplicitLod c.r = textureProj(depth2d, vec4(0.0, 0.0, 1.0, 1.0)); // OpImageSampleExplicitLod c = textureLod(tex1d, 0.0, 0.0); c = textureLod(tex2d, vec2(0.0, 0.0), 0.0); c = textureLod(tex3d, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(texCube, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(tex2dArray, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 0.0); // OpImageSampleDrefExplicitLod c.r = textureLod(depth2d, vec3(0.0, 0.0, 1.0), 0.0); // OpImageSampleProjExplicitLod c = textureProjLod(tex1d, vec2(0.0, 1.0), 0.0); c = textureProjLod(tex2d, vec3(0.0, 0.0, 1.0), 0.0); c = textureProjLod(tex3d, vec4(0.0, 0.0, 0.0, 1.0), 0.0); // OpImageSampleProjDrefExplicitLod c.r = textureProjLod(depth2d, vec4(0.0, 0.0, 1.0, 1.0), 0.0); // OpImageFetch c = texelFetch(tex1d, 0, 0); c = texelFetch(tex2d, ivec2(0, 0), 0); c = texelFetch(tex3d, ivec3(0, 0, 0), 0); c = texelFetch(tex2dArray, ivec3(0, 0, 0), 0); // Show that this transformation doesn't apply to Buffer images. c = texelFetch(texBuffer, 0); // OpImageGather c = textureGather(tex2d, vec2(0.0, 0.0), 0); c = textureGather(texCube, vec3(0.0, 0.0, 0.0), 1); c = textureGather(tex2dArray, vec3(0.0, 0.0, 0.0), 2); c = textureGather(texCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 3); // OpImageDrefGather c = textureGather(depth2d, vec2(0.0, 0.0), 1.0); c = textureGather(depthCube, vec3(0.0, 0.0, 0.0), 1.0); c = textureGather(depth2dArray, vec3(0.0, 0.0, 0.0), 1.0); c = textureGather(depthCubeArray, vec4(0.0, 0.0, 0.0, 0.0), 1.0); } ubo-array-multiple-structs-access-chain.argument.msl2.frag000066400000000000000000000002771400026215700340100ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/frag#version 450 struct Foo { vec4 v; }; layout(set = 0, binding = 0) uniform UBO { Foo foo; } ubos[2]; layout(location = 0) out vec4 FragColor; void main() { FragColor = ubos[1].foo.v; } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/ubo-array-multiple-structs-access-chain.frag000066400000000000000000000002771400026215700313720ustar00rootroot00000000000000#version 450 struct Foo { vec4 v; }; layout(set = 0, binding = 0) uniform UBO { Foo foo; } ubos[2]; layout(location = 0) out vec4 FragColor; void main() { FragColor = ubos[1].foo.v; } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/ubo-offset-out-of-order.frag000066400000000000000000000003631400026215700262010ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 0) uniform UBO { layout(offset = 16) mat4 m; layout(offset = 0) vec4 v; }; layout(location = 0) in vec4 vColor; void main() { FragColor = m * vColor + v; } spirv-cross-2021.01.15/shaders-msl-no-opt/frag/variables.zero-initialize.frag000066400000000000000000000005221400026215700266720ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 vColor; layout(location = 0) out vec4 FragColor; int uninit_int; ivec4 uninit_vector; mat4 uninit_matrix; struct Foo { int a; }; Foo uninit_foo; void main() { int uninit_function_int; if (vColor.x > 10.0) uninit_function_int = 10; else uninit_function_int = 20; FragColor = vColor; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/000077500000000000000000000000001400026215700214425ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/packing/array-of-vec3.comp000066400000000000000000000002751400026215700247040ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; layout(set = 0, binding = 0, scalar) buffer SSBO { vec3 v[16]; }; void main() { v[1] = v[0]; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/array-of-vec4.comp000066400000000000000000000002751400026215700247050ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; layout(set = 0, binding = 0, scalar) buffer SSBO { vec4 v[16]; }; void main() { v[1] = v[0]; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/isolated-scalar-access.comp000066400000000000000000000004611400026215700266310ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) buffer SSBO { vec4 v; mat4 cm; layout(row_major) mat4 rm; vec3 v3; float f; }; shared vec4 shared_vec4; shared vec3 shared_vec3; void main() { v.x = 10.0; v3.y = 40.0; cm[1][2] = 20.0; rm[3][1] = 30.0; shared_vec4.z = 40.0; shared_vec3.y = 1.0; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/load-store-col-rows.comp000066400000000000000000000013731400026215700261420ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; layout(binding = 0, std140) buffer SSBO1 { mat2 a; layout(row_major) mat2 a2; }; layout(scalar, binding = 1) buffer SSBO2 { mat2x3 b; layout(row_major) mat3x2 b2; }; void load_store_column() { vec2 u = a[0]; vec2 v = a[1]; u += v; a[0] = u; a[1] = v; } void load_store_row() { vec2 u = a2[0]; vec2 v = a2[1]; u += v; a2[0] = u; a2[1] = v; } void load_store_packed_column() { vec3 u = b[0]; vec3 v = b[1]; u += v; b[0] = u; b[1] = v; } void load_store_packed_row() { vec2 u = b2[0]; vec2 v = b2[1]; u += v; b2[0] = u; b2[1] = v; } void main() { load_store_column(); load_store_row(); load_store_packed_column(); load_store_packed_row(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-2x2-scalar.comp000066400000000000000000000027371400026215700255130ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; #define T mat2 #define PACKING scalar layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-2x2-std140.comp000066400000000000000000000026571400026215700252660ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat2 #define PACKING std140 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-2x2-std430.comp000066400000000000000000000026571400026215700252700ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat2 #define PACKING std430 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-2x3-scalar.comp000066400000000000000000000027411400026215700255070ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; #define T mat2x3 #define PACKING scalar layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-2x3-std140.comp000066400000000000000000000026611400026215700252620ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat2x3 #define PACKING std140 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-2x3-std430.comp000066400000000000000000000026611400026215700252640ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat2x3 #define PACKING std430 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-2x4-scalar.comp000066400000000000000000000027411400026215700255100ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; #define T mat2x4 #define PACKING scalar layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-2x4-std140.comp000066400000000000000000000026611400026215700252630ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat2x4 #define PACKING std140 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-2x4-std430.comp000066400000000000000000000026611400026215700252650ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat2x4 #define PACKING std430 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-3x2-scalar.comp000066400000000000000000000027411400026215700255070ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; #define T mat3x2 #define PACKING scalar layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-3x2-std140.comp000066400000000000000000000026611400026215700252620ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat3x2 #define PACKING std140 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-3x2-std430.comp000066400000000000000000000026611400026215700252640ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat3x2 #define PACKING std430 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-3x3-scalar.comp000066400000000000000000000027371400026215700255150ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; #define T mat3 #define PACKING scalar layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-3x3-std140.comp000066400000000000000000000026571400026215700252700ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat3 #define PACKING std140 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-3x3-std430.comp000066400000000000000000000026571400026215700252720ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat3 #define PACKING std430 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-3x4-scalar.comp000066400000000000000000000027411400026215700255110ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; #define T mat3x4 #define PACKING scalar layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-3x4-std140.comp000066400000000000000000000026611400026215700252640ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat3x4 #define PACKING std140 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-3x4-std430.comp000066400000000000000000000026611400026215700252660ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat3x4 #define PACKING std430 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-4x2-scalar.comp000066400000000000000000000027411400026215700255100ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; #define T mat4x2 #define PACKING scalar layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-4x2-std140.comp000066400000000000000000000026611400026215700252630ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat4x2 #define PACKING std140 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-4x2-std430.comp000066400000000000000000000026611400026215700252650ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat4x2 #define PACKING std430 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-4x3-scalar.comp000066400000000000000000000027411400026215700255110ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; #define T mat4x3 #define PACKING scalar layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-4x3-std140.comp000066400000000000000000000026611400026215700252640ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat4x3 #define PACKING std140 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-4x3-std430.comp000066400000000000000000000026611400026215700252660ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat4x3 #define PACKING std430 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-4x4-scalar.comp000066400000000000000000000027371400026215700255170ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; #define T mat4 #define PACKING scalar layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-4x4-std140.comp000066400000000000000000000026571400026215700252720ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat4 #define PACKING std140 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-4x4-std430.comp000066400000000000000000000026571400026215700252740ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; #define T mat4 #define PACKING std430 layout(set = 0, binding = 0, PACKING) buffer SSBOCol { layout(column_major) T col_major0; layout(column_major) T col_major1; }; layout(set = 0, binding = 1, PACKING) buffer SSBORow { layout(row_major) T row_major0; layout(row_major) T row_major1; }; void load_store_to_variable_col_major() { // Load to variable. T loaded = col_major0; // Store from variable. col_major1 = loaded; } void load_store_to_variable_row_major() { // Load to variable. T loaded = row_major0; // Store to variable. row_major0 = loaded; } void copy_col_major_to_col_major() { // Copy col -> col col_major0 = col_major1; } void copy_row_major_to_col_major() { // Copy row -> col col_major0 = row_major0; } void copy_col_major_to_row_major() { // Copy col -> row row_major0 = col_major0; } void copy_row_major_to_row_major() { // Copy row -> row row_major0 = row_major1; } void copy_columns() { // Copy columns/rows. col_major0[1] = row_major0[1]; row_major0[1] = col_major0[1]; } void copy_elements() { // Copy individual elements. col_major0[0][1] = row_major0[0][1]; row_major0[0][1] = col_major0[0][1]; } void main() { load_store_to_variable_col_major(); load_store_to_variable_row_major(); copy_col_major_to_col_major(); copy_col_major_to_row_major(); copy_row_major_to_col_major(); copy_row_major_to_row_major(); copy_columns(); copy_elements(); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-multiply-row-major.comp000066400000000000000000000003111400026215700274110ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(row_major, set = 0, binding = 0) buffer SSBO { mat3 m0; mat3 m1; vec3 v0; vec3 v1; }; void main() { v0 = (m0 * m1) * v1; v0 = m0 * (m1 * v1); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-multiply-unpacked-col-major-2.comp000066400000000000000000000004421400026215700313130ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; layout(scalar, set = 0, binding = 0) buffer SSBO { mat3 m0; mat3 m1; vec3 v0; vec3 v1; }; void main() { v0 = (m0 * m1) * v1; v0 = m0 * (m1 * v1); v0 = (v1 * m0) * m1; v0 = v1 * (m0 * m1); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-multiply-unpacked-col-major.comp000066400000000000000000000003621400026215700311550ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std140, set = 0, binding = 0) buffer SSBO { mat2 m0; mat2 m1; vec2 v0; vec2 v1; }; void main() { v0 = (m0 * m1) * v1; v0 = m0 * (m1 * v1); v0 = (v1 * m0) * m1; v0 = v1 * (m0 * m1); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-multiply-unpacked-row-major-2.comp000066400000000000000000000004551400026215700313510ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; layout(scalar, row_major, set = 0, binding = 0) buffer SSBO { mat3 m0; mat3 m1; vec3 v0; vec3 v1; }; void main() { v0 = (m0 * m1) * v1; v0 = m0 * (m1 * v1); v0 = (v1 * m0) * m1; v0 = v1 * (m0 * m1); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/matrix-multiply-unpacked-row-major.comp000066400000000000000000000003751400026215700312130ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std140, row_major, set = 0, binding = 0) buffer SSBO { mat2 m0; mat2 m1; vec2 v0; vec2 v1; }; void main() { v0 = (m0 * m1) * v1; v0 = m0 * (m1 * v1); v0 = (v1 * m0) * m1; v0 = v1 * (m0 * m1); } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/member-padding.comp000066400000000000000000000003041400026215700251720ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std140, set = 0, binding = 0) buffer SSBO { layout(offset = 16) float a; layout(offset = 40) float b; }; void main() { a = 10.0; b = 20.0; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/std140-array-of-vectors.comp000066400000000000000000000014711400026215700265450ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std140, set = 0, binding = 0) buffer SSBO { float v1[4]; vec2 v2[4]; vec3 v3[4]; vec4 v4[4]; float v1_array_of_array[4][4]; vec2 v2_array_of_array[4][4]; vec3 v3_array_of_array[4][4]; vec4 v4_array_of_array[4][4]; float v_unsized[]; }; void main() { float loaded1 = v1[1]; v1[2] = loaded1; vec2 loaded2 = v2[1]; v2[2] = loaded2; vec3 loaded3 = v3[1]; v3[2] = loaded3; vec4 loaded4 = v4[1]; v4[2] = loaded4; loaded1 = v1_array_of_array[1][2]; v1_array_of_array[2][3] = loaded1; loaded2 = v2_array_of_array[1][2]; v2_array_of_array[2][3] = loaded2; loaded3 = v3_array_of_array[1][2]; v3_array_of_array[2][3] = loaded3; loaded4 = v4_array_of_array[1][2]; v4_array_of_array[2][3] = loaded4; loaded1 = v_unsized[1]; v_unsized[2] = loaded1; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/struct-alignment.comp000066400000000000000000000005771400026215700256330ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; struct Foo { vec3 a; // <- This one should become packed_float3, and the MSL alignment of the struct is now 4. float b; }; layout(std140, set = 0, binding = 0) buffer SSBO { vec2 a; float b; // <- We expect 4 bytes of padding here since MSL alignment of Foo must be lowered to 4. Foo foo; }; void main() { a.x = 10.0; b = 20.0; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/struct-packing-array-of-scalar.comp000066400000000000000000000003711400026215700302420ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; struct Foo { vec3 a; }; layout(scalar, set = 0, binding = 0) buffer SSBOScalar { Foo v[]; } buffer_scalar; void main() { buffer_scalar.v[1].a.y = 1.0; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/struct-packing-recursive.comp000066400000000000000000000004731400026215700272710ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; struct Foo { vec4 a; }; struct Bar { Foo a; }; struct Baz { Bar a; }; layout(scalar, set = 0, binding = 0) buffer SSBOScalar { float v; Baz baz; } buffer_scalar; void main() { buffer_scalar.baz.a.a.a.a.x = 10.0; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/struct-packing.comp000066400000000000000000000007641400026215700252670ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; // Foo will be marked packed_float3 because offset of bar is just 12 bytes after foo. struct Foo { vec3 a; }; // Bar will be marked as packed due to alignment of the struct itself cannot work without packed. struct Bar { vec3 a; }; layout(scalar, set = 0, binding = 0) buffer SSBOScalar { Foo foo; Bar bar; } buffer_scalar; void main() { buffer_scalar.foo.a.x = 10.0; buffer_scalar.bar.a.x = 20.0; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/struct-size-padding-array-of-array.comp000066400000000000000000000005651400026215700310620ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; struct A { float v; }; struct B { vec2 v; }; struct C { vec3 v; }; struct D { vec4 v; }; struct E { vec4 a; vec2 b; }; layout(std140, set = 0, binding = 0) buffer SSBO { A a[2][4]; B b[2][4]; C c[2][4]; D d[2][4]; mat2 e[2][4]; E f[]; }; void main() { f[0].a = vec4(2.0); mat2 tmp = e[0][1]; e[1][2] = tmp; } spirv-cross-2021.01.15/shaders-msl-no-opt/packing/struct-size-padding.comp000066400000000000000000000005401400026215700262210ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; struct A { float v; }; struct B { vec2 v; }; struct C { vec3 v; }; struct D { vec4 v; }; struct E { vec4 a; vec2 b; }; layout(std140, set = 0, binding = 0) buffer SSBO { A a[4]; B b[4]; C c[4]; D d[4]; mat2 e[4]; E f[]; }; void main() { f[0].a = vec4(2.0); mat2 tmp = e[1]; e[2] = tmp; } spirv-cross-2021.01.15/shaders-msl-no-opt/vert/000077500000000000000000000000001400026215700210065ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/vert/functions_nested.vert000066400000000000000000000067261400026215700252750ustar00rootroot00000000000000#version 450 #extension GL_ARB_separate_shader_objects : enable layout(std140, set = 0, binding = 0) uniform VertexBuffer { mat4 scale_offset_mat; uint vertex_base_index; ivec4 input_attributes[16]; }; layout(set=0, binding=3) uniform usamplerBuffer buff_in_1; layout(set=0, binding=4) uniform usamplerBuffer buff_in_2; layout(location=10) out vec4 back_color; layout(location=0) out vec4 tc0; layout(std140, set=0, binding = 1) uniform VertexConstantsBuffer { vec4 vc[16]; }; struct attr_desc { int type; int attribute_size; int starting_offset; int stride; int swap_bytes; int is_volatile; }; uint get_bits(uvec4 v, int swap) { if (swap != 0) return (v.w | v.z << 8 | v.y << 16 | v.x << 24); return (v.x | v.y << 8 | v.z << 16 | v.w << 24); } vec4 fetch_attr(attr_desc desc, int vertex_id, usamplerBuffer input_stream) { vec4 result = vec4(0.0f, 0.0f, 0.0f, 1.0f); uvec4 tmp; uint bits; bool reverse_order = false; int first_byte = (vertex_id * desc.stride) + desc.starting_offset; for (int n = 0; n < 4; n++) { if (n == desc.attribute_size) break; switch (desc.type) { case 0: //signed normalized 16-bit tmp.x = texelFetch(input_stream, first_byte++).x; tmp.y = texelFetch(input_stream, first_byte++).x; result[n] = get_bits(tmp, desc.swap_bytes); break; case 1: //float tmp.x = texelFetch(input_stream, first_byte++).x; tmp.y = texelFetch(input_stream, first_byte++).x; tmp.z = texelFetch(input_stream, first_byte++).x; tmp.w = texelFetch(input_stream, first_byte++).x; result[n] = uintBitsToFloat(get_bits(tmp, desc.swap_bytes)); break; case 2: //unsigned byte result[n] = texelFetch(input_stream, first_byte++).x; reverse_order = (desc.swap_bytes != 0); break; } } return (reverse_order)? result.wzyx: result; } attr_desc fetch_desc(int location) { attr_desc result; int attribute_flags = input_attributes[location].w; result.type = input_attributes[location].x; result.attribute_size = input_attributes[location].y; result.starting_offset = input_attributes[location].z; result.stride = attribute_flags & 0xFF; result.swap_bytes = (attribute_flags >> 8) & 0x1; result.is_volatile = (attribute_flags >> 9) & 0x1; return result; } vec4 read_location(int location) { attr_desc desc = fetch_desc(location); int vertex_id = gl_VertexIndex - int(vertex_base_index); if (desc.is_volatile != 0) return fetch_attr(desc, vertex_id, buff_in_2); else return fetch_attr(desc, vertex_id, buff_in_1); } void vs_adjust(inout vec4 dst_reg0, inout vec4 dst_reg1, inout vec4 dst_reg7) { vec4 tmp0; vec4 tmp1; vec4 in_diff_color= read_location(3); vec4 in_pos= read_location(0); vec4 in_tc0= read_location(8); dst_reg1 = (in_diff_color * vc[13]); tmp0.x = vec4(dot(vec4(in_pos.xyzx.xyz, 1.0), vc[4])).x; tmp0.y = vec4(dot(vec4(in_pos.xyzx.xyz, 1.0), vc[5])).y; tmp0.z = vec4(dot(vec4(in_pos.xyzx.xyz, 1.0), vc[6])).z; tmp1.xy = in_tc0.xyxx.xy; tmp1.z = vc[15].xxxx.z; dst_reg7.y = vec4(dot(vec4(tmp1.xyzx.xyz, 1.0), vc[8])).y; dst_reg7.x = vec4(dot(vec4(tmp1.xyzx.xyz, 1.0), vc[7])).x; dst_reg0.y = vec4(dot(vec4(tmp0.xyzx.xyz, 1.0), vc[1])).y; dst_reg0.x = vec4(dot(vec4(tmp0.xyzx.xyz, 1.0), vc[0])).x; } void main () { vec4 dst_reg0= vec4(0.0f, 0.0f, 0.0f, 1.0f); vec4 dst_reg1= vec4(0.0, 0.0, 0.0, 0.0); vec4 dst_reg7= vec4(0.0, 0.0, 0.0, 0.0); vs_adjust(dst_reg0, dst_reg1, dst_reg7); gl_Position = dst_reg0; back_color = dst_reg1; tc0 = dst_reg7; gl_Position = gl_Position * scale_offset_mat; } spirv-cross-2021.01.15/shaders-msl-no-opt/vert/layer.msl11.invalid.vert000066400000000000000000000002531400026215700254050ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_viewport_layer_array : require layout(location = 0) in vec4 coord; void main() { gl_Position = coord; gl_Layer = int(coord.z); } spirv-cross-2021.01.15/shaders-msl-no-opt/vert/pass-array-by-value.force-native-array.vert000066400000000000000000000011461400026215700312130ustar00rootroot00000000000000#version 310 es layout(location = 0) in int Index1; layout(location = 1) in int Index2; vec4 consume_constant_arrays2(const vec4 positions[4], const vec4 positions2[4]) { return positions[Index1] + positions2[Index2]; } vec4 consume_constant_arrays(const vec4 positions[4], const vec4 positions2[4]) { return consume_constant_arrays2(positions, positions2); } const vec4 LUT1[] = vec4[](vec4(0.0), vec4(1.0), vec4(2.0), vec4(3.0)); void main() { vec4 LUT2[4]; LUT2[0] = vec4(10.0); LUT2[1] = vec4(11.0); LUT2[2] = vec4(12.0); LUT2[3] = vec4(13.0); gl_Position = consume_constant_arrays(LUT1, LUT2); } spirv-cross-2021.01.15/shaders-msl-no-opt/vert/pass-array-by-value.vert000066400000000000000000000011461400026215700255160ustar00rootroot00000000000000#version 310 es layout(location = 0) in int Index1; layout(location = 1) in int Index2; vec4 consume_constant_arrays2(const vec4 positions[4], const vec4 positions2[4]) { return positions[Index1] + positions2[Index2]; } vec4 consume_constant_arrays(const vec4 positions[4], const vec4 positions2[4]) { return consume_constant_arrays2(positions, positions2); } const vec4 LUT1[] = vec4[](vec4(0.0), vec4(1.0), vec4(2.0), vec4(3.0)); void main() { vec4 LUT2[4]; LUT2[0] = vec4(10.0); LUT2[1] = vec4(11.0); LUT2[2] = vec4(12.0); LUT2[3] = vec4(13.0); gl_Position = consume_constant_arrays(LUT1, LUT2); } spirv-cross-2021.01.15/shaders-msl-no-opt/vert/uninitialized-vertex-output.vert000066400000000000000000000001341400026215700274270ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 Pos; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders-msl-no-opt/vert/unused-subgroup-builtin.msl22.vert000066400000000000000000000001451400026215700274610ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_ballot : require void main() { gl_SubgroupEqMask; } spirv-cross-2021.01.15/shaders-msl-no-opt/vert/viewport-index.msl2.invalid.vert000066400000000000000000000002631400026215700271760ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_viewport_layer_array : require layout(location = 0) in vec4 coord; void main() { gl_Position = coord; gl_ViewportIndex = int(coord.z); } spirv-cross-2021.01.15/shaders-msl-no-opt/vulkan/000077500000000000000000000000001400026215700213265ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/vulkan/frag/000077500000000000000000000000001400026215700222455ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl-no-opt/vulkan/frag/texture-access-function.swizzle.vk.frag000066400000000000000000000067461400026215700320320ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1D tex1d; layout(binding = 1) uniform texture2D tex2d; layout(binding = 2) uniform sampler3D tex3d; layout(binding = 3) uniform textureCube texCube; layout(binding = 4) uniform sampler2DArray tex2dArray; layout(binding = 5) uniform samplerCubeArray texCubeArray; layout(binding = 6) uniform samplerBuffer texBuffer; layout(binding = 7) uniform sampler2DShadow depth2d; layout(binding = 8) uniform samplerCubeShadow depthCube; layout(binding = 9) uniform texture2DArray depth2dArray; layout(binding = 10) uniform samplerCubeArrayShadow depthCubeArray; layout(binding = 11) uniform sampler defaultSampler; layout(binding = 12) uniform samplerShadow shadowSampler; layout(location = 0) out vec4 fragColor; vec4 do_samples(sampler1D t1, texture2D t2, sampler3D t3, textureCube tc, sampler2DArray t2a, samplerCubeArray tca, samplerBuffer tb, sampler2DShadow d2, samplerCubeShadow dc, texture2DArray d2a, samplerCubeArrayShadow dca) { // OpImageSampleImplicitLod vec4 c = texture(t1, 0.0); c = texture(sampler2D(t2, defaultSampler), vec2(0.0, 0.0)); c = texture(t3, vec3(0.0, 0.0, 0.0)); c = texture(samplerCube(tc, defaultSampler), vec3(0.0, 0.0, 0.0)); c = texture(t2a, vec3(0.0, 0.0, 0.0)); c = texture(tca, vec4(0.0, 0.0, 0.0, 0.0)); // OpImageSampleDrefImplicitLod c.r = texture(d2, vec3(0.0, 0.0, 1.0)); c.r = texture(dc, vec4(0.0, 0.0, 0.0, 1.0)); c.r = texture(sampler2DArrayShadow(d2a, shadowSampler), vec4(0.0, 0.0, 0.0, 1.0)); c.r = texture(dca, vec4(0.0, 0.0, 0.0, 0.0), 1.0); // OpImageSampleProjImplicitLod c = textureProj(t1, vec2(0.0, 1.0)); c = textureProj(sampler2D(t2, defaultSampler), vec3(0.0, 0.0, 1.0)); c = textureProj(t3, vec4(0.0, 0.0, 0.0, 1.0)); // OpImageSampleProjDrefImplicitLod c.r = textureProj(d2, vec4(0.0, 0.0, 1.0, 1.0)); // OpImageSampleExplicitLod c = textureLod(t1, 0.0, 0.0); c = textureLod(sampler2D(t2, defaultSampler), vec2(0.0, 0.0), 0.0); c = textureLod(t3, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(samplerCube(tc, defaultSampler), vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(t2a, vec3(0.0, 0.0, 0.0), 0.0); c = textureLod(tca, vec4(0.0, 0.0, 0.0, 0.0), 0.0); // OpImageSampleDrefExplicitLod c.r = textureLod(d2, vec3(0.0, 0.0, 1.0), 0.0); // OpImageSampleProjExplicitLod c = textureProjLod(t1, vec2(0.0, 1.0), 0.0); c = textureProjLod(sampler2D(t2, defaultSampler), vec3(0.0, 0.0, 1.0), 0.0); c = textureProjLod(t3, vec4(0.0, 0.0, 0.0, 1.0), 0.0); // OpImageSampleProjDrefExplicitLod c.r = textureProjLod(d2, vec4(0.0, 0.0, 1.0, 1.0), 0.0); // OpImageFetch c = texelFetch(t1, 0, 0); c = texelFetch(sampler2D(t2, defaultSampler), ivec2(0, 0), 0); c = texelFetch(t3, ivec3(0, 0, 0), 0); c = texelFetch(t2a, ivec3(0, 0, 0), 0); // Show that this transformation doesn't apply to Buffer images. c = texelFetch(tb, 0); // OpImageGather c = textureGather(sampler2D(t2, defaultSampler), vec2(0.0, 0.0), 0); c = textureGather(samplerCube(tc, defaultSampler), vec3(0.0, 0.0, 0.0), 1); c = textureGather(t2a, vec3(0.0, 0.0, 0.0), 2); c = textureGather(tca, vec4(0.0, 0.0, 0.0, 0.0), 3); // OpImageDrefGather c = textureGather(d2, vec2(0.0, 0.0), 1.0); c = textureGather(dc, vec3(0.0, 0.0, 0.0), 1.0); c = textureGather(sampler2DArrayShadow(d2a, shadowSampler), vec3(0.0, 0.0, 0.0), 1.0); c = textureGather(dca, vec4(0.0, 0.0, 0.0, 0.0), 1.0); return c; } void main() { fragColor = do_samples(tex1d, tex2d, tex3d, texCube, tex2dArray, texCubeArray, texBuffer, depth2d, depthCube, depth2dArray, depthCubeArray); } spirv-cross-2021.01.15/shaders-msl/000077500000000000000000000000001400026215700166145ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/amd/000077500000000000000000000000001400026215700173555ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/amd/shader_trinary_minmax.msl21.comp000066400000000000000000000003101400026215700255530ustar00rootroot00000000000000#version 450 #extension GL_AMD_shader_trinary_minmax : require layout (local_size_x = 64) in; void main () { int t11 = min3(0, 3, 2); int t12 = max3(0, 3, 2); int t13 = mid3(0, 3, 2); } spirv-cross-2021.01.15/shaders-msl/asm/000077500000000000000000000000001400026215700173745ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/asm/comp/000077500000000000000000000000001400026215700203325ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/asm/comp/atomic-decrement.asm.comp000066400000000000000000000050431400026215700252130ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "main" %15 OpExecutionMode %3 LocalSize 4 1 1 OpName %3 "main" OpName %8 "u0" OpName %9 "u0_counters" OpMemberName %9 0 "c" OpName %11 "u0_counter" OpName %15 "vThreadID" OpName %19 "r0" OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 1 OpDecorate %11 Binding 0 OpDecorate %15 BuiltIn GlobalInvocationId %1 = OpTypeVoid %2 = OpTypeFunction %1 %5 = OpTypeInt 32 0 %6 = OpTypeImage %5 Buffer 0 0 0 2 R32ui %7 = OpTypePointer UniformConstant %6 %8 = OpVariable %7 UniformConstant %9 = OpTypeStruct %5 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpTypeVector %12 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpTypeFloat 32 %17 = OpTypeVector %16 4 %18 = OpTypePointer Function %17 %20 = OpTypePointer Uniform %5 %21 = OpConstant %5 0 %23 = OpConstant %5 1 %26 = OpTypePointer Function %16 %33 = OpConstant %12 0 %34 = OpConstant %5 2 %37 = OpTypePointer Input %12 %41 = OpTypeVector %5 4 %3 = OpFunction %1 None %2 %4 = OpLabel %19 = OpVariable %18 Function %22 = OpAccessChain %20 %11 %21 %24 = OpAtomicIDecrement %5 %22 %23 %21 %25 = OpBitcast %16 %24 %27 = OpInBoundsAccessChain %26 %19 %21 OpStore %27 %25 %28 = OpLoad %6 %8 %29 = OpInBoundsAccessChain %26 %19 %21 %30 = OpLoad %16 %29 %31 = OpBitcast %12 %30 %32 = OpIMul %5 %31 %23 %35 = OpShiftRightLogical %5 %33 %34 %36 = OpIAdd %5 %32 %35 %38 = OpInBoundsAccessChain %37 %15 %21 %39 = OpLoad %12 %38 %40 = OpBitcast %5 %39 %42 = OpCompositeConstruct %41 %40 %40 %40 %40 OpImageWrite %28 %36 %42 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/atomic-increment.asm.comp000066400000000000000000000050431400026215700252310ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "main" %15 OpExecutionMode %3 LocalSize 4 1 1 OpName %3 "main" OpName %8 "u0" OpName %9 "u0_counters" OpMemberName %9 0 "c" OpName %11 "u0_counter" OpName %15 "vThreadID" OpName %19 "r0" OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 1 OpDecorate %11 Binding 0 OpDecorate %15 BuiltIn GlobalInvocationId %1 = OpTypeVoid %2 = OpTypeFunction %1 %5 = OpTypeInt 32 0 %6 = OpTypeImage %5 Buffer 0 0 0 2 R32ui %7 = OpTypePointer UniformConstant %6 %8 = OpVariable %7 UniformConstant %9 = OpTypeStruct %5 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpTypeVector %12 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpTypeFloat 32 %17 = OpTypeVector %16 4 %18 = OpTypePointer Function %17 %20 = OpTypePointer Uniform %5 %21 = OpConstant %5 0 %23 = OpConstant %5 1 %26 = OpTypePointer Function %16 %33 = OpConstant %12 0 %34 = OpConstant %5 2 %37 = OpTypePointer Input %12 %41 = OpTypeVector %5 4 %3 = OpFunction %1 None %2 %4 = OpLabel %19 = OpVariable %18 Function %22 = OpAccessChain %20 %11 %21 %24 = OpAtomicIIncrement %5 %22 %23 %21 %25 = OpBitcast %16 %24 %27 = OpInBoundsAccessChain %26 %19 %21 OpStore %27 %25 %28 = OpLoad %6 %8 %29 = OpInBoundsAccessChain %26 %19 %21 %30 = OpLoad %16 %29 %31 = OpBitcast %12 %30 %32 = OpIMul %5 %31 %23 %35 = OpShiftRightLogical %5 %33 %34 %36 = OpIAdd %5 %32 %35 %38 = OpInBoundsAccessChain %37 %15 %21 %39 = OpLoad %12 %38 %40 = OpBitcast %5 %39 %42 = OpCompositeConstruct %41 %40 %40 %40 %40 OpImageWrite %28 %36 %42 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/bitcast_iadd.asm.comp000066400000000000000000000061311400026215700244040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %inputs Restrict OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 OpDecorate %outputs Restrict %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of IAdd %result_iadd_0 = OpIAdd %uvec4 %input0 %input1 %result_iadd_1 = OpIAdd %uvec4 %input1 %input0 %result_iadd_2 = OpIAdd %uvec4 %input0 %input0 %result_iadd_3 = OpIAdd %uvec4 %input1 %input1 %result_iadd_4 = OpIAdd %ivec4 %input0 %input0 %result_iadd_5 = OpIAdd %ivec4 %input1 %input1 %result_iadd_6 = OpIAdd %ivec4 %input0 %input1 %result_iadd_7 = OpIAdd %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/bitcast_icmp.asm.comp000066400000000000000000000072541400026215700244420ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %inputs Restrict OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 OpDecorate %outputs Restrict %void = OpTypeVoid %main_func = OpTypeFunction %void %bool = OpTypeBool %bvec4 = OpTypeVector %bool 4 %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %uzero = OpConstant %uint 0 %uone = OpConstant %uint 1 %utrue = OpConstantComposite %uvec4 %uone %uone %uone %uone %ufalse = OpConstantComposite %uvec4 %uzero %uzero %uzero %uzero %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %result_slt = OpSLessThan %bvec4 %input0 %input1 %result_sle = OpSLessThanEqual %bvec4 %input0 %input1 %result_ult = OpULessThan %bvec4 %input0 %input1 %result_ule = OpULessThanEqual %bvec4 %input0 %input1 %result_sgt = OpSGreaterThan %bvec4 %input0 %input1 %result_sge = OpSGreaterThanEqual %bvec4 %input0 %input1 %result_ugt = OpUGreaterThan %bvec4 %input0 %input1 %result_uge = OpUGreaterThanEqual %bvec4 %input0 %input1 %int_slt = OpSelect %uvec4 %result_slt %utrue %ufalse OpStore %output_ptr_uvec4 %int_slt %int_sle = OpSelect %uvec4 %result_sle %utrue %ufalse OpStore %output_ptr_uvec4 %int_sle %int_ult = OpSelect %uvec4 %result_ult %utrue %ufalse OpStore %output_ptr_uvec4 %int_ult %int_ule = OpSelect %uvec4 %result_ule %utrue %ufalse OpStore %output_ptr_uvec4 %int_ule %int_sgt = OpSelect %uvec4 %result_sgt %utrue %ufalse OpStore %output_ptr_uvec4 %int_sgt %int_sge = OpSelect %uvec4 %result_sge %utrue %ufalse OpStore %output_ptr_uvec4 %int_sge %int_ugt = OpSelect %uvec4 %result_ugt %utrue %ufalse OpStore %output_ptr_uvec4 %int_ugt %int_uge = OpSelect %uvec4 %result_uge %utrue %ufalse OpStore %output_ptr_uvec4 %int_uge OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/bitcast_sar.asm.comp000066400000000000000000000062441400026215700242750ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of ShiftRightArithmetic %result_iadd_0 = OpShiftRightArithmetic %uvec4 %input0 %input1 %result_iadd_1 = OpShiftRightArithmetic %uvec4 %input1 %input0 %result_iadd_2 = OpShiftRightArithmetic %uvec4 %input0 %input0 %result_iadd_3 = OpShiftRightArithmetic %uvec4 %input1 %input1 %result_iadd_4 = OpShiftRightArithmetic %ivec4 %input0 %input0 %result_iadd_5 = OpShiftRightArithmetic %ivec4 %input1 %input1 %result_iadd_6 = OpShiftRightArithmetic %ivec4 %input0 %input1 %result_iadd_7 = OpShiftRightArithmetic %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/bitcast_sdiv.asm.comp000066400000000000000000000060241400026215700244510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of SDiv %result_iadd_0 = OpSDiv %uvec4 %input0 %input1 %result_iadd_1 = OpSDiv %uvec4 %input1 %input0 %result_iadd_2 = OpSDiv %uvec4 %input0 %input0 %result_iadd_3 = OpSDiv %uvec4 %input1 %input1 %result_iadd_4 = OpSDiv %ivec4 %input0 %input0 %result_iadd_5 = OpSDiv %ivec4 %input1 %input1 %result_iadd_6 = OpSDiv %ivec4 %input0 %input1 %result_iadd_7 = OpSDiv %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/bitcast_slr.asm.comp000066400000000000000000000062111400026215700243020ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of ShiftRightLogical %result_iadd_0 = OpShiftRightLogical %uvec4 %input0 %input1 %result_iadd_1 = OpShiftRightLogical %uvec4 %input1 %input0 %result_iadd_2 = OpShiftRightLogical %uvec4 %input0 %input0 %result_iadd_3 = OpShiftRightLogical %uvec4 %input1 %input1 %result_iadd_4 = OpShiftRightLogical %ivec4 %input0 %input0 %result_iadd_5 = OpShiftRightLogical %ivec4 %input1 %input1 %result_iadd_6 = OpShiftRightLogical %ivec4 %input0 %input1 %result_iadd_7 = OpShiftRightLogical %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/block-name-alias-global.asm.comp000066400000000000000000000120731400026215700263310ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 59 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Foo "A" OpMemberName %Foo 0 "a" OpMemberName %Foo 1 "b" OpName %A "A" OpMemberName %A 0 "Data" OpName %C1 "C1" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpName %Foo_0 "A" OpMemberName %Foo_0 0 "a" OpMemberName %Foo_0 1 "b" OpName %A_0 "A" OpMemberName %A_0 0 "Data" OpName %C2 "C2" OpName %B "B" OpMemberName %B 0 "Data" OpName %C3 "C3" OpName %B_0 "B" OpMemberName %B_0 0 "Data" OpName %C4 "C4" OpMemberDecorate %Foo 0 Offset 0 OpMemberDecorate %Foo 1 Offset 4 OpDecorate %_runtimearr_Foo ArrayStride 8 OpMemberDecorate %A 0 Offset 0 OpDecorate %A BufferBlock OpDecorate %C1 DescriptorSet 0 OpDecorate %C1 Binding 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %Foo_0 1 Offset 4 OpDecorate %_arr_Foo_0_uint_1024 ArrayStride 16 OpMemberDecorate %A_0 0 Offset 0 OpDecorate %A_0 Block OpDecorate %C2 DescriptorSet 0 OpDecorate %C2 Binding 2 OpDecorate %_runtimearr_Foo_0 ArrayStride 8 OpMemberDecorate %B 0 Offset 0 OpDecorate %B BufferBlock OpDecorate %C3 DescriptorSet 0 OpDecorate %C3 Binding 0 OpDecorate %_arr_Foo_0_uint_1024_0 ArrayStride 16 OpMemberDecorate %B_0 0 Offset 0 OpDecorate %B_0 Block OpDecorate %C4 DescriptorSet 0 OpDecorate %C4 Binding 3 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %Foo = OpTypeStruct %int %int %_runtimearr_Foo = OpTypeRuntimeArray %Foo %A = OpTypeStruct %_runtimearr_Foo %_ptr_Uniform_A = OpTypePointer Uniform %A %C1 = OpVariable %_ptr_Uniform_A Uniform %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %Foo_0 = OpTypeStruct %int %int %uint_1024 = OpConstant %uint 1024 %_arr_Foo_0_uint_1024 = OpTypeArray %Foo_0 %uint_1024 %A_0 = OpTypeStruct %_arr_Foo_0_uint_1024 %_ptr_Uniform_A_0 = OpTypePointer Uniform %A_0 %C2 = OpVariable %_ptr_Uniform_A_0 Uniform %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Uniform_Foo = OpTypePointer Uniform %Foo %_ptr_Uniform_int = OpTypePointer Uniform %int %int_1 = OpConstant %int 1 %_runtimearr_Foo_0 = OpTypeRuntimeArray %Foo %B = OpTypeStruct %_runtimearr_Foo_0 %_ptr_Uniform_B = OpTypePointer Uniform %B %C3 = OpVariable %_ptr_Uniform_B Uniform %_arr_Foo_0_uint_1024_0 = OpTypeArray %Foo_0 %uint_1024 %B_0 = OpTypeStruct %_arr_Foo_0_uint_1024_0 %_ptr_Uniform_B_0 = OpTypePointer Uniform %B_0 %C4 = OpVariable %_ptr_Uniform_B_0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %20 = OpLoad %uint %19 %27 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %28 = OpLoad %uint %27 %30 = OpAccessChain %_ptr_Uniform_Foo_0 %C2 %int_0 %28 %31 = OpLoad %Foo_0 %30 %33 = OpAccessChain %_ptr_Uniform_Foo %C1 %int_0 %20 %34 = OpCompositeExtract %int %31 0 %36 = OpAccessChain %_ptr_Uniform_int %33 %int_0 OpStore %36 %34 %37 = OpCompositeExtract %int %31 1 %39 = OpAccessChain %_ptr_Uniform_int %33 %int_1 OpStore %39 %37 %44 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %45 = OpLoad %uint %44 %50 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %51 = OpLoad %uint %50 %52 = OpAccessChain %_ptr_Uniform_Foo_0 %C4 %int_0 %51 %53 = OpLoad %Foo_0 %52 %54 = OpAccessChain %_ptr_Uniform_Foo %C3 %int_0 %45 %55 = OpCompositeExtract %int %53 0 %56 = OpAccessChain %_ptr_Uniform_int %54 %int_0 OpStore %56 %55 %57 = OpCompositeExtract %int %53 1 %58 = OpAccessChain %_ptr_Uniform_int %54 %int_1 OpStore %58 %57 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/buffer-write-relative-addr.asm.comp000066400000000000000000000077361400026215700271300ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 59 ; Schema: 0 OpCapability Shader OpCapability UniformBufferArrayDynamicIndexing OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %vThreadIDInGroup OpExecutionMode %main LocalSize 4 1 1 OpName %main "main" OpName %cb5_struct "cb5_struct" OpName %cb0_5 "cb0_5" OpName %u0 "u0" OpName %vThreadIDInGroup "vThreadIDInGroup" OpName %r0 "r0" OpDecorate %_arr_v4float_uint_5 ArrayStride 16 OpDecorate %cb5_struct Block OpMemberDecorate %cb5_struct 0 Offset 0 OpDecorate %cb0_5 DescriptorSet 0 OpDecorate %cb0_5 Binding 1 OpDecorate %u0 DescriptorSet 0 OpDecorate %u0 Binding 0 OpDecorate %u0 NonReadable OpDecorate %vThreadIDInGroup BuiltIn LocalInvocationId %void = OpTypeVoid %2 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_5 = OpConstant %uint 5 %_arr_v4float_uint_5 = OpTypeArray %v4float %uint_5 %cb5_struct = OpTypeStruct %_arr_v4float_uint_5 %_ptr_Uniform_cb5_struct = OpTypePointer Uniform %cb5_struct %cb0_5 = OpVariable %_ptr_Uniform_cb5_struct Uniform %13 = OpTypeImage %uint Buffer 0 0 0 2 R32ui %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %u0 = OpVariable %_ptr_UniformConstant_13 UniformConstant %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 %_ptr_Input_v3int = OpTypePointer Input %v3int %vThreadIDInGroup = OpVariable %_ptr_Input_v3int Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_int = OpTypePointer Input %int %uint_0 = OpConstant %uint 0 %int_4 = OpConstant %int 4 %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %v4uint = OpTypeVector %uint 4 %uint_3 = OpConstant %uint 3 %main = OpFunction %void None %2 %4 = OpLabel %r0 = OpVariable %_ptr_Function_v4float Function %24 = OpInBoundsAccessChain %_ptr_Input_int %vThreadIDInGroup %uint_0 %25 = OpLoad %int %24 %27 = OpShiftLeftLogical %int %25 %int_4 %28 = OpBitcast %float %27 %30 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_0 OpStore %30 %28 %31 = OpInBoundsAccessChain %_ptr_Input_int %vThreadIDInGroup %uint_0 %32 = OpLoad %int %31 %33 = OpBitcast %float %32 %35 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_1 OpStore %35 %33 %36 = OpLoad %13 %u0 %37 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_0 %38 = OpLoad %float %37 %39 = OpBitcast %uint %38 %41 = OpShiftRightLogical %uint %39 %uint_2 %42 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_1 %43 = OpLoad %float %42 %44 = OpBitcast %int %43 %45 = OpIAdd %uint %44 %uint_1 %47 = OpAccessChain %_ptr_Uniform_v4float %cb0_5 %uint_0 %45 %48 = OpLoad %v4float %47 %50 = OpBitcast %v4uint %48 %51 = OpVectorShuffle %v4uint %50 %50 0 0 0 0 OpImageWrite %36 %41 %51 %52 = OpVectorShuffle %v4uint %50 %50 1 1 1 1 %53 = OpIAdd %uint %41 %uint_1 OpImageWrite %36 %53 %52 %54 = OpVectorShuffle %v4uint %50 %50 2 2 2 2 %55 = OpIAdd %uint %41 %uint_2 OpImageWrite %36 %55 %54 %56 = OpVectorShuffle %v4uint %50 %50 3 3 3 3 %58 = OpIAdd %uint %41 %uint_3 OpImageWrite %36 %58 %56 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/buffer-write.asm.comp000066400000000000000000000045131400026215700243750ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 63 ; Schema: 0 OpCapability Shader OpCapability ImageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %group_id %group_index OpExecutionMode %main LocalSize 32 1 1 OpSource HLSL 500 OpName %main "main" OpName %cb "cb" OpMemberName %cb 0 "value" OpName %_ "" OpName %buffer "buffer" OpName %group_id "group_id" OpName %group_index "group_index" OpMemberDecorate %cb 0 Offset 0 OpDecorate %cb Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 7 OpDecorate %buffer DescriptorSet 0 OpDecorate %buffer Binding 0 OpDecorate %group_id BuiltIn WorkgroupId OpDecorate %group_index BuiltIn LocalInvocationIndex %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %cb = OpTypeStruct %float %_ptr_Uniform_cb = OpTypePointer Uniform %cb %_ = OpVariable %_ptr_Uniform_cb Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %34 = OpTypeImage %float Buffer 0 0 0 2 R32f %_ptr_UniformConstant_34 = OpTypePointer UniformConstant %34 %buffer = OpVariable %_ptr_UniformConstant_34 UniformConstant %_ptr_Input_v3uint = OpTypePointer Input %v3uint %group_id = OpVariable %_ptr_Input_v3uint Input %_ptr_Input_uint = OpTypePointer Input %uint %group_index = OpVariable %_ptr_Input_uint Input %main = OpFunction %void None %3 %5 = OpLabel %43 = OpLoad %v3uint %group_id %47 = OpLoad %uint %group_index %56 = OpCompositeExtract %uint %43 0 %57 = OpIMul %uint %uint_32 %56 %59 = OpIAdd %uint %57 %47 %60 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %61 = OpLoad %float %60 %62 = OpLoad %34 %buffer OpImageWrite %62 %59 %61 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/global-parameter-name-alias.asm.comp000066400000000000000000000101621400026215700272140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 61 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %id_1 OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 500 OpName %main "main" OpName %Load_u1_ "Load(u1;" OpName %size "size" OpName %_main_vu3_ "@main(vu3;" OpName %id "id" OpName %data "data" OpName %byteAddrTemp "byteAddrTemp" OpName %ssbo "ssbo" OpMemberName %ssbo 0 "@data" OpName %ssbo_0 "ssbo" OpName %param "param" OpName %id_0 "id" OpName %id_1 "id" OpName %param_0 "param" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %ssbo 0 NonWritable OpMemberDecorate %ssbo 0 Offset 0 OpDecorate %ssbo BufferBlock OpDecorate %ssbo_0 DescriptorSet 0 OpDecorate %ssbo_0 Binding 1 OpDecorate %id_1 BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %8 = OpTypeFunction %void %_ptr_Function_uint %v3uint = OpTypeVector %uint 3 %_ptr_Function_v3uint = OpTypePointer Function %v3uint %14 = OpTypeFunction %void %_ptr_Function_v3uint %v4uint = OpTypeVector %uint 4 %_ptr_Function_v4uint = OpTypePointer Function %v4uint %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_2 = OpConstant %int 2 %_runtimearr_uint = OpTypeRuntimeArray %uint %ssbo = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_ssbo = OpTypePointer Uniform %ssbo %ssbo_0 = OpVariable %_ptr_Uniform_ssbo Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %uint_4 = OpConstant %uint 4 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %id_1 = OpVariable %_ptr_Input_v3uint Input %main = OpFunction %void None %3 %5 = OpLabel %id_0 = OpVariable %_ptr_Function_v3uint Function %param_0 = OpVariable %_ptr_Function_v3uint Function %57 = OpLoad %v3uint %id_1 OpStore %id_0 %57 %59 = OpLoad %v3uint %id_0 OpStore %param_0 %59 %60 = OpFunctionCall %void %_main_vu3_ %param_0 OpReturn OpFunctionEnd %Load_u1_ = OpFunction %void None %8 %size = OpFunctionParameter %_ptr_Function_uint %11 = OpLabel %data = OpVariable %_ptr_Function_v4uint Function %byteAddrTemp = OpVariable %_ptr_Function_int Function %24 = OpLoad %uint %size %26 = OpShiftRightLogical %int %24 %int_2 OpStore %byteAddrTemp %26 %32 = OpLoad %int %byteAddrTemp %34 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %32 %35 = OpLoad %uint %34 %36 = OpLoad %int %byteAddrTemp %38 = OpIAdd %int %36 %int_1 %39 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpLoad %int %byteAddrTemp %42 = OpIAdd %int %41 %int_2 %43 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %42 %44 = OpLoad %uint %43 %45 = OpLoad %int %byteAddrTemp %47 = OpIAdd %int %45 %int_3 %48 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %47 %49 = OpLoad %uint %48 %50 = OpCompositeConstruct %v4uint %35 %40 %44 %49 OpStore %data %50 OpReturn OpFunctionEnd %_main_vu3_ = OpFunction %void None %14 %id = OpFunctionParameter %_ptr_Function_v3uint %17 = OpLabel %param = OpVariable %_ptr_Function_uint Function OpStore %param %uint_4 %53 = OpFunctionCall %void %Load_u1_ %param OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/image-load-store-short-vector.invalid.asm.comp000066400000000000000000000060241400026215700312060ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 44 ; Schema: 0 OpCapability Shader OpCapability StorageImageExtendedFormats %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %id_1 OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 500 OpName %main "main" OpName %_main_vu3_ "@main(vu3;" OpName %id "id" OpName %loaded "loaded" OpName %TargetTexture "TargetTexture" OpName %storeTemp "storeTemp" OpName %id_0 "id" OpName %id_1 "id" OpName %param "param" OpDecorate %TargetTexture DescriptorSet 0 OpDecorate %TargetTexture Binding 0 OpDecorate %id_1 BuiltIn WorkgroupId %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Function_v3uint = OpTypePointer Function %v3uint %9 = OpTypeFunction %void %_ptr_Function_v3uint %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %17 = OpTypeImage %float 2D 0 0 0 2 Rg32f %_ptr_UniformConstant_17 = OpTypePointer UniformConstant %17 %TargetTexture = OpVariable %_ptr_UniformConstant_17 UniformConstant %v2uint = OpTypeVector %uint 2 %float_1 = OpConstant %float 1 %uint_1 = OpConstant %uint 1 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %id_1 = OpVariable %_ptr_Input_v3uint Input %main = OpFunction %void None %3 %5 = OpLabel %id_0 = OpVariable %_ptr_Function_v3uint Function %param = OpVariable %_ptr_Function_v3uint Function %40 = OpLoad %v3uint %id_1 OpStore %id_0 %40 %42 = OpLoad %v3uint %id_0 OpStore %param %42 %43 = OpFunctionCall %void %_main_vu3_ %param OpReturn OpFunctionEnd %_main_vu3_ = OpFunction %void None %9 %id = OpFunctionParameter %_ptr_Function_v3uint %12 = OpLabel %loaded = OpVariable %_ptr_Function_v2float Function %storeTemp = OpVariable %_ptr_Function_v2float Function %20 = OpLoad %17 %TargetTexture %22 = OpLoad %v3uint %id %23 = OpVectorShuffle %v2uint %22 %22 0 1 %24 = OpImageRead %v2float %20 %23 OpStore %loaded %24 %26 = OpLoad %v2float %loaded %28 = OpCompositeConstruct %v2float %float_1 %float_1 %29 = OpFAdd %v2float %26 %28 OpStore %storeTemp %29 %30 = OpLoad %17 %TargetTexture %31 = OpLoad %v3uint %id %32 = OpVectorShuffle %v2uint %31 %31 0 1 %34 = OpCompositeConstruct %v2uint %uint_1 %uint_1 %35 = OpIAdd %v2uint %32 %34 %36 = OpLoad %v2float %storeTemp OpImageWrite %30 %35 %36 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/multiple-entry.asm.comp000066400000000000000000000074221400026215700247700ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func_alt "main2" %frag_in %frag_out OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpExecutionMode %func_alt OriginUpperLeft OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %inputs Restrict OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 OpDecorate %outputs Restrict OpDecorate %frag_in Location 0 OpDecorate %frag_out Location 0 %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %float = OpTypeFloat 32 %vec4 = OpTypeVector %float 4 %vec4_input_ptr = OpTypePointer Input %vec4 %vec4_output_ptr = OpTypePointer Output %vec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %frag_in = OpVariable %vec4_input_ptr Input %frag_out = OpVariable %vec4_output_ptr Output %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of IAdd %result_iadd_0 = OpIAdd %uvec4 %input0 %input1 %result_iadd_1 = OpIAdd %uvec4 %input1 %input0 %result_iadd_2 = OpIAdd %uvec4 %input0 %input0 %result_iadd_3 = OpIAdd %uvec4 %input1 %input1 %result_iadd_4 = OpIAdd %ivec4 %input0 %input0 %result_iadd_5 = OpIAdd %ivec4 %input1 %input1 %result_iadd_6 = OpIAdd %ivec4 %input0 %input1 %result_iadd_7 = OpIAdd %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd %func_alt = OpFunction %void None %main_func %block_alt = OpLabel %frag_input_value = OpLoad %vec4 %frag_in OpStore %frag_out %frag_input_value OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/quantize.asm.comp000066400000000000000000000045461400026215700236420ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 38 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %10 "SSBO0" OpMemberName %10 0 "scalar" OpMemberName %10 1 "vec2_val" OpMemberName %10 2 "vec3_val" OpMemberName %10 3 "vec4_val" OpName %12 "" OpMemberDecorate %10 0 Offset 0 OpMemberDecorate %10 1 Offset 8 OpMemberDecorate %10 2 Offset 16 OpMemberDecorate %10 3 Offset 32 OpDecorate %10 BufferBlock OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypeVector %6 3 %9 = OpTypeVector %6 4 %10 = OpTypeStruct %6 %7 %8 %9 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %13 = OpTypeInt 32 1 %14 = OpConstant %13 0 %15 = OpTypePointer Uniform %6 %20 = OpConstant %13 1 %21 = OpTypePointer Uniform %7 %26 = OpConstant %13 2 %27 = OpTypePointer Uniform %8 %32 = OpConstant %13 3 %33 = OpTypePointer Uniform %9 %4 = OpFunction %2 None %3 %5 = OpLabel %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %6 %16 %18 = OpQuantizeToF16 %6 %17 %19 = OpAccessChain %15 %12 %14 OpStore %19 %18 %22 = OpAccessChain %21 %12 %20 %23 = OpLoad %7 %22 %24 = OpQuantizeToF16 %7 %23 %25 = OpAccessChain %21 %12 %20 OpStore %25 %24 %28 = OpAccessChain %27 %12 %26 %29 = OpLoad %8 %28 %30 = OpQuantizeToF16 %8 %29 %31 = OpAccessChain %27 %12 %26 OpStore %31 %30 %34 = OpAccessChain %33 %12 %32 %35 = OpLoad %9 %34 %36 = OpQuantizeToF16 %9 %35 %37 = OpAccessChain %33 %12 %32 OpStore %37 %36 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/relaxed-block-layout.asm.comp000066400000000000000000000114051400026215700260210ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 63 ; Schema: 0 OpCapability Shader OpCapability StorageBuffer16BitAccess OpCapability StorageBuffer8BitAccess OpCapability UniformAndStorageBuffer8BitAccess OpExtension "SPV_KHR_8bit_storage" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_LocalInvocationID %gl_GlobalInvocationID %gl_WorkGroupID %gl_NumWorkGroups OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_shader_16bit_storage" OpSourceExtension "GL_EXT_shader_8bit_storage" OpName %main "main" OpName %foo "foo" OpMemberName %foo 0 "bar" OpMemberName %foo 1 "baz" OpMemberName %foo 2 "quux" OpMemberName %foo 3 "blah" OpMemberName %foo 4 "wibble" OpName %_ "" OpName %gl_LocalInvocationID "gl_LocalInvocationID" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpName %gl_WorkGroupID "gl_WorkGroupID" OpName %gl_NumWorkGroups "gl_NumWorkGroups" OpMemberDecorate %foo 0 Offset 0 OpMemberDecorate %foo 1 Offset 4 OpMemberDecorate %foo 2 Offset 16 OpMemberDecorate %foo 3 Offset 17 OpMemberDecorate %foo 4 Offset 22 OpDecorate %foo BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %gl_NumWorkGroups BuiltIn NumWorkgroups %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %uchar = OpTypeInt 8 0 %v4uchar = OpTypeVector %uchar 4 %half = OpTypeFloat 16 %v2half = OpTypeVector %half 2 %foo = OpTypeStruct %uint %v3float %uchar %v4uchar %v2half %_ptr_Uniform_foo = OpTypePointer Uniform %foo %_ = OpVariable %_ptr_Uniform_foo Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_1 = OpConstant %int 1 %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %int_3 = OpConstant %int 3 %_ptr_Uniform_v4uchar = OpTypePointer Uniform %v4uchar %v4uint = OpTypeVector %uint 4 %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %int_4 = OpConstant %int 4 %_ptr_Uniform_v2half = OpTypePointer Uniform %v2half %v2float = OpTypeVector %float 2 %gl_NumWorkGroups = OpVariable %_ptr_Input_v3uint Input %v2uint = OpTypeVector %uint 2 %main = OpFunction %void None %3 %5 = OpLabel %23 = OpAccessChain %_ptr_Input_uint %gl_LocalInvocationID %uint_0 %24 = OpLoad %uint %23 %26 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 OpStore %26 %24 %29 = OpLoad %v3uint %gl_GlobalInvocationID %30 = OpConvertUToF %v3float %29 %32 = OpAccessChain %_ptr_Uniform_v3float %_ %int_1 OpStore %32 %30 %35 = OpAccessChain %_ptr_Uniform_v4uchar %_ %int_3 %36 = OpLoad %v4uchar %35 %38 = OpUConvert %v4uint %36 %39 = OpVectorShuffle %v3uint %38 %38 0 1 2 %41 = OpLoad %v3uint %gl_WorkGroupID %42 = OpIAdd %v3uint %39 %41 %43 = OpCompositeExtract %uint %42 0 %44 = OpCompositeExtract %uint %42 1 %45 = OpCompositeExtract %uint %42 2 %46 = OpCompositeConstruct %v4uint %43 %44 %45 %uint_0 %47 = OpUConvert %v4uchar %46 %48 = OpAccessChain %_ptr_Uniform_v4uchar %_ %int_3 OpStore %48 %47 %51 = OpAccessChain %_ptr_Uniform_v2half %_ %int_4 %52 = OpLoad %v2half %51 %54 = OpFConvert %v2float %52 %57 = OpLoad %v3uint %gl_NumWorkGroups %58 = OpVectorShuffle %v2uint %57 %57 0 1 %59 = OpConvertUToF %v2float %58 %60 = OpFMul %v2float %54 %59 %61 = OpFConvert %v2half %60 %62 = OpAccessChain %_ptr_Uniform_v2half %_ %int_4 OpStore %62 %61 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/specialization-constant-workgroup.asm.comp000066400000000000000000000033751400026215700307030ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 24 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 20 1 OpSource ESSL 310 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %19 SpecId 10 OpDecorate %21 SpecId 12 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %SSBO = OpTypeStruct %float %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %uint = OpTypeInt 32 0 %19 = OpSpecConstant %uint 9 %uint_20 = OpConstant %uint 20 %21 = OpSpecConstant %uint 4 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %19 %uint_20 %21 %main = OpFunction %void None %3 %5 = OpLabel %14 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %15 = OpLoad %float %14 %16 = OpFAdd %float %15 %float_1 %17 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %17 %16 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/struct-resource-name-aliasing.asm.comp000066400000000000000000000035431400026215700276520ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 21 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 8 8 1 OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %bufA "bufA" OpMemberName %bufA 0 "@data" OpName %bufA_0 "bufA" OpName %bufB "bufB" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %bufA 0 Offset 0 OpDecorate %bufA BufferBlock OpDecorate %bufA_0 DescriptorSet 0 OpDecorate %bufB DescriptorSet 0 OpDecorate %bufA_0 Binding 0 OpDecorate %bufB Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %bufA = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_bufA = OpTypePointer Uniform %bufA %bufA_0 = OpVariable %_ptr_Uniform_bufA Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bufB = OpVariable %_ptr_Uniform_bufA Uniform %main = OpFunction %void None %3 %5 = OpLabel %20 = OpFunctionCall %void %_main_ OpReturn OpFunctionEnd %_main_ = OpFunction %void None %3 %7 = OpLabel %17 = OpAccessChain %_ptr_Uniform_uint %bufA_0 %int_0 %int_0 OpStore %17 %uint_0 %19 = OpAccessChain %_ptr_Uniform_uint %bufB %int_0 %int_0 OpStore %19 %uint_0 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/variable-pointers-2.asm.comp000066400000000000000000000117611400026215700255640ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 65 ; Schema: 0 OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID %gl_LocalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %foo "foo" OpMemberName %foo 0 "a" OpMemberName %foo 1 "b" OpMemberName %foo 2 "c" OpName %bar "bar" OpMemberName %bar 0 "d" OpName %buf "buf" OpName %cb "cb" OpName %select_buffer "select_buffer" OpName %select_input "select_input" OpName %a "a" OpMemberDecorate %foo 0 Offset 0 OpMemberDecorate %foo 1 Offset 512 OpMemberDecorate %foo 2 Offset 520 OpMemberDecorate %bar 0 Offset 0 OpDecorate %foo Block OpDecorate %bar Block OpDecorate %buf DescriptorSet 0 OpDecorate %buf Binding 0 OpDecorate %cb DescriptorSet 0 OpDecorate %cb Binding 1 OpDecorate %_ptr_StorageBuffer_int ArrayStride 4 OpDecorate %_arr_int_uint_128 ArrayStride 4 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId %void = OpTypeVoid %15 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_128 = OpConstant %uint 128 %_arr_int_uint_128 = OpTypeArray %int %uint_128 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %foo = OpTypeStruct %_arr_int_uint_128 %uint %v2float %_ptr_StorageBuffer_foo = OpTypePointer StorageBuffer %foo %buf = OpVariable %_ptr_StorageBuffer_foo StorageBuffer %bar = OpTypeStruct %int %_ptr_Uniform_bar = OpTypePointer Uniform %bar %cb = OpVariable %_ptr_Uniform_bar Uniform %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %_ptr_Uniform_int = OpTypePointer Uniform %int %28 = OpTypeFunction %_ptr_StorageBuffer_foo %_ptr_StorageBuffer_foo %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %31 = OpConstantNull %_ptr_StorageBuffer_foo %32 = OpTypeFunction %_ptr_Input_v3uint %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %_ptr_Function__ptr_StorageBuffer_foo = OpTypePointer Function %_ptr_StorageBuffer_foo %select_buffer = OpFunction %_ptr_StorageBuffer_foo None %28 %a = OpFunctionParameter %_ptr_StorageBuffer_foo %33 = OpLabel %34 = OpAccessChain %_ptr_Uniform_int %cb %uint_0 %35 = OpLoad %int %34 %36 = OpINotEqual %bool %35 %int_0 %37 = OpSelect %_ptr_StorageBuffer_foo %36 %a %31 OpReturnValue %37 OpFunctionEnd %select_input = OpFunction %_ptr_Input_v3uint None %32 %38 = OpLabel %39 = OpAccessChain %_ptr_Uniform_int %cb %uint_0 %40 = OpLoad %int %39 %41 = OpINotEqual %bool %40 %int_0 %42 = OpSelect %_ptr_Input_v3uint %41 %gl_GlobalInvocationID %gl_LocalInvocationID OpReturnValue %42 OpFunctionEnd %main = OpFunction %void None %15 %43 = OpLabel %65 = OpVariable %_ptr_Function__ptr_StorageBuffer_foo Function %44 = OpFunctionCall %_ptr_StorageBuffer_foo %select_buffer %buf OpStore %65 %44 %45 = OpFunctionCall %_ptr_Input_v3uint %select_input %66 = OpLoad %_ptr_StorageBuffer_foo %65 %46 = OpAccessChain %_ptr_StorageBuffer_int %66 %uint_0 %uint_0 %47 = OpAccessChain %_ptr_StorageBuffer_int %buf %uint_0 %uint_0 OpBranch %48 %48 = OpLabel %49 = OpPhi %_ptr_StorageBuffer_int %46 %43 %50 %51 %52 = OpPhi %_ptr_StorageBuffer_int %47 %43 %53 %51 %54 = OpLoad %int %49 %55 = OpLoad %int %52 %56 = OpINotEqual %bool %54 %55 OpLoopMerge %58 %51 None OpBranchConditional %56 %57 %58 %57 = OpLabel %59 = OpIAdd %int %54 %55 %60 = OpLoad %v3uint %45 %61 = OpCompositeExtract %uint %60 0 %62 = OpBitcast %int %61 %63 = OpIAdd %int %59 %62 OpStore %49 %63 OpStore %52 %63 OpBranch %51 %51 = OpLabel %50 = OpPtrAccessChain %_ptr_StorageBuffer_int %49 %uint_1 %53 = OpPtrAccessChain %_ptr_StorageBuffer_int %52 %uint_1 OpBranch %48 %58 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/variable-pointers-store-forwarding.asm.comp000066400000000000000000000062541400026215700307200ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 40 ; Schema: 0 OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %foo "foo" OpMemberName %foo 0 "a" OpName %bar "bar" OpMemberName %bar 0 "b" OpName %x "x" OpName %y "y" OpName %a "a" OpName %b "b" OpMemberDecorate %foo 0 Offset 0 OpMemberDecorate %bar 0 Offset 0 OpDecorate %foo Block OpDecorate %bar Block OpDecorate %x DescriptorSet 0 OpDecorate %x Binding 0 OpDecorate %y DescriptorSet 0 OpDecorate %y Binding 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId %void = OpTypeVoid %11 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %foo = OpTypeStruct %int %_ptr_StorageBuffer_foo = OpTypePointer StorageBuffer %foo %x = OpVariable %_ptr_StorageBuffer_foo StorageBuffer %bar = OpTypeStruct %int %_ptr_StorageBuffer_bar = OpTypePointer StorageBuffer %bar %y = OpVariable %_ptr_StorageBuffer_bar StorageBuffer %uint_0 = OpConstant %uint 0 %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %22 = OpTypeFunction %_ptr_StorageBuffer_int %_ptr_StorageBuffer_foo %_ptr_StorageBuffer_bar %_ptr_Function__ptr_StorageBuffer_int = OpTypePointer Function %_ptr_StorageBuffer_int %24 = OpFunction %_ptr_StorageBuffer_int None %22 %a = OpFunctionParameter %_ptr_StorageBuffer_foo %b = OpFunctionParameter %_ptr_StorageBuffer_bar %25 = OpLabel %26 = OpLoad %v3uint %gl_GlobalInvocationID %27 = OpCompositeExtract %uint %26 0 %28 = OpINotEqual %bool %27 %uint_0 %29 = OpAccessChain %_ptr_StorageBuffer_int %a %uint_0 %30 = OpAccessChain %_ptr_StorageBuffer_int %b %uint_0 %31 = OpSelect %_ptr_StorageBuffer_int %28 %29 %30 OpReturnValue %31 OpFunctionEnd %main = OpFunction %void None %11 %32 = OpLabel %33 = OpVariable %_ptr_Function__ptr_StorageBuffer_int Function %34 = OpFunctionCall %_ptr_StorageBuffer_int %24 %x %y OpStore %33 %34 %35 = OpLoad %_ptr_StorageBuffer_int %33 %36 = OpAccessChain %_ptr_StorageBuffer_int %x %uint_0 %37 = OpLoad %int %36 OpStore %35 %int_0 %38 = OpIAdd %int %37 %37 %39 = OpAccessChain %_ptr_StorageBuffer_int %y %uint_0 OpStore %39 %38 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/vector-builtin-type-cast-func.asm.comp000066400000000000000000000134601400026215700276030ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 90 ; Schema: 0 OpCapability Shader OpCapability ImageQuery OpCapability StorageImageWriteWithoutFormat %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_LocalInvocationID OpExecutionMode %main LocalSize 16 16 1 OpSource GLSL 450 OpName %main "main" OpName %get_texcoord_vi2_vi2_ "get_texcoord(vi2;vi2;" OpName %base "base" OpName %index "index" OpName %gl_LocalInvocationID "gl_LocalInvocationID" OpName %r0 "r0" OpName %u0 "u0" OpName %i "i" OpName %j "j" OpName %param "param" OpName %param_0 "param" OpName %cb1_struct "cb1_struct" OpMemberName %cb1_struct 0 "_m0" OpName %cb0_1 "cb0_1" OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %u0 DescriptorSet 0 OpDecorate %u0 Binding 1 OpDecorate %u0 NonReadable OpDecorate %_arr_v4float_uint_1 ArrayStride 16 OpMemberDecorate %cb1_struct 0 Offset 0 OpDecorate %cb1_struct Block OpDecorate %cb0_1 DescriptorSet 0 OpDecorate %cb0_1 Binding 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %_ptr_Function_v2int = OpTypePointer Function %v2int %9 = OpTypeFunction %v2int %_ptr_Function_v2int %_ptr_Function_v2int %v3int = OpTypeVector %int 3 %_ptr_Input_v3int = OpTypePointer Input %v3int %gl_LocalInvocationID = OpVariable %_ptr_Input_v3int Input %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %float = OpTypeFloat 32 %30 = OpTypeImage %float 2D 0 0 0 2 Unknown %_ptr_UniformConstant_30 = OpTypePointer UniformConstant %30 %u0 = OpVariable %_ptr_UniformConstant_30 UniformConstant %uint_4 = OpConstant %uint 4 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %v4float = OpTypeVector %float 4 %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %cb1_struct = OpTypeStruct %_arr_v4float_uint_1 %_ptr_Uniform_cb1_struct = OpTypePointer Uniform %cb1_struct %cb0_1 = OpVariable %_ptr_Uniform_cb1_struct Uniform %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_1 = OpConstant %int 1 %uint_16 = OpConstant %uint 16 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %r0 = OpVariable %_ptr_Function_v2int Function %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function %param = OpVariable %_ptr_Function_v2int Function %param_0 = OpVariable %_ptr_Function_v2int Function %33 = OpLoad %30 %u0 %34 = OpImageQuerySize %v2int %33 %36 = OpCompositeConstruct %v2uint %uint_4 %uint_4 %37 = OpShiftRightArithmetic %v2int %34 %36 %38 = OpCompositeExtract %int %37 0 %39 = OpCompositeExtract %int %37 1 %40 = OpCompositeConstruct %v2int %38 %39 OpStore %r0 %40 OpStore %i %int_0 OpBranch %44 %44 = OpLabel OpLoopMerge %46 %47 None OpBranch %48 %48 = OpLabel %49 = OpLoad %int %i %51 = OpAccessChain %_ptr_Function_int %r0 %uint_1 %52 = OpLoad %int %51 %54 = OpSLessThan %bool %49 %52 OpBranchConditional %54 %45 %46 %45 = OpLabel OpStore %j %int_0 OpBranch %56 %56 = OpLabel OpLoopMerge %58 %59 None OpBranch %60 %60 = OpLabel %61 = OpLoad %int %j %63 = OpAccessChain %_ptr_Function_int %r0 %uint_0 %64 = OpLoad %int %63 %65 = OpSLessThan %bool %61 %64 OpBranchConditional %65 %57 %58 %57 = OpLabel %66 = OpLoad %30 %u0 %67 = OpLoad %int %i %68 = OpLoad %int %j %69 = OpCompositeConstruct %v2int %67 %68 %71 = OpLoad %v2int %r0 OpStore %param %71 OpStore %param_0 %69 %73 = OpFunctionCall %v2int %get_texcoord_vi2_vi2_ %param %param_0 %80 = OpAccessChain %_ptr_Uniform_v4float %cb0_1 %int_0 %int_0 %81 = OpLoad %v4float %80 %82 = OpVectorShuffle %v4float %81 %81 0 0 0 0 OpImageWrite %66 %73 %82 OpBranch %59 %59 = OpLabel %83 = OpLoad %int %j %85 = OpIAdd %int %83 %int_1 OpStore %j %85 OpBranch %56 %58 = OpLabel OpBranch %47 %47 = OpLabel %86 = OpLoad %int %i %87 = OpIAdd %int %86 %int_1 OpStore %i %87 OpBranch %44 %46 = OpLabel OpReturn OpFunctionEnd %get_texcoord_vi2_vi2_ = OpFunction %v2int None %9 %base = OpFunctionParameter %_ptr_Function_v2int %index = OpFunctionParameter %_ptr_Function_v2int %13 = OpLabel %14 = OpLoad %v2int %base %20 = OpLoad %v3int %gl_LocalInvocationID %21 = OpVectorShuffle %v2int %20 %20 0 1 %23 = OpIMul %v2int %14 %21 %24 = OpLoad %v2int %index %25 = OpIAdd %v2int %23 %24 OpReturnValue %25 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/comp/vector-builtin-type-cast.asm.comp000066400000000000000000000117071400026215700266540ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 78 ; Schema: 0 OpCapability Shader OpCapability ImageQuery OpCapability StorageImageWriteWithoutFormat %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_LocalInvocationID OpExecutionMode %main LocalSize 16 16 1 OpSource GLSL 450 OpName %main "main" OpName %r0 "r0" OpName %u0 "u0" OpName %i "i" OpName %j "j" OpName %gl_LocalInvocationID "gl_LocalInvocationID" OpName %cb1_struct "cb1_struct" OpMemberName %cb1_struct 0 "_m0" OpName %cb0_1 "cb0_1" OpDecorate %u0 DescriptorSet 0 OpDecorate %u0 Binding 1 OpDecorate %u0 NonReadable OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %_arr_v4float_uint_1 ArrayStride 16 OpMemberDecorate %cb1_struct 0 Offset 0 OpDecorate %cb1_struct Block OpDecorate %cb0_1 DescriptorSet 0 OpDecorate %cb0_1 Binding 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %_ptr_Function_v2int = OpTypePointer Function %v2int %float = OpTypeFloat 32 %11 = OpTypeImage %float 2D 0 0 0 2 Unknown %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %u0 = OpVariable %_ptr_UniformConstant_11 UniformConstant %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %v2uint = OpTypeVector %uint 2 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %v3int = OpTypeVector %int 3 %_ptr_Input_v3int = OpTypePointer Input %v3int %gl_LocalInvocationID = OpVariable %_ptr_Input_v3int Input %v4float = OpTypeVector %float 4 %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %cb1_struct = OpTypeStruct %_arr_v4float_uint_1 %_ptr_Uniform_cb1_struct = OpTypePointer Uniform %cb1_struct %cb0_1 = OpVariable %_ptr_Uniform_cb1_struct Uniform %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_1 = OpConstant %int 1 %uint_16 = OpConstant %uint 16 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %r0 = OpVariable %_ptr_Function_v2int Function %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function %14 = OpLoad %11 %u0 %15 = OpImageQuerySize %v2int %14 %19 = OpCompositeConstruct %v2uint %uint_4 %uint_4 %20 = OpShiftRightArithmetic %v2int %15 %19 %21 = OpCompositeExtract %int %20 0 %22 = OpCompositeExtract %int %20 1 %23 = OpCompositeConstruct %v2int %21 %22 OpStore %r0 %23 OpStore %i %int_0 OpBranch %27 %27 = OpLabel OpLoopMerge %29 %30 None OpBranch %31 %31 = OpLabel %32 = OpLoad %int %i %34 = OpAccessChain %_ptr_Function_int %r0 %uint_1 %35 = OpLoad %int %34 %37 = OpSLessThan %bool %32 %35 OpBranchConditional %37 %28 %29 %28 = OpLabel OpStore %j %int_0 OpBranch %39 %39 = OpLabel OpLoopMerge %41 %42 None OpBranch %43 %43 = OpLabel %44 = OpLoad %int %j %46 = OpAccessChain %_ptr_Function_int %r0 %uint_0 %47 = OpLoad %int %46 %48 = OpSLessThan %bool %44 %47 OpBranchConditional %48 %40 %41 %40 = OpLabel %49 = OpLoad %11 %u0 %50 = OpLoad %v2int %r0 %54 = OpLoad %v3int %gl_LocalInvocationID %55 = OpVectorShuffle %v2int %54 %54 0 1 %57 = OpIMul %v2int %50 %55 %58 = OpLoad %int %i %59 = OpLoad %int %j %60 = OpCompositeConstruct %v2int %58 %59 %61 = OpIAdd %v2int %57 %60 %68 = OpAccessChain %_ptr_Uniform_v4float %cb0_1 %int_0 %int_0 %69 = OpLoad %v4float %68 %70 = OpVectorShuffle %v4float %69 %69 0 0 0 0 OpImageWrite %49 %61 %70 OpBranch %42 %42 = OpLabel %71 = OpLoad %int %j %73 = OpIAdd %int %71 %int_1 OpStore %j %73 OpBranch %39 %41 = OpLabel OpBranch %30 %30 = OpLabel %74 = OpLoad %int %i %75 = OpIAdd %int %74 %int_1 OpStore %i %75 OpBranch %27 %29 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/000077500000000000000000000000001400026215700203135ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/asm/frag/combined-sampler-reuse.asm.frag000066400000000000000000000044421400026215700263010ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 36 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vUV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %uTex "uTex" OpName %uSampler "uSampler" OpName %vUV "vUV" OpDecorate %FragColor Location 0 OpDecorate %uTex DescriptorSet 0 OpDecorate %uTex Binding 1 OpDecorate %uSampler DescriptorSet 0 OpDecorate %uSampler Binding 0 OpDecorate %vUV Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %uTex = OpVariable %_ptr_UniformConstant_10 UniformConstant %14 = OpTypeSampler %_ptr_UniformConstant_14 = OpTypePointer UniformConstant %14 %uSampler = OpVariable %_ptr_UniformConstant_14 UniformConstant %18 = OpTypeSampledImage %10 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %int_1 = OpConstant %int 1 %32 = OpConstantComposite %v2int %int_1 %int_1 %main = OpFunction %void None %3 %5 = OpLabel %13 = OpLoad %10 %uTex %17 = OpLoad %14 %uSampler %19 = OpSampledImage %18 %13 %17 %23 = OpLoad %v2float %vUV %24 = OpImageSampleImplicitLod %v4float %19 %23 OpStore %FragColor %24 %28 = OpLoad %v2float %vUV %33 = OpImageSampleImplicitLod %v4float %19 %28 ConstOffset %32 %34 = OpLoad %v4float %FragColor %35 = OpFAdd %v4float %34 %33 OpStore %FragColor %35 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/default-member-names.asm.frag000066400000000000000000000045351400026215700257340ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 43 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %12 = OpTypeFunction %v4float %_struct_5 = OpTypeStruct %float %_struct_6 = OpTypeStruct %float %float %float %float %float %float %float %float %float %float %float %float %_struct_5 %_ptr_Function__struct_6 = OpTypePointer Function %_struct_6 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Function_float = OpTypePointer Function %float %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %2 = OpFunction %void None %9 %22 = OpLabel %23 = OpVariable %_ptr_Function__struct_6 Function %24 = OpAccessChain %_ptr_Function_float %23 %int_0 %25 = OpLoad %float %24 %26 = OpAccessChain %_ptr_Function_float %23 %int_1 %27 = OpLoad %float %26 %28 = OpAccessChain %_ptr_Function_float %23 %int_2 %29 = OpLoad %float %28 %30 = OpAccessChain %_ptr_Function_float %23 %int_3 %31 = OpLoad %float %30 %32 = OpCompositeConstruct %v4float %25 %27 %29 %31 OpStore %3 %32 OpReturn OpFunctionEnd %4 = OpFunction %v4float None %12 %33 = OpLabel %7 = OpVariable %_ptr_Function__struct_6 Function %34 = OpAccessChain %_ptr_Function_float %7 %int_0 %35 = OpLoad %float %34 %36 = OpAccessChain %_ptr_Function_float %7 %int_1 %37 = OpLoad %float %36 %38 = OpAccessChain %_ptr_Function_float %7 %int_2 %39 = OpLoad %float %38 %40 = OpAccessChain %_ptr_Function_float %7 %int_3 %41 = OpLoad %float %40 %42 = OpCompositeConstruct %v4float %35 %37 %39 %41 OpReturnValue %42 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/descriptor-array-unnamed.asm.frag000066400000000000000000000054101400026215700266520ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 39 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %FragColor Location 0 OpMemberDecorate %SSBO 0 NonWritable OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %ssbos DescriptorSet 0 OpDecorate %ssbos Binding 5 OpMemberDecorate %Registers 0 Offset 0 OpDecorate %Registers Block OpMemberDecorate %UBO 0 Offset 0 OpDecorate %UBO Block OpDecorate %ubos DescriptorSet 0 OpDecorate %ubos Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %SSBO = OpTypeStruct %v4float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %_arr_SSBO_uint_4 = OpTypeArray %SSBO %uint_4 %_ptr_Uniform__arr_SSBO_uint_4 = OpTypePointer Uniform %_arr_SSBO_uint_4 %ssbos = OpVariable %_ptr_Uniform__arr_SSBO_uint_4 Uniform %int = OpTypeInt 32 1 %Registers = OpTypeStruct %int %_ptr_PushConstant_Registers = OpTypePointer PushConstant %Registers %registers = OpVariable %_ptr_PushConstant_Registers PushConstant %int_0 = OpConstant %int 0 %_ptr_PushConstant_int = OpTypePointer PushConstant %int %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %UBO = OpTypeStruct %v4float %_arr_UBO_uint_4 = OpTypeArray %UBO %uint_4 %_ptr_Uniform__arr_UBO_uint_4 = OpTypePointer Uniform %_arr_UBO_uint_4 %ubos = OpVariable %_ptr_Uniform__arr_UBO_uint_4 Uniform %float_0_200000003 = OpConstant %float 0.200000003 %36 = OpConstantComposite %v4float %float_0_200000003 %float_0_200000003 %float_0_200000003 %float_0_200000003 %main = OpFunction %void None %3 %5 = OpLabel %22 = OpAccessChain %_ptr_PushConstant_int %registers %int_0 %23 = OpLoad %int %22 %25 = OpAccessChain %_ptr_Uniform_v4float %ssbos %23 %int_0 %26 = OpLoad %v4float %25 %31 = OpAccessChain %_ptr_PushConstant_int %registers %int_0 %32 = OpLoad %int %31 %33 = OpAccessChain %_ptr_Uniform_v4float %ubos %32 %int_0 %34 = OpLoad %v4float %33 %37 = OpFMul %v4float %34 %36 %38 = OpFAdd %v4float %26 %37 OpStore %FragColor %38 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/disable-renamed-output.frag-output.asm.frag000066400000000000000000000071261400026215700305670ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 37 ; Schema: 0 OpCapability Shader OpCapability StencilExportEXT OpExtension "SPV_EXT_shader_stencil_export" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o0 %o1 %o2 %o3 %o4 %o5 %o6 %o7 %oDepth %oStencil OpExecutionMode %main OriginUpperLeft OpExecutionMode %main DepthReplacing OpSource GLSL 450 OpSourceExtension "GL_ARB_shader_stencil_export" OpName %main "main" OpName %o0 "o0" OpName %o1 "o1" OpName %o2 "o2" OpName %o3 "o3" OpName %o4 "o4" OpName %o5 "o5" OpName %o6 "o6" OpName %o7 "o7" OpName %oDepth "oDepth" OpName %oStencil "oStencil" OpDecorate %o0 Location 0 OpDecorate %o1 Location 1 OpDecorate %o2 Location 2 OpDecorate %o3 Location 3 OpDecorate %o4 Location 4 OpDecorate %o5 Location 5 OpDecorate %o6 Location 6 OpDecorate %o7 Location 7 OpDecorate %oDepth BuiltIn FragDepth OpDecorate %oStencil BuiltIn FragStencilRefEXT %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %o0 = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %12 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1 %o1 = OpVariable %_ptr_Output_v4float Output %14 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %o2 = OpVariable %_ptr_Output_v4float Output %16 = OpConstantComposite %v4float %float_0 %float_1 %float_0 %float_1 %o3 = OpVariable %_ptr_Output_v4float Output %18 = OpConstantComposite %v4float %float_0 %float_0 %float_1 %float_1 %o4 = OpVariable %_ptr_Output_v4float Output %float_0_5 = OpConstant %float 0.5 %21 = OpConstantComposite %v4float %float_1 %float_0 %float_1 %float_0_5 %o5 = OpVariable %_ptr_Output_v4float Output %float_0_25 = OpConstant %float 0.25 %24 = OpConstantComposite %v4float %float_0_25 %float_0_25 %float_0_25 %float_0_25 %o6 = OpVariable %_ptr_Output_v4float Output %float_0_75 = OpConstant %float 0.75 %27 = OpConstantComposite %v4float %float_0_75 %float_0_75 %float_0_75 %float_0_75 %o7 = OpVariable %_ptr_Output_v4float Output %29 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_float = OpTypePointer Output %float %oDepth = OpVariable %_ptr_Output_float Output %float_0_899999976 = OpConstant %float 0.899999976 %int = OpTypeInt 32 1 %_ptr_Output_int = OpTypePointer Output %int %oStencil = OpVariable %_ptr_Output_int Output %int_127 = OpConstant %int 127 %main = OpFunction %void None %3 %5 = OpLabel OpStore %o0 %12 OpStore %o1 %14 OpStore %o2 %16 OpStore %o3 %18 OpStore %o4 %21 OpStore %o5 %24 OpStore %o6 %27 OpStore %o7 %29 OpStore %oDepth %float_0_899999976 OpStore %oStencil %int_127 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/empty-struct.asm.frag000066400000000000000000000041221400026215700244120ustar00rootroot00000000000000; SPIR-V ; Version: 1.2 ; Generator: Khronos; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %EntryPoint_Main "main" OpExecutionMode %EntryPoint_Main OriginUpperLeft OpSource Unknown 100 OpName %EmptyStructTest "EmptyStructTest" OpName %GetValue "GetValue" OpName %GetValue2 "GetValue" OpName %self "self" OpName %self2 "self" OpName %emptyStruct "emptyStruct" OpName %value "value" OpName %EntryPoint_Main "EntryPoint_Main" %EmptyStructTest = OpTypeStruct %_ptr_Function_EmptyStructTest = OpTypePointer Function %EmptyStructTest %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %5 = OpTypeFunction %float %_ptr_Function_EmptyStructTest %6 = OpTypeFunction %float %EmptyStructTest %void = OpTypeVoid %_ptr_Function_void = OpTypePointer Function %void %8 = OpTypeFunction %void %_ptr_Function_EmptyStructTest %9 = OpTypeFunction %void %float_0 = OpConstant %float 0 %GetValue = OpFunction %float None %5 %self = OpFunctionParameter %_ptr_Function_EmptyStructTest %13 = OpLabel OpReturnValue %float_0 OpFunctionEnd %GetValue2 = OpFunction %float None %6 %self2 = OpFunctionParameter %EmptyStructTest %14 = OpLabel OpReturnValue %float_0 OpFunctionEnd %EntryPoint_Main = OpFunction %void None %9 %37 = OpLabel %emptyStruct = OpVariable %_ptr_Function_EmptyStructTest Function %18 = OpVariable %_ptr_Function_EmptyStructTest Function %value = OpVariable %_ptr_Function_float Function %value2 = OpCompositeConstruct %EmptyStructTest %22 = OpFunctionCall %float %GetValue %emptyStruct %23 = OpFunctionCall %float %GetValue2 %value2 OpStore %value %22 OpStore %value %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/extract-packed-from-composite.asm.frag000066400000000000000000000110071400026215700275720ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 64 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %pos_1 %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %_main_vf4_ "@main(vf4;" OpName %pos "pos" OpName %Foo "Foo" OpMemberName %Foo 0 "a" OpMemberName %Foo 1 "b" OpName %foo "foo" OpName %Foo_0 "Foo" OpMemberName %Foo_0 0 "a" OpMemberName %Foo_0 1 "b" OpName %buf "buf" OpMemberName %buf 0 "results" OpMemberName %buf 1 "bar" OpName %_ "" OpName %pos_0 "pos" OpName %pos_1 "pos" OpName %_entryPointOutput "@entryPointOutput" OpName %param "param" OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %Foo_0 1 Offset 12 OpDecorate %_arr_Foo_0_uint_16 ArrayStride 16 OpMemberDecorate %buf 0 Offset 0 OpMemberDecorate %buf 1 Offset 256 OpDecorate %buf Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %pos_1 BuiltIn FragCoord OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %9 = OpTypeFunction %v4float %_ptr_Function_v4float %v3float = OpTypeVector %float 3 %Foo = OpTypeStruct %v3float %float %_ptr_Function_Foo = OpTypePointer Function %Foo %Foo_0 = OpTypeStruct %v3float %float %uint = OpTypeInt 32 0 %uint_16 = OpConstant %uint 16 %_arr_Foo_0_uint_16 = OpTypeArray %Foo_0 %uint_16 %buf = OpTypeStruct %_arr_Foo_0_uint_16 %v4float %_ptr_Uniform_buf = OpTypePointer Uniform %buf %_ = OpVariable %_ptr_Uniform_buf Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %int_16 = OpConstant %int 16 %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Function_v3float = OpTypePointer Function %v3float %int_1 = OpConstant %int 1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %float_0 = OpConstant %float 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %pos_1 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %pos_0 = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %58 = OpLoad %v4float %pos_1 OpStore %pos_0 %58 %62 = OpLoad %v4float %pos_0 OpStore %param %62 %63 = OpFunctionCall %v4float %_main_vf4_ %param OpStore %_entryPointOutput %63 OpReturn OpFunctionEnd %_main_vf4_ = OpFunction %v4float None %9 %pos = OpFunctionParameter %_ptr_Function_v4float %12 = OpLabel %foo = OpVariable %_ptr_Function_Foo Function %28 = OpAccessChain %_ptr_Function_float %pos %uint_0 %29 = OpLoad %float %28 %30 = OpConvertFToS %int %29 %32 = OpSMod %int %30 %int_16 %34 = OpAccessChain %_ptr_Uniform_Foo_0 %_ %int_0 %32 %35 = OpLoad %Foo_0 %34 %36 = OpCompositeExtract %v3float %35 0 %38 = OpAccessChain %_ptr_Function_v3float %foo %int_0 OpStore %38 %36 %39 = OpCompositeExtract %float %35 1 %41 = OpAccessChain %_ptr_Function_float %foo %int_1 OpStore %41 %39 %42 = OpAccessChain %_ptr_Function_v3float %foo %int_0 %43 = OpLoad %v3float %42 %45 = OpAccessChain %_ptr_Uniform_v4float %_ %int_1 %46 = OpLoad %v4float %45 %47 = OpVectorShuffle %v3float %46 %46 0 1 2 %48 = OpDot %float %43 %47 %49 = OpAccessChain %_ptr_Function_float %foo %int_1 %50 = OpLoad %float %49 %52 = OpCompositeConstruct %v4float %48 %50 %float_0 %float_0 OpReturnValue %52 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/frem.asm.frag000066400000000000000000000030741400026215700226700ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 16 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vA %vB OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %vA "vA" OpName %vB "vB" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %vA RelaxedPrecision OpDecorate %vA Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %vB RelaxedPrecision OpDecorate %vB Location 1 OpDecorate %14 RelaxedPrecision OpDecorate %15 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %vA = OpVariable %_ptr_Input_v4float Input %vB = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %3 %5 = OpLabel %12 = OpLoad %v4float %vA %14 = OpLoad %v4float %vB %15 = OpFRem %v4float %12 %14 OpStore %FragColor %15 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/function-overload-alias.asm.frag000066400000000000000000000150611400026215700264630ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 76 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %foobar_vf4_ "foo" OpName %a "foo" OpName %foobar_vf3_ "foo" OpName %a_0 "foo" OpName %foobaz_vf4_ "foo" OpName %a_1 "foo" OpName %foobaz_vf2_ "foo" OpName %a_2 "foo" OpName %a_3 "foo" OpName %param "foo" OpName %b "foo" OpName %param_0 "foo" OpName %c "foo" OpName %param_1 "foo" OpName %d "foo" OpName %param_2 "foo" OpName %FragColor "FragColor" OpDecorate %foobar_vf4_ RelaxedPrecision OpDecorate %a RelaxedPrecision OpDecorate %foobar_vf3_ RelaxedPrecision OpDecorate %a_0 RelaxedPrecision OpDecorate %foobaz_vf4_ RelaxedPrecision OpDecorate %a_1 RelaxedPrecision OpDecorate %foobaz_vf2_ RelaxedPrecision OpDecorate %a_2 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %a_3 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %b RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %c RelaxedPrecision OpDecorate %62 RelaxedPrecision OpDecorate %d RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %69 RelaxedPrecision OpDecorate %70 RelaxedPrecision OpDecorate %71 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %74 RelaxedPrecision OpDecorate %75 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %9 = OpTypeFunction %v4float %_ptr_Function_v4float %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %15 = OpTypeFunction %v4float %_ptr_Function_v3float %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %24 = OpTypeFunction %v4float %_ptr_Function_v2float %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %53 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %57 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %64 = OpConstantComposite %v2float %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %a_3 = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %b = OpVariable %_ptr_Function_v4float Function %param_0 = OpVariable %_ptr_Function_v3float Function %c = OpVariable %_ptr_Function_v4float Function %param_1 = OpVariable %_ptr_Function_v4float Function %d = OpVariable %_ptr_Function_v4float Function %param_2 = OpVariable %_ptr_Function_v2float Function OpStore %param %53 %55 = OpFunctionCall %v4float %foobar_vf4_ %param OpStore %a_3 %55 OpStore %param_0 %57 %59 = OpFunctionCall %v4float %foobar_vf3_ %param_0 OpStore %b %59 OpStore %param_1 %53 %62 = OpFunctionCall %v4float %foobaz_vf4_ %param_1 OpStore %c %62 OpStore %param_2 %64 %66 = OpFunctionCall %v4float %foobaz_vf2_ %param_2 OpStore %d %66 %69 = OpLoad %v4float %a_3 %70 = OpLoad %v4float %b %71 = OpFAdd %v4float %69 %70 %72 = OpLoad %v4float %c %73 = OpFAdd %v4float %71 %72 %74 = OpLoad %v4float %d %75 = OpFAdd %v4float %73 %74 OpStore %FragColor %75 OpReturn OpFunctionEnd %foobar_vf4_ = OpFunction %v4float None %9 %a = OpFunctionParameter %_ptr_Function_v4float %12 = OpLabel %28 = OpLoad %v4float %a %30 = OpCompositeConstruct %v4float %float_1 %float_1 %float_1 %float_1 %31 = OpFAdd %v4float %28 %30 OpReturnValue %31 OpFunctionEnd %foobar_vf3_ = OpFunction %v4float None %15 %a_0 = OpFunctionParameter %_ptr_Function_v3float %18 = OpLabel %34 = OpLoad %v3float %a_0 %35 = OpVectorShuffle %v4float %34 %34 0 1 2 2 %36 = OpCompositeConstruct %v4float %float_1 %float_1 %float_1 %float_1 %37 = OpFAdd %v4float %35 %36 OpReturnValue %37 OpFunctionEnd %foobaz_vf4_ = OpFunction %v4float None %9 %a_1 = OpFunctionParameter %_ptr_Function_v4float %21 = OpLabel %40 = OpLoad %v4float %a_1 %42 = OpCompositeConstruct %v4float %float_2 %float_2 %float_2 %float_2 %43 = OpFAdd %v4float %40 %42 OpReturnValue %43 OpFunctionEnd %foobaz_vf2_ = OpFunction %v4float None %24 %a_2 = OpFunctionParameter %_ptr_Function_v2float %27 = OpLabel %46 = OpLoad %v2float %a_2 %47 = OpVectorShuffle %v4float %46 %46 0 1 0 1 %48 = OpCompositeConstruct %v4float %float_2 %float_2 %float_2 %float_2 %49 = OpFAdd %v4float %47 %48 OpReturnValue %49 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/image-extract-reuse.asm.frag000066400000000000000000000030251400026215700256060ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 19 ; Schema: 0 OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %Size OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %Size "Size" OpName %uTexture "uTexture" OpDecorate %Size Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %_ptr_Output_v2int = OpTypePointer Output %v2int %Size = OpVariable %_ptr_Output_v2int Output %float = OpTypeFloat 32 %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %12 = OpTypeSampledImage %11 %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %uTexture = OpVariable %_ptr_UniformConstant_12 UniformConstant %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpLoad %12 %uTexture %17 = OpImage %11 %15 %18 = OpImageQuerySizeLod %v2int %17 %int_0 %19 = OpImageQuerySizeLod %v2int %17 %int_1 %20 = OpIAdd %v2int %18 %19 OpStore %Size %20 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/implicit-read-dep-phi.asm.frag000066400000000000000000000064051400026215700260070ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 60 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %v0 %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %phi "phi" OpName %i "i" OpName %v0 "v0" OpName %FragColor "FragColor" OpName %uImage "uImage" OpDecorate %v0 Location 0 OpDecorate %FragColor Location 0 OpDecorate %uImage DescriptorSet 0 OpDecorate %uImage Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %v0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %36 = OpTypeImage %float 2D 0 0 0 1 Unknown %37 = OpTypeSampledImage %36 %_ptr_UniformConstant_37 = OpTypePointer UniformConstant %37 %uImage = OpVariable %_ptr_UniformConstant_37 UniformConstant %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %float_2 = OpConstant %float 2 %int_1 = OpConstant %int 1 %float_1_vec = OpConstantComposite %v4float %float_1 %float_2 %float_1 %float_2 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %loop_header %loop_header = OpLabel %phi = OpPhi %float %float_1 %5 %phi_plus_2 %continue_block %tex_phi = OpPhi %v4float %float_1_vec %5 %texture_load_result %continue_block OpLoopMerge %merge_block %continue_block None OpBranch %loop_body %loop_body = OpLabel OpStore %FragColor %tex_phi %19 = OpLoad %int %i %22 = OpSLessThan %bool %19 %int_4 OpBranchConditional %22 %15 %merge_block %15 = OpLabel %26 = OpLoad %int %i %28 = OpAccessChain %_ptr_Input_float %v0 %26 %29 = OpLoad %float %28 %31 = OpFOrdGreaterThan %bool %29 %float_0 OpBranchConditional %31 %continue_block %merge_block %continue_block = OpLabel %40 = OpLoad %37 %uImage %43 = OpCompositeConstruct %v2float %phi %phi %texture_load_result = OpImageSampleExplicitLod %v4float %40 %43 Lod %float_0 %phi_plus_2 = OpFAdd %float %phi %float_2 %54 = OpLoad %int %i %56 = OpIAdd %int %54 %int_1 OpStore %i %56 OpBranch %loop_header %merge_block = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/inf-nan-constant.asm.frag000066400000000000000000000021471400026215700251140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 14 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %FragColor = OpVariable %_ptr_Output_v3float Output %float_0x1p_128 = OpConstant %float 0x1p+128 %float_n0x1p_128 = OpConstant %float -0x1p+128 %float_0x1_8p_128 = OpConstant %float 0x1.8p+128 %13 = OpConstantComposite %v3float %float_0x1p_128 %float_n0x1p_128 %float_0x1_8p_128 %main = OpFunction %void None %3 %5 = OpLabel OpStore %FragColor %13 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/interpolation-qualifiers-struct.asm.frag000066400000000000000000000067111400026215700303130ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 51 ; Schema: 0 OpCapability Shader OpCapability SampleRateShading %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %inp OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %Input "Input" OpMemberName %Input 0 "v0" OpMemberName %Input 1 "v1" OpMemberName %Input 2 "v2" OpMemberName %Input 3 "v3" OpMemberName %Input 4 "v4" OpMemberName %Input 5 "v5" OpMemberName %Input 6 "v6" OpName %inp "inp" OpDecorate %FragColor Location 0 OpDecorate %inp Location 0 OpMemberDecorate %Input 1 NoPerspective OpMemberDecorate %Input 2 Centroid OpMemberDecorate %Input 3 Centroid OpMemberDecorate %Input 3 NoPerspective OpMemberDecorate %Input 4 Sample OpMemberDecorate %Input 5 Sample OpMemberDecorate %Input 5 NoPerspective OpMemberDecorate %Input 6 Flat %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %Input = OpTypeStruct %v2float %v2float %v3float %v4float %float %float %float %_ptr_Input_Input = OpTypePointer Input %Input %inp = OpVariable %_ptr_Input_Input Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %uint_1 = OpConstant %uint 1 %int_2 = OpConstant %int 2 %_ptr_Input_v3float = OpTypePointer Input %v3float %int_3 = OpConstant %int 3 %uint_3 = OpConstant %uint 3 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %int_6 = OpConstant %int 6 %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_float %inp %int_0 %uint_0 %21 = OpLoad %float %20 %24 = OpAccessChain %_ptr_Input_float %inp %int_1 %uint_1 %25 = OpLoad %float %24 %26 = OpFAdd %float %21 %25 %29 = OpAccessChain %_ptr_Input_v3float %inp %int_2 %30 = OpLoad %v3float %29 %31 = OpVectorShuffle %v2float %30 %30 0 1 %34 = OpAccessChain %_ptr_Input_float %inp %int_3 %uint_3 %35 = OpLoad %float %34 %37 = OpAccessChain %_ptr_Input_float %inp %int_4 %38 = OpLoad %float %37 %39 = OpFMul %float %35 %38 %41 = OpAccessChain %_ptr_Input_float %inp %int_5 %42 = OpLoad %float %41 %43 = OpFAdd %float %39 %42 %45 = OpAccessChain %_ptr_Input_float %inp %int_6 %46 = OpLoad %float %45 %47 = OpFSub %float %43 %46 %48 = OpCompositeExtract %float %31 0 %49 = OpCompositeExtract %float %31 1 %50 = OpCompositeConstruct %v4float %26 %48 %49 %47 OpStore %FragColor %50 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/line-directive.line.asm.frag000066400000000000000000000144301400026215700255660ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google Shaderc over Glslang; 7 ; Bound: 83 ; Schema: 0 OpCapability Shader %2 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vColor OpExecutionMode %main OriginUpperLeft %1 = OpString "test.frag" OpSource GLSL 450 %1 "// OpModuleProcessed entry-point main // OpModuleProcessed client vulkan100 // OpModuleProcessed target-env vulkan1.0 // OpModuleProcessed entry-point main #line 1 #version 450 layout(location = 0) in float vColor; layout(location = 0) out float FragColor; void func() { FragColor = 1.0; FragColor = 2.0; if (vColor < 0.0) { FragColor = 3.0; } else { FragColor = 4.0; } for (int i = 0; i < 40 + vColor; i += int(vColor) + 5) { FragColor += 0.2; FragColor += 0.3; } switch (int(vColor)) { case 0: FragColor += 0.2; break; case 1: FragColor += 0.4; break; default: FragColor += 0.8; break; } do { FragColor += 10.0 + vColor; } while(FragColor < 100.0); } void main() { func(); } " OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %func_ "func(" OpName %FragColor "FragColor" OpName %vColor "vColor" OpName %i "i" OpDecorate %FragColor Location 0 OpDecorate %vColor Location 0 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %_ptr_Input_float = OpTypePointer Input %float %vColor = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %int = OpTypeInt 32 1 ; Should be ignored OpLine %1 5 0 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %float_40 = OpConstant %float 40 %float_0_200000003 = OpConstant %float 0.200000003 %float_0_300000012 = OpConstant %float 0.300000012 %int_5 = OpConstant %int 5 ; Should be ignored OpLine %1 5 0 %float_0_400000006 = OpConstant %float 0.400000006 %float_0_800000012 = OpConstant %float 0.800000012 %float_10 = OpConstant %float 10 %float_100 = OpConstant %float 100 %main = OpFunction %void None %4 OpLine %1 46 0 %6 = OpLabel OpLine %1 48 0 %82 = OpFunctionCall %void %func_ OpReturn OpFunctionEnd ; Should be ignored OpLine %1 5 0 %func_ = OpFunction %void None %4 OpLine %1 6 0 %8 = OpLabel %i = OpVariable %_ptr_Function_int Function OpLine %1 8 0 OpStore %FragColor %float_1 OpLine %1 9 0 OpStore %FragColor %float_2 OpLine %1 10 0 %16 = OpLoad %float %vColor %19 = OpFOrdLessThan %bool %16 %float_0 OpSelectionMerge %21 None OpBranchConditional %19 %20 %23 %20 = OpLabel OpLine %1 12 0 OpStore %FragColor %float_3 OpBranch %21 %23 = OpLabel OpLine %1 16 0 OpStore %FragColor %float_4 OpBranch %21 %21 = OpLabel OpLine %1 19 0 OpStore %i %int_0 OpBranch %29 %29 = OpLabel OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %34 = OpLoad %int %i %35 = OpConvertSToF %float %34 %37 = OpLoad %float %vColor %38 = OpFAdd %float %float_40 %37 %39 = OpFOrdLessThan %bool %35 %38 OpBranchConditional %39 %30 %31 %30 = OpLabel OpLine %1 21 0 %41 = OpLoad %float %FragColor %42 = OpFAdd %float %41 %float_0_200000003 OpStore %FragColor %42 OpLine %1 22 0 %44 = OpLoad %float %FragColor %45 = OpFAdd %float %44 %float_0_300000012 OpStore %FragColor %45 OpBranch %32 %32 = OpLabel OpLine %1 19 0 %46 = OpLoad %float %vColor %47 = OpConvertFToS %int %46 %49 = OpIAdd %int %47 %int_5 %50 = OpLoad %int %i %51 = OpIAdd %int %50 %49 OpStore %i %51 OpBranch %29 %31 = OpLabel OpLine %1 25 0 %52 = OpLoad %float %vColor %53 = OpConvertFToS %int %52 OpSelectionMerge %57 None OpSwitch %53 %56 0 %54 1 %55 %56 = OpLabel OpLine %1 36 0 %66 = OpLoad %float %FragColor %67 = OpFAdd %float %66 %float_0_800000012 OpStore %FragColor %67 OpLine %1 37 0 OpBranch %57 %54 = OpLabel OpLine %1 28 0 %58 = OpLoad %float %FragColor %59 = OpFAdd %float %58 %float_0_200000003 OpStore %FragColor %59 OpLine %1 29 0 OpBranch %57 %55 = OpLabel OpLine %1 32 0 %62 = OpLoad %float %FragColor %63 = OpFAdd %float %62 %float_0_400000006 OpStore %FragColor %63 OpLine %1 33 0 OpBranch %57 %57 = OpLabel OpBranch %70 OpLine %1 43 0 %70 = OpLabel OpLoopMerge %72 %73 None OpBranch %71 %71 = OpLabel OpLine %1 42 0 %75 = OpLoad %float %vColor %76 = OpFAdd %float %float_10 %75 %77 = OpLoad %float %FragColor %78 = OpFAdd %float %77 %76 OpStore %FragColor %78 OpBranch %73 %73 = OpLabel OpLine %1 43 0 %79 = OpLoad %float %FragColor %81 = OpFOrdLessThan %bool %79 %float_100 OpBranchConditional %81 %70 %72 %72 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/locations-components.asm.frag000066400000000000000000000102661400026215700261160ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 67 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %8 %16 %22 %28 %33 %o0 OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %v1 "v1" OpName %v2 "v2" OpName %o0 "o0" OpName %r0 "r0" OpDecorate %8 Location 1 OpDecorate %16 Location 1 OpDecorate %16 Component 2 OpDecorate %22 Location 2 OpDecorate %22 Flat OpDecorate %28 Location 2 OpDecorate %28 Component 1 OpDecorate %28 Flat OpDecorate %33 Location 2 OpDecorate %33 Component 2 OpDecorate %33 Flat OpDecorate %o0 Location 0 %void = OpTypeVoid %2 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %8 = OpVariable %_ptr_Input_v2float Input %v4float = OpTypeVector %float 4 %_ptr_Private_v4float = OpTypePointer Private %v4float %v1 = OpVariable %_ptr_Private_v4float Private %_ptr_Input_float = OpTypePointer Input %float %16 = OpVariable %_ptr_Input_float Input %_ptr_Private_float = OpTypePointer Private %float %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %22 = OpVariable %_ptr_Input_float Input %v2 = OpVariable %_ptr_Private_v4float Private %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %28 = OpVariable %_ptr_Input_uint Input %uint_1 = OpConstant %uint 1 %33 = OpVariable %_ptr_Input_uint Input %_ptr_Output_v4float = OpTypePointer Output %v4float %o0 = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %int = OpTypeInt 32 1 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %2 %4 = OpLabel %r0 = OpVariable %_ptr_Function_v4float Function %12 = OpLoad %v2float %8 %13 = OpLoad %v4float %v1 %14 = OpVectorShuffle %v4float %13 %12 4 5 2 3 OpStore %v1 %14 %17 = OpLoad %float %16 %21 = OpInBoundsAccessChain %_ptr_Private_float %v1 %uint_2 OpStore %21 %17 %24 = OpLoad %float %22 %26 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_0 OpStore %26 %24 %29 = OpLoad %uint %28 %30 = OpBitcast %float %29 %32 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_1 OpStore %32 %30 %34 = OpLoad %uint %33 %35 = OpBitcast %float %34 %36 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_2 OpStore %36 %35 %42 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_1 %43 = OpLoad %float %42 %44 = OpBitcast %int %43 %45 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_2 %46 = OpLoad %float %45 %47 = OpBitcast %int %46 %48 = OpIAdd %int %44 %47 %49 = OpBitcast %float %48 %51 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_0 OpStore %51 %49 %52 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_0 %53 = OpLoad %float %52 %54 = OpBitcast %uint %53 %55 = OpConvertUToF %float %54 %57 = OpInBoundsAccessChain %_ptr_Output_float %o0 %uint_1 OpStore %57 %55 %58 = OpInBoundsAccessChain %_ptr_Private_float %v1 %uint_1 %59 = OpLoad %float %58 %60 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_0 %61 = OpLoad %float %60 %62 = OpFAdd %float %59 %61 %63 = OpInBoundsAccessChain %_ptr_Output_float %o0 %uint_0 OpStore %63 %62 %64 = OpLoad %v4float %v1 %65 = OpLoad %v4float %o0 %66 = OpVectorShuffle %v4float %65 %64 0 1 6 4 OpStore %o0 %66 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/lut-promotion-initializer.asm.frag000066400000000000000000000210011400026215700270760ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 111 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %index OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %index "index" OpName %indexable "indexable" OpName %indexable_0 "indexable" OpName %indexable_1 "indexable" OpName %foo "foo" OpName %foobar "foobar" OpName %baz "baz" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %index RelaxedPrecision OpDecorate %index Flat OpDecorate %index Location 0 OpDecorate %20 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %foo RelaxedPrecision OpDecorate %61 RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %71 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %79 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision OpDecorate %foobar RelaxedPrecision OpDecorate %83 RelaxedPrecision OpDecorate %90 RelaxedPrecision OpDecorate %91 RelaxedPrecision OpDecorate %93 RelaxedPrecision OpDecorate %94 RelaxedPrecision OpDecorate %95 RelaxedPrecision OpDecorate %baz RelaxedPrecision OpDecorate %105 RelaxedPrecision OpDecorate %106 RelaxedPrecision OpDecorate %108 RelaxedPrecision OpDecorate %109 RelaxedPrecision OpDecorate %110 RelaxedPrecision OpDecorate %16 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %uint = OpTypeInt 32 0 %uint_16 = OpConstant %uint 16 %_arr_float_uint_16 = OpTypeArray %float %uint_16 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %16 = OpConstantComposite %_arr_float_uint_16 %float_1 %float_2 %float_3 %float_4 %float_1 %float_2 %float_3 %float_4 %float_1 %float_2 %float_3 %float_4 %float_1 %float_2 %float_3 %float_4 %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %index = OpVariable %_ptr_Input_int Input %_ptr_Function__arr_float_uint_16 = OpTypePointer Function %_arr_float_uint_16 %_ptr_Function_float = OpTypePointer Function %float %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %v4float = OpTypeVector %float 4 %uint_4 = OpConstant %uint 4 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %_ptr_Function__arr_v4float_uint_4 = OpTypePointer Function %_arr_v4float_uint_4 %float_0 = OpConstant %float 0 %54 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %55 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_8 = OpConstant %float 8 %57 = OpConstantComposite %v4float %float_8 %float_8 %float_8 %float_8 %float_5 = OpConstant %float 5 %59 = OpConstantComposite %v4float %float_5 %float_5 %float_5 %float_5 %60 = OpConstantComposite %_arr_v4float_uint_4 %54 %55 %57 %59 %int_30 = OpConstant %int 30 %int_3 = OpConstant %int 3 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %float_20 = OpConstant %float 20 %uint_2 = OpConstant %uint 2 %97 = OpConstantComposite %v4float %float_20 %float_20 %float_20 %float_20 %float_30 = OpConstant %float 30 %99 = OpConstantComposite %v4float %float_30 %float_30 %float_30 %float_30 %float_50 = OpConstant %float 50 %101 = OpConstantComposite %v4float %float_50 %float_50 %float_50 %float_50 %float_60 = OpConstant %float 60 %103 = OpConstantComposite %v4float %float_60 %float_60 %float_60 %float_60 %104 = OpConstantComposite %_arr_v4float_uint_4 %97 %99 %101 %103 %main = OpFunction %void None %3 %5 = OpLabel %indexable = OpVariable %_ptr_Function__arr_float_uint_16 Function %16 %indexable_0 = OpVariable %_ptr_Function__arr_float_uint_16 Function %16 %indexable_1 = OpVariable %_ptr_Function__arr_float_uint_16 Function %16 %foo = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %60 %foobar = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %60 %baz = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %60 %20 = OpLoad %int %index %24 = OpAccessChain %_ptr_Function_float %indexable %20 %25 = OpLoad %float %24 OpStore %FragColor %25 %26 = OpLoad %int %index %29 = OpSLessThan %bool %26 %int_10 OpSelectionMerge %31 None OpBranchConditional %29 %30 %40 %30 = OpLabel %32 = OpLoad %int %index %34 = OpBitwiseXor %int %32 %int_1 %36 = OpAccessChain %_ptr_Function_float %indexable_0 %34 %37 = OpLoad %float %36 %38 = OpLoad %float %FragColor %39 = OpFAdd %float %38 %37 OpStore %FragColor %39 OpBranch %31 %40 = OpLabel %41 = OpLoad %int %index %42 = OpBitwiseAnd %int %41 %int_1 %44 = OpAccessChain %_ptr_Function_float %indexable_1 %42 %45 = OpLoad %float %44 %46 = OpLoad %float %FragColor %47 = OpFAdd %float %46 %45 OpStore %FragColor %47 OpBranch %31 %31 = OpLabel %61 = OpLoad %int %index %63 = OpSGreaterThan %bool %61 %int_30 OpSelectionMerge %65 None OpBranchConditional %63 %64 %74 %64 = OpLabel %66 = OpLoad %int %index %68 = OpBitwiseAnd %int %66 %int_3 %70 = OpAccessChain %_ptr_Function_float %foo %68 %uint_1 %71 = OpLoad %float %70 %72 = OpLoad %float %FragColor %73 = OpFAdd %float %72 %71 OpStore %FragColor %73 OpBranch %65 %74 = OpLabel %75 = OpLoad %int %index %76 = OpBitwiseAnd %int %75 %int_1 %78 = OpAccessChain %_ptr_Function_float %foo %76 %uint_0 %79 = OpLoad %float %78 %80 = OpLoad %float %FragColor %81 = OpFAdd %float %80 %79 OpStore %FragColor %81 OpBranch %65 %65 = OpLabel %83 = OpLoad %int %index %84 = OpSGreaterThan %bool %83 %int_30 OpSelectionMerge %86 None OpBranchConditional %84 %85 %86 %85 = OpLabel %89 = OpAccessChain %_ptr_Function_float %foobar %int_1 %uint_2 OpStore %89 %float_20 OpBranch %86 %86 = OpLabel %90 = OpLoad %int %index %91 = OpBitwiseAnd %int %90 %int_3 %92 = OpAccessChain %_ptr_Function_float %foobar %91 %uint_2 %93 = OpLoad %float %92 %94 = OpLoad %float %FragColor %95 = OpFAdd %float %94 %93 OpStore %FragColor %95 OpStore %baz %104 %105 = OpLoad %int %index %106 = OpBitwiseAnd %int %105 %int_3 %107 = OpAccessChain %_ptr_Function_float %baz %106 %uint_2 %108 = OpLoad %float %107 %109 = OpLoad %float %FragColor %110 = OpFAdd %float %109 %108 OpStore %FragColor %110 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/min-lod.msl22.asm.frag000066400000000000000000000032151400026215700242310ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 21 ; Schema: 0 OpCapability Shader OpCapability MinLod %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vUV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %uSampler "uSampler" OpName %vUV "vUV" OpDecorate %FragColor Location 0 OpDecorate %uSampler DescriptorSet 0 OpDecorate %uSampler Binding 0 OpDecorate %vUV Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %uSampler = OpVariable %_ptr_UniformConstant_11 UniformConstant %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %float_4 = OpConstant %float 4 %main = OpFunction %void None %3 %5 = OpLabel %14 = OpLoad %11 %uSampler %18 = OpLoad %v2float %vUV %20 = OpImageSampleImplicitLod %v4float %14 %18 MinLod %float_4 OpStore %FragColor %20 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/op-constant-null.asm.frag000066400000000000000000000065551400026215700251630ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 45 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %a "a" OpName %b "b" OpName %c "c" OpName %D "D" OpMemberName %D 0 "a" OpMemberName %D 1 "b" OpName %d "d" OpName %e "e" OpName %FragColor "FragColor" OpDecorate %a RelaxedPrecision OpDecorate %b RelaxedPrecision OpDecorate %c RelaxedPrecision OpMemberDecorate %D 0 RelaxedPrecision OpMemberDecorate %D 1 RelaxedPrecision OpDecorate %e RelaxedPrecision OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %44 RelaxedPrecision OpDecorate %float_1 RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %41 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstantNull %float %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_2 = OpConstantNull %float %14 = OpConstantNull %v4float %v3float = OpTypeVector %float 3 %mat2v3float = OpTypeMatrix %v3float 2 %_ptr_Function_mat2v3float = OpTypePointer Function %mat2v3float %float_4 = OpConstantNull %float %20 = OpConstantNull %v3float %float_5 = OpConstantNull %float %22 = OpConstantNull %v3float %23 = OpConstantNull %mat2v3float %D = OpTypeStruct %v4float %float %_ptr_Function_D = OpTypePointer Function %D %27 = OpConstantNull %D %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %_ptr_Function__arr_v4float_uint_4 = OpTypePointer Function %_arr_v4float_uint_4 %float_10 = OpConstantNull %float %34 = OpConstantNull %v4float %float_11 = OpConstantNull %float %36 = OpConstantNull %v4float %float_12 = OpConstantNull %float %38 = OpConstantNull %v4float %float_13 = OpConstantNull %float %40 = OpConstantNull %v4float %41 = OpConstantNull %_arr_v4float_uint_4 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_float Function %b = OpVariable %_ptr_Function_v4float Function %c = OpVariable %_ptr_Function_mat2v3float Function %d = OpVariable %_ptr_Function_D Function %e = OpVariable %_ptr_Function__arr_v4float_uint_4 Function OpStore %a %float_1 OpStore %b %14 OpStore %c %23 OpStore %d %27 OpStore %e %41 %44 = OpLoad %float %a OpStore %FragColor %44 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/op-image-sampled-image.asm.frag000066400000000000000000000066441400026215700261460ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 54 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o0 OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %t0 "t0" OpName %o0 "o0" OpName %r0 "r0" OpName %push_cb "push_cb" OpMemberName %push_cb 0 "cb0" OpName %dummy_sampler "dummy_sampler" OpDecorate %t0 DescriptorSet 0 OpDecorate %t0 Binding 2 OpDecorate %o0 Location 0 OpDecorate %_arr_v4float_uint_1 ArrayStride 16 OpDecorate %push_cb Block OpMemberDecorate %push_cb 0 Offset 0 OpDecorate %dummy_sampler DescriptorSet 0 OpDecorate %dummy_sampler Binding 4 %void = OpTypeVoid %2 = OpTypeFunction %void %float = OpTypeFloat 32 %6 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_6 = OpTypePointer UniformConstant %6 %t0 = OpVariable %_ptr_UniformConstant_6 UniformConstant %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %o0 = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %push_cb = OpTypeStruct %_arr_v4float_uint_1 %_ptr_PushConstant_push_cb = OpTypePointer PushConstant %push_cb %19 = OpVariable %_ptr_PushConstant_push_cb PushConstant %uint_0 = OpConstant %uint 0 %_ptr_PushConstant_v4float = OpTypePointer PushConstant %v4float %_ptr_PushConstant_float = OpTypePointer PushConstant %float %int = OpTypeInt 32 1 %v2float = OpTypeVector %float 2 %float_0 = OpConstant %float 0 %30 = OpConstantComposite %v2float %float_0 %float_0 %33 = OpTypeSampler %_ptr_UniformConstant_33 = OpTypePointer UniformConstant %33 %dummy_sampler = OpVariable %_ptr_UniformConstant_33 UniformConstant %38 = OpTypeSampledImage %6 %v2int = OpTypeVector %int 2 %_ptr_Function_float = OpTypePointer Function %float %uint_3 = OpConstant %uint 3 %int_n1 = OpConstant %int -1 %int_n2 = OpConstant %int -2 %52 = OpConstantComposite %v2int %int_n1 %int_n2 %main = OpFunction %void None %2 %4 = OpLabel %r0 = OpVariable %_ptr_Function_v4float Function %23 = OpAccessChain %_ptr_PushConstant_v4float %19 %uint_0 %uint_0 %25 = OpLoad %v4float %23 %26 = OpLoad %v4float %r0 %27 = OpVectorShuffle %v4float %26 %25 6 7 2 3 OpStore %r0 %27 %31 = OpLoad %v4float %r0 %32 = OpVectorShuffle %v4float %31 %30 0 1 4 5 OpStore %r0 %32 %36 = OpLoad %6 %t0 %37 = OpLoad %33 %dummy_sampler %39 = OpSampledImage %38 %36 %37 %40 = OpImage %6 %39 %41 = OpLoad %v4float %r0 %42 = OpVectorShuffle %v2float %41 %41 0 1 %44 = OpBitcast %v2int %42 %47 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_3 %48 = OpLoad %float %47 %49 = OpBitcast %int %48 %54 = OpImageFetch %v4float %40 %44 Lod|ConstOffset %49 %52 OpStore %o0 %54 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/pass-by-value.asm.frag000066400000000000000000000040131400026215700244210ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 32 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %add_value_f1_f1_ "add_value(f1;f1;" OpName %v "v" OpName %w "w" OpName %FragColor "FragColor" OpName %Registers "Registers" OpMemberName %Registers 0 "foo" OpName %registers "registers" OpDecorate %FragColor Location 0 OpMemberDecorate %Registers 0 Offset 0 OpDecorate %Registers Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %8 = OpTypeFunction %float %float %float %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %float_10 = OpConstant %float 10 %Registers = OpTypeStruct %float %_ptr_PushConstant_Registers = OpTypePointer PushConstant %Registers %registers = OpVariable %_ptr_PushConstant_Registers PushConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_PushConstant_float = OpTypePointer PushConstant %float %main = OpFunction %void None %3 %5 = OpLabel %29 = OpAccessChain %_ptr_PushConstant_float %registers %int_0 %30 = OpLoad %float %29 %31 = OpFunctionCall %float %add_value_f1_f1_ %float_10 %30 OpStore %FragColor %31 OpReturn OpFunctionEnd %add_value_f1_f1_ = OpFunction %float None %8 %v = OpFunctionParameter %float %w = OpFunctionParameter %float %12 = OpLabel %15 = OpFAdd %float %v %w OpReturnValue %15 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/phi-loop-variable.asm.frag000066400000000000000000000046751400026215700252610ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 59 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat2v2float = OpTypeMatrix %v2float 2 %_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float %v3float = OpTypeVector %float 3 %11 = OpTypeFunction %v3float %_ptr_Function_mat2v2float %_ptr_Function_v3float = OpTypePointer Function %v3float %float_1 = OpConstant %float 1 %18 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_35 = OpConstant %int 35 %int_0 = OpConstant %int 0 %bool = OpTypeBool %int_1 = OpConstant %int 1 %4 = OpFunction %void None %3 %5 = OpLabel OpBranch %48 %48 = OpLabel %58 = OpPhi %int %int_35 %5 %56 %50 OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %53 = OpSGreaterThanEqual %bool %58 %int_0 OpBranchConditional %53 %54 %49 %54 = OpLabel OpBranch %50 %50 = OpLabel %56 = OpISub %int %58 %int_1 OpBranch %48 %49 = OpLabel OpReturn OpFunctionEnd %13 = OpFunction %v3float None %11 %12 = OpFunctionParameter %_ptr_Function_mat2v2float %14 = OpLabel %16 = OpVariable %_ptr_Function_v3float Function %21 = OpVariable %_ptr_Function_int Function OpStore %16 %18 OpStore %21 %int_35 OpBranch %23 %23 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %28 = OpLoad %int %21 %31 = OpSGreaterThanEqual %bool %28 %int_0 OpBranchConditional %31 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %32 = OpLoad %int %21 %34 = OpISub %int %32 %int_1 OpStore %21 %34 OpBranch %23 %25 = OpLabel %35 = OpLoad %v3float %16 OpReturnValue %35 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/pull-model-interpolation.asm.msl23.frag000066400000000000000000000472061400026215700276420ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 325 ; Schema: 0 OpCapability Shader OpCapability SampleRateShading OpCapability InterpolationFunction %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %baz %a %s %foo %sid %bar %b %c OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %func_ "func(" OpName %FragColor "FragColor" OpName %baz "baz" OpName %a "a" OpName %_ "" OpMemberName %_ 0 "x" OpMemberName %_ 1 "y" OpMemberName %_ 2 "z" OpMemberName %_ 3 "u" OpMemberName %_ 4 "v" OpMemberName %_ 5 "w" OpName %s "s" OpName %foo "foo" OpName %sid "sid" OpName %bar "bar" OpName %b "b" OpName %c "c" OpDecorate %FragColor Location 0 OpDecorate %baz Sample OpDecorate %baz Location 2 OpDecorate %a Location 4 OpDecorate %s Location 10 OpDecorate %foo NoPerspective OpDecorate %foo Location 0 OpDecorate %sid Flat OpDecorate %sid Location 3 OpDecorate %bar Centroid OpDecorate %bar Location 1 OpDecorate %b Centroid OpDecorate %b Location 6 OpDecorate %c Sample OpDecorate %c Location 8 OpMemberDecorate %_ 1 Centroid OpMemberDecorate %_ 1 NoPerspective OpMemberDecorate %_ 2 Sample OpMemberDecorate %_ 3 Centroid OpMemberDecorate %_ 4 Sample OpMemberDecorate %_ 4 NoPerspective %void = OpTypeVoid %15 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %baz = OpVariable %_ptr_Input_v2float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_float = OpTypePointer Output %float %uint_1 = OpConstant %uint 1 %int = OpTypeInt 32 1 %int_3 = OpConstant %int 3 %float_n0_100000001 = OpConstant %float -0.100000001 %float_0_100000001 = OpConstant %float 0.100000001 %30 = OpConstantComposite %v2float %float_n0_100000001 %float_0_100000001 %uint_2 = OpConstant %uint 2 %_arr_v2float_uint_2 = OpTypeArray %v2float %uint_2 %_ptr_Input__arr_v2float_uint_2 = OpTypePointer Input %_arr_v2float_uint_2 %a = OpVariable %_ptr_Input__arr_v2float_uint_2 Input %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_ptr_Input__arr_v4float_uint_2 = OpTypePointer Input %_arr_v4float_uint_2 %uint_3 = OpConstant %uint 3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %_ = OpTypeStruct %v4float %v4float %v4float %_arr_v4float_uint_2 %_arr_v2float_uint_2 %_arr_float_uint_3 %_ptr_Input__ = OpTypePointer Input %_ %s = OpVariable %_ptr_Input__ Input %_ptr_Input_v4float = OpTypePointer Input %v4float %foo = OpVariable %_ptr_Input_v4float Input %_ptr_Input_int = OpTypePointer Input %int %sid = OpVariable %_ptr_Input_int Input %44 = OpConstantComposite %v2float %float_0_100000001 %float_0_100000001 %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %bar = OpVariable %_ptr_Input_v3float Input %47 = OpConstantComposite %v2float %float_n0_100000001 %float_n0_100000001 %b = OpVariable %_ptr_Input__arr_v2float_uint_2 Input %c = OpVariable %_ptr_Input__arr_v2float_uint_2 Input %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %main = OpFunction %void None %15 %50 = OpLabel %51 = OpLoad %v4float %foo OpStore %FragColor %51 %52 = OpExtInst %v4float %1 InterpolateAtCentroid %foo %53 = OpLoad %v4float %FragColor %54 = OpFAdd %v4float %53 %52 OpStore %FragColor %54 %55 = OpLoad %int %sid %56 = OpExtInst %v4float %1 InterpolateAtSample %foo %55 %57 = OpLoad %v4float %FragColor %58 = OpFAdd %v4float %57 %56 OpStore %FragColor %58 %59 = OpExtInst %v4float %1 InterpolateAtOffset %foo %44 %60 = OpLoad %v4float %FragColor %61 = OpFAdd %v4float %60 %59 OpStore %FragColor %61 %62 = OpLoad %v3float %bar %63 = OpLoad %v4float %FragColor %64 = OpVectorShuffle %v3float %63 %63 0 1 2 %65 = OpFAdd %v3float %64 %62 %66 = OpLoad %v4float %FragColor %67 = OpVectorShuffle %v4float %66 %65 4 5 6 3 OpStore %FragColor %67 %68 = OpExtInst %v3float %1 InterpolateAtCentroid %bar %69 = OpLoad %v4float %FragColor %70 = OpVectorShuffle %v3float %69 %69 0 1 2 %71 = OpFAdd %v3float %70 %68 %72 = OpLoad %v4float %FragColor %73 = OpVectorShuffle %v4float %72 %71 4 5 6 3 OpStore %FragColor %73 %74 = OpLoad %int %sid %75 = OpExtInst %v3float %1 InterpolateAtSample %bar %74 %76 = OpLoad %v4float %FragColor %77 = OpVectorShuffle %v3float %76 %76 0 1 2 %78 = OpFAdd %v3float %77 %75 %79 = OpLoad %v4float %FragColor %80 = OpVectorShuffle %v4float %79 %78 4 5 6 3 OpStore %FragColor %80 %81 = OpExtInst %v3float %1 InterpolateAtOffset %bar %47 %82 = OpLoad %v4float %FragColor %83 = OpVectorShuffle %v3float %82 %82 0 1 2 %84 = OpFAdd %v3float %83 %81 %85 = OpLoad %v4float %FragColor %86 = OpVectorShuffle %v4float %85 %84 4 5 6 3 OpStore %FragColor %86 %87 = OpAccessChain %_ptr_Input_v2float %b %int_0 %88 = OpLoad %v2float %87 %89 = OpLoad %v4float %FragColor %90 = OpVectorShuffle %v2float %89 %89 0 1 %91 = OpFAdd %v2float %90 %88 %92 = OpLoad %v4float %FragColor %93 = OpVectorShuffle %v4float %92 %91 4 5 2 3 OpStore %FragColor %93 %94 = OpAccessChain %_ptr_Input_v2float %b %int_1 %95 = OpExtInst %v2float %1 InterpolateAtCentroid %94 %96 = OpLoad %v4float %FragColor %97 = OpVectorShuffle %v2float %96 %96 0 1 %98 = OpFAdd %v2float %97 %95 %99 = OpLoad %v4float %FragColor %100 = OpVectorShuffle %v4float %99 %98 4 5 2 3 OpStore %FragColor %100 %101 = OpAccessChain %_ptr_Input_v2float %b %int_0 %102 = OpExtInst %v2float %1 InterpolateAtSample %101 %int_2 %103 = OpLoad %v4float %FragColor %104 = OpVectorShuffle %v2float %103 %103 0 1 %105 = OpFAdd %v2float %104 %102 %106 = OpLoad %v4float %FragColor %107 = OpVectorShuffle %v4float %106 %105 4 5 2 3 OpStore %FragColor %107 %108 = OpAccessChain %_ptr_Input_v2float %b %int_1 %109 = OpExtInst %v2float %1 InterpolateAtOffset %108 %30 %110 = OpLoad %v4float %FragColor %111 = OpVectorShuffle %v2float %110 %110 0 1 %112 = OpFAdd %v2float %111 %109 %113 = OpLoad %v4float %FragColor %114 = OpVectorShuffle %v4float %113 %112 4 5 2 3 OpStore %FragColor %114 %115 = OpAccessChain %_ptr_Input_v2float %c %int_0 %116 = OpLoad %v2float %115 %117 = OpLoad %v4float %FragColor %118 = OpVectorShuffle %v2float %117 %117 0 1 %119 = OpFAdd %v2float %118 %116 %120 = OpLoad %v4float %FragColor %121 = OpVectorShuffle %v4float %120 %119 4 5 2 3 OpStore %FragColor %121 %122 = OpAccessChain %_ptr_Input_v2float %c %int_1 %123 = OpExtInst %v2float %1 InterpolateAtCentroid %122 %124 = OpVectorShuffle %v2float %123 %123 0 1 %125 = OpLoad %v4float %FragColor %126 = OpVectorShuffle %v2float %125 %125 0 1 %127 = OpFAdd %v2float %126 %124 %128 = OpLoad %v4float %FragColor %129 = OpVectorShuffle %v4float %128 %127 4 5 2 3 OpStore %FragColor %129 %130 = OpAccessChain %_ptr_Input_v2float %c %int_0 %131 = OpExtInst %v2float %1 InterpolateAtSample %130 %int_2 %132 = OpVectorShuffle %v2float %131 %131 1 0 %133 = OpLoad %v4float %FragColor %134 = OpVectorShuffle %v2float %133 %133 0 1 %135 = OpFAdd %v2float %134 %132 %136 = OpLoad %v4float %FragColor %137 = OpVectorShuffle %v4float %136 %135 4 5 2 3 OpStore %FragColor %137 %138 = OpAccessChain %_ptr_Input_v2float %c %int_1 %139 = OpExtInst %v2float %1 InterpolateAtOffset %138 %30 %140 = OpVectorShuffle %v2float %139 %139 0 0 %141 = OpLoad %v4float %FragColor %142 = OpVectorShuffle %v2float %141 %141 0 1 %143 = OpFAdd %v2float %142 %140 %144 = OpLoad %v4float %FragColor %145 = OpVectorShuffle %v4float %144 %143 4 5 2 3 OpStore %FragColor %145 %146 = OpAccessChain %_ptr_Input_v4float %s %int_0 %147 = OpLoad %v4float %146 %148 = OpLoad %v4float %FragColor %149 = OpFAdd %v4float %148 %147 OpStore %FragColor %149 %150 = OpAccessChain %_ptr_Input_v4float %s %int_0 %151 = OpExtInst %v4float %1 InterpolateAtCentroid %150 %152 = OpLoad %v4float %FragColor %153 = OpFAdd %v4float %152 %151 OpStore %FragColor %153 %154 = OpAccessChain %_ptr_Input_v4float %s %int_0 %155 = OpLoad %int %sid %156 = OpExtInst %v4float %1 InterpolateAtSample %154 %155 %157 = OpLoad %v4float %FragColor %158 = OpFAdd %v4float %157 %156 OpStore %FragColor %158 %159 = OpAccessChain %_ptr_Input_v4float %s %int_0 %160 = OpExtInst %v4float %1 InterpolateAtOffset %159 %44 %161 = OpLoad %v4float %FragColor %162 = OpFAdd %v4float %161 %160 OpStore %FragColor %162 %163 = OpAccessChain %_ptr_Input_v4float %s %int_1 %164 = OpLoad %v4float %163 %165 = OpLoad %v4float %FragColor %166 = OpFAdd %v4float %165 %164 OpStore %FragColor %166 %167 = OpAccessChain %_ptr_Input_v4float %s %int_1 %168 = OpExtInst %v4float %1 InterpolateAtCentroid %167 %169 = OpLoad %v4float %FragColor %170 = OpFAdd %v4float %169 %168 OpStore %FragColor %170 %171 = OpAccessChain %_ptr_Input_v4float %s %int_1 %172 = OpLoad %int %sid %173 = OpExtInst %v4float %1 InterpolateAtSample %171 %172 %174 = OpLoad %v4float %FragColor %175 = OpFAdd %v4float %174 %173 OpStore %FragColor %175 %176 = OpAccessChain %_ptr_Input_v4float %s %int_1 %177 = OpExtInst %v4float %1 InterpolateAtOffset %176 %47 %178 = OpLoad %v4float %FragColor %179 = OpFAdd %v4float %178 %177 OpStore %FragColor %179 %180 = OpAccessChain %_ptr_Input_v2float %s %int_4 %int_0 %181 = OpLoad %v2float %180 %182 = OpLoad %v4float %FragColor %183 = OpVectorShuffle %v2float %182 %182 0 1 %184 = OpFAdd %v2float %183 %181 %185 = OpLoad %v4float %FragColor %186 = OpVectorShuffle %v4float %185 %184 4 5 2 3 OpStore %FragColor %186 %187 = OpAccessChain %_ptr_Input_v2float %s %int_4 %int_1 %188 = OpExtInst %v2float %1 InterpolateAtCentroid %187 %189 = OpLoad %v4float %FragColor %190 = OpVectorShuffle %v2float %189 %189 0 1 %191 = OpFAdd %v2float %190 %188 %192 = OpLoad %v4float %FragColor %193 = OpVectorShuffle %v4float %192 %191 4 5 2 3 OpStore %FragColor %193 %194 = OpAccessChain %_ptr_Input_v2float %s %int_4 %int_0 %195 = OpExtInst %v2float %1 InterpolateAtSample %194 %int_2 %196 = OpLoad %v4float %FragColor %197 = OpVectorShuffle %v2float %196 %196 0 1 %198 = OpFAdd %v2float %197 %195 %199 = OpLoad %v4float %FragColor %200 = OpVectorShuffle %v4float %199 %198 4 5 2 3 OpStore %FragColor %200 %201 = OpAccessChain %_ptr_Input_v2float %s %int_4 %int_1 %202 = OpExtInst %v2float %1 InterpolateAtOffset %201 %30 %203 = OpLoad %v4float %FragColor %204 = OpVectorShuffle %v2float %203 %203 0 1 %205 = OpFAdd %v2float %204 %202 %206 = OpLoad %v4float %FragColor %207 = OpVectorShuffle %v4float %206 %205 4 5 2 3 OpStore %FragColor %207 %208 = OpAccessChain %_ptr_Input_float %s %int_5 %int_0 %209 = OpLoad %float %208 %210 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 %211 = OpLoad %float %210 %212 = OpFAdd %float %211 %209 %213 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 OpStore %213 %212 %214 = OpAccessChain %_ptr_Input_float %s %int_5 %int_1 %215 = OpExtInst %float %1 InterpolateAtCentroid %214 %216 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 %217 = OpLoad %float %216 %218 = OpFAdd %float %217 %215 %219 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 OpStore %219 %218 %220 = OpAccessChain %_ptr_Input_float %s %int_5 %int_0 %221 = OpExtInst %float %1 InterpolateAtSample %220 %int_2 %222 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 %223 = OpLoad %float %222 %224 = OpFAdd %float %223 %221 %225 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 OpStore %225 %224 %226 = OpAccessChain %_ptr_Input_float %s %int_5 %int_1 %227 = OpExtInst %float %1 InterpolateAtOffset %226 %30 %228 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 %229 = OpLoad %float %228 %230 = OpFAdd %float %229 %227 %231 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 OpStore %231 %230 %232 = OpFunctionCall %void %func_ OpReturn OpFunctionEnd %func_ = OpFunction %void None %15 %233 = OpLabel %234 = OpLoad %v2float %baz %235 = OpLoad %v4float %FragColor %236 = OpVectorShuffle %v2float %235 %235 0 1 %237 = OpFAdd %v2float %236 %234 %238 = OpLoad %v4float %FragColor %239 = OpVectorShuffle %v4float %238 %237 4 5 2 3 OpStore %FragColor %239 %240 = OpAccessChain %_ptr_Input_float %baz %uint_0 %241 = OpExtInst %float %1 InterpolateAtCentroid %240 %242 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 %243 = OpLoad %float %242 %244 = OpFAdd %float %243 %241 %245 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 OpStore %245 %244 %246 = OpAccessChain %_ptr_Input_float %baz %uint_1 %247 = OpExtInst %float %1 InterpolateAtSample %246 %int_3 %248 = OpAccessChain %_ptr_Output_float %FragColor %uint_1 %249 = OpLoad %float %248 %250 = OpFAdd %float %249 %247 %251 = OpAccessChain %_ptr_Output_float %FragColor %uint_1 OpStore %251 %250 %252 = OpAccessChain %_ptr_Input_float %baz %uint_1 %253 = OpExtInst %float %1 InterpolateAtOffset %252 %30 %254 = OpAccessChain %_ptr_Output_float %FragColor %uint_2 %255 = OpLoad %float %254 %256 = OpFAdd %float %255 %253 %257 = OpAccessChain %_ptr_Output_float %FragColor %uint_2 OpStore %257 %256 %258 = OpAccessChain %_ptr_Input_v2float %a %int_1 %259 = OpExtInst %v2float %1 InterpolateAtCentroid %258 %260 = OpLoad %v4float %FragColor %261 = OpVectorShuffle %v2float %260 %260 0 1 %262 = OpFAdd %v2float %261 %259 %263 = OpLoad %v4float %FragColor %264 = OpVectorShuffle %v4float %263 %262 4 5 2 3 OpStore %FragColor %264 %265 = OpAccessChain %_ptr_Input_v2float %a %int_0 %266 = OpExtInst %v2float %1 InterpolateAtSample %265 %int_2 %267 = OpLoad %v4float %FragColor %268 = OpVectorShuffle %v2float %267 %267 0 1 %269 = OpFAdd %v2float %268 %266 %270 = OpLoad %v4float %FragColor %271 = OpVectorShuffle %v4float %270 %269 4 5 2 3 OpStore %FragColor %271 %272 = OpAccessChain %_ptr_Input_v2float %a %int_1 %273 = OpExtInst %v2float %1 InterpolateAtOffset %272 %30 %274 = OpLoad %v4float %FragColor %275 = OpVectorShuffle %v2float %274 %274 0 1 %276 = OpFAdd %v2float %275 %273 %277 = OpLoad %v4float %FragColor %278 = OpVectorShuffle %v4float %277 %276 4 5 2 3 OpStore %FragColor %278 %279 = OpAccessChain %_ptr_Input_v4float %s %int_2 %280 = OpLoad %v4float %279 %281 = OpLoad %v4float %FragColor %282 = OpFAdd %v4float %281 %280 OpStore %FragColor %282 %283 = OpAccessChain %_ptr_Input_v4float %s %int_2 %284 = OpExtInst %v4float %1 InterpolateAtCentroid %283 %285 = OpVectorShuffle %v2float %284 %284 1 1 %286 = OpLoad %v4float %FragColor %287 = OpVectorShuffle %v2float %286 %286 0 1 %288 = OpFAdd %v2float %287 %285 %289 = OpLoad %v4float %FragColor %290 = OpVectorShuffle %v4float %289 %288 4 5 2 3 OpStore %FragColor %290 %291 = OpAccessChain %_ptr_Input_v4float %s %int_2 %292 = OpExtInst %v4float %1 InterpolateAtSample %291 %int_3 %293 = OpVectorShuffle %v2float %292 %292 0 1 %294 = OpLoad %v4float %FragColor %295 = OpVectorShuffle %v2float %294 %294 1 2 %296 = OpFAdd %v2float %295 %293 %297 = OpLoad %v4float %FragColor %298 = OpVectorShuffle %v4float %297 %296 0 4 5 3 OpStore %FragColor %298 %299 = OpAccessChain %_ptr_Input_v4float %s %int_2 %300 = OpExtInst %v4float %1 InterpolateAtOffset %299 %30 %301 = OpVectorShuffle %v2float %300 %300 3 0 %302 = OpLoad %v4float %FragColor %303 = OpVectorShuffle %v2float %302 %302 2 3 %304 = OpFAdd %v2float %303 %301 %305 = OpLoad %v4float %FragColor %306 = OpVectorShuffle %v4float %305 %304 0 1 4 5 OpStore %FragColor %306 %308 = OpAccessChain %_ptr_Input_v4float %s %int_3 %int_0 %309 = OpLoad %v4float %308 %310 = OpLoad %v4float %FragColor %311 = OpFAdd %v4float %310 %309 OpStore %FragColor %311 %312 = OpAccessChain %_ptr_Input__arr_v4float_uint_2 %s %int_3 %313 = OpAccessChain %_ptr_Input_v4float %312 %int_1 %314 = OpExtInst %v4float %1 InterpolateAtCentroid %313 %315 = OpLoad %v4float %FragColor %316 = OpFAdd %v4float %315 %314 OpStore %FragColor %316 %317 = OpAccessChain %_ptr_Input_v4float %s %int_3 %int_0 %318 = OpExtInst %v4float %1 InterpolateAtSample %317 %int_2 %319 = OpLoad %v4float %FragColor %320 = OpFAdd %v4float %319 %318 OpStore %FragColor %320 %321 = OpAccessChain %_ptr_Input_v4float %s %int_3 %int_1 %322 = OpExtInst %v4float %1 InterpolateAtOffset %321 %30 %323 = OpLoad %v4float %FragColor %324 = OpFAdd %v4float %323 %322 OpStore %FragColor %324 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/sample-and-compare.asm.frag000066400000000000000000000055611400026215700254070ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 32 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_TEXCOORD0 %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_2d_image "type.2d.image" OpName %g_Texture "g_Texture" OpName %type_sampler "type.sampler" OpName %g_Sampler "g_Sampler" OpName %g_CompareSampler "g_CompareSampler" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %g_Texture DescriptorSet 0 OpDecorate %g_Texture Binding 0 OpDecorate %g_Sampler DescriptorSet 0 OpDecorate %g_Sampler Binding 0 OpDecorate %g_CompareSampler DescriptorSet 0 OpDecorate %g_CompareSampler Binding 1 %float = OpTypeFloat 32 %float_0_5 = OpConstant %float 0.5 %float_0 = OpConstant %float 0 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Output_float = OpTypePointer Output %float %void = OpTypeVoid %19 = OpTypeFunction %void %type_sampled_image = OpTypeSampledImage %type_2d_image %v4float = OpTypeVector %float 4 %g_Texture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %g_CompareSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %19 %21 = OpLabel %22 = OpLoad %v2float %in_var_TEXCOORD0 %23 = OpLoad %type_2d_image %g_Texture %24 = OpLoad %type_sampler %g_Sampler %25 = OpSampledImage %type_sampled_image %23 %24 %26 = OpImageSampleImplicitLod %v4float %25 %22 None %27 = OpCompositeExtract %float %26 0 %28 = OpLoad %type_sampler %g_CompareSampler %29 = OpSampledImage %type_sampled_image %23 %28 %30 = OpImageSampleDrefExplicitLod %float %29 %22 %float_0_5 Lod %float_0 %31 = OpFAdd %float %27 %30 OpStore %out_var_SV_Target %31 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/single-function-private-lut.asm.frag000066400000000000000000000070071400026215700273150ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 54 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %o_color OpExecutionMode %main OriginUpperLeft OpSource GLSL 460 OpName %main "main" OpName %myType "myType" OpMemberName %myType 0 "data" OpName %myData "myData" OpName %uv "uv" OpName %gl_FragCoord "gl_FragCoord" OpName %index "index" OpName %elt "elt" OpName %o_color "o_color" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %o_color Location 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %myType = OpTypeStruct %float %uint = OpTypeInt 32 0 %uint_5 = OpConstant %uint 5 %_arr_myType_uint_5 = OpTypeArray %myType %uint_5 %_ptr_Private__arr_myType_uint_5 = OpTypePointer Private %_arr_myType_uint_5 %myData = OpVariable %_ptr_Private__arr_myType_uint_5 Private %float_0 = OpConstant %float 0 %18 = OpConstantComposite %myType %float_0 %float_1 = OpConstant %float 1 %20 = OpConstantComposite %myType %float_1 %21 = OpConstantComposite %_arr_myType_uint_5 %18 %20 %18 %20 %18 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %float_4 = OpConstant %float 4 %_ptr_Function_myType = OpTypePointer Function %myType %_ptr_Private_myType = OpTypePointer Private %myType %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_Output_v4float = OpTypePointer Output %v4float %o_color = OpVariable %_ptr_Output_v4float Output %36 = OpConstantComposite %v4float %float_0 %float_1 %float_0 %float_1 %37 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %main = OpFunction %void None %11 %38 = OpLabel %uv = OpVariable %_ptr_Function_v2float Function %index = OpVariable %_ptr_Function_int Function %elt = OpVariable %_ptr_Function_myType Function OpStore %myData %21 %39 = OpLoad %v4float %gl_FragCoord %40 = OpVectorShuffle %v2float %39 %39 0 1 OpStore %uv %40 %41 = OpAccessChain %_ptr_Function_float %uv %uint_0 %42 = OpLoad %float %41 %43 = OpFMod %float %42 %float_4 %44 = OpConvertFToS %int %43 OpStore %index %44 %45 = OpLoad %int %index %46 = OpAccessChain %_ptr_Private_myType %myData %45 %47 = OpLoad %myType %46 OpStore %elt %47 %48 = OpAccessChain %_ptr_Function_float %elt %int_0 %49 = OpLoad %float %48 %50 = OpFOrdGreaterThan %bool %49 %float_0 OpSelectionMerge %51 None OpBranchConditional %50 %52 %53 %52 = OpLabel OpStore %o_color %36 OpBranch %51 %53 = OpLabel OpStore %o_color %37 OpBranch %51 %51 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/srem.asm.frag000066400000000000000000000030661400026215700227060ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 23 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vA %vB OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %vA "vA" OpName %vB "vB" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %vA Flat OpDecorate %vA Location 0 OpDecorate %vB Flat OpDecorate %vB Location 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %_ptr_Input_v4int = OpTypePointer Input %v4int %vA = OpVariable %_ptr_Input_v4int Input %vB = OpVariable %_ptr_Input_v4int Input %main = OpFunction %void None %3 %5 = OpLabel %14 = OpLoad %v4int %vA %16 = OpLoad %v4int %vB %17 = OpLoad %v4int %vA %18 = OpLoad %v4int %vB %19 = OpSRem %v4int %17 %18 %20 = OpConvertSToF %v4float %19 OpStore %FragColor %20 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/storage-class-output-initializer.asm.frag000066400000000000000000000033231400026215700303620ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 25 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColors %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColors "FragColors" OpName %FragColor "FragColor" OpDecorate %FragColors Location 0 OpDecorate %FragColor Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_ptr_Output__arr_v4float_uint_2 = OpTypePointer Output %_arr_v4float_uint_2 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %17 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4 %float_10 = OpConstant %float 10 %19 = OpConstantComposite %v4float %float_10 %float_10 %float_10 %float_10 %20 = OpConstantComposite %_arr_v4float_uint_2 %17 %19 %_ptr_Output_v4float = OpTypePointer Output %v4float %float_5 = OpConstant %float 5 %24 = OpConstantComposite %v4float %float_5 %float_5 %float_5 %float_5 %FragColors = OpVariable %_ptr_Output__arr_v4float_uint_2 Output %20 %FragColor = OpVariable %_ptr_Output_v4float Output %24 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/texel-fetch-no-lod.asm.frag000066400000000000000000000035061400026215700253350ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 26 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %uTexture "uTexture" OpName %gl_FragCoord "gl_FragCoord" OpDecorate %FragColor Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 0 OpDecorate %gl_FragCoord BuiltIn FragCoord %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %uTexture = OpVariable %_ptr_UniformConstant_11 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %int_0 = OpConstant %int 0 %main = OpFunction %void None %3 %5 = OpLabel %14 = OpLoad %11 %uTexture %18 = OpLoad %v4float %gl_FragCoord %19 = OpVectorShuffle %v2float %18 %18 0 1 %22 = OpConvertFToS %v2int %19 %24 = OpImage %10 %14 %25 = OpImageFetch %v4float %24 %22 OpStore %FragColor %25 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/texture-sampling-fp16.asm.frag000066400000000000000000000035621400026215700260230ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 25 ; Schema: 0 OpCapability Shader OpCapability StorageInputOutput16 OpCapability Float16 OpExtension "SPV_KHR_16bit_storage" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %UV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_shader_explicit_arithmetic_types_float16" OpName %main "main" OpName %FragColor "FragColor" OpName %uTexture "uTexture" OpName %UV "UV" OpDecorate %FragColor Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 0 OpDecorate %UV Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %half = OpTypeFloat 16 %float = OpTypeFloat 32 %v4half = OpTypeVector %half 4 %v4float = OpTypeVector %float 4 %_ptr_Output_v4half = OpTypePointer Output %v4half %FragColor = OpVariable %_ptr_Output_v4half Output %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %12 = OpTypeSampledImage %11 %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %uTexture = OpVariable %_ptr_UniformConstant_12 UniformConstant %v2half = OpTypeVector %half 2 %_ptr_Input_v2half = OpTypePointer Input %v2half %UV = OpVariable %_ptr_Input_v2half Input %main = OpFunction %void None %3 %5 = OpLabel %15 = OpLoad %12 %uTexture %19 = OpLoad %v2half %UV %23 = OpImageSampleImplicitLod %v4float %15 %19 %24 = OpFConvert %v4half %23 OpStore %FragColor %24 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/undef-variable-store.asm.frag000066400000000000000000000063331400026215700257560ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 50 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %fragmentProgram "main" %_entryPointOutput OpExecutionMode %fragmentProgram OriginUpperLeft OpSource HLSL 500 OpName %fragmentProgram "fragmentProgram" OpName %_fragmentProgram_ "@fragmentProgram(" OpName %uv "uv" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %float_0 = OpConstant %float 0 %15 = OpConstantComposite %v2float %float_0 %float_0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %bool = OpTypeBool %float_1 = OpConstant %float 1 %26 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %29 = OpConstantComposite %v4float %float_1 %float_1 %float_0 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %false = OpConstantFalse %bool %fragmentProgram = OpFunction %void None %3 %5 = OpLabel %35 = OpVariable %_ptr_Function_v2float Function %37 = OpVariable %_ptr_Function_v4float Function OpBranch %38 %38 = OpLabel OpLoopMerge %39 %40 None OpBranch %41 %41 = OpLabel OpStore %35 %15 %42 = OpAccessChain %_ptr_Function_float %35 %uint_0 %43 = OpLoad %float %42 %44 = OpFOrdNotEqual %bool %43 %float_0 OpSelectionMerge %45 None OpBranchConditional %44 %46 %47 %46 = OpLabel OpStore %37 %26 OpBranch %39 %47 = OpLabel OpStore %37 %29 OpBranch %39 %45 = OpLabel %48 = OpUndef %v4float OpStore %37 %48 OpBranch %39 %40 = OpLabel OpBranchConditional %false %38 %39 %39 = OpLabel %34 = OpLoad %v4float %37 OpStore %_entryPointOutput %34 OpReturn OpFunctionEnd %_fragmentProgram_ = OpFunction %v4float None %8 %10 = OpLabel %uv = OpVariable %_ptr_Function_v2float Function OpStore %uv %15 %19 = OpAccessChain %_ptr_Function_float %uv %uint_0 %20 = OpLoad %float %19 %22 = OpFOrdNotEqual %bool %20 %float_0 OpSelectionMerge %24 None OpBranchConditional %22 %23 %28 %23 = OpLabel OpReturnValue %26 %28 = OpLabel OpReturnValue %29 %24 = OpLabel %31 = OpUndef %v4float OpReturnValue %31 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/unknown-depth-state.asm.frag000066400000000000000000000056641400026215700256650ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 44 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vUV %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %sample_combined_ "sample_combined(" OpName %sample_separate_ "sample_separate(" OpName %uShadow "uShadow" OpName %vUV "vUV" OpName %uTexture "uTexture" OpName %uSampler "uSampler" OpName %FragColor "FragColor" OpDecorate %uShadow DescriptorSet 0 OpDecorate %uShadow Binding 0 OpDecorate %vUV Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 1 OpDecorate %uSampler DescriptorSet 0 OpDecorate %uSampler Binding 2 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeFunction %float %12 = OpTypeImage %float 2D 2 0 0 1 Unknown %13 = OpTypeSampledImage %12 %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %uShadow = OpVariable %_ptr_UniformConstant_13 UniformConstant %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %vUV = OpVariable %_ptr_Input_v3float Input %_ptr_UniformConstant_25 = OpTypePointer UniformConstant %12 %uTexture = OpVariable %_ptr_UniformConstant_25 UniformConstant %29 = OpTypeSampler %_ptr_UniformConstant_29 = OpTypePointer UniformConstant %29 %uSampler = OpVariable %_ptr_UniformConstant_29 UniformConstant %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %41 = OpFunctionCall %float %sample_combined_ %42 = OpFunctionCall %float %sample_separate_ %43 = OpFAdd %float %41 %42 OpStore %FragColor %43 OpReturn OpFunctionEnd %sample_combined_ = OpFunction %float None %7 %9 = OpLabel %16 = OpLoad %13 %uShadow %20 = OpLoad %v3float %vUV %21 = OpCompositeExtract %float %20 2 %22 = OpImageSampleDrefImplicitLod %float %16 %20 %21 OpReturnValue %22 OpFunctionEnd %sample_separate_ = OpFunction %float None %7 %11 = OpLabel %28 = OpLoad %12 %uTexture %32 = OpLoad %29 %uSampler %33 = OpSampledImage %13 %28 %32 %34 = OpLoad %v3float %vUV %35 = OpCompositeExtract %float %34 2 %36 = OpImageSampleDrefImplicitLod %float %33 %34 %35 OpReturnValue %36 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/unord-relational-op.asm.frag000066400000000000000000000177741400026215700256460ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 122 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %c %d %e %f %g %h %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 460 OpName %main "main" OpName %t0 "t0" OpName %a "a" OpName %t1 "t1" OpName %b "b" OpName %c1 "c1" OpName %c2 "c2" OpName %c3 "c3" OpName %c4 "c4" OpName %c5 "c5" OpName %c6 "c6" OpName %c7 "c7" OpName %c "c" OpName %d "d" OpName %c8 "c8" OpName %c9 "c9" OpName %c10 "c10" OpName %c11 "c11" OpName %c12 "c12" OpName %c13 "c13" OpName %e "e" OpName %f "f" OpName %c14 "c14" OpName %c15 "c15" OpName %c16 "c16" OpName %c17 "c17" OpName %c18 "c18" OpName %c19 "c19" OpName %g "g" OpName %h "h" OpName %c20 "c20" OpName %c21 "c21" OpName %c22 "c22" OpName %c23 "c23" OpName %c24 "c24" OpName %FragColor "FragColor" OpDecorate %a SpecId 1 OpDecorate %b SpecId 2 OpDecorate %c Location 2 OpDecorate %d Location 3 OpDecorate %e Location 4 OpDecorate %f Location 5 OpDecorate %g Location 6 OpDecorate %h Location 7 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %a = OpSpecConstant %float 1 %b = OpSpecConstant %float 2 %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %v2bool = OpTypeVector %bool 2 %_ptr_Function_v2bool = OpTypePointer Function %v2bool %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %c = OpVariable %_ptr_Input_v2float Input %d = OpVariable %_ptr_Input_v2float Input %v3bool = OpTypeVector %bool 3 %_ptr_Function_v3bool = OpTypePointer Function %v3bool %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %e = OpVariable %_ptr_Input_v3float Input %f = OpVariable %_ptr_Input_v3float Input %v4bool = OpTypeVector %bool 4 %_ptr_Function_v4bool = OpTypePointer Function %v4bool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %g = OpVariable %_ptr_Input_v4float Input %h = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %t0 = OpVariable %_ptr_Function_float Function %t1 = OpVariable %_ptr_Function_float Function %c1 = OpVariable %_ptr_Function_bool Function %c2 = OpVariable %_ptr_Function_bool Function %c3 = OpVariable %_ptr_Function_bool Function %c4 = OpVariable %_ptr_Function_bool Function %c5 = OpVariable %_ptr_Function_bool Function %c6 = OpVariable %_ptr_Function_bool Function %c7 = OpVariable %_ptr_Function_v2bool Function %c8 = OpVariable %_ptr_Function_v2bool Function %c9 = OpVariable %_ptr_Function_v2bool Function %c10 = OpVariable %_ptr_Function_v2bool Function %c11 = OpVariable %_ptr_Function_v2bool Function %c12 = OpVariable %_ptr_Function_v2bool Function %c13 = OpVariable %_ptr_Function_v3bool Function %c14 = OpVariable %_ptr_Function_v3bool Function %c15 = OpVariable %_ptr_Function_v3bool Function %c16 = OpVariable %_ptr_Function_v3bool Function %c17 = OpVariable %_ptr_Function_v3bool Function %c18 = OpVariable %_ptr_Function_v3bool Function %c19 = OpVariable %_ptr_Function_v4bool Function %c20 = OpVariable %_ptr_Function_v4bool Function %c21 = OpVariable %_ptr_Function_v4bool Function %c22 = OpVariable %_ptr_Function_v4bool Function %c23 = OpVariable %_ptr_Function_v4bool Function %c24 = OpVariable %_ptr_Function_v4bool Function OpStore %t0 %a OpStore %t1 %b %15 = OpFUnordEqual %bool %a %b OpStore %c1 %15 %17 = OpFUnordNotEqual %bool %a %b OpStore %c2 %17 %19 = OpFUnordLessThan %bool %a %b OpStore %c3 %19 %21 = OpFUnordGreaterThan %bool %a %b OpStore %c4 %21 %23 = OpFUnordLessThanEqual %bool %a %b OpStore %c5 %23 %25 = OpFUnordGreaterThanEqual %bool %a %b OpStore %c6 %25 %32 = OpLoad %v2float %c %34 = OpLoad %v2float %d %35 = OpFUnordEqual %v2bool %32 %34 OpStore %c7 %35 %37 = OpLoad %v2float %c %38 = OpLoad %v2float %d %39 = OpFUnordNotEqual %v2bool %37 %38 OpStore %c8 %39 %41 = OpLoad %v2float %c %42 = OpLoad %v2float %d %43 = OpFUnordLessThan %v2bool %41 %42 OpStore %c9 %43 %45 = OpLoad %v2float %c %46 = OpLoad %v2float %d %47 = OpFUnordGreaterThan %v2bool %45 %46 OpStore %c10 %47 %49 = OpLoad %v2float %c %50 = OpLoad %v2float %d %51 = OpFUnordLessThanEqual %v2bool %49 %50 OpStore %c11 %51 %53 = OpLoad %v2float %c %54 = OpLoad %v2float %d %55 = OpFUnordGreaterThanEqual %v2bool %53 %54 OpStore %c12 %55 %62 = OpLoad %v3float %e %64 = OpLoad %v3float %f %65 = OpFUnordEqual %v3bool %62 %64 OpStore %c13 %65 %67 = OpLoad %v3float %e %68 = OpLoad %v3float %f %69 = OpFUnordNotEqual %v3bool %67 %68 OpStore %c14 %69 %71 = OpLoad %v3float %e %72 = OpLoad %v3float %f %73 = OpFUnordLessThan %v3bool %71 %72 OpStore %c15 %73 %75 = OpLoad %v3float %e %76 = OpLoad %v3float %f %77 = OpFUnordGreaterThan %v3bool %75 %76 OpStore %c16 %77 %79 = OpLoad %v3float %e %80 = OpLoad %v3float %f %81 = OpFUnordLessThanEqual %v3bool %79 %80 OpStore %c17 %81 %83 = OpLoad %v3float %e %84 = OpLoad %v3float %f %85 = OpFUnordGreaterThanEqual %v3bool %83 %84 OpStore %c18 %85 %92 = OpLoad %v4float %g %94 = OpLoad %v4float %h %95 = OpFUnordEqual %v4bool %92 %94 OpStore %c19 %95 %97 = OpLoad %v4float %g %98 = OpLoad %v4float %h %99 = OpFUnordNotEqual %v4bool %97 %98 OpStore %c20 %99 %101 = OpLoad %v4float %g %102 = OpLoad %v4float %h %103 = OpFUnordLessThan %v4bool %101 %102 OpStore %c21 %103 %105 = OpLoad %v4float %g %106 = OpLoad %v4float %h %107 = OpFUnordGreaterThan %v4bool %105 %106 OpStore %c22 %107 %109 = OpLoad %v4float %g %110 = OpLoad %v4float %h %111 = OpFUnordLessThanEqual %v4bool %109 %110 OpStore %c23 %111 %113 = OpLoad %v4float %g %114 = OpLoad %v4float %h %115 = OpFUnordGreaterThanEqual %v4bool %113 %114 OpStore %c24 %115 %118 = OpLoad %float %t0 %119 = OpLoad %float %t1 %120 = OpFAdd %float %118 %119 %121 = OpCompositeConstruct %v4float %120 %120 %120 %120 OpStore %FragColor %121 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/unreachable.asm.frag000066400000000000000000000043361400026215700242120ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 47 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %counter %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %counter "counter" OpName %FragColor "FragColor" OpDecorate %counter Flat OpDecorate %counter Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %counter = OpVariable %_ptr_Input_int Input %int_10 = OpConstant %int 10 %bool = OpTypeBool %float_10 = OpConstant %float 10 %21 = OpConstantComposite %v4float %float_10 %float_10 %float_10 %float_10 %float_30 = OpConstant %float 30 %25 = OpConstantComposite %v4float %float_30 %float_30 %float_30 %float_30 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %false = OpConstantFalse %bool %44 = OpUndef %v4float %main = OpFunction %void None %3 %5 = OpLabel OpBranch %33 %33 = OpLabel %45 = OpPhi %v4float %44 %5 %44 %35 OpLoopMerge %34 %35 None OpBranch %36 %36 = OpLabel %37 = OpLoad %int %counter %38 = OpIEqual %bool %37 %int_10 OpSelectionMerge %39 None OpBranchConditional %38 %40 %41 %40 = OpLabel OpBranch %34 %41 = OpLabel OpBranch %34 %39 = OpLabel OpUnreachable %35 = OpLabel OpBranchConditional %false %33 %34 %34 = OpLabel %46 = OpPhi %v4float %21 %40 %25 %41 %44 %35 OpStore %FragColor %46 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/frag/vector-shuffle-oom.asm.frag000066400000000000000000001322041400026215700254610ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 25007 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %5663 "main" %5800 %gl_FragCoord %4317 OpExecutionMode %5663 OriginUpperLeft OpMemberDecorate %_struct_1116 0 Offset 0 OpMemberDecorate %_struct_1116 1 Offset 16 OpMemberDecorate %_struct_1116 2 Offset 32 OpDecorate %_struct_1116 Block OpDecorate %22044 DescriptorSet 0 OpDecorate %22044 Binding 0 OpDecorate %5785 DescriptorSet 0 OpDecorate %5785 Binding 14 OpDecorate %5688 DescriptorSet 0 OpDecorate %5688 Binding 6 OpMemberDecorate %_struct_994 0 Offset 0 OpMemberDecorate %_struct_994 1 Offset 16 OpMemberDecorate %_struct_994 2 Offset 28 OpMemberDecorate %_struct_994 3 Offset 32 OpMemberDecorate %_struct_994 4 Offset 44 OpMemberDecorate %_struct_994 5 Offset 48 OpMemberDecorate %_struct_994 6 Offset 60 OpMemberDecorate %_struct_994 7 Offset 64 OpMemberDecorate %_struct_994 8 Offset 76 OpMemberDecorate %_struct_994 9 Offset 80 OpMemberDecorate %_struct_994 10 Offset 92 OpMemberDecorate %_struct_994 11 Offset 96 OpMemberDecorate %_struct_994 12 Offset 108 OpMemberDecorate %_struct_994 13 Offset 112 OpMemberDecorate %_struct_994 14 Offset 120 OpMemberDecorate %_struct_994 15 Offset 128 OpMemberDecorate %_struct_994 16 Offset 140 OpMemberDecorate %_struct_994 17 Offset 144 OpMemberDecorate %_struct_994 18 Offset 148 OpMemberDecorate %_struct_994 19 Offset 152 OpMemberDecorate %_struct_994 20 Offset 156 OpMemberDecorate %_struct_994 21 Offset 160 OpMemberDecorate %_struct_994 22 Offset 176 OpMemberDecorate %_struct_994 23 RowMajor OpMemberDecorate %_struct_994 23 Offset 192 OpMemberDecorate %_struct_994 23 MatrixStride 16 OpMemberDecorate %_struct_994 24 Offset 256 OpDecorate %_struct_994 Block OpDecorate %12348 DescriptorSet 0 OpDecorate %12348 Binding 2 OpDecorate %3312 DescriptorSet 0 OpDecorate %3312 Binding 13 OpDecorate %4646 DescriptorSet 0 OpDecorate %4646 Binding 5 OpDecorate %4862 DescriptorSet 0 OpDecorate %4862 Binding 4 OpDecorate %3594 DescriptorSet 0 OpDecorate %3594 Binding 3 OpDecorate %_arr_mat4v4float_uint_2 ArrayStride 64 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpMemberDecorate %_struct_408 0 RowMajor OpMemberDecorate %_struct_408 0 Offset 0 OpMemberDecorate %_struct_408 0 MatrixStride 16 OpMemberDecorate %_struct_408 1 RowMajor OpMemberDecorate %_struct_408 1 Offset 64 OpMemberDecorate %_struct_408 1 MatrixStride 16 OpMemberDecorate %_struct_408 2 RowMajor OpMemberDecorate %_struct_408 2 Offset 128 OpMemberDecorate %_struct_408 2 MatrixStride 16 OpMemberDecorate %_struct_408 3 RowMajor OpMemberDecorate %_struct_408 3 Offset 192 OpMemberDecorate %_struct_408 3 MatrixStride 16 OpMemberDecorate %_struct_408 4 Offset 256 OpMemberDecorate %_struct_408 5 Offset 272 OpMemberDecorate %_struct_408 6 Offset 288 OpMemberDecorate %_struct_408 7 Offset 292 OpMemberDecorate %_struct_408 8 Offset 296 OpMemberDecorate %_struct_408 9 Offset 300 OpMemberDecorate %_struct_408 10 Offset 304 OpMemberDecorate %_struct_408 11 Offset 316 OpMemberDecorate %_struct_408 12 Offset 320 OpMemberDecorate %_struct_408 13 Offset 332 OpMemberDecorate %_struct_408 14 Offset 336 OpMemberDecorate %_struct_408 15 Offset 348 OpMemberDecorate %_struct_408 16 Offset 352 OpMemberDecorate %_struct_408 17 Offset 364 OpMemberDecorate %_struct_408 18 Offset 368 OpMemberDecorate %_struct_408 19 Offset 372 OpMemberDecorate %_struct_408 20 Offset 376 OpMemberDecorate %_struct_408 21 Offset 384 OpMemberDecorate %_struct_408 22 Offset 392 OpMemberDecorate %_struct_408 23 Offset 400 OpMemberDecorate %_struct_408 24 Offset 416 OpMemberDecorate %_struct_408 25 Offset 424 OpMemberDecorate %_struct_408 26 Offset 432 OpMemberDecorate %_struct_408 27 Offset 448 OpMemberDecorate %_struct_408 28 Offset 460 OpMemberDecorate %_struct_408 29 Offset 464 OpMemberDecorate %_struct_408 30 Offset 468 OpMemberDecorate %_struct_408 31 Offset 472 OpMemberDecorate %_struct_408 32 Offset 476 OpMemberDecorate %_struct_408 33 Offset 480 OpMemberDecorate %_struct_408 34 Offset 488 OpMemberDecorate %_struct_408 35 Offset 492 OpMemberDecorate %_struct_408 36 Offset 496 OpMemberDecorate %_struct_408 37 RowMajor OpMemberDecorate %_struct_408 37 Offset 512 OpMemberDecorate %_struct_408 37 MatrixStride 16 OpMemberDecorate %_struct_408 38 Offset 640 OpDecorate %_struct_408 Block OpDecorate %15259 DescriptorSet 0 OpDecorate %15259 Binding 1 OpDecorate %5800 Location 0 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %4317 Location 0 OpMemberDecorate %_struct_1395 0 Offset 0 OpMemberDecorate %_struct_1395 1 Offset 16 OpMemberDecorate %_struct_1395 2 Offset 32 OpMemberDecorate %_struct_1395 3 Offset 40 OpMemberDecorate %_struct_1395 4 Offset 48 OpMemberDecorate %_struct_1395 5 Offset 60 OpMemberDecorate %_struct_1395 6 Offset 64 OpMemberDecorate %_struct_1395 7 Offset 76 OpMemberDecorate %_struct_1395 8 Offset 80 OpMemberDecorate %_struct_1395 9 Offset 96 OpMemberDecorate %_struct_1395 10 Offset 112 OpMemberDecorate %_struct_1395 11 Offset 128 OpMemberDecorate %_struct_1395 12 Offset 140 OpMemberDecorate %_struct_1395 13 Offset 144 OpMemberDecorate %_struct_1395 14 Offset 156 OpMemberDecorate %_struct_1395 15 Offset 160 OpMemberDecorate %_struct_1395 16 Offset 176 OpMemberDecorate %_struct_1395 17 Offset 192 OpMemberDecorate %_struct_1395 18 Offset 204 OpMemberDecorate %_struct_1395 19 Offset 208 OpMemberDecorate %_struct_1395 20 Offset 224 OpDecorate %_struct_1395 Block OpMemberDecorate %_struct_1018 0 Offset 0 OpDecorate %_struct_1018 Block %void = OpTypeVoid %1282 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %_struct_1017 = OpTypeStruct %v4float %_struct_1116 = OpTypeStruct %v4float %float %v4float %_ptr_Uniform__struct_1116 = OpTypePointer Uniform %_struct_1116 %22044 = OpVariable %_ptr_Uniform__struct_1116 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %150 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_150 = OpTypePointer UniformConstant %150 %5785 = OpVariable %_ptr_UniformConstant_150 UniformConstant %508 = OpTypeSampler %_ptr_UniformConstant_508 = OpTypePointer UniformConstant %508 %5688 = OpVariable %_ptr_UniformConstant_508 UniformConstant %510 = OpTypeSampledImage %150 %float_0 = OpConstant %float 0 %uint = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %float_1 = OpConstant %float 1 %mat4v4float = OpTypeMatrix %v4float 4 %_struct_994 = OpTypeStruct %v3float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v2float %v2float %v3float %float %float %float %float %float %v4float %v4float %mat4v4float %v4float %_ptr_Uniform__struct_994 = OpTypePointer Uniform %_struct_994 %12348 = OpVariable %_ptr_Uniform__struct_994 Uniform %int_5 = OpConstant %int 5 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %3312 = OpVariable %_ptr_UniformConstant_150 UniformConstant %4646 = OpVariable %_ptr_UniformConstant_508 UniformConstant %bool = OpTypeBool %4862 = OpVariable %_ptr_UniformConstant_150 UniformConstant %3594 = OpVariable %_ptr_UniformConstant_508 UniformConstant %uint_2 = OpConstant %uint 2 %2938 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_arr_mat4v4float_uint_2 = OpTypeArray %mat4v4float %uint_2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_struct_408 = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %float %float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %v2float %v2float %v2float %v4float %v2float %v2float %v2float %v3float %float %float %float %float %float %v2float %float %float %v3float %_arr_mat4v4float_uint_2 %_arr_v4float_uint_2 %_ptr_Uniform__struct_408 = OpTypePointer Uniform %_struct_408 %15259 = OpVariable %_ptr_Uniform__struct_408 Uniform %int_23 = OpConstant %int 23 %int_2 = OpConstant %int 2 %float_n2 = OpConstant %float -2 %float_0_5 = OpConstant %float 0.5 %1196 = OpConstantComposite %v3float %float_0 %float_n2 %float_0_5 %float_n1 = OpConstant %float -1 %836 = OpConstantComposite %v3float %float_n1 %float_n1 %float_0_5 %float_0_75 = OpConstant %float 0.75 %1367 = OpConstantComposite %v3float %float_0 %float_n1 %float_0_75 %141 = OpConstantComposite %v3float %float_1 %float_n1 %float_0_5 %38 = OpConstantComposite %v3float %float_n2 %float_0 %float_0_5 %95 = OpConstantComposite %v3float %float_n1 %float_0 %float_0_75 %626 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %2411 = OpConstantComposite %v3float %float_1 %float_0 %float_0_75 %float_2 = OpConstant %float 2 %2354 = OpConstantComposite %v3float %float_2 %float_0 %float_0_5 %837 = OpConstantComposite %v3float %float_n1 %float_1 %float_0_5 %1368 = OpConstantComposite %v3float %float_0 %float_1 %float_0_75 %142 = OpConstantComposite %v3float %float_1 %float_1 %float_0_5 %1197 = OpConstantComposite %v3float %float_0 %float_2 %float_0_5 %_ptr_Input_v2float = OpTypePointer Input %v2float %5800 = OpVariable %_ptr_Input_v2float Input %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %4317 = OpVariable %_ptr_Output_v4float Output %_struct_1395 = OpTypeStruct %v4float %v4float %v2float %v2float %v3float %float %v3float %float %v4float %v4float %v4float %v3float %float %v3float %float %v3float %v4float %v3float %float %v3float %v2float %_struct_1018 = OpTypeStruct %v4float %10264 = OpUndef %_struct_1017 %5663 = OpFunction %void None %1282 %25006 = OpLabel %17463 = OpLoad %v4float %gl_FragCoord %13863 = OpCompositeInsert %_struct_1017 %2938 %10264 0 %22969 = OpVectorShuffle %v2float %17463 %17463 0 1 %13206 = OpAccessChain %_ptr_Uniform_v4float %15259 %int_23 %10343 = OpLoad %v4float %13206 %7422 = OpVectorShuffle %v2float %10343 %10343 0 1 %19927 = OpFMul %v2float %22969 %7422 %18174 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_2 %16206 = OpLoad %v4float %18174 %20420 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %21354 = OpLoad %v4float %20420 %7688 = OpVectorShuffle %v4float %21354 %21354 0 1 0 1 %17581 = OpFMul %v4float %16206 %7688 %10673 = OpVectorShuffle %v2float %1196 %1196 0 1 %18824 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10344 = OpLoad %v4float %18824 %8638 = OpVectorShuffle %v2float %10344 %10344 0 1 %9197 = OpFMul %v2float %10673 %8638 %18505 = OpFAdd %v2float %19927 %9197 %7011 = OpVectorShuffle %v2float %17581 %17581 0 1 %21058 = OpVectorShuffle %v2float %17581 %17581 2 3 %13149 = OpExtInst %v2float %1 FClamp %18505 %7011 %21058 %23584 = OpLoad %150 %5785 %10339 = OpLoad %508 %5688 %12147 = OpSampledImage %510 %23584 %10339 %15371 = OpImageSampleExplicitLod %v4float %12147 %13149 Lod %float_0 %15266 = OpCompositeExtract %float %15371 3 %12116 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12972 = OpLoad %float %12116 %15710 = OpFMul %float %15266 %12972 %15279 = OpExtInst %float %1 FClamp %15710 %float_0 %float_1 %22213 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11756 = OpLoad %v3float %22213 %12103 = OpVectorTimesScalar %v3float %11756 %15279 %15516 = OpLoad %150 %3312 %24569 = OpLoad %508 %4646 %12148 = OpSampledImage %510 %15516 %24569 %17670 = OpImageSampleExplicitLod %v4float %12148 %13149 Lod %float_0 %16938 = OpCompositeExtract %float %17670 1 %14185 = OpFOrdGreaterThan %bool %16938 %float_0 OpSelectionMerge %22307 DontFlatten OpBranchConditional %14185 %12821 %22307 %12821 = OpLabel %13239 = OpLoad %150 %4862 %19960 = OpLoad %508 %3594 %12149 = OpSampledImage %510 %13239 %19960 %15675 = OpImageSampleExplicitLod %v4float %12149 %13149 Lod %float_0 %13866 = OpCompositeExtract %float %17670 1 %12427 = OpCompositeExtract %float %17670 2 %23300 = OpFMul %float %13866 %12427 %17612 = OpExtInst %float %1 FClamp %23300 %float_0 %float_1 %20291 = OpVectorShuffle %v3float %15675 %15675 0 1 2 %11186 = OpVectorTimesScalar %v3float %20291 %17612 %15293 = OpFAdd %v3float %12103 %11186 OpBranch %22307 %22307 = OpLabel %7719 = OpPhi %v3float %12103 %25006 %15293 %12821 %23399 = OpVectorTimesScalar %v3float %7719 %float_0_5 %9339 = OpFAdd %float %float_0 %float_0_5 %16235 = OpVectorShuffle %v3float %2938 %2938 0 1 2 %22177 = OpFAdd %v3float %16235 %23399 %15527 = OpVectorShuffle %v4float %2938 %22177 4 5 6 3 %6434 = OpCompositeInsert %_struct_1017 %15527 %13863 0 %24572 = OpVectorShuffle %v2float %836 %836 0 1 %13207 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10345 = OpLoad %v4float %13207 %8639 = OpVectorShuffle %v2float %10345 %10345 0 1 %9198 = OpFMul %v2float %24572 %8639 %18506 = OpFAdd %v2float %19927 %9198 %7012 = OpVectorShuffle %v2float %17581 %17581 0 1 %21059 = OpVectorShuffle %v2float %17581 %17581 2 3 %13150 = OpExtInst %v2float %1 FClamp %18506 %7012 %21059 %23585 = OpLoad %150 %5785 %10340 = OpLoad %508 %5688 %12150 = OpSampledImage %510 %23585 %10340 %15372 = OpImageSampleExplicitLod %v4float %12150 %13150 Lod %float_0 %15267 = OpCompositeExtract %float %15372 3 %12117 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12973 = OpLoad %float %12117 %15711 = OpFMul %float %15267 %12973 %15280 = OpExtInst %float %1 FClamp %15711 %float_0 %float_1 %22214 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11757 = OpLoad %v3float %22214 %12104 = OpVectorTimesScalar %v3float %11757 %15280 %15517 = OpLoad %150 %3312 %24570 = OpLoad %508 %4646 %12151 = OpSampledImage %510 %15517 %24570 %17671 = OpImageSampleExplicitLod %v4float %12151 %13150 Lod %float_0 %16939 = OpCompositeExtract %float %17671 1 %14186 = OpFOrdGreaterThan %bool %16939 %float_0 OpSelectionMerge %22308 DontFlatten OpBranchConditional %14186 %12822 %22308 %12822 = OpLabel %13240 = OpLoad %150 %4862 %19961 = OpLoad %508 %3594 %12152 = OpSampledImage %510 %13240 %19961 %15676 = OpImageSampleExplicitLod %v4float %12152 %13150 Lod %float_0 %13867 = OpCompositeExtract %float %17671 1 %12428 = OpCompositeExtract %float %17671 2 %23301 = OpFMul %float %13867 %12428 %17613 = OpExtInst %float %1 FClamp %23301 %float_0 %float_1 %20292 = OpVectorShuffle %v3float %15676 %15676 0 1 2 %11187 = OpVectorTimesScalar %v3float %20292 %17613 %15294 = OpFAdd %v3float %12104 %11187 OpBranch %22308 %22308 = OpLabel %7720 = OpPhi %v3float %12104 %22307 %15294 %12822 %23400 = OpVectorTimesScalar %v3float %7720 %float_0_5 %9340 = OpFAdd %float %9339 %float_0_5 %16236 = OpVectorShuffle %v3float %15527 %15527 0 1 2 %22178 = OpFAdd %v3float %16236 %23400 %15528 = OpVectorShuffle %v4float %15527 %22178 4 5 6 3 %6435 = OpCompositeInsert %_struct_1017 %15528 %6434 0 %24573 = OpVectorShuffle %v2float %1367 %1367 0 1 %13208 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10346 = OpLoad %v4float %13208 %8640 = OpVectorShuffle %v2float %10346 %10346 0 1 %9199 = OpFMul %v2float %24573 %8640 %18507 = OpFAdd %v2float %19927 %9199 %7013 = OpVectorShuffle %v2float %17581 %17581 0 1 %21060 = OpVectorShuffle %v2float %17581 %17581 2 3 %13151 = OpExtInst %v2float %1 FClamp %18507 %7013 %21060 %23586 = OpLoad %150 %5785 %10341 = OpLoad %508 %5688 %12153 = OpSampledImage %510 %23586 %10341 %15373 = OpImageSampleExplicitLod %v4float %12153 %13151 Lod %float_0 %15268 = OpCompositeExtract %float %15373 3 %12118 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12974 = OpLoad %float %12118 %15712 = OpFMul %float %15268 %12974 %15281 = OpExtInst %float %1 FClamp %15712 %float_0 %float_1 %22215 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11758 = OpLoad %v3float %22215 %12105 = OpVectorTimesScalar %v3float %11758 %15281 %15518 = OpLoad %150 %3312 %24571 = OpLoad %508 %4646 %12154 = OpSampledImage %510 %15518 %24571 %17672 = OpImageSampleExplicitLod %v4float %12154 %13151 Lod %float_0 %16940 = OpCompositeExtract %float %17672 1 %14187 = OpFOrdGreaterThan %bool %16940 %float_0 OpSelectionMerge %22309 DontFlatten OpBranchConditional %14187 %12823 %22309 %12823 = OpLabel %13241 = OpLoad %150 %4862 %19962 = OpLoad %508 %3594 %12155 = OpSampledImage %510 %13241 %19962 %15677 = OpImageSampleExplicitLod %v4float %12155 %13151 Lod %float_0 %13868 = OpCompositeExtract %float %17672 1 %12429 = OpCompositeExtract %float %17672 2 %23302 = OpFMul %float %13868 %12429 %17614 = OpExtInst %float %1 FClamp %23302 %float_0 %float_1 %20293 = OpVectorShuffle %v3float %15677 %15677 0 1 2 %11188 = OpVectorTimesScalar %v3float %20293 %17614 %15295 = OpFAdd %v3float %12105 %11188 OpBranch %22309 %22309 = OpLabel %7721 = OpPhi %v3float %12105 %22308 %15295 %12823 %23401 = OpVectorTimesScalar %v3float %7721 %float_0_75 %9341 = OpFAdd %float %9340 %float_0_75 %16237 = OpVectorShuffle %v3float %15528 %15528 0 1 2 %22179 = OpFAdd %v3float %16237 %23401 %15529 = OpVectorShuffle %v4float %15528 %22179 4 5 6 3 %6436 = OpCompositeInsert %_struct_1017 %15529 %6435 0 %24574 = OpVectorShuffle %v2float %141 %141 0 1 %13209 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10347 = OpLoad %v4float %13209 %8641 = OpVectorShuffle %v2float %10347 %10347 0 1 %9200 = OpFMul %v2float %24574 %8641 %18508 = OpFAdd %v2float %19927 %9200 %7014 = OpVectorShuffle %v2float %17581 %17581 0 1 %21061 = OpVectorShuffle %v2float %17581 %17581 2 3 %13152 = OpExtInst %v2float %1 FClamp %18508 %7014 %21061 %23587 = OpLoad %150 %5785 %10342 = OpLoad %508 %5688 %12156 = OpSampledImage %510 %23587 %10342 %15374 = OpImageSampleExplicitLod %v4float %12156 %13152 Lod %float_0 %15269 = OpCompositeExtract %float %15374 3 %12119 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12975 = OpLoad %float %12119 %15713 = OpFMul %float %15269 %12975 %15282 = OpExtInst %float %1 FClamp %15713 %float_0 %float_1 %22216 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11759 = OpLoad %v3float %22216 %12106 = OpVectorTimesScalar %v3float %11759 %15282 %15519 = OpLoad %150 %3312 %24575 = OpLoad %508 %4646 %12157 = OpSampledImage %510 %15519 %24575 %17673 = OpImageSampleExplicitLod %v4float %12157 %13152 Lod %float_0 %16941 = OpCompositeExtract %float %17673 1 %14188 = OpFOrdGreaterThan %bool %16941 %float_0 OpSelectionMerge %22310 DontFlatten OpBranchConditional %14188 %12824 %22310 %12824 = OpLabel %13242 = OpLoad %150 %4862 %19963 = OpLoad %508 %3594 %12158 = OpSampledImage %510 %13242 %19963 %15678 = OpImageSampleExplicitLod %v4float %12158 %13152 Lod %float_0 %13869 = OpCompositeExtract %float %17673 1 %12430 = OpCompositeExtract %float %17673 2 %23303 = OpFMul %float %13869 %12430 %17615 = OpExtInst %float %1 FClamp %23303 %float_0 %float_1 %20294 = OpVectorShuffle %v3float %15678 %15678 0 1 2 %11189 = OpVectorTimesScalar %v3float %20294 %17615 %15296 = OpFAdd %v3float %12106 %11189 OpBranch %22310 %22310 = OpLabel %7722 = OpPhi %v3float %12106 %22309 %15296 %12824 %23402 = OpVectorTimesScalar %v3float %7722 %float_0_5 %9342 = OpFAdd %float %9341 %float_0_5 %16238 = OpVectorShuffle %v3float %15529 %15529 0 1 2 %22180 = OpFAdd %v3float %16238 %23402 %15530 = OpVectorShuffle %v4float %15529 %22180 4 5 6 3 %6437 = OpCompositeInsert %_struct_1017 %15530 %6436 0 %24576 = OpVectorShuffle %v2float %38 %38 0 1 %13210 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10348 = OpLoad %v4float %13210 %8642 = OpVectorShuffle %v2float %10348 %10348 0 1 %9201 = OpFMul %v2float %24576 %8642 %18509 = OpFAdd %v2float %19927 %9201 %7015 = OpVectorShuffle %v2float %17581 %17581 0 1 %21062 = OpVectorShuffle %v2float %17581 %17581 2 3 %13153 = OpExtInst %v2float %1 FClamp %18509 %7015 %21062 %23588 = OpLoad %150 %5785 %10349 = OpLoad %508 %5688 %12159 = OpSampledImage %510 %23588 %10349 %15375 = OpImageSampleExplicitLod %v4float %12159 %13153 Lod %float_0 %15270 = OpCompositeExtract %float %15375 3 %12120 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12976 = OpLoad %float %12120 %15714 = OpFMul %float %15270 %12976 %15283 = OpExtInst %float %1 FClamp %15714 %float_0 %float_1 %22217 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11760 = OpLoad %v3float %22217 %12107 = OpVectorTimesScalar %v3float %11760 %15283 %15520 = OpLoad %150 %3312 %24577 = OpLoad %508 %4646 %12160 = OpSampledImage %510 %15520 %24577 %17674 = OpImageSampleExplicitLod %v4float %12160 %13153 Lod %float_0 %16942 = OpCompositeExtract %float %17674 1 %14189 = OpFOrdGreaterThan %bool %16942 %float_0 OpSelectionMerge %22311 DontFlatten OpBranchConditional %14189 %12825 %22311 %12825 = OpLabel %13243 = OpLoad %150 %4862 %19964 = OpLoad %508 %3594 %12161 = OpSampledImage %510 %13243 %19964 %15679 = OpImageSampleExplicitLod %v4float %12161 %13153 Lod %float_0 %13870 = OpCompositeExtract %float %17674 1 %12431 = OpCompositeExtract %float %17674 2 %23304 = OpFMul %float %13870 %12431 %17616 = OpExtInst %float %1 FClamp %23304 %float_0 %float_1 %20295 = OpVectorShuffle %v3float %15679 %15679 0 1 2 %11190 = OpVectorTimesScalar %v3float %20295 %17616 %15297 = OpFAdd %v3float %12107 %11190 OpBranch %22311 %22311 = OpLabel %7723 = OpPhi %v3float %12107 %22310 %15297 %12825 %23403 = OpVectorTimesScalar %v3float %7723 %float_0_5 %9343 = OpFAdd %float %9342 %float_0_5 %16239 = OpVectorShuffle %v3float %15530 %15530 0 1 2 %22181 = OpFAdd %v3float %16239 %23403 %15531 = OpVectorShuffle %v4float %15530 %22181 4 5 6 3 %6438 = OpCompositeInsert %_struct_1017 %15531 %6437 0 %24578 = OpVectorShuffle %v2float %95 %95 0 1 %13211 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10350 = OpLoad %v4float %13211 %8643 = OpVectorShuffle %v2float %10350 %10350 0 1 %9202 = OpFMul %v2float %24578 %8643 %18510 = OpFAdd %v2float %19927 %9202 %7016 = OpVectorShuffle %v2float %17581 %17581 0 1 %21063 = OpVectorShuffle %v2float %17581 %17581 2 3 %13154 = OpExtInst %v2float %1 FClamp %18510 %7016 %21063 %23589 = OpLoad %150 %5785 %10351 = OpLoad %508 %5688 %12162 = OpSampledImage %510 %23589 %10351 %15376 = OpImageSampleExplicitLod %v4float %12162 %13154 Lod %float_0 %15271 = OpCompositeExtract %float %15376 3 %12121 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12977 = OpLoad %float %12121 %15715 = OpFMul %float %15271 %12977 %15284 = OpExtInst %float %1 FClamp %15715 %float_0 %float_1 %22218 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11761 = OpLoad %v3float %22218 %12108 = OpVectorTimesScalar %v3float %11761 %15284 %15521 = OpLoad %150 %3312 %24579 = OpLoad %508 %4646 %12163 = OpSampledImage %510 %15521 %24579 %17675 = OpImageSampleExplicitLod %v4float %12163 %13154 Lod %float_0 %16943 = OpCompositeExtract %float %17675 1 %14190 = OpFOrdGreaterThan %bool %16943 %float_0 OpSelectionMerge %22312 DontFlatten OpBranchConditional %14190 %12826 %22312 %12826 = OpLabel %13244 = OpLoad %150 %4862 %19965 = OpLoad %508 %3594 %12164 = OpSampledImage %510 %13244 %19965 %15680 = OpImageSampleExplicitLod %v4float %12164 %13154 Lod %float_0 %13871 = OpCompositeExtract %float %17675 1 %12432 = OpCompositeExtract %float %17675 2 %23305 = OpFMul %float %13871 %12432 %17617 = OpExtInst %float %1 FClamp %23305 %float_0 %float_1 %20296 = OpVectorShuffle %v3float %15680 %15680 0 1 2 %11191 = OpVectorTimesScalar %v3float %20296 %17617 %15298 = OpFAdd %v3float %12108 %11191 OpBranch %22312 %22312 = OpLabel %7724 = OpPhi %v3float %12108 %22311 %15298 %12826 %23404 = OpVectorTimesScalar %v3float %7724 %float_0_75 %9344 = OpFAdd %float %9343 %float_0_75 %16240 = OpVectorShuffle %v3float %15531 %15531 0 1 2 %22182 = OpFAdd %v3float %16240 %23404 %15532 = OpVectorShuffle %v4float %15531 %22182 4 5 6 3 %6439 = OpCompositeInsert %_struct_1017 %15532 %6438 0 %24580 = OpVectorShuffle %v2float %626 %626 0 1 %13212 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10352 = OpLoad %v4float %13212 %8644 = OpVectorShuffle %v2float %10352 %10352 0 1 %9203 = OpFMul %v2float %24580 %8644 %18511 = OpFAdd %v2float %19927 %9203 %7017 = OpVectorShuffle %v2float %17581 %17581 0 1 %21064 = OpVectorShuffle %v2float %17581 %17581 2 3 %13155 = OpExtInst %v2float %1 FClamp %18511 %7017 %21064 %23590 = OpLoad %150 %5785 %10353 = OpLoad %508 %5688 %12165 = OpSampledImage %510 %23590 %10353 %15377 = OpImageSampleExplicitLod %v4float %12165 %13155 Lod %float_0 %15272 = OpCompositeExtract %float %15377 3 %12122 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12978 = OpLoad %float %12122 %15716 = OpFMul %float %15272 %12978 %15285 = OpExtInst %float %1 FClamp %15716 %float_0 %float_1 %22219 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11762 = OpLoad %v3float %22219 %12109 = OpVectorTimesScalar %v3float %11762 %15285 %15522 = OpLoad %150 %3312 %24581 = OpLoad %508 %4646 %12166 = OpSampledImage %510 %15522 %24581 %17676 = OpImageSampleExplicitLod %v4float %12166 %13155 Lod %float_0 %16944 = OpCompositeExtract %float %17676 1 %14191 = OpFOrdGreaterThan %bool %16944 %float_0 OpSelectionMerge %22313 DontFlatten OpBranchConditional %14191 %12827 %22313 %12827 = OpLabel %13245 = OpLoad %150 %4862 %19966 = OpLoad %508 %3594 %12167 = OpSampledImage %510 %13245 %19966 %15681 = OpImageSampleExplicitLod %v4float %12167 %13155 Lod %float_0 %13872 = OpCompositeExtract %float %17676 1 %12433 = OpCompositeExtract %float %17676 2 %23306 = OpFMul %float %13872 %12433 %17618 = OpExtInst %float %1 FClamp %23306 %float_0 %float_1 %20297 = OpVectorShuffle %v3float %15681 %15681 0 1 2 %11192 = OpVectorTimesScalar %v3float %20297 %17618 %15299 = OpFAdd %v3float %12109 %11192 OpBranch %22313 %22313 = OpLabel %7725 = OpPhi %v3float %12109 %22312 %15299 %12827 %23405 = OpVectorTimesScalar %v3float %7725 %float_1 %9345 = OpFAdd %float %9344 %float_1 %16241 = OpVectorShuffle %v3float %15532 %15532 0 1 2 %22183 = OpFAdd %v3float %16241 %23405 %15533 = OpVectorShuffle %v4float %15532 %22183 4 5 6 3 %6440 = OpCompositeInsert %_struct_1017 %15533 %6439 0 %24582 = OpVectorShuffle %v2float %2411 %2411 0 1 %13213 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10354 = OpLoad %v4float %13213 %8645 = OpVectorShuffle %v2float %10354 %10354 0 1 %9204 = OpFMul %v2float %24582 %8645 %18512 = OpFAdd %v2float %19927 %9204 %7018 = OpVectorShuffle %v2float %17581 %17581 0 1 %21065 = OpVectorShuffle %v2float %17581 %17581 2 3 %13156 = OpExtInst %v2float %1 FClamp %18512 %7018 %21065 %23591 = OpLoad %150 %5785 %10355 = OpLoad %508 %5688 %12168 = OpSampledImage %510 %23591 %10355 %15378 = OpImageSampleExplicitLod %v4float %12168 %13156 Lod %float_0 %15273 = OpCompositeExtract %float %15378 3 %12123 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12979 = OpLoad %float %12123 %15717 = OpFMul %float %15273 %12979 %15286 = OpExtInst %float %1 FClamp %15717 %float_0 %float_1 %22220 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11763 = OpLoad %v3float %22220 %12110 = OpVectorTimesScalar %v3float %11763 %15286 %15523 = OpLoad %150 %3312 %24583 = OpLoad %508 %4646 %12169 = OpSampledImage %510 %15523 %24583 %17677 = OpImageSampleExplicitLod %v4float %12169 %13156 Lod %float_0 %16945 = OpCompositeExtract %float %17677 1 %14192 = OpFOrdGreaterThan %bool %16945 %float_0 OpSelectionMerge %22314 DontFlatten OpBranchConditional %14192 %12828 %22314 %12828 = OpLabel %13246 = OpLoad %150 %4862 %19967 = OpLoad %508 %3594 %12170 = OpSampledImage %510 %13246 %19967 %15682 = OpImageSampleExplicitLod %v4float %12170 %13156 Lod %float_0 %13873 = OpCompositeExtract %float %17677 1 %12434 = OpCompositeExtract %float %17677 2 %23307 = OpFMul %float %13873 %12434 %17619 = OpExtInst %float %1 FClamp %23307 %float_0 %float_1 %20298 = OpVectorShuffle %v3float %15682 %15682 0 1 2 %11193 = OpVectorTimesScalar %v3float %20298 %17619 %15300 = OpFAdd %v3float %12110 %11193 OpBranch %22314 %22314 = OpLabel %7726 = OpPhi %v3float %12110 %22313 %15300 %12828 %23406 = OpVectorTimesScalar %v3float %7726 %float_0_75 %9346 = OpFAdd %float %9345 %float_0_75 %16242 = OpVectorShuffle %v3float %15533 %15533 0 1 2 %22184 = OpFAdd %v3float %16242 %23406 %15534 = OpVectorShuffle %v4float %15533 %22184 4 5 6 3 %6441 = OpCompositeInsert %_struct_1017 %15534 %6440 0 %24584 = OpVectorShuffle %v2float %2354 %2354 0 1 %13214 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10356 = OpLoad %v4float %13214 %8646 = OpVectorShuffle %v2float %10356 %10356 0 1 %9205 = OpFMul %v2float %24584 %8646 %18513 = OpFAdd %v2float %19927 %9205 %7019 = OpVectorShuffle %v2float %17581 %17581 0 1 %21066 = OpVectorShuffle %v2float %17581 %17581 2 3 %13157 = OpExtInst %v2float %1 FClamp %18513 %7019 %21066 %23592 = OpLoad %150 %5785 %10357 = OpLoad %508 %5688 %12171 = OpSampledImage %510 %23592 %10357 %15379 = OpImageSampleExplicitLod %v4float %12171 %13157 Lod %float_0 %15274 = OpCompositeExtract %float %15379 3 %12124 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12980 = OpLoad %float %12124 %15718 = OpFMul %float %15274 %12980 %15287 = OpExtInst %float %1 FClamp %15718 %float_0 %float_1 %22221 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11764 = OpLoad %v3float %22221 %12111 = OpVectorTimesScalar %v3float %11764 %15287 %15524 = OpLoad %150 %3312 %24585 = OpLoad %508 %4646 %12172 = OpSampledImage %510 %15524 %24585 %17678 = OpImageSampleExplicitLod %v4float %12172 %13157 Lod %float_0 %16946 = OpCompositeExtract %float %17678 1 %14193 = OpFOrdGreaterThan %bool %16946 %float_0 OpSelectionMerge %22315 DontFlatten OpBranchConditional %14193 %12829 %22315 %12829 = OpLabel %13247 = OpLoad %150 %4862 %19968 = OpLoad %508 %3594 %12173 = OpSampledImage %510 %13247 %19968 %15683 = OpImageSampleExplicitLod %v4float %12173 %13157 Lod %float_0 %13874 = OpCompositeExtract %float %17678 1 %12435 = OpCompositeExtract %float %17678 2 %23308 = OpFMul %float %13874 %12435 %17620 = OpExtInst %float %1 FClamp %23308 %float_0 %float_1 %20299 = OpVectorShuffle %v3float %15683 %15683 0 1 2 %11194 = OpVectorTimesScalar %v3float %20299 %17620 %15301 = OpFAdd %v3float %12111 %11194 OpBranch %22315 %22315 = OpLabel %7727 = OpPhi %v3float %12111 %22314 %15301 %12829 %23407 = OpVectorTimesScalar %v3float %7727 %float_0_5 %9347 = OpFAdd %float %9346 %float_0_5 %16243 = OpVectorShuffle %v3float %15534 %15534 0 1 2 %22185 = OpFAdd %v3float %16243 %23407 %15535 = OpVectorShuffle %v4float %15534 %22185 4 5 6 3 %6442 = OpCompositeInsert %_struct_1017 %15535 %6441 0 %24586 = OpVectorShuffle %v2float %837 %837 0 1 %13215 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10358 = OpLoad %v4float %13215 %8647 = OpVectorShuffle %v2float %10358 %10358 0 1 %9206 = OpFMul %v2float %24586 %8647 %18514 = OpFAdd %v2float %19927 %9206 %7020 = OpVectorShuffle %v2float %17581 %17581 0 1 %21067 = OpVectorShuffle %v2float %17581 %17581 2 3 %13158 = OpExtInst %v2float %1 FClamp %18514 %7020 %21067 %23593 = OpLoad %150 %5785 %10359 = OpLoad %508 %5688 %12174 = OpSampledImage %510 %23593 %10359 %15380 = OpImageSampleExplicitLod %v4float %12174 %13158 Lod %float_0 %15275 = OpCompositeExtract %float %15380 3 %12125 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12981 = OpLoad %float %12125 %15719 = OpFMul %float %15275 %12981 %15288 = OpExtInst %float %1 FClamp %15719 %float_0 %float_1 %22222 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11765 = OpLoad %v3float %22222 %12112 = OpVectorTimesScalar %v3float %11765 %15288 %15525 = OpLoad %150 %3312 %24587 = OpLoad %508 %4646 %12175 = OpSampledImage %510 %15525 %24587 %17679 = OpImageSampleExplicitLod %v4float %12175 %13158 Lod %float_0 %16947 = OpCompositeExtract %float %17679 1 %14194 = OpFOrdGreaterThan %bool %16947 %float_0 OpSelectionMerge %22316 DontFlatten OpBranchConditional %14194 %12830 %22316 %12830 = OpLabel %13248 = OpLoad %150 %4862 %19969 = OpLoad %508 %3594 %12176 = OpSampledImage %510 %13248 %19969 %15684 = OpImageSampleExplicitLod %v4float %12176 %13158 Lod %float_0 %13875 = OpCompositeExtract %float %17679 1 %12436 = OpCompositeExtract %float %17679 2 %23309 = OpFMul %float %13875 %12436 %17621 = OpExtInst %float %1 FClamp %23309 %float_0 %float_1 %20300 = OpVectorShuffle %v3float %15684 %15684 0 1 2 %11195 = OpVectorTimesScalar %v3float %20300 %17621 %15302 = OpFAdd %v3float %12112 %11195 OpBranch %22316 %22316 = OpLabel %7728 = OpPhi %v3float %12112 %22315 %15302 %12830 %23408 = OpVectorTimesScalar %v3float %7728 %float_0_5 %9348 = OpFAdd %float %9347 %float_0_5 %16244 = OpVectorShuffle %v3float %15535 %15535 0 1 2 %22186 = OpFAdd %v3float %16244 %23408 %15536 = OpVectorShuffle %v4float %15535 %22186 4 5 6 3 %6443 = OpCompositeInsert %_struct_1017 %15536 %6442 0 %24588 = OpVectorShuffle %v2float %1368 %1368 0 1 %13216 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10360 = OpLoad %v4float %13216 %8648 = OpVectorShuffle %v2float %10360 %10360 0 1 %9207 = OpFMul %v2float %24588 %8648 %18515 = OpFAdd %v2float %19927 %9207 %7021 = OpVectorShuffle %v2float %17581 %17581 0 1 %21068 = OpVectorShuffle %v2float %17581 %17581 2 3 %13159 = OpExtInst %v2float %1 FClamp %18515 %7021 %21068 %23594 = OpLoad %150 %5785 %10361 = OpLoad %508 %5688 %12177 = OpSampledImage %510 %23594 %10361 %15381 = OpImageSampleExplicitLod %v4float %12177 %13159 Lod %float_0 %15276 = OpCompositeExtract %float %15381 3 %12126 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12982 = OpLoad %float %12126 %15720 = OpFMul %float %15276 %12982 %15289 = OpExtInst %float %1 FClamp %15720 %float_0 %float_1 %22223 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11766 = OpLoad %v3float %22223 %12113 = OpVectorTimesScalar %v3float %11766 %15289 %15526 = OpLoad %150 %3312 %24589 = OpLoad %508 %4646 %12178 = OpSampledImage %510 %15526 %24589 %17680 = OpImageSampleExplicitLod %v4float %12178 %13159 Lod %float_0 %16948 = OpCompositeExtract %float %17680 1 %14195 = OpFOrdGreaterThan %bool %16948 %float_0 OpSelectionMerge %22317 DontFlatten OpBranchConditional %14195 %12831 %22317 %12831 = OpLabel %13249 = OpLoad %150 %4862 %19970 = OpLoad %508 %3594 %12179 = OpSampledImage %510 %13249 %19970 %15685 = OpImageSampleExplicitLod %v4float %12179 %13159 Lod %float_0 %13876 = OpCompositeExtract %float %17680 1 %12437 = OpCompositeExtract %float %17680 2 %23310 = OpFMul %float %13876 %12437 %17622 = OpExtInst %float %1 FClamp %23310 %float_0 %float_1 %20301 = OpVectorShuffle %v3float %15685 %15685 0 1 2 %11196 = OpVectorTimesScalar %v3float %20301 %17622 %15303 = OpFAdd %v3float %12113 %11196 OpBranch %22317 %22317 = OpLabel %7729 = OpPhi %v3float %12113 %22316 %15303 %12831 %23409 = OpVectorTimesScalar %v3float %7729 %float_0_75 %9349 = OpFAdd %float %9348 %float_0_75 %16245 = OpVectorShuffle %v3float %15536 %15536 0 1 2 %22187 = OpFAdd %v3float %16245 %23409 %15537 = OpVectorShuffle %v4float %15536 %22187 4 5 6 3 %6444 = OpCompositeInsert %_struct_1017 %15537 %6443 0 %24590 = OpVectorShuffle %v2float %142 %142 0 1 %13217 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10362 = OpLoad %v4float %13217 %8649 = OpVectorShuffle %v2float %10362 %10362 0 1 %9208 = OpFMul %v2float %24590 %8649 %18516 = OpFAdd %v2float %19927 %9208 %7022 = OpVectorShuffle %v2float %17581 %17581 0 1 %21069 = OpVectorShuffle %v2float %17581 %17581 2 3 %13160 = OpExtInst %v2float %1 FClamp %18516 %7022 %21069 %23595 = OpLoad %150 %5785 %10363 = OpLoad %508 %5688 %12180 = OpSampledImage %510 %23595 %10363 %15382 = OpImageSampleExplicitLod %v4float %12180 %13160 Lod %float_0 %15277 = OpCompositeExtract %float %15382 3 %12127 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12983 = OpLoad %float %12127 %15721 = OpFMul %float %15277 %12983 %15290 = OpExtInst %float %1 FClamp %15721 %float_0 %float_1 %22224 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11767 = OpLoad %v3float %22224 %12114 = OpVectorTimesScalar %v3float %11767 %15290 %15538 = OpLoad %150 %3312 %24591 = OpLoad %508 %4646 %12181 = OpSampledImage %510 %15538 %24591 %17681 = OpImageSampleExplicitLod %v4float %12181 %13160 Lod %float_0 %16949 = OpCompositeExtract %float %17681 1 %14196 = OpFOrdGreaterThan %bool %16949 %float_0 OpSelectionMerge %22318 DontFlatten OpBranchConditional %14196 %12832 %22318 %12832 = OpLabel %13250 = OpLoad %150 %4862 %19971 = OpLoad %508 %3594 %12182 = OpSampledImage %510 %13250 %19971 %15686 = OpImageSampleExplicitLod %v4float %12182 %13160 Lod %float_0 %13877 = OpCompositeExtract %float %17681 1 %12438 = OpCompositeExtract %float %17681 2 %23311 = OpFMul %float %13877 %12438 %17623 = OpExtInst %float %1 FClamp %23311 %float_0 %float_1 %20302 = OpVectorShuffle %v3float %15686 %15686 0 1 2 %11197 = OpVectorTimesScalar %v3float %20302 %17623 %15304 = OpFAdd %v3float %12114 %11197 OpBranch %22318 %22318 = OpLabel %7730 = OpPhi %v3float %12114 %22317 %15304 %12832 %23410 = OpVectorTimesScalar %v3float %7730 %float_0_5 %9350 = OpFAdd %float %9349 %float_0_5 %16246 = OpVectorShuffle %v3float %15537 %15537 0 1 2 %22188 = OpFAdd %v3float %16246 %23410 %15539 = OpVectorShuffle %v4float %15537 %22188 4 5 6 3 %6445 = OpCompositeInsert %_struct_1017 %15539 %6444 0 %24592 = OpVectorShuffle %v2float %1197 %1197 0 1 %13218 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10364 = OpLoad %v4float %13218 %8650 = OpVectorShuffle %v2float %10364 %10364 0 1 %9209 = OpFMul %v2float %24592 %8650 %18517 = OpFAdd %v2float %19927 %9209 %7023 = OpVectorShuffle %v2float %17581 %17581 0 1 %21070 = OpVectorShuffle %v2float %17581 %17581 2 3 %13161 = OpExtInst %v2float %1 FClamp %18517 %7023 %21070 %23596 = OpLoad %150 %5785 %10365 = OpLoad %508 %5688 %12183 = OpSampledImage %510 %23596 %10365 %15383 = OpImageSampleExplicitLod %v4float %12183 %13161 Lod %float_0 %15278 = OpCompositeExtract %float %15383 3 %12128 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12984 = OpLoad %float %12128 %15722 = OpFMul %float %15278 %12984 %15291 = OpExtInst %float %1 FClamp %15722 %float_0 %float_1 %22225 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11768 = OpLoad %v3float %22225 %12115 = OpVectorTimesScalar %v3float %11768 %15291 %15540 = OpLoad %150 %3312 %24593 = OpLoad %508 %4646 %12184 = OpSampledImage %510 %15540 %24593 %17682 = OpImageSampleExplicitLod %v4float %12184 %13161 Lod %float_0 %16950 = OpCompositeExtract %float %17682 1 %14197 = OpFOrdGreaterThan %bool %16950 %float_0 OpSelectionMerge %22319 DontFlatten OpBranchConditional %14197 %12833 %22319 %12833 = OpLabel %13251 = OpLoad %150 %4862 %19972 = OpLoad %508 %3594 %12185 = OpSampledImage %510 %13251 %19972 %15687 = OpImageSampleExplicitLod %v4float %12185 %13161 Lod %float_0 %13878 = OpCompositeExtract %float %17682 1 %12439 = OpCompositeExtract %float %17682 2 %23312 = OpFMul %float %13878 %12439 %17624 = OpExtInst %float %1 FClamp %23312 %float_0 %float_1 %20303 = OpVectorShuffle %v3float %15687 %15687 0 1 2 %11198 = OpVectorTimesScalar %v3float %20303 %17624 %15305 = OpFAdd %v3float %12115 %11198 OpBranch %22319 %22319 = OpLabel %7731 = OpPhi %v3float %12115 %22318 %15305 %12833 %23411 = OpVectorTimesScalar %v3float %7731 %float_0_5 %9351 = OpFAdd %float %9350 %float_0_5 %16247 = OpVectorShuffle %v3float %15539 %15539 0 1 2 %22189 = OpFAdd %v3float %16247 %23411 %15541 = OpVectorShuffle %v4float %15539 %22189 4 5 6 3 %6719 = OpCompositeInsert %_struct_1017 %15541 %6445 0 %23412 = OpVectorShuffle %v3float %15541 %15541 0 1 2 %10833 = OpCompositeConstruct %v3float %9351 %9351 %9351 %13750 = OpFDiv %v3float %23412 %10833 %24033 = OpVectorShuffle %v4float %15541 %13750 4 5 6 3 %8636 = OpCompositeInsert %_struct_1017 %24033 %6719 0 %16315 = OpCompositeInsert %_struct_1017 %float_1 %8636 0 3 %11544 = OpCompositeExtract %v4float %16315 0 OpStore %4317 %11544 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/tesc/000077500000000000000000000000001400026215700203325ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/asm/tesc/tess-level-overrun.asm.tesc000066400000000000000000000116621400026215700255600ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 46 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_TessLevelInner %gl_TessLevelOuter OpExecutionMode %main OutputVertices 1 OpExecutionMode %main Triangles OpSource ESSL 310 OpSourceExtension "GL_EXT_shader_io_blocks" OpSourceExtension "GL_EXT_tessellation_shader" OpName %main "main" OpName %gl_TessLevelInner "gl_TessLevelInner" OpName %TessLevels "TessLevels" OpMemberName %TessLevels 0 "inner0" OpMemberName %TessLevels 1 "inner1" OpMemberName %TessLevels 2 "outer0" OpMemberName %TessLevels 3 "outer1" OpMemberName %TessLevels 4 "outer2" OpMemberName %TessLevels 5 "outer3" OpName %sb_levels "sb_levels" OpName %gl_TessLevelOuter "gl_TessLevelOuter" OpDecorate %gl_TessLevelInner Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpMemberDecorate %TessLevels 0 Restrict OpMemberDecorate %TessLevels 0 NonWritable OpMemberDecorate %TessLevels 0 Offset 0 OpMemberDecorate %TessLevels 1 Restrict OpMemberDecorate %TessLevels 1 NonWritable OpMemberDecorate %TessLevels 1 Offset 4 OpMemberDecorate %TessLevels 2 Restrict OpMemberDecorate %TessLevels 2 NonWritable OpMemberDecorate %TessLevels 2 Offset 8 OpMemberDecorate %TessLevels 3 Restrict OpMemberDecorate %TessLevels 3 NonWritable OpMemberDecorate %TessLevels 3 Offset 12 OpMemberDecorate %TessLevels 4 Restrict OpMemberDecorate %TessLevels 4 NonWritable OpMemberDecorate %TessLevels 4 Offset 16 OpMemberDecorate %TessLevels 5 Restrict OpMemberDecorate %TessLevels 5 NonWritable OpMemberDecorate %TessLevels 5 Offset 20 OpDecorate %TessLevels Block OpDecorate %sb_levels DescriptorSet 0 OpDecorate %sb_levels Binding 0 OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %gl_TessLevelInner = OpVariable %_ptr_Output__arr_float_uint_2 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %TessLevels = OpTypeStruct %float %float %float %float %float %float %_ptr_StorageBuffer_TessLevels = OpTypePointer StorageBuffer %TessLevels %sb_levels = OpVariable %_ptr_StorageBuffer_TessLevels StorageBuffer %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_ptr_Output_float = OpTypePointer Output %float %int_1 = OpConstant %int 1 %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %gl_TessLevelOuter = OpVariable %_ptr_Output__arr_float_uint_4 Output %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_0 %19 = OpLoad %float %18 %21 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_0 OpStore %21 %19 %23 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_1 %24 = OpLoad %float %23 %25 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_1 OpStore %25 %24 %31 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_2 %32 = OpLoad %float %31 %33 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_0 OpStore %33 %32 %35 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_3 %36 = OpLoad %float %35 %37 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_1 OpStore %37 %36 %39 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_4 %40 = OpLoad %float %39 %41 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_2 OpStore %41 %40 %43 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_5 %44 = OpLoad %float %43 %45 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_3 OpStore %45 %44 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/tesc/tess-level-overrun.multi-patch.asm.tesc000066400000000000000000000116621400026215700300060ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 46 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_TessLevelInner %gl_TessLevelOuter OpExecutionMode %main OutputVertices 1 OpExecutionMode %main Triangles OpSource ESSL 310 OpSourceExtension "GL_EXT_shader_io_blocks" OpSourceExtension "GL_EXT_tessellation_shader" OpName %main "main" OpName %gl_TessLevelInner "gl_TessLevelInner" OpName %TessLevels "TessLevels" OpMemberName %TessLevels 0 "inner0" OpMemberName %TessLevels 1 "inner1" OpMemberName %TessLevels 2 "outer0" OpMemberName %TessLevels 3 "outer1" OpMemberName %TessLevels 4 "outer2" OpMemberName %TessLevels 5 "outer3" OpName %sb_levels "sb_levels" OpName %gl_TessLevelOuter "gl_TessLevelOuter" OpDecorate %gl_TessLevelInner Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpMemberDecorate %TessLevels 0 Restrict OpMemberDecorate %TessLevels 0 NonWritable OpMemberDecorate %TessLevels 0 Offset 0 OpMemberDecorate %TessLevels 1 Restrict OpMemberDecorate %TessLevels 1 NonWritable OpMemberDecorate %TessLevels 1 Offset 4 OpMemberDecorate %TessLevels 2 Restrict OpMemberDecorate %TessLevels 2 NonWritable OpMemberDecorate %TessLevels 2 Offset 8 OpMemberDecorate %TessLevels 3 Restrict OpMemberDecorate %TessLevels 3 NonWritable OpMemberDecorate %TessLevels 3 Offset 12 OpMemberDecorate %TessLevels 4 Restrict OpMemberDecorate %TessLevels 4 NonWritable OpMemberDecorate %TessLevels 4 Offset 16 OpMemberDecorate %TessLevels 5 Restrict OpMemberDecorate %TessLevels 5 NonWritable OpMemberDecorate %TessLevels 5 Offset 20 OpDecorate %TessLevels Block OpDecorate %sb_levels DescriptorSet 0 OpDecorate %sb_levels Binding 0 OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %gl_TessLevelInner = OpVariable %_ptr_Output__arr_float_uint_2 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %TessLevels = OpTypeStruct %float %float %float %float %float %float %_ptr_StorageBuffer_TessLevels = OpTypePointer StorageBuffer %TessLevels %sb_levels = OpVariable %_ptr_StorageBuffer_TessLevels StorageBuffer %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_ptr_Output_float = OpTypePointer Output %float %int_1 = OpConstant %int 1 %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %gl_TessLevelOuter = OpVariable %_ptr_Output__arr_float_uint_4 Output %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_0 %19 = OpLoad %float %18 %21 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_0 OpStore %21 %19 %23 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_1 %24 = OpLoad %float %23 %25 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_1 OpStore %25 %24 %31 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_2 %32 = OpLoad %float %31 %33 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_0 OpStore %33 %32 %35 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_3 %36 = OpLoad %float %35 %37 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_1 OpStore %37 %36 %39 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_4 %40 = OpLoad %float %39 %41 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_2 OpStore %41 %40 %43 = OpAccessChain %_ptr_StorageBuffer_float %sb_levels %int_5 %44 = OpLoad %float %43 %45 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_3 OpStore %45 %44 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/tese/000077500000000000000000000000001400026215700203345ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/asm/tese/unnamed-builtin-array.asm.tese000066400000000000000000000105141400026215700262050ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 72 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" %_ %gl_TessCoord %gl_TessLevelInner %gl_TessLevelOuter OpExecutionMode %main Quads OpExecutionMode %main SpacingFractionalEven OpExecutionMode %main VertexOrderCw OpSource ESSL 310 OpSourceExtension "GL_EXT_shader_io_blocks" OpSourceExtension "GL_EXT_tessellation_shader" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpDecorate %gl_PerVertex Block OpDecorate %gl_TessCoord BuiltIn TessCoord OpDecorate %gl_TessLevelInner Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %gl_PerVertex = OpTypeStruct %v4float %float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %gl_TessCoord = OpVariable %_ptr_Input_v3float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Input__arr_float_uint_2 = OpTypePointer Input %_arr_float_uint_2 %gl_TessLevelInner = OpVariable %_ptr_Input__arr_float_uint_2 Input %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Input__arr_float_uint_4 = OpTypePointer Input %_arr_float_uint_4 %gl_TessLevelOuter = OpVariable %_ptr_Input__arr_float_uint_4 Input %float_1 = OpConstant %float 1 %int_2 = OpConstant %int 2 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %float_0 = OpConstant %float 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Input_float %gl_TessCoord %uint_0 %20 = OpLoad %float %19 %25 = OpAccessChain %_ptr_Input_float %gl_TessLevelInner %int_0 %26 = OpLoad %float %25 %27 = OpFMul %float %20 %26 %32 = OpAccessChain %_ptr_Input_float %gl_TessLevelOuter %int_0 %33 = OpLoad %float %32 %34 = OpFMul %float %27 %33 %36 = OpAccessChain %_ptr_Input_float %gl_TessCoord %uint_0 %37 = OpLoad %float %36 %38 = OpFSub %float %float_1 %37 %39 = OpAccessChain %_ptr_Input_float %gl_TessLevelInner %int_0 %40 = OpLoad %float %39 %41 = OpFMul %float %38 %40 %43 = OpAccessChain %_ptr_Input_float %gl_TessLevelOuter %int_2 %44 = OpLoad %float %43 %45 = OpFMul %float %41 %44 %46 = OpFAdd %float %34 %45 %48 = OpAccessChain %_ptr_Input_float %gl_TessCoord %uint_1 %49 = OpLoad %float %48 %51 = OpAccessChain %_ptr_Input_float %gl_TessLevelInner %int_1 %52 = OpLoad %float %51 %53 = OpFMul %float %49 %52 %54 = OpAccessChain %_ptr_Input_float %gl_TessLevelOuter %int_1 %55 = OpLoad %float %54 %56 = OpFMul %float %53 %55 %57 = OpAccessChain %_ptr_Input_float %gl_TessCoord %uint_1 %58 = OpLoad %float %57 %59 = OpFSub %float %float_1 %58 %60 = OpAccessChain %_ptr_Input_float %gl_TessLevelInner %int_1 %61 = OpLoad %float %60 %62 = OpFMul %float %59 %61 %64 = OpAccessChain %_ptr_Input_float %gl_TessLevelOuter %int_3 %65 = OpLoad %float %64 %66 = OpFMul %float %62 %65 %67 = OpFAdd %float %56 %66 %69 = OpCompositeConstruct %v4float %46 %67 %float_0 %float_1 %71 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %71 %69 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/000077500000000000000000000000001400026215700203545ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/asm/vert/clip-distance-plain-variable.asm.vert000066400000000000000000000077311400026215700274500ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 56 ; Schema: 0 OpCapability Shader OpCapability ClipDistance %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %pos_1 %_entryPointOutput_pos %_entryPointOutput_clip OpSource HLSL 500 OpName %main "main" OpName %VSOut "VSOut" OpMemberName %VSOut 0 "pos" OpMemberName %VSOut 1 "clip" OpName %_main_vf4_ "@main(vf4;" OpName %pos "pos" OpName %vout "vout" OpName %pos_0 "pos" OpName %pos_1 "pos" OpName %flattenTemp "flattenTemp" OpName %param "param" OpName %_entryPointOutput_pos "@entryPointOutput.pos" OpName %_entryPointOutput_clip "@entryPointOutput.clip" OpDecorate %pos_1 Location 0 OpDecorate %_entryPointOutput_pos BuiltIn Position OpDecorate %_entryPointOutput_clip BuiltIn ClipDistance %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %v2float = OpTypeVector %float 2 %VSOut = OpTypeStruct %v4float %v2float %11 = OpTypeFunction %VSOut %_ptr_Function_v4float %_ptr_Function_VSOut = OpTypePointer Function %VSOut %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v4float = OpTypePointer Input %v4float %pos_1 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_pos = OpVariable %_ptr_Output_v4float Output %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %_entryPointOutput_clip = OpVariable %_ptr_Output__arr_float_uint_2 Output %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_float = OpTypePointer Output %float %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel %pos_0 = OpVariable %_ptr_Function_v4float Function %flattenTemp = OpVariable %_ptr_Function_VSOut Function %param = OpVariable %_ptr_Function_v4float Function %32 = OpLoad %v4float %pos_1 OpStore %pos_0 %32 %35 = OpLoad %v4float %pos_0 OpStore %param %35 %36 = OpFunctionCall %VSOut %_main_vf4_ %param OpStore %flattenTemp %36 %39 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0 %40 = OpLoad %v4float %39 OpStore %_entryPointOutput_pos %40 %48 = OpAccessChain %_ptr_Function_float %flattenTemp %int_1 %uint_0 %49 = OpLoad %float %48 %51 = OpAccessChain %_ptr_Output_float %_entryPointOutput_clip %int_0 OpStore %51 %49 %53 = OpAccessChain %_ptr_Function_float %flattenTemp %int_1 %uint_1 %54 = OpLoad %float %53 %55 = OpAccessChain %_ptr_Output_float %_entryPointOutput_clip %int_1 OpStore %55 %54 OpReturn OpFunctionEnd %_main_vf4_ = OpFunction %VSOut None %11 %pos = OpFunctionParameter %_ptr_Function_v4float %14 = OpLabel %vout = OpVariable %_ptr_Function_VSOut Function %19 = OpLoad %v4float %pos %20 = OpAccessChain %_ptr_Function_v4float %vout %int_0 OpStore %20 %19 %22 = OpLoad %v4float %pos %23 = OpVectorShuffle %v2float %22 %22 0 1 %25 = OpAccessChain %_ptr_Function_v2float %vout %int_1 OpStore %25 %23 %26 = OpLoad %VSOut %vout OpReturnValue %26 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/clip-distance-plain-variable.no-user-varying.asm.vert000066400000000000000000000077311400026215700325140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 56 ; Schema: 0 OpCapability Shader OpCapability ClipDistance %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %pos_1 %_entryPointOutput_pos %_entryPointOutput_clip OpSource HLSL 500 OpName %main "main" OpName %VSOut "VSOut" OpMemberName %VSOut 0 "pos" OpMemberName %VSOut 1 "clip" OpName %_main_vf4_ "@main(vf4;" OpName %pos "pos" OpName %vout "vout" OpName %pos_0 "pos" OpName %pos_1 "pos" OpName %flattenTemp "flattenTemp" OpName %param "param" OpName %_entryPointOutput_pos "@entryPointOutput.pos" OpName %_entryPointOutput_clip "@entryPointOutput.clip" OpDecorate %pos_1 Location 0 OpDecorate %_entryPointOutput_pos BuiltIn Position OpDecorate %_entryPointOutput_clip BuiltIn ClipDistance %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %v2float = OpTypeVector %float 2 %VSOut = OpTypeStruct %v4float %v2float %11 = OpTypeFunction %VSOut %_ptr_Function_v4float %_ptr_Function_VSOut = OpTypePointer Function %VSOut %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v4float = OpTypePointer Input %v4float %pos_1 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_pos = OpVariable %_ptr_Output_v4float Output %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %_entryPointOutput_clip = OpVariable %_ptr_Output__arr_float_uint_2 Output %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_float = OpTypePointer Output %float %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel %pos_0 = OpVariable %_ptr_Function_v4float Function %flattenTemp = OpVariable %_ptr_Function_VSOut Function %param = OpVariable %_ptr_Function_v4float Function %32 = OpLoad %v4float %pos_1 OpStore %pos_0 %32 %35 = OpLoad %v4float %pos_0 OpStore %param %35 %36 = OpFunctionCall %VSOut %_main_vf4_ %param OpStore %flattenTemp %36 %39 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0 %40 = OpLoad %v4float %39 OpStore %_entryPointOutput_pos %40 %48 = OpAccessChain %_ptr_Function_float %flattenTemp %int_1 %uint_0 %49 = OpLoad %float %48 %51 = OpAccessChain %_ptr_Output_float %_entryPointOutput_clip %int_0 OpStore %51 %49 %53 = OpAccessChain %_ptr_Function_float %flattenTemp %int_1 %uint_1 %54 = OpLoad %float %53 %55 = OpAccessChain %_ptr_Output_float %_entryPointOutput_clip %int_1 OpStore %55 %54 OpReturn OpFunctionEnd %_main_vf4_ = OpFunction %VSOut None %11 %pos = OpFunctionParameter %_ptr_Function_v4float %14 = OpLabel %vout = OpVariable %_ptr_Function_VSOut Function %19 = OpLoad %v4float %pos %20 = OpAccessChain %_ptr_Function_v4float %vout %int_0 OpStore %20 %19 %22 = OpLoad %v4float %pos %23 = OpVectorShuffle %v2float %22 %22 0 1 %25 = OpAccessChain %_ptr_Function_v2float %vout %int_1 OpStore %25 %23 %26 = OpLoad %VSOut %vout OpReturnValue %26 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/copy-memory-interface.asm.vert000066400000000000000000000020661400026215700262570ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 1 ; Bound: 13 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %8 %9 %11 %12 OpName %1 "main" OpName %8 "v0" OpName %9 "v1" OpName %11 "o0" OpName %12 "o1" OpDecorate %8 Location 0 OpDecorate %9 Location 1 OpDecorate %11 BuiltIn Position OpDecorate %12 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 4 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %9 = OpVariable %7 Input %10 = OpTypePointer Output %6 %11 = OpVariable %10 Output %12 = OpVariable %10 Output %1 = OpFunction %2 None %3 %4 = OpLabel OpCopyMemory %11 %8 OpCopyMemory %12 %9 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/extract-transposed-matrix-from-struct.asm.vert000066400000000000000000000153111400026215700314550ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 79 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %VS "main" %PosL_1 %instanceID_1 %_entryPointOutput_Position %_entryPointOutput_Color OpSource HLSL 500 OpName %VS "VS" OpName %V2F "V2F" OpMemberName %V2F 0 "Position" OpMemberName %V2F 1 "Color" OpName %_VS_vf3_u1_ "@VS(vf3;u1;" OpName %PosL "PosL" OpName %instanceID "instanceID" OpName %InstanceData "InstanceData" OpMemberName %InstanceData 0 "MATRIX_MVP" OpMemberName %InstanceData 1 "Color" OpName %instData "instData" OpName %InstanceData_0 "InstanceData" OpMemberName %InstanceData_0 0 "MATRIX_MVP" OpMemberName %InstanceData_0 1 "Color" OpName %gInstanceData "gInstanceData" OpMemberName %gInstanceData 0 "@data" OpName %gInstanceData_0 "gInstanceData" OpName %v2f "v2f" OpName %PosL_0 "PosL" OpName %PosL_1 "PosL" OpName %instanceID_0 "instanceID" OpName %instanceID_1 "instanceID" OpName %flattenTemp "flattenTemp" OpName %param "param" OpName %param_0 "param" OpName %_entryPointOutput_Position "@entryPointOutput.Position" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpMemberDecorate %InstanceData_0 0 RowMajor OpMemberDecorate %InstanceData_0 0 Offset 0 OpMemberDecorate %InstanceData_0 0 MatrixStride 16 OpMemberDecorate %InstanceData_0 1 Offset 64 OpDecorate %_runtimearr_InstanceData_0 ArrayStride 80 OpMemberDecorate %gInstanceData 0 NonWritable OpMemberDecorate %gInstanceData 0 Offset 0 OpDecorate %gInstanceData BufferBlock OpDecorate %gInstanceData_0 DescriptorSet 1 OpDecorate %gInstanceData_0 Binding 0 OpDecorate %PosL_1 Location 0 OpDecorate %instanceID_1 BuiltIn InstanceIndex OpDecorate %_entryPointOutput_Position BuiltIn Position OpDecorate %_entryPointOutput_Color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %v4float = OpTypeVector %float 4 %V2F = OpTypeStruct %v4float %v4float %13 = OpTypeFunction %V2F %_ptr_Function_v3float %_ptr_Function_uint %mat4v4float = OpTypeMatrix %v4float 4 %InstanceData = OpTypeStruct %mat4v4float %v4float %_ptr_Function_InstanceData = OpTypePointer Function %InstanceData %InstanceData_0 = OpTypeStruct %mat4v4float %v4float %_runtimearr_InstanceData_0 = OpTypeRuntimeArray %InstanceData_0 %gInstanceData = OpTypeStruct %_runtimearr_InstanceData_0 %_ptr_Uniform_gInstanceData = OpTypePointer Uniform %gInstanceData %gInstanceData_0 = OpVariable %_ptr_Uniform_gInstanceData Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_InstanceData_0 = OpTypePointer Uniform %InstanceData_0 %_ptr_Function_mat4v4float = OpTypePointer Function %mat4v4float %int_1 = OpConstant %int 1 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_V2F = OpTypePointer Function %V2F %float_1 = OpConstant %float 1 %_ptr_Input_v3float = OpTypePointer Input %v3float %PosL_1 = OpVariable %_ptr_Input_v3float Input %_ptr_Input_uint = OpTypePointer Input %uint %instanceID_1 = OpVariable %_ptr_Input_uint Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Position = OpVariable %_ptr_Output_v4float Output %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %VS = OpFunction %void None %3 %5 = OpLabel %PosL_0 = OpVariable %_ptr_Function_v3float Function %instanceID_0 = OpVariable %_ptr_Function_uint Function %flattenTemp = OpVariable %_ptr_Function_V2F Function %param = OpVariable %_ptr_Function_v3float Function %param_0 = OpVariable %_ptr_Function_uint Function %61 = OpLoad %v3float %PosL_1 OpStore %PosL_0 %61 %65 = OpLoad %uint %instanceID_1 OpStore %instanceID_0 %65 %68 = OpLoad %v3float %PosL_0 OpStore %param %68 %70 = OpLoad %uint %instanceID_0 OpStore %param_0 %70 %71 = OpFunctionCall %V2F %_VS_vf3_u1_ %param %param_0 OpStore %flattenTemp %71 %74 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0 %75 = OpLoad %v4float %74 OpStore %_entryPointOutput_Position %75 %77 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_1 %78 = OpLoad %v4float %77 OpStore %_entryPointOutput_Color %78 OpReturn OpFunctionEnd %_VS_vf3_u1_ = OpFunction %V2F None %13 %PosL = OpFunctionParameter %_ptr_Function_v3float %instanceID = OpFunctionParameter %_ptr_Function_uint %17 = OpLabel %instData = OpVariable %_ptr_Function_InstanceData Function %v2f = OpVariable %_ptr_Function_V2F Function %29 = OpLoad %uint %instanceID %31 = OpAccessChain %_ptr_Uniform_InstanceData_0 %gInstanceData_0 %int_0 %29 %32 = OpLoad %InstanceData_0 %31 %33 = OpCompositeExtract %mat4v4float %32 0 %35 = OpAccessChain %_ptr_Function_mat4v4float %instData %int_0 OpStore %35 %33 %36 = OpCompositeExtract %v4float %32 1 %39 = OpAccessChain %_ptr_Function_v4float %instData %int_1 OpStore %39 %36 %42 = OpAccessChain %_ptr_Function_mat4v4float %instData %int_0 %43 = OpLoad %mat4v4float %42 %44 = OpLoad %v3float %PosL %46 = OpCompositeExtract %float %44 0 %47 = OpCompositeExtract %float %44 1 %48 = OpCompositeExtract %float %44 2 %49 = OpCompositeConstruct %v4float %46 %47 %48 %float_1 %50 = OpMatrixTimesVector %v4float %43 %49 %51 = OpAccessChain %_ptr_Function_v4float %v2f %int_0 OpStore %51 %50 %52 = OpAccessChain %_ptr_Function_v4float %instData %int_1 %53 = OpLoad %v4float %52 %54 = OpAccessChain %_ptr_Function_v4float %v2f %int_1 OpStore %54 %53 %55 = OpLoad %V2F %v2f OpReturnValue %55 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/fake-builtin-input.asm.vert000066400000000000000000000046601400026215700255520ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Google spiregg; 0 ; Bound: 29 ; Schema: 0 OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %vertexShader "main" %in_var_POSITION %gl_Position %gl_FragCoord %out_var_SV_Target OpEntryPoint Fragment %fragmentShader "fragmentShader" %in_var_POSITION %gl_Position %gl_FragCoord %out_var_SV_Target OpExecutionMode %fragmentShader OriginUpperLeft OpSource HLSL 640 OpName %in_var_POSITION "in.var.POSITION" OpName %out_var_SV_Target "out.var.SV_Target" OpName %vertexShader "vertexShader" OpName %fragmentShader "fragmentShader" OpDecorate %gl_Position BuiltIn Position OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %in_var_POSITION Location 0 OpDecorate %out_var_SV_Target Location 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %half = OpTypeFloat 16 %half_0x1p_0 = OpConstant %half 0x1p+0 %half_0x0p_0 = OpConstant %half 0x0p+0 %v4half = OpTypeVector %half 4 %14 = OpConstantComposite %v4half %half_0x1p_0 %half_0x0p_0 %half_0x1p_0 %half_0x1p_0 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4half = OpTypePointer Output %v4half %void = OpTypeVoid %22 = OpTypeFunction %void %in_var_POSITION = OpVariable %_ptr_Input_v2float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target = OpVariable %_ptr_Output_v4half Output %vertexShader = OpFunction %void None %22 %23 = OpLabel %24 = OpLoad %v2float %in_var_POSITION %25 = OpCompositeExtract %float %24 0 %26 = OpCompositeExtract %float %24 1 %27 = OpCompositeConstruct %v4float %25 %26 %float_0 %float_1 OpStore %gl_Position %27 OpReturn OpFunctionEnd %fragmentShader = OpFunction %void None %22 %28 = OpLabel OpStore %out_var_SV_Target %14 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/invariant.msl21.asm.vert000066400000000000000000000024371400026215700247730ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 18 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_entryPointOutput OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %_entryPointOutput Invariant OpDecorate %_entryPointOutput BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %12 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %17 = OpFunctionCall %v4float %_main_ OpStore %_entryPointOutput %17 OpReturn OpFunctionEnd %_main_ = OpFunction %v4float None %8 %10 = OpLabel OpReturnValue %12 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/packed-bool-to-uint.asm.vert000066400000000000000000000121221400026215700256100ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 62 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %gl_VertexIndex %a_position OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %Struct "Struct" OpMemberName %Struct 0 "flags" OpName %defaultUniformsVS "defaultUniformsVS" OpMemberName %defaultUniformsVS 0 "flags" OpMemberName %defaultUniformsVS 1 "uquad" OpMemberName %defaultUniformsVS 2 "umatrix" OpName %__0 "" OpName %gl_VertexIndex "gl_VertexIndex" OpName %a_position "a_position" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %_arr_uint_uint_1 ArrayStride 16 OpMemberDecorate %Struct 0 Offset 0 OpDecorate %_arr_v2float_uint_4 ArrayStride 16 OpMemberDecorate %defaultUniformsVS 0 Offset 0 OpMemberDecorate %defaultUniformsVS 1 Offset 16 OpMemberDecorate %defaultUniformsVS 2 ColMajor OpMemberDecorate %defaultUniformsVS 2 Offset 80 OpMemberDecorate %defaultUniformsVS 2 MatrixStride 16 OpDecorate %defaultUniformsVS Block OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpDecorate %a_position Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_arr_uint_uint_1 = OpTypeArray %uint %uint_1 %Struct = OpTypeStruct %_arr_uint_uint_1 %v2float = OpTypeVector %float 2 %uint_4 = OpConstant %uint 4 %_arr_v2float_uint_4 = OpTypeArray %v2float %uint_4 %mat4v4float = OpTypeMatrix %v4float 4 %defaultUniformsVS = OpTypeStruct %Struct %_arr_v2float_uint_4 %mat4v4float %_ptr_Uniform_defaultUniformsVS = OpTypePointer Uniform %defaultUniformsVS %__0 = OpVariable %_ptr_Uniform_defaultUniformsVS Uniform %int_2 = OpConstant %int 2 %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %int_1 = OpConstant %int 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Input_v4float = OpTypePointer Input %v4float %a_position = OpVariable %_ptr_Input_v4float Input %uint_2 = OpConstant %uint 2 %_ptr_Input_float = OpTypePointer Input %float %uint_3 = OpConstant %uint 3 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_0 = OpConstant %float 0 %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %27 = OpAccessChain %_ptr_Uniform_mat4v4float %__0 %int_2 %28 = OpLoad %mat4v4float %27 %32 = OpLoad %int %gl_VertexIndex %34 = OpAccessChain %_ptr_Uniform_v2float %__0 %int_1 %32 %35 = OpLoad %v2float %34 %40 = OpAccessChain %_ptr_Input_float %a_position %uint_2 %41 = OpLoad %float %40 %43 = OpAccessChain %_ptr_Input_float %a_position %uint_3 %44 = OpLoad %float %43 %45 = OpCompositeExtract %float %35 0 %46 = OpCompositeExtract %float %35 1 %47 = OpCompositeConstruct %v4float %45 %46 %41 %44 %48 = OpMatrixTimesVector %v4float %28 %47 %50 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %50 %48 %52 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %int_0 %int_0 %53 = OpLoad %uint %52 %56 = OpINotEqual %bool %53 %uint_0 OpSelectionMerge %58 None OpBranchConditional %56 %57 %58 %57 = OpLabel %61 = OpAccessChain %_ptr_Output_float %_ %int_0 %uint_2 OpStore %61 %float_0 OpBranch %58 %58 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/packed-bool2-to-packed_uint2.asm.vert000066400000000000000000000122521400026215700272670ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 64 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %gl_VertexIndex %a_position OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %Struct "Struct" OpMemberName %Struct 0 "flags" OpName %defaultUniformsVS "defaultUniformsVS" OpMemberName %defaultUniformsVS 0 "flags" OpMemberName %defaultUniformsVS 1 "uquad" OpMemberName %defaultUniformsVS 2 "umatrix" OpName %__0 "" OpName %gl_VertexIndex "gl_VertexIndex" OpName %a_position "a_position" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %_arr_v2uint_uint_1 ArrayStride 16 OpMemberDecorate %Struct 0 Offset 0 OpDecorate %_arr_v2float_uint_4 ArrayStride 16 OpMemberDecorate %defaultUniformsVS 0 Offset 0 OpMemberDecorate %defaultUniformsVS 1 Offset 16 OpMemberDecorate %defaultUniformsVS 2 ColMajor OpMemberDecorate %defaultUniformsVS 2 Offset 80 OpMemberDecorate %defaultUniformsVS 2 MatrixStride 16 OpDecorate %defaultUniformsVS Block OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpDecorate %a_position Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %v2uint = OpTypeVector %uint 2 %_arr_v2uint_uint_1 = OpTypeArray %v2uint %uint_1 %Struct = OpTypeStruct %_arr_v2uint_uint_1 %v2float = OpTypeVector %float 2 %uint_4 = OpConstant %uint 4 %_arr_v2float_uint_4 = OpTypeArray %v2float %uint_4 %mat4v4float = OpTypeMatrix %v4float 4 %defaultUniformsVS = OpTypeStruct %Struct %_arr_v2float_uint_4 %mat4v4float %_ptr_Uniform_defaultUniformsVS = OpTypePointer Uniform %defaultUniformsVS %__0 = OpVariable %_ptr_Uniform_defaultUniformsVS Uniform %int_2 = OpConstant %int 2 %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %int_1 = OpConstant %int 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Input_v4float = OpTypePointer Input %v4float %a_position = OpVariable %_ptr_Input_v4float Input %uint_2 = OpConstant %uint 2 %_ptr_Input_float = OpTypePointer Input %float %uint_3 = OpConstant %uint 3 %_ptr_Output_v4float = OpTypePointer Output %v4float %bool = OpTypeBool %v2bool = OpTypeVector %bool 2 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %float_0 = OpConstant %float 0 %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %28 = OpAccessChain %_ptr_Uniform_mat4v4float %__0 %int_2 %29 = OpLoad %mat4v4float %28 %33 = OpLoad %int %gl_VertexIndex %35 = OpAccessChain %_ptr_Uniform_v2float %__0 %int_1 %33 %36 = OpLoad %v2float %35 %41 = OpAccessChain %_ptr_Input_float %a_position %uint_2 %42 = OpLoad %float %41 %44 = OpAccessChain %_ptr_Input_float %a_position %uint_3 %45 = OpLoad %float %44 %46 = OpCompositeExtract %float %36 0 %47 = OpCompositeExtract %float %36 1 %48 = OpCompositeConstruct %v4float %46 %47 %42 %45 %49 = OpMatrixTimesVector %v4float %29 %48 %51 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %51 %49 %56 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %int_0 %int_0 %uint_0 %57 = OpLoad %uint %56 %58 = OpINotEqual %bool %57 %uint_0 OpSelectionMerge %60 None OpBranchConditional %58 %59 %60 %59 = OpLabel %63 = OpAccessChain %_ptr_Output_float %_ %int_0 %uint_2 OpStore %63 %float_0 OpBranch %60 %60 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/packing-test.asm.vert000066400000000000000000000033001400026215700244220ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 18 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 500 OpName %main "main" OpName %TestStruct "TestStruct" OpMemberName %TestStruct 0 "transforms" OpName %CB0 "CB0" OpMemberName %CB0 0 "CB0" OpName %_ "" OpDecorate %_arr_mat4v4float_uint_6 ArrayStride 64 OpMemberDecorate %TestStruct 0 RowMajor OpMemberDecorate %TestStruct 0 Offset 0 OpMemberDecorate %TestStruct 0 MatrixStride 16 OpDecorate %_arr_TestStruct_uint_16 ArrayStride 384 OpMemberDecorate %CB0 0 Offset 0 OpDecorate %CB0 Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %uint = OpTypeInt 32 0 %uint_6 = OpConstant %uint 6 %_arr_mat4v4float_uint_6 = OpTypeArray %mat4v4float %uint_6 %TestStruct = OpTypeStruct %_arr_mat4v4float_uint_6 %uint_16 = OpConstant %uint 16 %_arr_TestStruct_uint_16 = OpTypeArray %TestStruct %uint_16 %CB0 = OpTypeStruct %_arr_TestStruct_uint_16 %_ptr_Uniform_CB0 = OpTypePointer Uniform %CB0 %_ = OpVariable %_ptr_Uniform_CB0 Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/spec-constant-op-composite.asm.vert000066400000000000000000000072201400026215700272330ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 58 ; Schema: 0 OpCapability Shader OpCapability ClipDistance OpCapability CullDistance %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %52 %output OpSource GLSL 450 OpName %4 "main" OpName %9 "pos" OpName %50 "gl_PerVertex" OpMemberName %50 0 "gl_Position" OpMemberName %50 1 "gl_PointSize" OpMemberName %50 2 "gl_ClipDistance" OpMemberName %50 3 "gl_CullDistance" OpName %52 "" OpDecorate %13 SpecId 201 OpDecorate %24 SpecId 202 OpMemberDecorate %50 0 BuiltIn Position OpMemberDecorate %50 1 BuiltIn PointSize OpMemberDecorate %50 2 BuiltIn ClipDistance OpMemberDecorate %50 3 BuiltIn CullDistance OpDecorate %50 Block OpDecorate %57 SpecId 200 OpDecorate %output Flat OpDecorate %output Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Function %7 %10 = OpConstant %6 0 %11 = OpConstantComposite %7 %10 %10 %10 %10 %12 = OpTypeInt 32 1 %int_ptr = OpTypePointer Output %12 %13 = OpSpecConstant %12 -10 %14 = OpConstant %12 2 %15 = OpSpecConstantOp %12 IAdd %13 %14 %17 = OpTypeInt 32 0 %18 = OpConstant %17 1 %19 = OpTypePointer Function %6 %24 = OpSpecConstant %17 100 %25 = OpConstant %17 5 %26 = OpSpecConstantOp %17 UMod %24 %25 %28 = OpConstant %17 2 %33 = OpConstant %12 20 %34 = OpConstant %12 30 %35 = OpTypeVector %12 4 %36 = OpSpecConstantComposite %35 %33 %34 %15 %15 %40 = OpTypeVector %12 2 %41 = OpSpecConstantOp %40 VectorShuffle %36 %36 1 0 %foo = OpSpecConstantOp %12 CompositeExtract %36 1 %42 = OpTypeVector %6 2 %49 = OpTypeArray %6 %18 %50 = OpTypeStruct %7 %6 %49 %49 %51 = OpTypePointer Output %50 %52 = OpVariable %51 Output %output = OpVariable %int_ptr Output %53 = OpConstant %12 0 %55 = OpTypePointer Output %7 %57 = OpSpecConstant %6 3.14159 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %11 %16 = OpConvertSToF %6 %15 %20 = OpAccessChain %19 %9 %18 %21 = OpLoad %6 %20 %22 = OpFAdd %6 %21 %16 %23 = OpAccessChain %19 %9 %18 OpStore %23 %22 %27 = OpConvertUToF %6 %26 %29 = OpAccessChain %19 %9 %28 %30 = OpLoad %6 %29 %31 = OpFAdd %6 %30 %27 %32 = OpAccessChain %19 %9 %28 OpStore %32 %31 %37 = OpConvertSToF %7 %36 %38 = OpLoad %7 %9 %39 = OpFAdd %7 %38 %37 OpStore %9 %39 %43 = OpConvertSToF %42 %41 %44 = OpLoad %7 %9 %45 = OpVectorShuffle %42 %44 %44 0 1 %46 = OpFAdd %42 %45 %43 %47 = OpLoad %7 %9 %48 = OpVectorShuffle %7 %47 %46 4 5 2 3 OpStore %9 %48 %54 = OpLoad %7 %9 %56 = OpAccessChain %55 %52 %53 OpStore %56 %54 OpStore %output %foo OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/asm/vert/uint-vertex-id-instance-id.asm.vert000066400000000000000000000051401400026215700271150ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 36 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %vid_1 %iid_1 %_entryPointOutput OpSource HLSL 500 OpName %main "main" OpName %_main_u1_u1_ "@main(u1;u1;" OpName %vid "vid" OpName %iid "iid" OpName %vid_0 "vid" OpName %vid_1 "vid" OpName %iid_0 "iid" OpName %iid_1 "iid" OpName %_entryPointOutput "@entryPointOutput" OpName %param "param" OpName %param_0 "param" OpDecorate %vid_1 BuiltIn VertexIndex OpDecorate %iid_1 BuiltIn InstanceIndex OpDecorate %_entryPointOutput BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %10 = OpTypeFunction %v4float %_ptr_Function_uint %_ptr_Function_uint %_ptr_Input_uint = OpTypePointer Input %uint %vid_1 = OpVariable %_ptr_Input_uint Input %iid_1 = OpVariable %_ptr_Input_uint Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %vid_0 = OpVariable %_ptr_Function_uint Function %iid_0 = OpVariable %_ptr_Function_uint Function %param = OpVariable %_ptr_Function_uint Function %param_0 = OpVariable %_ptr_Function_uint Function %25 = OpLoad %uint %vid_1 OpStore %vid_0 %25 %28 = OpLoad %uint %iid_1 OpStore %iid_0 %28 %32 = OpLoad %uint %vid_0 OpStore %param %32 %34 = OpLoad %uint %iid_0 OpStore %param_0 %34 %35 = OpFunctionCall %v4float %_main_u1_u1_ %param %param_0 OpStore %_entryPointOutput %35 OpReturn OpFunctionEnd %_main_u1_u1_ = OpFunction %v4float None %10 %vid = OpFunctionParameter %_ptr_Function_uint %iid = OpFunctionParameter %_ptr_Function_uint %14 = OpLabel %15 = OpLoad %uint %vid %16 = OpLoad %uint %iid %17 = OpIAdd %uint %15 %16 %18 = OpConvertUToF %float %17 %19 = OpCompositeConstruct %v4float %18 %18 %18 %18 OpReturnValue %19 OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/comp/000077500000000000000000000000001400026215700175525ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/comp/access-private-workgroup-in-function.comp000066400000000000000000000003761400026215700276350ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; int f; shared int u; void set_f() { f = 40; } void set_shared_u() { u = 50; } void main() { set_f(); set_shared_u(); if (gl_LocalInvocationIndex == 0u) { f = 10; } else { f = 30; u = 20; } } spirv-cross-2021.01.15/shaders-msl/comp/argument-buffers-discrete.msl2.argument.discrete.comp000066400000000000000000000006161400026215700320070ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 0) readonly buffer SSBO0 { vec4 v; } ssbo0; layout(set = 1, binding = 0) readonly buffer SSBO1 { vec4 v; } ssbo1; layout(set = 2, binding = 5) readonly buffer SSBO2 { vec4 v; } ssbo2; layout(set = 3, binding = 6) writeonly buffer SSBO3 { vec4 v; } ssbo3; void main() { ssbo3.v = ssbo0.v + ssbo1.v + ssbo2.v; } spirv-cross-2021.01.15/shaders-msl/comp/argument-buffers-image-load-store.ios.msl2.argument.comp000066400000000000000000000004321400026215700323220ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 1, r32f) writeonly uniform image2D uImage; layout(set = 0, binding = 2, r32f) readonly uniform image2D uImageRead; void main() { ivec2 coord = ivec2(gl_GlobalInvocationID.xy); imageStore(uImage, coord, imageLoad(uImageRead, coord)); } spirv-cross-2021.01.15/shaders-msl/comp/argument-buffers-image-load-store.msl2.argument.comp000066400000000000000000000004321400026215700315310ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 1, r32f) writeonly uniform image2D uImage; layout(set = 0, binding = 2, r32f) readonly uniform image2D uImageRead; void main() { ivec2 coord = ivec2(gl_GlobalInvocationID.xy); imageStore(uImage, coord, imageLoad(uImageRead, coord)); } spirv-cross-2021.01.15/shaders-msl/comp/array-length.comp000066400000000000000000000004531400026215700230310ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 1, std140) buffer SSBO { uint size; float v[]; }; layout(set = 0, binding = 2, std430) buffer SSBO1 { float bz[]; } ssbos[2]; uint get_size() { return v.length() + ssbos[1].bz.length(); } void main() { size = get_size(); } spirv-cross-2021.01.15/shaders-msl/comp/array-length.msl2.argument.discrete.comp000066400000000000000000000010271400026215700273250ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 1, std140) buffer SSBO { uint size; float v[]; }; layout(set = 1, binding = 2, std430) buffer SSBO1 { float bz[]; } ssbos[2]; layout(set = 2, binding = 5, std140) buffer SSBO2 { uint size2; float w[]; }; layout(set = 3, binding = 2, std430) buffer SSBO3 { float bz[]; } ssbos2[2]; uint get_size() { uint len = v.length(); len += ssbos[1].bz.length(); len += w.length(); len += ssbos2[0].bz.length(); return len; } void main() { size = get_size(); } spirv-cross-2021.01.15/shaders-msl/comp/atomic.comp000066400000000000000000000025571400026215700217170ustar00rootroot00000000000000#version 310 es #extension GL_OES_shader_image_atomic : require layout(local_size_x = 1) in; layout(r32ui, binding = 0) uniform highp uimage2D uImage; layout(r32i, binding = 1) uniform highp iimage2D iImage; layout(binding = 2, std430) buffer SSBO { uint u32; int i32; } ssbo; shared uint shared_u32; shared int shared_i32; void main() { atomicAdd(ssbo.u32, 1u); atomicOr(ssbo.u32, 1u); atomicXor(ssbo.u32, 1u); atomicAnd(ssbo.u32, 1u); atomicMin(ssbo.u32, 1u); atomicMax(ssbo.u32, 1u); atomicExchange(ssbo.u32, 1u); atomicCompSwap(ssbo.u32, 10u, 2u); atomicAdd(ssbo.i32, 1); atomicOr(ssbo.i32, 1); atomicXor(ssbo.i32, 1); atomicAnd(ssbo.i32, 1); atomicMin(ssbo.i32, 1); atomicMax(ssbo.i32, 1); atomicExchange(ssbo.i32, 1); atomicCompSwap(ssbo.i32, 10, 2); shared_u32 = 10u; shared_i32 = 10; atomicAdd(shared_u32, 1u); atomicOr(shared_u32, 1u); atomicXor(shared_u32, 1u); atomicAnd(shared_u32, 1u); atomicMin(shared_u32, 1u); atomicMax(shared_u32, 1u); atomicExchange(shared_u32, 1u); atomicCompSwap(shared_u32, 10u, 2u); atomicAdd(shared_i32, 1); atomicOr(shared_i32, 1); atomicXor(shared_i32, 1); atomicAnd(shared_i32, 1); atomicMin(shared_i32, 1); atomicMax(shared_i32, 1); atomicExchange(shared_i32, 1); atomicCompSwap(shared_i32, 10, 2); } spirv-cross-2021.01.15/shaders-msl/comp/barriers.comp000066400000000000000000000016001400026215700222400ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4) in; void barrier_shared() { memoryBarrierShared(); } void full_barrier() { memoryBarrier(); } void image_barrier() { memoryBarrierImage(); } void buffer_barrier() { memoryBarrierBuffer(); } void group_barrier() { groupMemoryBarrier(); } void barrier_shared_exec() { memoryBarrierShared(); barrier(); } void full_barrier_exec() { memoryBarrier(); barrier(); } void image_barrier_exec() { memoryBarrierImage(); barrier(); } void buffer_barrier_exec() { memoryBarrierBuffer(); barrier(); } void group_barrier_exec() { groupMemoryBarrier(); barrier(); } void exec_barrier() { barrier(); } void main() { barrier_shared(); full_barrier(); image_barrier(); buffer_barrier(); group_barrier(); barrier_shared_exec(); full_barrier_exec(); image_barrier_exec(); buffer_barrier_exec(); group_barrier_exec(); exec_barrier(); } spirv-cross-2021.01.15/shaders-msl/comp/basic.comp000066400000000000000000000007261400026215700215200ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; layout(std430, binding = 2) buffer SSBO3 { uint counter; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 idata = in_data[ident]; if (dot(idata, vec4(1.0, 5.0, 6.0, 2.0)) > 8.2) { out_data[atomicAdd(counter, 1u)] = idata; } } spirv-cross-2021.01.15/shaders-msl/comp/basic.dispatchbase.comp000066400000000000000000000010011400026215700241340ustar00rootroot00000000000000#version 310 es layout(local_size_x_id = 10) in; layout(std430, binding = 0) readonly buffer SSBO { vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; layout(std430, binding = 2) buffer SSBO3 { uint counter; }; void main() { uint ident = gl_GlobalInvocationID.x; uint workgroup = gl_WorkGroupID.x; vec4 idata = in_data[ident]; if (dot(idata, vec4(1.0, 5.0, 6.0, 2.0)) > 8.2) { out_data[atomicAdd(counter, 1u)] = idata; } } spirv-cross-2021.01.15/shaders-msl/comp/basic.dispatchbase.msl11.comp000066400000000000000000000007751400026215700251110ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; layout(std430, binding = 2) buffer SSBO3 { uint counter; }; void main() { uint ident = gl_GlobalInvocationID.x; uint workgroup = gl_WorkGroupID.x; vec4 idata = in_data[ident]; if (dot(idata, vec4(1.0, 5.0, 6.0, 2.0)) > 8.2) { out_data[atomicAdd(counter, 1u)] = idata; } } spirv-cross-2021.01.15/shaders-msl/comp/basic.inline-block.msl2.comp000066400000000000000000000007601400026215700247370ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 3, local_size_y = 3, local_size_z = 2) in; struct X { int x; int y; float z; }; layout(set = 0, binding = 0, scalar) uniform Foo { int a; int b; mat4 c; X x[2]; }; layout(set = 0, binding = 1) uniform Bar { int d; int e; }; layout(set = 1, binding = 2) buffer Baz { int f; int g; } baz[3]; void main() { uvec3 coords = gl_GlobalInvocationID; baz[coords.x].f = a + d; baz[coords.x].g = b * e; } spirv-cross-2021.01.15/shaders-msl/comp/builtins.comp000066400000000000000000000005361400026215700222670ustar00rootroot00000000000000#version 310 es layout(local_size_x = 8, local_size_y = 4, local_size_z = 2) in; void main() { uvec3 local_id = gl_LocalInvocationID; uvec3 global_id = gl_GlobalInvocationID; uint local_index = gl_LocalInvocationIndex; uvec3 work_group_size = gl_WorkGroupSize; uvec3 num_work_groups = gl_NumWorkGroups; uvec3 work_group_id = gl_WorkGroupID; } spirv-cross-2021.01.15/shaders-msl/comp/cfg-preserve-parameter.comp000066400000000000000000000014551400026215700250050ustar00rootroot00000000000000#version 310 es // We write in all paths (and no reads), so should just be out. void out_test_0(int cond, inout int i) { if (cond == 0) i = 40; else i = 60; } // We write in all paths (and no reads), so should just be out. void out_test_1(int cond, inout int i) { switch (cond) { case 40: i = 40; break; default: i = 70; break; } } // We don't write in all paths, so should be inout. void inout_test_0(int cond, inout int i) { if (cond == 0) i = 40; } void inout_test_1(int cond, inout int i) { switch (cond) { case 40: i = 40; break; } } void main() { int cond = 40; int i = 50; out_test_0(cond, i); out_test_1(cond, i); inout_test_0(cond, i); inout_test_1(cond, i); } spirv-cross-2021.01.15/shaders-msl/comp/coherent-block.comp000066400000000000000000000002431400026215700233300ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 1) coherent restrict writeonly buffer SSBO { vec4 value; }; void main() { value = vec4(20.0); } spirv-cross-2021.01.15/shaders-msl/comp/coherent-image.comp000066400000000000000000000004151400026215700233210ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 1) coherent restrict writeonly buffer SSBO { ivec4 value; }; layout(r32i, binding = 3) coherent readonly restrict uniform mediump iimage2D uImage; void main() { value = imageLoad(uImage, ivec2(10)); } spirv-cross-2021.01.15/shaders-msl/comp/complex-composite-constant-array.comp000066400000000000000000000003261400026215700270450ustar00rootroot00000000000000#version 450 layout(std430, set = 0, binding = 0) buffer SSBO { mat4 a; uint index; }; const mat4 as[] = mat4[](mat4(1.0), mat4(2.0)); void write_global() { a = as[index]; } void main() { write_global(); } spirv-cross-2021.01.15/shaders-msl/comp/complex-type-alias.comp000066400000000000000000000010201400026215700241400ustar00rootroot00000000000000#version 450 layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in; struct Foo0 { float a; }; struct Foo1 { Foo0 a; }; void Zero(out Foo0 v) { v.a = 0.0; } struct Foo2 { Foo1 a; float weight; }; layout(std430, binding = 0) buffer SSBO { Foo2 outputs[]; }; shared Foo2 coeffs[64]; void main() { Foo2 data; data.weight = 0.0; Zero(data.a.a); coeffs[gl_LocalInvocationIndex] = data; barrier(); if (gl_LocalInvocationIndex == 0u) outputs[gl_WorkGroupID.x] = coeffs[0]; } spirv-cross-2021.01.15/shaders-msl/comp/composite-array-initialization.comp000066400000000000000000000007451400026215700266030ustar00rootroot00000000000000#version 450 layout(local_size_x = 2) in; struct Data { float a; float b; }; layout(std430, binding = 0) buffer SSBO { Data outdata[]; }; layout(constant_id = 0) const float X = 4.0; Data data[2] = Data[](Data(1.0, 2.0), Data(3.0, 4.0)); Data data2[2] = Data[](Data(X, 2.0), Data(3.0, 5.0)); Data combine(Data a, Data b) { return Data(a.a + b.a, a.b + b.b); } void main() { outdata[gl_WorkGroupID.x] = combine(data[gl_LocalInvocationID.x], data2[gl_LocalInvocationID.x]); } spirv-cross-2021.01.15/shaders-msl/comp/composite-array-initialization.force-native-array.comp000066400000000000000000000007451400026215700323000ustar00rootroot00000000000000#version 450 layout(local_size_x = 2) in; struct Data { float a; float b; }; layout(std430, binding = 0) buffer SSBO { Data outdata[]; }; layout(constant_id = 0) const float X = 4.0; Data data[2] = Data[](Data(1.0, 2.0), Data(3.0, 4.0)); Data data2[2] = Data[](Data(X, 2.0), Data(3.0, 5.0)); Data combine(Data a, Data b) { return Data(a.a + b.a, a.b + b.b); } void main() { outdata[gl_WorkGroupID.x] = combine(data[gl_LocalInvocationID.x], data2[gl_LocalInvocationID.x]); } spirv-cross-2021.01.15/shaders-msl/comp/composite-construct.comp000066400000000000000000000010441400026215700244550ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO0 { vec4 as[]; }; layout(std430, binding = 1) buffer SSBO1 { vec4 bs[]; }; struct Composite { vec4 a; vec4 b; }; const vec4 const_values[2] = vec4[](vec4(20.0), vec4(40.0)); void main() { vec4 values[2] = vec4[](as[gl_GlobalInvocationID.x], bs[gl_GlobalInvocationID.x]); vec4 copy_values[2]; copy_values = const_values; Composite c = Composite(values[0], copy_values[1]); as[0] = values[gl_LocalInvocationIndex]; bs[1] = c.b; } spirv-cross-2021.01.15/shaders-msl/comp/copy-array-of-arrays.comp000066400000000000000000000010141400026215700244150ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 0, std430) buffer BUF { int a; float b; float c; } o; void main() { const float a[2][2][2] = float[][][](float[][](float[](1.0, 2.0), float[](3.0, 4.0)), float[][](float[](1.0, 2.0), float[](3.0, 4.0))); float b[2][2][2] = a; float c[2][2][2] = b; o.a = int(c[1][1][1]); float d[2][2][2] = float[][][](float[][](float[](o.b, o.c), float[](o.b, o.b)), float[][](float[](o.c, o.c), float[](o.c, o.b))); float e[2][2][2] = d; o.b = e[1][0][1]; } spirv-cross-2021.01.15/shaders-msl/comp/copy-array-of-arrays.force-native-array.comp000066400000000000000000000010141400026215700301120ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 0, std430) buffer BUF { int a; float b; float c; } o; void main() { const float a[2][2][2] = float[][][](float[][](float[](1.0, 2.0), float[](3.0, 4.0)), float[][](float[](1.0, 2.0), float[](3.0, 4.0))); float b[2][2][2] = a; float c[2][2][2] = b; o.a = int(c[1][1][1]); float d[2][2][2] = float[][][](float[][](float[](o.b, o.c), float[](o.b, o.b)), float[][](float[](o.c, o.c), float[](o.c, o.b))); float e[2][2][2] = d; o.b = e[1][0][1]; } spirv-cross-2021.01.15/shaders-msl/comp/culling.comp000066400000000000000000000006531400026215700220730ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4) in; layout(std430, binding = 0) readonly buffer SSBO { float in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { float out_data[]; }; layout(std430, binding = 2) buffer SSBO3 { uint count; }; void main() { uint ident = gl_GlobalInvocationID.x; float idata = in_data[ident]; if (idata > 12.0) out_data[atomicAdd(count, 1u)] = idata; } spirv-cross-2021.01.15/shaders-msl/comp/defer-parens.comp000066400000000000000000000010651400026215700230070ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO { vec4 data; int index; }; void main() { // Tests defer-parens behavior where a binary expression is OpCompositeExtracted chained together // with an OpCompositeConstruct optimization. vec4 d = data; data = vec4(d.x, d.yz + 10.0, d.w); // Verify binary ops. data = d + d + d; // Verify swizzles. data = (d.yz + 10.0).xxyy; // OpCompositeExtract float t = (d.yz + 10.0).y; data = vec4(t); // OpVectorExtractDynamic t = (d.zw + 10.0)[index]; data = vec4(t); } spirv-cross-2021.01.15/shaders-msl/comp/dowhile.comp000066400000000000000000000006531400026215700220710ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; int i; void main() { uint ident = gl_GlobalInvocationID.x; i = 0; vec4 idat = in_data[ident]; do { idat = mvp * idat; i++; } while(i < 16); out_data[ident] = idat; } spirv-cross-2021.01.15/shaders-msl/comp/force-recompile-hooks.swizzle.comp000066400000000000000000000003001400026215700263250ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D foo; layout(binding = 1, rgba8) uniform image2D bar; void main() { vec4 a = texture(foo, vec2(1, 1)); imageStore(bar, ivec2(0, 0), a); } spirv-cross-2021.01.15/shaders-msl/comp/functions.comp000066400000000000000000000001361400026215700224420ustar00rootroot00000000000000#version 450 shared int foo[1337]; void myfunc() { foo[0]=13; } void main() { myfunc(); } spirv-cross-2021.01.15/shaders-msl/comp/global-invocation-id-writable-ssbo-in-function.comp000066400000000000000000000004461400026215700314410ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) buffer myBlock { int a; float b[1]; } myStorage; float getB() { return myStorage.b[gl_GlobalInvocationID.x]; } void main() { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_GlobalInvocationID.x] = mod((getB() + 0.02), 1.0); } spirv-cross-2021.01.15/shaders-msl/comp/global-invocation-id.comp000066400000000000000000000004021400026215700244270ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) buffer myBlock { int a; float b[1]; } myStorage; void main() { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_GlobalInvocationID.x] = mod((myStorage.b[gl_GlobalInvocationID.x] + 0.02), 1.0); } spirv-cross-2021.01.15/shaders-msl/comp/image-atomic-automatic-bindings.argument.msl2.comp000066400000000000000000000006151400026215700312440ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 0, r32ui) uniform uimage2D uImage; layout(set = 0, binding = 1) uniform sampler2D uTexture; layout(set = 0, binding = 2) buffer SSBO { vec4 outdata; }; void main() { uint ret = imageAtomicAdd(uImage, ivec2(gl_GlobalInvocationID.xy), 10u); outdata = textureLod(uTexture, vec2(gl_GlobalInvocationID.xy), 0.0) + float(ret); } spirv-cross-2021.01.15/shaders-msl/comp/image-atomic-automatic-bindings.comp000066400000000000000000000006151400026215700265470ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 0, r32ui) uniform uimage2D uImage; layout(set = 0, binding = 1) uniform sampler2D uTexture; layout(set = 0, binding = 2) buffer SSBO { vec4 outdata; }; void main() { uint ret = imageAtomicAdd(uImage, ivec2(gl_GlobalInvocationID.xy), 10u); outdata = textureLod(uTexture, vec2(gl_GlobalInvocationID.xy), 0.0) + float(ret); } spirv-cross-2021.01.15/shaders-msl/comp/image-cube-array-load-store.comp000066400000000000000000000004711400026215700256150ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(r32f, binding = 0) uniform readonly imageCubeArray uImageIn; layout(r32f, binding = 1) uniform writeonly imageCubeArray uImageOut; void main() { ivec3 coord = ivec3(9, 7, 11); vec4 indata = imageLoad(uImageIn, coord); imageStore(uImageOut, coord, indata); } spirv-cross-2021.01.15/shaders-msl/comp/image.comp000066400000000000000000000005461400026215700215210ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(rgba8, binding = 0) uniform readonly mediump image2D uImageIn; layout(rgba8, binding = 1) uniform writeonly mediump image2D uImageOut; void main() { vec4 v = imageLoad(uImageIn, ivec2(gl_GlobalInvocationID.xy) + imageSize(uImageIn)); imageStore(uImageOut, ivec2(gl_GlobalInvocationID.xy), v); } spirv-cross-2021.01.15/shaders-msl/comp/insert.comp000066400000000000000000000004621400026215700217400ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) writeonly buffer SSBO { vec4 out_data[]; }; void main() { vec4 v; v.x = 10.0; v.y = 30.0; v.z = 70.0; v.w = 90.0; out_data[gl_GlobalInvocationID.x] = v; out_data[gl_GlobalInvocationID.x].y = 20.0; } spirv-cross-2021.01.15/shaders-msl/comp/inverse.comp000066400000000000000000000005061400026215700221060ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std430, binding = 0) writeonly buffer MatrixOut { mat2 m2out; mat3 m3out; mat4 m4out; }; layout(std430, binding = 1) readonly buffer MatrixIn { mat2 m2in; mat3 m3in; mat4 m4in; }; void main() { m2out = inverse(m2in); m3out = inverse(m3in); m4out = inverse(m4in); } spirv-cross-2021.01.15/shaders-msl/comp/local-invocation-id.comp000066400000000000000000000004001400026215700242570ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) buffer myBlock { int a; float b[1]; } myStorage; void main() { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_LocalInvocationID.x] = mod((myStorage.b[gl_LocalInvocationID.x] + 0.02), 1.0); } spirv-cross-2021.01.15/shaders-msl/comp/local-invocation-index.comp000066400000000000000000000004061400026215700250000ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) buffer myBlock { int a; float b[1]; } myStorage; void main() { myStorage.a = (myStorage.a + 1) % 256; myStorage.b[gl_LocalInvocationIndex.x] = mod((myStorage.b[gl_LocalInvocationIndex.x] + 0.02), 1.0); } spirv-cross-2021.01.15/shaders-msl/comp/mat3.comp000066400000000000000000000003671400026215700213040ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 1) writeonly buffer SSBO2 { mat3 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; out_data[ident] = mat3(vec3(10.0), vec3(20.0), vec3(40.0)); } spirv-cross-2021.01.15/shaders-msl/comp/mod.comp000066400000000000000000000011111400026215700212030ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 v = mod(in_data[ident], out_data[ident]); out_data[ident] = v; uvec4 vu = floatBitsToUint(in_data[ident]) % floatBitsToUint(out_data[ident]); out_data[ident] = uintBitsToFloat(vu); ivec4 vi = floatBitsToInt(in_data[ident]) % floatBitsToInt(out_data[ident]); out_data[ident] = intBitsToFloat(vi); } spirv-cross-2021.01.15/shaders-msl/comp/modf.comp000066400000000000000000000006331400026215700213610ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 i; //vec4 v = frexp(in_data[ident], i); //out_data[ident] = ldexp(v, i); vec4 v = modf(in_data[ident], i); out_data[ident] = v; } spirv-cross-2021.01.15/shaders-msl/comp/outer-product.comp000066400000000000000000000011241400026215700232440ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 0, std430) writeonly buffer SSBO { mat2 m22; mat2x3 m23; mat2x4 m24; mat3x2 m32; mat3 m33; mat3x4 m34; mat4x2 m42; mat4x3 m43; mat4 m44; }; layout(set = 0, binding = 1, std430) readonly buffer ReadSSBO { vec2 v2; vec3 v3; vec4 v4; }; void main() { m22 = outerProduct(v2, v2); m23 = outerProduct(v3, v2); m24 = outerProduct(v4, v2); m32 = outerProduct(v2, v3); m33 = outerProduct(v3, v3); m34 = outerProduct(v4, v3); m42 = outerProduct(v2, v4); m43 = outerProduct(v3, v4); m44 = outerProduct(v4, v4); } spirv-cross-2021.01.15/shaders-msl/comp/packing-test-1.comp000066400000000000000000000005551400026215700231660ustar00rootroot00000000000000#version 450 struct T1 { vec3 a; float b; }; layout(std430, binding = 1) buffer Buffer0 { T1 buf0[]; }; layout(std430, binding = 2) buffer Buffer1 { float buf1[]; }; layout(local_size_x = 32, local_size_y = 1, local_size_z = 1) in; void main() { // broken case in Metal! T1 v = buf0[0]; float x = v.b; buf1[gl_GlobalInvocationID.x] = x; } spirv-cross-2021.01.15/shaders-msl/comp/packing-test-2.comp000066400000000000000000000005021400026215700231570ustar00rootroot00000000000000#version 450 struct T1 { vec3 a; float b; }; layout(std430, binding = 1) buffer Buffer0 { T1 buf0[]; }; layout(std430, binding = 2) buffer Buffer1 { float buf1[]; }; layout(local_size_x = 32, local_size_y = 1, local_size_z = 1) in; void main() { float x = buf0[0].b; buf1[gl_GlobalInvocationID.x] = x; } spirv-cross-2021.01.15/shaders-msl/comp/read-write-only.comp000066400000000000000000000005761400026215700234640ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 0, std430) readonly buffer SSBO0 { vec4 data0; vec4 data1; }; layout(binding = 1, std430) restrict buffer SSBO1 { vec4 data2; vec4 data3; }; layout(binding = 2, std430) restrict writeonly buffer SSBO2 { vec4 data4; vec4 data5; }; void main() { data4 = data0 + data2; data5 = data1 + data3; } spirv-cross-2021.01.15/shaders-msl/comp/rmw-matrix.comp000066400000000000000000000003061400026215700225400ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float a; vec4 b; mat4 c; float a1; vec4 b1; mat4 c1; }; void main() { a *= a1; b *= b1; c *= c1; } spirv-cross-2021.01.15/shaders-msl/comp/rmw-opt.comp000066400000000000000000000004501400026215700220360ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { int a; }; void main() { a += 10; a -= 10; a *= 10; a /= 10; a <<= 2; a >>= 3; a &= 40; a ^= 10; a %= 40; a |= 1; bool c = false; bool d = true; c = c && d; d = d || c; a = c && d ? 1 : 0; } spirv-cross-2021.01.15/shaders-msl/comp/scalar-std450-distance-length-normalize.comp000066400000000000000000000003771400026215700277740ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std430, set = 0, binding = 0) buffer SSBO { float a; float b; float c; float d; float e; float f; }; void main() { c = distance(a, b); d = length(a); e = normalize(a); f = distance(a-1, b-2); } spirv-cross-2021.01.15/shaders-msl/comp/shared-array-of-arrays.comp000066400000000000000000000010211400026215700247070ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4, local_size_y = 4) in; shared float foo[4][4]; layout(binding = 0, std430) buffer SSBO { float out_data[]; }; void work() { foo[gl_LocalInvocationID.x][gl_LocalInvocationID.y] = float(gl_LocalInvocationIndex); memoryBarrierShared(); barrier(); float x = 0.0; x += foo[gl_LocalInvocationID.x][0]; x += foo[gl_LocalInvocationID.x][1]; x += foo[gl_LocalInvocationID.x][2]; x += foo[gl_LocalInvocationID.x][3]; out_data[gl_GlobalInvocationID.x] = x; } void main() { work(); } spirv-cross-2021.01.15/shaders-msl/comp/shared.comp000066400000000000000000000007751400026215700217110ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4) in; shared float sShared[gl_WorkGroupSize.x]; layout(std430, binding = 0) readonly buffer SSBO { float in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { float out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; float idata = in_data[ident]; sShared[gl_LocalInvocationIndex] = idata; memoryBarrierShared(); barrier(); out_data[ident] = sShared[gl_WorkGroupSize.x - gl_LocalInvocationIndex - 1u]; } spirv-cross-2021.01.15/shaders-msl/comp/spec-constant-op-member-array.comp000066400000000000000000000007761400026215700262220ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(constant_id = 0) const int a = 100; layout(constant_id = 1) const int b = 200; layout(constant_id = 2) const int c = 300; const int d = c + 50; layout(constant_id = 3) const int e = 400; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; layout(set = 1, binding = 0) buffer SSBO { A member_a; B member_b; int v[a]; int w[d]; }; void main() { w[gl_GlobalInvocationID.x] += v[gl_GlobalInvocationID.x] + e; } spirv-cross-2021.01.15/shaders-msl/comp/spec-constant-work-group-size.comp000066400000000000000000000005721400026215700263010ustar00rootroot00000000000000#version 450 layout(local_size_x_id = 10, local_size_y = 20) in; layout(constant_id = 0) const int a = 1; layout(constant_id = 1) const int b = 2; layout(set = 1, binding = 0) writeonly buffer SSBO { int v[]; }; void main() { int spec_const_array_size[b]; spec_const_array_size[a] = a; v[a + gl_WorkGroupSize.x + gl_WorkGroupSize.y] = b + spec_const_array_size[1 - a]; } spirv-cross-2021.01.15/shaders-msl/comp/storage-buffer-std140-vector-array.comp000066400000000000000000000007141400026215700270000ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; struct Sub { float f[2]; vec2 f2[2]; vec3 f3[2]; vec4 f4[2]; }; layout(std140, binding = 0) buffer SSBO { Sub sub[2]; }; void main() { Sub foo = sub[gl_WorkGroupID.x]; foo.f[gl_GlobalInvocationID.x] += 1.0; foo.f2[gl_GlobalInvocationID.x] += 2.0; foo.f3[gl_GlobalInvocationID.x] += 3.0; foo.f4[gl_GlobalInvocationID.x] += 4.0; sub[gl_WorkGroupID.x] = foo; sub[0].f[0] += 5.0; sub[0].f2[1] += 5.0; } spirv-cross-2021.01.15/shaders-msl/comp/struct-layout.comp000066400000000000000000000005321400026215700232710ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; struct Foo { mat4 m; }; layout(std430, binding = 0) readonly buffer SSBO { Foo in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { Foo out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; out_data[ident].m = in_data[ident].m * in_data[ident].m; } spirv-cross-2021.01.15/shaders-msl/comp/struct-nested.comp000066400000000000000000000004031400026215700232330ustar00rootroot00000000000000#version 450 struct s1 { int a; }; struct s2 { s1 b; }; layout(std430, binding = 1) buffer dstbuffer{ s2 test[]; }; layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; void main() { s2 testVal; testVal.b.a = 0; test[0] = testVal; }spirv-cross-2021.01.15/shaders-msl/comp/struct-packing.comp000066400000000000000000000021171400026215700233710ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; struct S0 { vec2 a[1]; float b; }; struct S1 { vec3 a; float b; }; struct S2 { vec3 a[1]; float b; }; struct S3 { vec2 a; float b; }; struct S4 { vec2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; S4 m3s[8]; }; layout(binding = 1, std430) buffer SSBO1 { Content content; Content content1[2]; Content content2; layout(column_major) mat2 m0; layout(column_major) mat2 m1; layout(column_major) mat2x3 m2[4]; layout(column_major) mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_430; layout(binding = 0, std140) buffer SSBO0 { Content content; Content content1[2]; Content content2; float array[]; } ssbo_140; void main() { ssbo_430.content = ssbo_140.content; ssbo_430.content.m1.a = ssbo_430.m6[1][1] * ssbo_430.content.m3.a; // test packed matrix access } spirv-cross-2021.01.15/shaders-msl/comp/torture-loop.comp000066400000000000000000000012001400026215700230760ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 idat = in_data[ident]; int k = 0; // Continue with side effects. while (++k < 10) { idat *= 2.0; k++; } // Again used here ... for (uint i = 0u; i < 16u; i++, k++) for (uint j = 0u; j < 30u; j++) idat = mvp * idat; do { k++; } while (k > 10); out_data[ident] = idat; } spirv-cross-2021.01.15/shaders-msl/comp/type-alias.comp000066400000000000000000000010311400026215700224750ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; struct S0 { vec4 a; }; struct S1 { vec4 a; }; vec4 overload(S0 s0) { return s0.a; } vec4 overload(S1 s1) { return s1.a; } layout(std430, binding = 0) buffer SSBO0 { S0 s0s[]; }; layout(std430, binding = 1) buffer SSBO1 { S1 s1s[]; }; layout(std430, binding = 2) buffer SSBO2 { vec4 outputs[]; }; void main() { S0 s0 = s0s[gl_GlobalInvocationID.x]; S1 s1 = s1s[gl_GlobalInvocationID.x]; outputs[gl_GlobalInvocationID.x] = overload(s0) + overload(s1); } spirv-cross-2021.01.15/shaders-msl/comp/udiv.comp000066400000000000000000000004201400026215700213750ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { uint inputs[]; }; layout(std430, binding = 1) buffer SSBO2 { uint outputs[]; }; void main() { outputs[gl_GlobalInvocationID.x] = inputs[gl_GlobalInvocationID.x] / 29u; } spirv-cross-2021.01.15/shaders-msl/comp/writable-ssbo.comp000066400000000000000000000003151400026215700232060ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) buffer myBlock { int a; float b; } myStorage; void main() { myStorage.a = (myStorage.a + 1) % 256; myStorage.b = mod((myStorage.b + 0.02), 1.0); } spirv-cross-2021.01.15/shaders-msl/desktop-only/000077500000000000000000000000001400026215700212445ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/desktop-only/comp/000077500000000000000000000000001400026215700222025ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/desktop-only/comp/extended-arithmetic.desktop.comp000066400000000000000000000016461400026215700304700ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBOUint { uint a, b, c, d; uvec2 a2, b2, c2, d2; uvec3 a3, b3, c3, d3; uvec4 a4, b4, c4, d4; } u; layout(binding = 1, std430) buffer SSBOInt { int a, b, c, d; ivec2 a2, b2, c2, d2; ivec3 a3, b3, c3, d3; ivec4 a4, b4, c4, d4; } i; void main() { u.c = uaddCarry(u.a, u.b, u.d); u.c2 = uaddCarry(u.a2, u.b2, u.d2); u.c3 = uaddCarry(u.a3, u.b3, u.d3); u.c4 = uaddCarry(u.a4, u.b4, u.d4); u.c = usubBorrow(u.a, u.b, u.d); u.c2 = usubBorrow(u.a2, u.b2, u.d2); u.c3 = usubBorrow(u.a3, u.b3, u.d3); u.c4 = usubBorrow(u.a4, u.b4, u.d4); umulExtended(u.a, u.b, u.c, u.d); umulExtended(u.a2, u.b2, u.c2, u.d2); umulExtended(u.a3, u.b3, u.c3, u.d3); umulExtended(u.a4, u.b4, u.c4, u.d4); imulExtended(i.a, i.b, i.c, i.d); imulExtended(i.a2, i.b2, i.c2, i.d2); imulExtended(i.a3, i.b3, i.c3, i.d3); imulExtended(i.a4, i.b4, i.c4, i.d4); } spirv-cross-2021.01.15/shaders-msl/desktop-only/frag/000077500000000000000000000000001400026215700221635ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/desktop-only/frag/image-ms.desktop.frag000066400000000000000000000005711400026215700261760ustar00rootroot00000000000000#version 450 layout(rgba8, binding = 0) uniform image2D uImage; layout(rgba8, binding = 1) uniform image2DArray uImageArray; layout(rgba8, binding = 2) uniform image2DMS uImageMS; void main() { vec4 a = imageLoad(uImageMS, ivec2(1, 2), 2); vec4 b = imageLoad(uImageArray, ivec3(1, 2, 4)); imageStore(uImage, ivec2(2, 3), a); imageStore(uImageArray, ivec3(2, 3, 7), b); } spirv-cross-2021.01.15/shaders-msl/desktop-only/frag/query-levels.desktop.frag000066400000000000000000000002651400026215700271340ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(textureQueryLevels(uSampler))); } spirv-cross-2021.01.15/shaders-msl/desktop-only/frag/sampler-ms-query.desktop.frag000066400000000000000000000004221400026215700277150ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2DMS uSampler; layout(binding = 2, rgba8) uniform readonly writeonly image2DMS uImage; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(textureSamples(uSampler) + imageSamples(uImage))); } spirv-cross-2021.01.15/shaders-msl/desktop-only/tesc/000077500000000000000000000000001400026215700222025ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/desktop-only/tesc/arrayed-output.desktop.sso.tesc000066400000000000000000000013251400026215700303230ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; layout(location = 0) patch out vec3 vPatch[2]; layout(location = 2) out vec3 vVertex[]; layout(location = 0) in vec3 vInput[]; void main() { vVertex[gl_InvocationID] = vInput[gl_InvocationID] + vInput[gl_InvocationID ^ 1]; barrier(); if (gl_InvocationID == 0) { vPatch[0] = vec3(10.0); vPatch[1] = vec3(20.0); gl_TessLevelOuter[0] = 1.0; gl_TessLevelOuter[1] = 2.0; gl_TessLevelOuter[2] = 3.0; gl_TessLevelOuter[3] = 4.0; gl_TessLevelInner[0] = 1.0; gl_TessLevelInner[1] = 2.0; } } spirv-cross-2021.01.15/shaders-msl/desktop-only/tesc/basic.desktop.sso.multi-patch.tesc000066400000000000000000000010721400026215700306440ustar00rootroot00000000000000#version 450 layout(vertices = 1) out; in gl_PerVertex { vec4 gl_Position; } gl_in[gl_MaxPatchVertices]; out gl_PerVertex { vec4 gl_Position; } gl_out[1]; layout(location = 0) patch out vec3 vFoo; void set_position() { gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position; } void main() { gl_TessLevelInner[0] = 8.9; gl_TessLevelInner[1] = 6.9; gl_TessLevelOuter[0] = 8.9; gl_TessLevelOuter[1] = 6.9; gl_TessLevelOuter[2] = 3.9; gl_TessLevelOuter[3] = 4.9; vFoo = vec3(1.0); set_position(); } spirv-cross-2021.01.15/shaders-msl/desktop-only/tesc/basic.desktop.sso.tesc000066400000000000000000000010721400026215700264160ustar00rootroot00000000000000#version 450 layout(vertices = 1) out; in gl_PerVertex { vec4 gl_Position; } gl_in[gl_MaxPatchVertices]; out gl_PerVertex { vec4 gl_Position; } gl_out[1]; layout(location = 0) patch out vec3 vFoo; void set_position() { gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position; } void main() { gl_TessLevelInner[0] = 8.9; gl_TessLevelInner[1] = 6.9; gl_TessLevelOuter[0] = 8.9; gl_TessLevelOuter[1] = 6.9; gl_TessLevelOuter[2] = 3.9; gl_TessLevelOuter[3] = 4.9; vFoo = vec3(1.0); set_position(); } spirv-cross-2021.01.15/shaders-msl/desktop-only/tesc/struct-copy.desktop.sso.multi-patch.tesc000066400000000000000000000007151400026215700320620ustar00rootroot00000000000000#version 450 struct Boo { vec3 a; uvec3 b; }; layout(vertices = 4) out; layout(location = 0) out Boo vVertex[]; layout(location = 0) in Boo vInput[]; void main() { vVertex[gl_InvocationID] = vInput[gl_InvocationID]; gl_TessLevelOuter[0] = 1.0; gl_TessLevelOuter[1] = 2.0; gl_TessLevelOuter[2] = 3.0; gl_TessLevelOuter[3] = 4.0; gl_TessLevelInner[0] = 1.0; gl_TessLevelInner[1] = 2.0; } spirv-cross-2021.01.15/shaders-msl/desktop-only/tesc/struct-copy.desktop.sso.tesc000066400000000000000000000007141400026215700276330ustar00rootroot00000000000000#version 450 struct Boo { vec3 a; vec3 b; }; layout(vertices = 4) out; layout(location = 0) out Boo vVertex[]; layout(location = 0) in Boo vInput[]; void main() { vVertex[gl_InvocationID] = vInput[gl_InvocationID]; gl_TessLevelOuter[0] = 1.0; gl_TessLevelOuter[1] = 2.0; gl_TessLevelOuter[2] = 3.0; gl_TessLevelOuter[3] = 4.0; gl_TessLevelInner[0] = 1.0; gl_TessLevelInner[1] = 2.0; } spirv-cross-2021.01.15/shaders-msl/desktop-only/tese/000077500000000000000000000000001400026215700222045ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/desktop-only/tese/triangle.desktop.sso.tese000066400000000000000000000005371400026215700271530ustar00rootroot00000000000000#version 450 layout(cw, triangles, fractional_even_spacing) in; in gl_PerVertex { vec4 gl_Position; } gl_in[gl_MaxPatchVertices]; out gl_PerVertex { vec4 gl_Position; }; void main() { gl_Position = gl_in[0].gl_Position * gl_TessCoord.x + gl_in[1].gl_Position * gl_TessCoord.y + gl_in[2].gl_Position * gl_TessCoord.z; } spirv-cross-2021.01.15/shaders-msl/desktop-only/vert/000077500000000000000000000000001400026215700222245ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/desktop-only/vert/basic.desktop.sso.vert000066400000000000000000000004461400026215700264660ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; }; layout(std140) uniform UBO { mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = uMVP * aVertex; vNormal = aNormal; } clip-cull-distance..no-user-varying.desktop.vert000066400000000000000000000002631400026215700333160ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/desktop-only/vert#version 450 void main() { gl_Position = vec4(10.0); gl_ClipDistance[0] = 1.0; gl_ClipDistance[1] = 4.0; //gl_CullDistance[0] = 4.0; //gl_CullDistance[1] = 9.0; } spirv-cross-2021.01.15/shaders-msl/desktop-only/vert/clip-cull-distance.desktop.vert000066400000000000000000000002631400026215700302530ustar00rootroot00000000000000#version 450 void main() { gl_Position = vec4(10.0); gl_ClipDistance[0] = 1.0; gl_ClipDistance[1] = 4.0; //gl_CullDistance[0] = 4.0; //gl_CullDistance[1] = 9.0; } spirv-cross-2021.01.15/shaders-msl/desktop-only/vert/shader-draw-parameters.desktop.for-tess.vert000066400000000000000000000002111400026215700326730ustar00rootroot00000000000000#version 460 out gl_PerVertex { vec4 gl_Position; }; void main() { gl_Position = vec4(gl_BaseVertex, gl_BaseInstance, 0, 1); } spirv-cross-2021.01.15/shaders-msl/desktop-only/vert/shader-draw-parameters.desktop.vert000066400000000000000000000002111400026215700311320ustar00rootroot00000000000000#version 460 out gl_PerVertex { vec4 gl_Position; }; void main() { gl_Position = vec4(gl_BaseVertex, gl_BaseInstance, 0, 1); } spirv-cross-2021.01.15/shaders-msl/flatten/000077500000000000000000000000001400026215700202515ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/flatten/basic.flatten.vert000066400000000000000000000003761400026215700236760ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders-msl/flatten/multiindex.flatten.vert000066400000000000000000000002521400026215700247700ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { vec4 Data[3][5]; }; layout(location = 0) in ivec2 aIndex; void main() { gl_Position = Data[aIndex.x][aIndex.y]; } spirv-cross-2021.01.15/shaders-msl/flatten/push-constant.flatten.vert000066400000000000000000000006611400026215700254200ustar00rootroot00000000000000#version 310 es layout(push_constant, std430) uniform PushMe { mat4 MVP; mat2 Rot; // The MatrixStride will be 8 here. float Arr[4]; } registers; layout(location = 0) in vec2 Rot; layout(location = 1) in vec4 Pos; layout(location = 0) out vec2 vRot; void main() { gl_Position = registers.MVP * Pos; vRot = registers.Rot * Rot + registers.Arr[2]; // Constant access should work even if array stride is just 4 here. } spirv-cross-2021.01.15/shaders-msl/flatten/rowmajor.flatten.vert000066400000000000000000000004371400026215700244530ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { layout(column_major) mat4 uMVPR; layout(row_major) mat4 uMVPC; layout(row_major) mat2x4 uMVP; }; layout(location = 0) in vec4 aVertex; void main() { vec2 v = aVertex * uMVP; gl_Position = uMVPR * aVertex + uMVPC * aVertex; } spirv-cross-2021.01.15/shaders-msl/flatten/struct.flatten.vert000066400000000000000000000007621400026215700241400ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; layout(std140) uniform UBO { mat4 uMVP; Light light; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec4 vColor; void main() { gl_Position = uMVP * aVertex; vColor = vec4(0.0); vec3 L = aVertex.xyz - light.Position; vColor += dot(aNormal, normalize(L)) * (clamp(1.0 - length(L) / light.Radius, 0.0, 1.0) * light.Color); } spirv-cross-2021.01.15/shaders-msl/flatten/swizzle.flatten.vert000066400000000000000000000020251400026215700243150ustar00rootroot00000000000000#version 310 es // comments note the 16b alignment boundaries (see GL spec 7.6.2.2 Standard Uniform Block Layout) layout(std140) uniform UBO { // 16b boundary vec4 A; // 16b boundary vec2 B0; vec2 B1; // 16b boundary float C0; // 16b boundary (vec3 is aligned to 16b) vec3 C1; // 16b boundary vec3 D0; float D1; // 16b boundary float E0; float E1; float E2; float E3; // 16b boundary float F0; vec2 F1; // 16b boundary (vec2 before us is aligned to 8b) float F2; }; layout(location = 0) out vec4 oA; layout(location = 1) out vec4 oB; layout(location = 2) out vec4 oC; layout(location = 3) out vec4 oD; layout(location = 4) out vec4 oE; layout(location = 5) out vec4 oF; void main() { gl_Position = vec4(0.0); oA = A; oB = vec4(B0, B1); oC = vec4(C0, C1) + vec4(C1.xy, C1.z, C0); // not packed oD = vec4(D0, D1) + vec4(D0.xy, D0.z, D1); // packed - must convert for swizzle oE = vec4(E0, E1, E2, E3); oF = vec4(F0, F1, F2); } spirv-cross-2021.01.15/shaders-msl/flatten/types.flatten.frag000066400000000000000000000005661400026215700237210ustar00rootroot00000000000000#version 310 es precision mediump float; layout(std140, binding = 0) uniform UBO0 { vec4 a; vec4 b; }; layout(std140, binding = 1) uniform UBO1 { ivec4 c; ivec4 d; }; layout(std140, binding = 2) uniform UBO2 { uvec4 e; uvec4 f; }; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(c) + vec4(d) + vec4(e) + vec4(f) + a + b; } spirv-cross-2021.01.15/shaders-msl/frag/000077500000000000000000000000001400026215700175335ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/frag/argument-buffers.msl2.argument.frag000066400000000000000000000023211400026215700263430ustar00rootroot00000000000000#version 450 layout(std430, push_constant) uniform Push { vec4 push; } registers; layout(std140, set = 0, binding = 5) uniform UBO { vec4 ubo; }; layout(std430, set = 1, binding = 7) buffer SSBO { vec4 ssbo; }; layout(std430, set = 1, binding = 8) readonly buffer SSBOs { vec4 ssbo; } ssbos[2]; layout(std140, set = 2, binding = 4) uniform UBOs { vec4 ubo; } ubos[4]; layout(set = 0, binding = 2) uniform sampler2D uTexture; layout(set = 0, binding = 6) uniform sampler2D uTextures[2]; layout(set = 1, binding = 3) uniform texture2D uTexture2[4]; layout(set = 1, binding = 10) uniform sampler uSampler[2]; layout(location = 0) in vec2 vUV; layout(location = 0) out vec4 FragColor; vec4 sample_in_function2() { vec4 ret = texture(uTexture, vUV); ret += texture(sampler2D(uTexture2[2], uSampler[1]), vUV); ret += texture(uTextures[1], vUV); ret += ssbo; ret += ssbos[0].ssbo; ret += registers.push; return ret; } vec4 sample_in_function() { vec4 ret = sample_in_function2(); ret += ubo; ret += ubos[0].ubo; return ret; } void main() { FragColor = sample_in_function(); FragColor += ubo; FragColor += ssbo; FragColor += ubos[1].ubo; FragColor += registers.push; } spirv-cross-2021.01.15/shaders-msl/frag/array-lut-no-loop-variable.frag000066400000000000000000000003571400026215700254650ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 v0; void main() { float lut[5] = float[](1.0, 2.0, 3.0, 4.0, 5.0); for (int i = 0; i < 4; i++, FragColor += lut[i]) { } } spirv-cross-2021.01.15/shaders-msl/frag/array-of-array-lut.frag000066400000000000000000000004211400026215700240270ustar00rootroot00000000000000#version 450 layout(location = 0) out float vOutput; layout(location = 0) flat in int vIndex1; layout(location = 1) flat in int vIndex2; const float FOO[2][3] = float[][](float[](1.0, 2.0, 3.0), float[](4.0, 5.0, 6.0)); void main() { vOutput = FOO[vIndex1][vIndex2]; } array-of-texture-swizzle-nonconstant-uniform.msl2.argument.discrete.swizzle.frag000066400000000000000000000011001400026215700372530ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/frag#version 450 layout(set = 0, binding = 0) uniform sampler2D uSampler[4]; layout(set = 0, binding = 1) uniform sampler2D uSamp; layout(set = 0, binding = 2) uniform UBO { uint index; } uUBO; layout(set = 0, binding = 3) uniform UBO2 { uint index2; }; layout(location = 0) in vec2 vUV; layout(location = 0) out vec4 FragColor; vec4 sample_in_func() { return texture(uSampler[uUBO.index], vUV); } vec4 sample_single_in_func(sampler2D s) { return texture(s, vUV); } void main() { FragColor = sample_in_func(); FragColor += sample_single_in_func(uSampler[index2]); } array-of-texture-swizzle-nonconstant-uniform.msl2.swizzle.frag000066400000000000000000000011001400026215700336310ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/frag#version 450 layout(set = 0, binding = 0) uniform sampler2D uSampler[4]; layout(set = 0, binding = 1) uniform sampler2D uSamp; layout(set = 0, binding = 2) uniform UBO { uint index; } uUBO; layout(set = 0, binding = 3) uniform UBO2 { uint index2; }; layout(location = 0) in vec2 vUV; layout(location = 0) out vec4 FragColor; vec4 sample_in_func() { return texture(uSampler[uUBO.index], vUV); } vec4 sample_single_in_func(sampler2D s) { return texture(s, vUV); } void main() { FragColor = sample_in_func(); FragColor += sample_single_in_func(uSampler[index2]); } spirv-cross-2021.01.15/shaders-msl/frag/array-of-texture-swizzle.msl2.argument.discrete.swizzle.frag000066400000000000000000000012031400026215700333170ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 1) uniform sampler2D uSampler0[4]; layout(set = 2, binding = 0) uniform sampler2D uSampler1; layout(set = 1, binding = 4) uniform sampler2D uSamp; layout(location = 0) in vec2 vUV; layout(location = 0) out vec4 FragColor; vec4 sample_in_func_1() { return texture(uSampler0[2], vUV); } vec4 sample_in_func_2() { return texture(uSampler1, vUV); } vec4 sample_single_in_func(sampler2D s) { return texture(s, vUV); } void main() { FragColor = sample_in_func_1(); FragColor += sample_in_func_2(); FragColor += sample_single_in_func(uSampler0[1]); FragColor += sample_single_in_func(uSampler1); } spirv-cross-2021.01.15/shaders-msl/frag/array-of-texture-swizzle.msl2.swizzle.frag000066400000000000000000000006621400026215700277050ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform sampler2D uSampler[4]; layout(set = 0, binding = 1) uniform sampler2D uSamp; layout(location = 0) in vec2 vUV; layout(location = 0) out vec4 FragColor; vec4 sample_in_func() { return texture(uSampler[2], vUV); } vec4 sample_single_in_func(sampler2D s) { return texture(s, vUV); } void main() { FragColor = sample_in_func(); FragColor += sample_single_in_func(uSampler[1]); } spirv-cross-2021.01.15/shaders-msl/frag/barycentric-nv-nopersp.msl22.frag000066400000000000000000000006571400026215700257540ustar00rootroot00000000000000#version 450 #extension GL_NV_fragment_shader_barycentric : require layout(location = 0) out vec2 value; layout(set = 0, binding = 0) readonly buffer Vertices { vec2 uvs[]; }; void main () { int prim = gl_PrimitiveID; vec2 uv0 = uvs[3 * prim + 0]; vec2 uv1 = uvs[3 * prim + 1]; vec2 uv2 = uvs[3 * prim + 2]; value = gl_BaryCoordNoPerspNV.x * uv0 + gl_BaryCoordNoPerspNV.y * uv1 + gl_BaryCoordNoPerspNV.z * uv2; } spirv-cross-2021.01.15/shaders-msl/frag/barycentric-nv.msl22.frag000066400000000000000000000006321400026215700242610ustar00rootroot00000000000000#version 450 #extension GL_NV_fragment_shader_barycentric : require layout(location = 0) out vec2 value; layout(set = 0, binding = 0) readonly buffer Vertices { vec2 uvs[]; }; void main () { int prim = gl_PrimitiveID; vec2 uv0 = uvs[3 * prim + 0]; vec2 uv1 = uvs[3 * prim + 1]; vec2 uv2 = uvs[3 * prim + 2]; value = gl_BaryCoordNV.x * uv0 + gl_BaryCoordNV.y * uv1 + gl_BaryCoordNV.z * uv2; } spirv-cross-2021.01.15/shaders-msl/frag/basic.force-sample.frag000066400000000000000000000004071400026215700240320ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; layout(binding = 0) uniform sampler2D uTex; layout(location = 0) out vec4 FragColor; void main() { FragColor = vColor * texture(uTex, vTex); } spirv-cross-2021.01.15/shaders-msl/frag/basic.frag000066400000000000000000000004071400026215700214560ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; layout(binding = 0) uniform sampler2D uTex; layout(location = 0) out vec4 FragColor; void main() { FragColor = vColor * texture(uTex, vTex); } spirv-cross-2021.01.15/shaders-msl/frag/binary-func-unpack-pack-arguments.frag000066400000000000000000000003161400026215700270070ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(binding = 0, std140) uniform UBO { vec3 color; float v; }; layout(location = 0) in vec3 vIn; void main() { FragColor = dot(vIn, color); } spirv-cross-2021.01.15/shaders-msl/frag/binary-unpack-pack-arguments.frag000066400000000000000000000003251400026215700260560ustar00rootroot00000000000000#version 450 layout(location = 0) out vec3 FragColor; layout(binding = 0, std140) uniform UBO { vec3 color; float v; }; layout(location = 0) in vec3 vIn; void main() { FragColor = cross(vIn, color - vIn); } spirv-cross-2021.01.15/shaders-msl/frag/bitcasting.1d-as-2d.frag000066400000000000000000000013401400026215700237300ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1D TextureBase; layout(binding = 1) uniform sampler1D TextureDetail; layout(location = 0) in vec4 VertGeom; layout(location = 0) out vec4 FragColor0; layout(location = 1) out vec4 FragColor1; void main() { vec4 texSample0 = texture(TextureBase, VertGeom.x); vec4 texSample1 = textureOffset(TextureDetail, VertGeom.x, 3); ivec4 iResult0 = floatBitsToInt(texSample0); ivec4 iResult1 = floatBitsToInt(texSample1); FragColor0 = (intBitsToFloat(iResult0) * intBitsToFloat(iResult1)); uvec4 uResult0 = floatBitsToUint(texSample0); uvec4 uResult1 = floatBitsToUint(texSample1); FragColor1 = (uintBitsToFloat(uResult0) * uintBitsToFloat(uResult1)); } spirv-cross-2021.01.15/shaders-msl/frag/bitcasting.frag000066400000000000000000000014071400026215700225250ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 0) uniform sampler2D TextureBase; layout(binding = 1) uniform sampler2D TextureDetail; layout(location = 0) in vec4 VertGeom; layout(location = 0) out vec4 FragColor0; layout(location = 1) out vec4 FragColor1; void main() { vec4 texSample0 = texture(TextureBase, VertGeom.xy); vec4 texSample1 = textureOffset(TextureDetail, VertGeom.xy, ivec2(3, 2)); ivec4 iResult0 = floatBitsToInt(texSample0); ivec4 iResult1 = floatBitsToInt(texSample1); FragColor0 = (intBitsToFloat(iResult0) * intBitsToFloat(iResult1)); uvec4 uResult0 = floatBitsToUint(texSample0); uvec4 uResult1 = floatBitsToUint(texSample1); FragColor1 = (uintBitsToFloat(uResult0) * uintBitsToFloat(uResult1)); }spirv-cross-2021.01.15/shaders-msl/frag/buffer-read-write.frag000066400000000000000000000004341400026215700237070ustar00rootroot00000000000000#version 450 layout(rgba8, binding = 0) uniform readonly imageBuffer buf; layout(rgba8, binding = 1) uniform writeonly imageBuffer bufOut; layout(location = 0) out vec4 FragColor; void main() { FragColor = imageLoad(buf, 0); imageStore(bufOut, int(gl_FragCoord.x), FragColor); } spirv-cross-2021.01.15/shaders-msl/frag/buffer-read-write.texture-buffer-native.msl21.frag000066400000000000000000000004341400026215700310760ustar00rootroot00000000000000#version 450 layout(rgba8, binding = 0) uniform readonly imageBuffer buf; layout(rgba8, binding = 1) uniform writeonly imageBuffer bufOut; layout(location = 0) out vec4 FragColor; void main() { FragColor = imageLoad(buf, 0); imageStore(bufOut, int(gl_FragCoord.x), FragColor); } spirv-cross-2021.01.15/shaders-msl/frag/builtins.frag000066400000000000000000000003021400026215700222200ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vColor; void main() { FragColor = gl_FragCoord + vColor; gl_FragDepth = 0.5; } spirv-cross-2021.01.15/shaders-msl/frag/clip-distance-varying.frag000066400000000000000000000002531400026215700245700ustar00rootroot00000000000000#version 450 in float gl_ClipDistance[2]; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0 - gl_ClipDistance[0] - gl_ClipDistance[1]); } spirv-cross-2021.01.15/shaders-msl/frag/complex-expression-in-access-chain.frag000066400000000000000000000007651400026215700271730ustar00rootroot00000000000000#version 310 es precision mediump float; struct Foo { vec4 a; vec4 b; }; layout(binding = 0) buffer UBO { vec4 results[1024]; }; layout(binding = 1) uniform highp isampler2D Buf; layout(location = 0) flat in int vIn; layout(location = 1) flat in int vIn2; layout(location = 0) out vec4 FragColor; void main() { ivec4 coords = texelFetch(Buf, ivec2(gl_FragCoord.xy), 0); vec4 foo = results[coords.x % 16]; int c = vIn * vIn; int d = vIn2 * vIn2; FragColor = foo + foo + results[c + d]; } spirv-cross-2021.01.15/shaders-msl/frag/composite-extract-forced-temporary.frag000066400000000000000000000003761400026215700273340ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 0) uniform sampler2D Texture; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTexCoord; void main() { float f = texture(Texture, vTexCoord).x; FragColor = vec4(f * f); } spirv-cross-2021.01.15/shaders-msl/frag/constant-array.frag000066400000000000000000000011071400026215700233400ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in int index; struct Foobar { float a; float b; }; vec4 resolve(Foobar f) { return vec4(f.a + f.b); } void main() { const vec4 foo[3] = vec4[](vec4(1.0), vec4(2.0), vec4(3.0)); const vec4 foobars[2][2] = vec4[][](vec4[](vec4(1.0), vec4(2.0)), vec4[](vec4(8.0), vec4(10.0))); const Foobar foos[2] = Foobar[](Foobar(10.0, 40.0), Foobar(90.0, 70.0)); FragColor = foo[index] + foobars[index][index + 1] + resolve(Foobar(10.0, 20.0)) + resolve(foos[index]); } spirv-cross-2021.01.15/shaders-msl/frag/constant-composites.frag000066400000000000000000000005461400026215700244150ustar00rootroot00000000000000#version 310 es precision mediump float; float lut[4] = float[](1.0, 4.0, 3.0, 2.0); struct Foo { float a; float b; }; Foo foos[2] = Foo[](Foo(10.0, 20.0), Foo(30.0, 40.0)); layout(location = 0) out vec4 FragColor; layout(location = 0) flat in int line; void main() { FragColor = vec4(lut[line]); FragColor += foos[line].a * foos[1 - line].a; } spirv-cross-2021.01.15/shaders-msl/frag/control-dependent-in-branch.desktop.frag000066400000000000000000000012711400026215700273300ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) in vec4 vInput; void main() { FragColor = vInput; vec4 t = texture(uSampler, vInput.xy); vec4 d0 = dFdx(vInput); vec4 d1 = dFdy(vInput); vec4 d2 = fwidth(vInput); vec4 d3 = dFdxCoarse(vInput); vec4 d4 = dFdyCoarse(vInput); vec4 d5 = fwidthCoarse(vInput); vec4 d6 = dFdxFine(vInput); vec4 d7 = dFdyFine(vInput); vec4 d8 = fwidthFine(vInput); if (vInput.y > 10.0) { FragColor += t; FragColor += d0; FragColor += d1; FragColor += d2; FragColor += d3; FragColor += d4; FragColor += d5; FragColor += d6; FragColor += d7; FragColor += d8; } } spirv-cross-2021.01.15/shaders-msl/frag/depth-greater-than.frag000066400000000000000000000001411400026215700240530ustar00rootroot00000000000000#version 450 layout(depth_greater) out float gl_FragDepth; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/shaders-msl/frag/depth-less-than.frag000066400000000000000000000001361400026215700233740ustar00rootroot00000000000000#version 450 layout(depth_less) out float gl_FragDepth; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/shaders-msl/frag/disable-frag-output.frag-output.frag000066400000000000000000000012161400026215700265260ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_stencil_export : require layout(location = 0) out vec4 buf0; layout(location = 1) out vec4 buf1; layout(location = 2) out vec4 buf2; layout(location = 3) out vec4 buf3; layout(location = 4) out vec4 buf4; layout(location = 5) out vec4 buf5; layout(location = 6) out vec4 buf6; layout(location = 7) out vec4 buf7; void main() { buf0 = vec4(0, 0, 0, 1); buf1 = vec4(1, 0, 0, 1); buf2 = vec4(0, 1, 0, 1); buf3 = vec4(0, 0, 1, 1); buf4 = vec4(1, 0, 1, 0.5); buf5 = vec4(0.25, 0.25, 0.25, 0.25); buf6 = vec4(0.75, 0.75, 0.75, 0.75); buf7 = vec4(1, 1, 1, 1); gl_FragDepth = 0.9; gl_FragStencilRefARB = 127; } spirv-cross-2021.01.15/shaders-msl/frag/dual-source-blending.frag000066400000000000000000000002731400026215700244010ustar00rootroot00000000000000#version 450 layout(location = 0, index = 0) out vec4 FragColor0; layout(location = 0, index = 1) out vec4 FragColor1; void main() { FragColor0 = vec4(1.0); FragColor1 = vec4(2.0); } spirv-cross-2021.01.15/shaders-msl/frag/early-fragment-tests.frag000066400000000000000000000002011400026215700244420ustar00rootroot00000000000000#version 450 layout(early_fragment_tests) in; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0); } spirv-cross-2021.01.15/shaders-msl/frag/false-loop-init.frag000066400000000000000000000004261400026215700234000ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 accum; layout(location = 0) out vec4 result; void main() { result = vec4(0.0); uint j; for (int i = 0; i < 4; i += int(j)) { if (accum.y > 10.0) j = 40u; else j = 30u; result += accum; } } spirv-cross-2021.01.15/shaders-msl/frag/flush_params.frag000066400000000000000000000004331400026215700230600ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; struct Structy { vec4 c; }; void foo2(out Structy f) { f.c = vec4(10.0); } Structy foo() { Structy f; foo2(f); return f; } void main() { Structy s = foo(); FragColor = s.c; } spirv-cross-2021.01.15/shaders-msl/frag/for-loop-continue-control-flow.frag000066400000000000000000000002711400026215700263760ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(0.0); for (int i = 0; i < 3; (0 > 1) ? 1 : i ++) { int a = i; FragColor[a] += float(i); } } spirv-cross-2021.01.15/shaders-msl/frag/for-loop-init.frag000066400000000000000000000017621400026215700231000ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out int FragColor; void main() { FragColor = 16; // Basic loop variable. for (int i = 0; i < 25; i++) FragColor += 10; // Multiple loop variables. for (int i = 1, j = 4; i < 30; i++, j += 4) FragColor += 11; // A potential loop variables, but we access it outside the loop, // so cannot be one. int k = 0; for (; k < 20; k++) FragColor += 12; k += 3; FragColor += k; // Potential loop variables, but the dominator is not trivial. int l; if (k == 40) { for (l = 0; l < 40; l++) FragColor += 13; return; } else { l = k; FragColor += l; } // Vectors cannot be loop variables for (ivec2 i = ivec2(0); i.x < 10; i.x += 4) { FragColor += i.y; } // Check that static expressions can be used before the loop header. int m = 0; m = k; int o = m; for (; m < 40; m++) FragColor += m; FragColor += o; } spirv-cross-2021.01.15/shaders-msl/frag/fp16-packing.frag000066400000000000000000000003751400026215700225670ustar00rootroot00000000000000#version 450 layout(location = 0) flat in uint FP16; layout(location = 1) flat in vec2 FP32; layout(location = 0) out vec2 FP32Out; layout(location = 1) out uint FP16Out; void main() { FP32Out = unpackHalf2x16(FP16); FP16Out = packHalf2x16(FP32); } spirv-cross-2021.01.15/shaders-msl/frag/fragment-component-padding.pad-fragment.frag000066400000000000000000000005261400026215700301520ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColors[2]; layout(location = 2) out vec2 FragColor2; layout(location = 3) out vec3 FragColor3; layout(location = 0) in vec3 vColor; void set_globals() { FragColors[0] = vColor.x; FragColors[1] = vColor.y; FragColor2 = vColor.xz; FragColor3 = vColor.zzz; } void main() { set_globals(); } spirv-cross-2021.01.15/shaders-msl/frag/front-facing.frag000066400000000000000000000003451400026215700227530ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in vec4 vB; void main() { if (gl_FrontFacing) FragColor = vA; else FragColor = vB; } spirv-cross-2021.01.15/shaders-msl/frag/gather-dref.frag000066400000000000000000000003551400026215700225670ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 0) uniform mediump sampler2DShadow uT; layout(location = 0) in vec3 vUV; layout(location = 0) out vec4 FragColor; void main() { FragColor = textureGather(uT, vUV.xy, vUV.z); } spirv-cross-2021.01.15/shaders-msl/frag/gather-offset.frag000066400000000000000000000002431400026215700231310ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uT; layout(location = 0) out vec4 FragColor; void main() { FragColor = textureGather(uT, vec2(0.5), 3); } spirv-cross-2021.01.15/shaders-msl/frag/helper-invocation.msl21.frag000066400000000000000000000005261400026215700247620ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; layout(binding = 0) uniform sampler2D uSampler; vec4 foo() { vec4 color; if (!gl_HelperInvocation) color = textureLod(uSampler, vUV, 0.0); else color = vec4(1.0); return color; } void main() { FragColor = foo(); } huge-argument-buffer.device-argument-buffer.argument.msl2.frag000066400000000000000000000007241400026215700333610ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/frag#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; layout(set = 0, binding = 0) uniform sampler2D uSamplers[10000]; layout(set = 2, binding = 0) uniform sampler2D uSampler; layout(set = 1, binding = 0) uniform UBO { vec4 v; } vs[10000]; vec4 samp_array() { return texture(uSamplers[9999], vUV) + vs[5000].v; } vec4 samp_single() { return texture(uSampler, vUV); } void main() { FragColor = samp_array() + samp_single(); } spirv-cross-2021.01.15/shaders-msl/frag/illegal-name-test-0.frag000066400000000000000000000003521400026215700240350ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { vec4 fragment = vec4(10.0); vec4 compute = vec4(10.0); vec4 kernel = vec4(10.0); vec4 vertex = vec4(10.0); FragColor = fragment + compute + kernel + vertex; } spirv-cross-2021.01.15/shaders-msl/frag/image-query-lod.msl22.frag000066400000000000000000000024451400026215700243400ustar00rootroot00000000000000#version 450 layout(location = 0) out vec2 FragColor; layout(set = 0, binding = 0) uniform sampler2D uSampler2D; layout(set = 0, binding = 1) uniform sampler3D uSampler3D; layout(set = 0, binding = 2) uniform samplerCube uSamplerCube; layout(set = 0, binding = 3) uniform sampler uSampler; layout(set = 0, binding = 4) uniform texture2D uTexture2D; layout(set = 0, binding = 5) uniform texture3D uTexture3D; layout(set = 0, binding = 6) uniform textureCube uTextureCube; layout(location = 0) in vec3 vUV; void from_function() { FragColor += textureQueryLod(uSampler2D, vUV.xy); FragColor += textureQueryLod(uSampler3D, vUV); FragColor += textureQueryLod(uSamplerCube, vUV); FragColor += textureQueryLod(sampler2D(uTexture2D, uSampler), vUV.xy); FragColor += textureQueryLod(sampler3D(uTexture3D, uSampler), vUV); FragColor += textureQueryLod(samplerCube(uTextureCube, uSampler), vUV); } void main() { FragColor = vec2(0.0); FragColor += textureQueryLod(uSampler2D, vUV.xy); FragColor += textureQueryLod(uSampler3D, vUV); FragColor += textureQueryLod(uSamplerCube, vUV); FragColor += textureQueryLod(sampler2D(uTexture2D, uSampler), vUV.xy); FragColor += textureQueryLod(sampler3D(uTexture3D, uSampler), vUV); FragColor += textureQueryLod(samplerCube(uTextureCube, uSampler), vUV); from_function(); } spirv-cross-2021.01.15/shaders-msl/frag/in_block.frag000066400000000000000000000003031400026215700221500ustar00rootroot00000000000000#version 450 layout(location = 2) in VertexOut { vec4 color; vec4 color2; } inputs; layout(location = 0) out vec4 FragColor; void main() { FragColor = inputs.color + inputs.color2; } spirv-cross-2021.01.15/shaders-msl/frag/in_mat.frag000066400000000000000000000007471400026215700216530ustar00rootroot00000000000000#version 450 layout(binding = 1) uniform samplerCube samplerColor; layout(location = 0) in vec3 inPos; layout(location = 1) in vec3 inNormal; layout(location = 2) in mat4 inInvModelView; layout(location = 6) in float inLodBias; layout(location = 0) out vec4 outFragColor; void main() { vec3 cI = normalize(inPos); vec3 cR = reflect(cI, normalize(inNormal)); cR = vec3((inInvModelView * vec4(cR, 0.0)).xyz); cR.x *= (-1.0); outFragColor = texture(samplerColor, cR, inLodBias); } spirv-cross-2021.01.15/shaders-msl/frag/input-attachment-ms.arrayed-subpass.msl21.frag000066400000000000000000000007031400026215700303370ustar00rootroot00000000000000#version 450 layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInputMS uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform subpassInputMS uSubpass1; layout(location = 0) out vec4 FragColor; vec4 load_subpasses(mediump subpassInputMS uInput) { return subpassLoad(uInput, gl_SampleID); } void main() { FragColor = subpassLoad(uSubpass0, 1) + subpassLoad(uSubpass1, 2) + load_subpasses(uSubpass0); } spirv-cross-2021.01.15/shaders-msl/frag/input-attachment-ms.frag000066400000000000000000000007031400026215700242760ustar00rootroot00000000000000#version 450 layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInputMS uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform subpassInputMS uSubpass1; layout(location = 0) out vec4 FragColor; vec4 load_subpasses(mediump subpassInputMS uInput) { return subpassLoad(uInput, gl_SampleID); } void main() { FragColor = subpassLoad(uSubpass0, 1) + subpassLoad(uSubpass1, 2) + load_subpasses(uSubpass0); } spirv-cross-2021.01.15/shaders-msl/frag/input-attachment-ms.multiview.msl21.frag000066400000000000000000000007031400026215700272570ustar00rootroot00000000000000#version 450 layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInputMS uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform subpassInputMS uSubpass1; layout(location = 0) out vec4 FragColor; vec4 load_subpasses(mediump subpassInputMS uInput) { return subpassLoad(uInput, gl_SampleID); } void main() { FragColor = subpassLoad(uSubpass0, 1) + subpassLoad(uSubpass1, 2) + load_subpasses(uSubpass0); } spirv-cross-2021.01.15/shaders-msl/frag/input-attachment.arrayed-subpass.frag000066400000000000000000000006751400026215700267750ustar00rootroot00000000000000#version 310 es precision mediump float; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec4 FragColor; vec4 load_subpasses(mediump subpassInput uInput) { return subpassLoad(uInput); } void main() { FragColor = subpassLoad(uSubpass0) + load_subpasses(uSubpass1); } spirv-cross-2021.01.15/shaders-msl/frag/input-attachment.frag000066400000000000000000000006751400026215700236710ustar00rootroot00000000000000#version 310 es precision mediump float; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec4 FragColor; vec4 load_subpasses(mediump subpassInput uInput) { return subpassLoad(uInput); } void main() { FragColor = subpassLoad(uSubpass0) + load_subpasses(uSubpass1); } spirv-cross-2021.01.15/shaders-msl/frag/input-attachment.multiview.frag000066400000000000000000000006751400026215700257150ustar00rootroot00000000000000#version 310 es precision mediump float; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec4 FragColor; vec4 load_subpasses(mediump subpassInput uInput) { return subpassLoad(uInput); } void main() { FragColor = subpassLoad(uSubpass0) + load_subpasses(uSubpass1); } spirv-cross-2021.01.15/shaders-msl/frag/interpolation-qualifiers-block.frag000066400000000000000000000004631400026215700265200ustar00rootroot00000000000000#version 450 struct Input { vec2 v0; vec2 v1; vec3 v2; vec4 v3; float v4; float v5; float v6; }; layout(location=0) in centroid noperspective Input inp; layout(location=0) out vec4 FragColor; void main() { FragColor = vec4(inp.v0.x + inp.v1.y, inp.v2.xy, inp.v3.w * inp.v4 + inp.v5 - inp.v6); } spirv-cross-2021.01.15/shaders-msl/frag/interpolation-qualifiers.frag000066400000000000000000000006561400026215700254340ustar00rootroot00000000000000#version 450 layout(location=0) in vec2 v0; layout(location=1) in noperspective vec2 v1; layout(location=2) in centroid vec3 v2; layout(location=3) in centroid noperspective vec4 v3; layout(location=4) in sample float v4; layout(location=5) in sample noperspective float v5; layout(location=6) in flat float v6; layout(location=0) out vec4 FragColor; void main() { FragColor = vec4(v0.x + v1.y, v2.xy, v3.w * v4 + v5 - v6); } spirv-cross-2021.01.15/shaders-msl/frag/lut-promotion.frag000066400000000000000000000021661400026215700232310ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out float FragColor; layout(location = 0) flat in int index; const float LUT[16] = float[]( 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0); void main() { // Try reading LUTs, both in branches and not branch. FragColor = LUT[index]; if (index < 10) FragColor += LUT[index ^ 1]; else FragColor += LUT[index & 1]; // Not declared as a LUT, but can be promoted to one. vec4 foo[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); if (index > 30) { FragColor += foo[index & 3].y; } else { FragColor += foo[index & 1].x; } // Not declared as a LUT, but this cannot be promoted, because we have a partial write. vec4 foobar[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); if (index > 30) { foobar[1].z = 20.0; } FragColor += foobar[index & 3].z; // Not declared as a LUT, but this cannot be promoted, because we have two complete writes. vec4 baz[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0)); FragColor += baz[index & 3].z; } spirv-cross-2021.01.15/shaders-msl/frag/mix.frag000066400000000000000000000007151400026215700211740ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vIn0; layout(location = 1) in vec4 vIn1; layout(location = 2) in float vIn2; layout(location = 3) in float vIn3; layout(location = 0) out vec4 FragColor; void main() { bvec4 l = bvec4(false, true, false, false); FragColor = mix(vIn0, vIn1, l); bool f = true; FragColor = vec4(mix(vIn2, vIn3, f)); FragColor = f ? vIn0 : vIn1; FragColor = vec4(f ? vIn2 : vIn3); } spirv-cross-2021.01.15/shaders-msl/frag/mrt-array.frag000066400000000000000000000006071400026215700223150ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor[4]; layout(location = 0) in vec4 vA; layout(location = 1) in vec4 vB; void write_deeper_in_function() { FragColor[3] = vA * vB; } void write_in_function() { FragColor[2] = vA - vB; write_deeper_in_function(); } void main() { FragColor[0] = mod(vA, vB); FragColor[1] = vA + vB; write_in_function(); } spirv-cross-2021.01.15/shaders-msl/frag/nonuniform-qualifier.msl2.frag000066400000000000000000000014721400026215700254250ustar00rootroot00000000000000#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(binding = 0) uniform texture2D uSamplers[8]; layout(binding = 8) uniform sampler2D uCombinedSamplers[8]; layout(binding = 1) uniform sampler uSamps[7]; layout(location = 0) flat in int vIndex; layout(location = 1) in vec2 vUV; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 0) uniform UBO { vec4 v[64]; } ubos[2]; layout(set = 0, binding = 2) readonly buffer SSBO { vec4 v[]; } ssbos[2]; void main() { int i = vIndex; FragColor = texture(sampler2D(uSamplers[nonuniformEXT(i + 10)], uSamps[nonuniformEXT(i + 40)]), vUV); FragColor = texture(uCombinedSamplers[nonuniformEXT(i + 10)], vUV); FragColor += ubos[nonuniformEXT(i + 20)].v[nonuniformEXT(i + 40)]; FragColor += ssbos[nonuniformEXT(i + 50)].v[nonuniformEXT(i + 60)]; } spirv-cross-2021.01.15/shaders-msl/frag/packed-expression-vector-shuffle.frag000066400000000000000000000003011400026215700267440ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0, std140) uniform UBO { vec3 color; float v; }; void main() { vec4 f = vec4(1.0); f.rgb = color; FragColor = f; } spirv-cross-2021.01.15/shaders-msl/frag/packing-test-3.frag000066400000000000000000000010731400026215700231260ustar00rootroot00000000000000#version 450 struct VertexOutput { vec4 HPosition; }; struct TestStruct { vec3 position; float radius; }; layout(binding = 0, std140) uniform CB0 { TestStruct CB0[16]; } _24; layout(location = 0) out vec4 _entryPointOutput; vec4 _main(VertexOutput IN) { TestStruct st; st.position = _24.CB0[1].position; st.radius = _24.CB0[1].radius; vec4 col = vec4(st.position, st.radius); return col; } void main() { VertexOutput IN; IN.HPosition = gl_FragCoord; VertexOutput param = IN; _entryPointOutput = _main(param); } spirv-cross-2021.01.15/shaders-msl/frag/pixel-interlock-ordered.msl2.argument.frag000066400000000000000000000015271400026215700276310ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; layout(binding = 2, rgba8) uniform readonly image2D img3; layout(binding = 3) coherent buffer Buffer { int foo; uint bar; }; layout(binding = 4) buffer Buffer2 { uint quux; }; layout(binding = 5, rgba8) uniform writeonly image2D img4; layout(binding = 6) buffer Buffer3 { int baz; }; void main() { // Deliberately outside the critical section to test usage tracking. baz = 0; imageStore(img4, ivec2(1, 1), vec4(1.0, 0.0, 0.0, 1.0)); beginInvocationInterlockARB(); imageStore(img, ivec2(0, 0), imageLoad(img3, ivec2(0, 0))); imageAtomicAdd(img2, ivec2(0, 0), 1u); foo += 42; atomicAnd(bar, quux); endInvocationInterlockARB(); } spirv-cross-2021.01.15/shaders-msl/frag/pixel-interlock-ordered.msl2.frag000066400000000000000000000015271400026215700260100ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; layout(binding = 2, rgba8) uniform readonly image2D img3; layout(binding = 3) coherent buffer Buffer { int foo; uint bar; }; layout(binding = 4) buffer Buffer2 { uint quux; }; layout(binding = 5, rgba8) uniform writeonly image2D img4; layout(binding = 6) buffer Buffer3 { int baz; }; void main() { // Deliberately outside the critical section to test usage tracking. baz = 0; imageStore(img4, ivec2(1, 1), vec4(1.0, 0.0, 0.0, 1.0)); beginInvocationInterlockARB(); imageStore(img, ivec2(0, 0), imageLoad(img3, ivec2(0, 0))); imageAtomicAdd(img2, ivec2(0, 0), 1u); foo += 42; atomicAnd(bar, quux); endInvocationInterlockARB(); } spirv-cross-2021.01.15/shaders-msl/frag/pls.frag000066400000000000000000000007341400026215700211760ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 PLSIn0; layout(location = 1) in vec4 PLSIn1; layout(location = 2) in vec4 PLSIn2; layout(location = 3) in vec4 PLSIn3; layout(location = 0) out vec4 PLSOut0; layout(location = 1) out vec4 PLSOut1; layout(location = 2) out vec4 PLSOut2; layout(location = 3) out vec4 PLSOut3; void main() { PLSOut0 = 2.0 * PLSIn0; PLSOut1 = 6.0 * PLSIn1; PLSOut2 = 7.0 * PLSIn2; PLSOut3 = 4.0 * PLSIn3; } spirv-cross-2021.01.15/shaders-msl/frag/post-depth-coverage.ios.msl2.frag000066400000000000000000000003001400026215700257120ustar00rootroot00000000000000#version 450 #extension GL_ARB_post_depth_coverage : require layout(post_depth_coverage) in; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(gl_SampleMaskIn[0]); } spirv-cross-2021.01.15/shaders-msl/frag/post-depth-coverage.msl23.frag000066400000000000000000000003001400026215700252040ustar00rootroot00000000000000#version 450 #extension GL_ARB_post_depth_coverage : require layout(post_depth_coverage) in; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(gl_SampleMaskIn[0]); } spirv-cross-2021.01.15/shaders-msl/frag/private-variable-prototype-declaration.frag000066400000000000000000000005311400026215700301560ustar00rootroot00000000000000#version 450 struct AStruct { vec4 foobar; }; void someFunction(out AStruct s) { s.foobar = vec4(1.0); } highp vec3 global_variable; void otherFunction() { global_variable = vec3(1.0); } layout(location = 0) out vec3 FragColor; void main() { AStruct inputs; someFunction(inputs); otherFunction(); FragColor = global_variable; } spirv-cross-2021.01.15/shaders-msl/frag/readonly-ssbo.frag000066400000000000000000000003271400026215700231570ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0, std430) readonly buffer SSBO { vec4 v; }; vec4 read_from_function() { return v; } void main() { FragColor = v + read_from_function(); } spirv-cross-2021.01.15/shaders-msl/frag/sample-depth-propagate-state-from-resource.frag000066400000000000000000000011571400026215700306470ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform texture2D uTexture; layout(set = 0, binding = 1) uniform sampler uSampler; layout(set = 0, binding = 2) uniform samplerShadow uSamplerShadow; layout(location = 0) out float FragColor; layout(location = 0) in vec3 vUV; float sample_normal2(texture2D tex) { return texture(sampler2D(tex, uSampler), vUV.xy).x; } float sample_normal(texture2D tex) { return sample_normal2(tex); } float sample_comp(texture2D tex) { return texture(sampler2DShadow(tex, uSamplerShadow), vUV); } void main() { FragColor = sample_normal(uTexture); FragColor += sample_comp(uTexture); } spirv-cross-2021.01.15/shaders-msl/frag/sample-depth-separate-image-sampler.frag000066400000000000000000000012151400026215700273010ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform texture2D uDepth; layout(set = 0, binding = 1) uniform texture2D uColor; layout(set = 0, binding = 2) uniform sampler uSampler; layout(set = 0, binding = 3) uniform samplerShadow uSamplerShadow; layout(location = 0) out float FragColor; float sample_depth_from_function(texture2D uT, samplerShadow uS) { return texture(sampler2DShadow(uT, uS), vec3(0.5)); } float sample_color_from_function(texture2D uT, sampler uS) { return texture(sampler2D(uT, uS), vec2(0.5)).x; } void main() { FragColor = sample_depth_from_function(uDepth, uSamplerShadow) + sample_color_from_function(uColor, uSampler); } spirv-cross-2021.01.15/shaders-msl/frag/sample-mask-in-and-out.fixed-sample-mask.frag000066400000000000000000000002111400026215700300570ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0); gl_SampleMask[0] = gl_SampleMaskIn[0]; } spirv-cross-2021.01.15/shaders-msl/frag/sample-mask-not-used.fixed-sample-mask.frag000066400000000000000000000001401400026215700276430ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0); } spirv-cross-2021.01.15/shaders-msl/frag/sample-mask.fixed-sample-mask.frag000066400000000000000000000001701400026215700261120ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0); gl_SampleMask[0] = 0; } spirv-cross-2021.01.15/shaders-msl/frag/sample-mask.frag000066400000000000000000000001701400026215700226040ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(1.0); gl_SampleMask[0] = 0; } spirv-cross-2021.01.15/shaders-msl/frag/sample-position-func.frag000066400000000000000000000003221400026215700244450ustar00rootroot00000000000000#version 450 layout(location = 0) in flat int index; layout(location = 0) out vec4 FragColor; vec4 getColor(int i) { return vec4(gl_SamplePosition, i, 1.0); } void main() { FragColor = getColor(index); } spirv-cross-2021.01.15/shaders-msl/frag/sample-position.frag000066400000000000000000000002001400026215700235070ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(gl_SamplePosition, gl_SampleID, 1.0); } spirv-cross-2021.01.15/shaders-msl/frag/sample-rate-frag-coord-sample-id.frag000066400000000000000000000003101400026215700264720ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform sampler2DArray tex; layout(location = 0) out vec4 FragColor; void main() { FragColor = texture(tex, vec3(gl_FragCoord.xy, float(gl_SampleID))); } spirv-cross-2021.01.15/shaders-msl/frag/sample-rate-frag-coord-sample-input.frag000066400000000000000000000003431400026215700272430ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform sampler2DArray tex; layout(location = 0) sample in float foo; layout(location = 0) out vec4 FragColor; void main() { FragColor = texture(tex, vec3(gl_FragCoord.xy, foo)); } spirv-cross-2021.01.15/shaders-msl/frag/sample-rate-frag-coord-sample-pos.frag000066400000000000000000000002751400026215700267110ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform sampler2D tex; layout(location = 0) out vec4 FragColor; void main() { FragColor = texture(tex, gl_FragCoord.xy - gl_SamplePosition); } spirv-cross-2021.01.15/shaders-msl/frag/sample-rate-frag-coord.force-sample.frag000066400000000000000000000002511400026215700272010ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform sampler2D tex; layout(location = 0) out vec4 FragColor; void main() { FragColor = texture(tex, gl_FragCoord.xy); } spirv-cross-2021.01.15/shaders-msl/frag/sampler-1d-lod.1d-as-2d.frag000066400000000000000000000004331400026215700243240ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) flat in float vTex; layout(binding = 0) uniform sampler1D uSampler; void main() { FragColor += texture(uSampler, vTex, 2.0) + textureLod(uSampler, vTex, 3.0) + textureGrad(uSampler, vTex, 5.0, 8.0); } spirv-cross-2021.01.15/shaders-msl/frag/sampler-1d-lod.frag000066400000000000000000000004331400026215700231150ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) flat in float vTex; layout(binding = 0) uniform sampler1D uSampler; void main() { FragColor += texture(uSampler, vTex, 2.0) + textureLod(uSampler, vTex, 3.0) + textureGrad(uSampler, vTex, 5.0, 8.0); } spirv-cross-2021.01.15/shaders-msl/frag/sampler-compare-bias.msl23.1d-as-2d.frag000066400000000000000000000004241400026215700265450ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform texture1DArray uTex; layout(binding = 1) uniform samplerShadow uShadow; layout(location = 0) in vec3 vUV; layout(location = 0) out float FragColor; void main() { FragColor = texture(sampler1DArrayShadow(uTex, uShadow), vUV, 1.0); } spirv-cross-2021.01.15/shaders-msl/frag/sampler-compare-cascade-gradient.frag000066400000000000000000000004511400026215700266370ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform texture2DArray uTex; layout(binding = 1) uniform samplerShadow uShadow; layout(location = 0) in vec4 vUV; layout(location = 0) out float FragColor; void main() { FragColor = textureGrad(sampler2DArrayShadow(uTex, uShadow), vUV, vec2(0.0), vec2(0.0)); } spirv-cross-2021.01.15/shaders-msl/frag/sampler-compare-cascade-gradient.ios.frag000066400000000000000000000004511400026215700274300ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform texture2DArray uTex; layout(binding = 1) uniform samplerShadow uShadow; layout(location = 0) in vec4 vUV; layout(location = 0) out float FragColor; void main() { FragColor = textureGrad(sampler2DArrayShadow(uTex, uShadow), vUV, vec2(0.0), vec2(0.0)); } spirv-cross-2021.01.15/shaders-msl/frag/sampler-compare-cascade-gradient.msl23.frag000066400000000000000000000005671400026215700276060ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform texture2DArray uTex; layout(binding = 1) uniform samplerShadow uShadow; layout(location = 0) in vec4 vUV; layout(location = 0) out float FragColor; void main() { FragColor = textureGrad(sampler2DArrayShadow(uTex, uShadow), vUV, vec2(0.0), vec2(0.0)) + textureGrad(sampler2DArrayShadow(uTex, uShadow), vUV, vec2(1.0), vec2(1.0)); } spirv-cross-2021.01.15/shaders-msl/frag/sampler-image-arrays.msl2.frag000066400000000000000000000015231400026215700252730ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) flat in vec2 vTex; layout(location = 1) flat in int vIndex; layout(binding = 0) uniform sampler2D uSampler[4]; layout(binding = 4) uniform sampler uSamplers[4]; layout(binding = 8) uniform texture2D uTextures[4]; vec4 sample_from_argument(sampler2D samplers[4]) { return texture(samplers[vIndex], vTex + 0.2); } vec4 sample_single_from_argument(sampler2D samp) { return texture(samp, vTex + 0.3); } vec4 sample_from_global() { return texture(uSampler[vIndex], vTex + 0.1); } void main() { FragColor = vec4(0.0); FragColor += texture(sampler2D(uTextures[2], uSamplers[1]), vTex); FragColor += texture(uSampler[vIndex], vTex); FragColor += sample_from_global(); FragColor += sample_from_argument(uSampler); FragColor += sample_single_from_argument(uSampler[3]); } spirv-cross-2021.01.15/shaders-msl/frag/sampler-ms.frag000066400000000000000000000005621400026215700224570ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2DMS uSampler; layout(location = 0) out vec4 FragColor; void main() { ivec2 coord = ivec2(gl_FragCoord.xy); FragColor = texelFetch(uSampler, coord, 0) + texelFetch(uSampler, coord, 1) + texelFetch(uSampler, coord, 2) + texelFetch(uSampler, coord, 3); } spirv-cross-2021.01.15/shaders-msl/frag/sampler.frag000066400000000000000000000005341400026215700220410ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; layout(binding = 0) uniform sampler2D uTex; layout(location = 0) out vec4 FragColor; vec4 sample_texture(sampler2D tex, vec2 uv) { return texture(tex, uv); } void main() { FragColor = vColor * sample_texture(uTex, vTex); } spirv-cross-2021.01.15/shaders-msl/frag/scalar-refract-reflect.frag000066400000000000000000000005131400026215700247060ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(location = 0) in vec3 vRefract; void main() { FragColor = refract(vRefract.x, vRefract.y, vRefract.z); FragColor += reflect(vRefract.x, vRefract.y); FragColor += refract(vRefract.xy, vRefract.yz, vRefract.z).y; FragColor += reflect(vRefract.xy, vRefract.zy).y; } spirv-cross-2021.01.15/shaders-msl/frag/separate-image-sampler-argument.frag000066400000000000000000000005471400026215700265470ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump sampler uSampler; layout(set = 0, binding = 1) uniform mediump texture2D uDepth; layout(location = 0) out vec4 FragColor; vec4 samp(texture2D t, mediump sampler s) { return texture(sampler2D(t, s), vec2(0.5)); } void main() { FragColor = samp(uDepth, uSampler); } spirv-cross-2021.01.15/shaders-msl/frag/shader-arithmetic-8bit.frag000066400000000000000000000030141400026215700246330ustar00rootroot00000000000000#version 450 #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require #extension GL_EXT_shader_explicit_arithmetic_types_int16 : require layout(location = 0) flat in ivec4 vColor; layout(location = 0) out ivec4 FragColorInt; layout(location = 1) out uvec4 FragColorUint; layout(push_constant, std140) uniform Push { int8_t i8; uint8_t u8; } registers; layout(binding = 1, std140) uniform UBO { int8_t i8; uint8_t u8; } ubo; layout(binding = 2, std430) buffer SSBO { int8_t i8[16]; uint8_t u8[16]; } ssbo; void packing_int8() { int16_t i16 = 10s; int i32 = 20; i8vec2 i8_2 = unpack8(i16); i8vec4 i8_4 = unpack8(i32); i16 = pack16(i8_2); i32 = pack32(i8_4); ssbo.i8[0] = i8_4.x; ssbo.i8[1] = i8_4.y; ssbo.i8[2] = i8_4.z; ssbo.i8[3] = i8_4.w; } void packing_uint8() { uint16_t u16 = 10us; uint u32 = 20u; u8vec2 u8_2 = unpack8(u16); u8vec4 u8_4 = unpack8(u32); u16 = pack16(u8_2); u32 = pack32(u8_4); ssbo.u8[0] = u8_4.x; ssbo.u8[1] = u8_4.y; ssbo.u8[2] = u8_4.z; ssbo.u8[3] = u8_4.w; } void compute_int8() { i8vec4 tmp = i8vec4(vColor); tmp += registers.i8; tmp += int8_t(-40); tmp += i8vec4(-50); tmp += i8vec4(10, 20, 30, 40); tmp += ssbo.i8[4]; tmp += ubo.i8; FragColorInt = ivec4(tmp); } void compute_uint8() { u8vec4 tmp = u8vec4(vColor); tmp += registers.u8; tmp += uint8_t(-40); tmp += u8vec4(-50); tmp += u8vec4(10, 20, 30, 40); tmp += ssbo.u8[4]; tmp += ubo.u8; FragColorUint = uvec4(tmp); } void main() { packing_int8(); packing_uint8(); compute_int8(); compute_uint8(); } spirv-cross-2021.01.15/shaders-msl/frag/spec-constant-block-size.frag000066400000000000000000000004371400026215700252210ustar00rootroot00000000000000#version 310 es precision mediump float; layout(constant_id = 10) const int Value = 2; layout(binding = 0) uniform SpecConstArray { vec4 samples[Value]; }; layout(location = 0) flat in int Index; layout(location = 0) out vec4 FragColor; void main() { FragColor = samples[Index]; } spirv-cross-2021.01.15/shaders-msl/frag/spec-constant-ternary.frag000066400000000000000000000002571400026215700246430ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(constant_id = 0) const uint s = 10u; const uint f = s > 20u ? 30u : 50u; void main() { FragColor = float(f); } spirv-cross-2021.01.15/shaders-msl/frag/stencil-export.msl21.frag000066400000000000000000000004651400026215700243160ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_stencil_export : require layout(location = 0) out vec4 MRT0; layout(location = 1) out vec4 MRT1; void update_stencil() { gl_FragStencilRefARB += 10; } void main() { MRT0 = vec4(1.0); MRT1 = vec4(1.0, 0.0, 1.0, 1.0); gl_FragStencilRefARB = 100; update_stencil(); } spirv-cross-2021.01.15/shaders-msl/frag/subgroup-builtins.msl22.frag000066400000000000000000000003031400026215700250230ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require layout(location = 0) out uvec2 FragColor; void main() { FragColor.x = gl_SubgroupSize; FragColor.y = gl_SubgroupInvocationID; } spirv-cross-2021.01.15/shaders-msl/frag/subgroup-globals-extract.msl22.frag000066400000000000000000000010761400026215700262750ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require layout(location = 0) out uvec2 FragColor; uint sub1() { return subgroupBallotFindLSB(uvec4(1,2,3,4)); } uint sub2() { return subgroupBallotFindMSB(uvec4(1,2,3,4)); } uint sub3() { return subgroupBallotBitCount(uvec4(1,2,3,4)); } uint sub4() { return subgroupBallotInclusiveBitCount(uvec4(1,2,3,4)); } uint sub5() { return subgroupBallotExclusiveBitCount(uvec4(1,2,3,4)); } void main() { FragColor.x = sub1() + sub2() + sub3() + sub4() + sub5(); } spirv-cross-2021.01.15/shaders-msl/frag/switch-unsigned-case.frag000066400000000000000000000005461400026215700244250ustar00rootroot00000000000000#version 310 es precision mediump float; #define ENUM_0 0u #define ENUM_1 1u layout(set = 0, binding = 0) uniform Buff { uint TestVal; }; layout(location = 0) out vec4 fsout_Color; void main() { fsout_Color = vec4(1.0); switch (TestVal) { case ENUM_0: fsout_Color = vec4(0.1); break; case ENUM_1: fsout_Color = vec4(0.2); break; } } spirv-cross-2021.01.15/shaders-msl/frag/swizzle.frag000066400000000000000000000010061400026215700221000ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 0) uniform sampler2D samp; layout(location = 0) out vec4 FragColor; layout(location = 1) in vec3 vNormal; layout(location = 2) in vec2 vUV; void main() { FragColor = vec4(texture(samp, vUV).xyz, 1.0); FragColor = vec4(texture(samp, vUV).xz, 1.0, 4.0); FragColor = vec4(texture(samp, vUV).xx, texture(samp, vUV + vec2(0.1)).yy); FragColor = vec4(vNormal, 1.0); FragColor = vec4(vNormal + 1.8, 1.0); FragColor = vec4(vUV, vUV + 1.8); } spirv-cross-2021.01.15/shaders-msl/frag/texel-fetch-offset.1d-as-2d.frag000066400000000000000000000005051400026215700252770ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uTexture; layout(binding = 1) uniform sampler1D uTexture2; void main() { FragColor = texelFetchOffset(uTexture, ivec2(gl_FragCoord.xy), 0, ivec2(1, 1)); FragColor += texelFetchOffset(uTexture2, int(gl_FragCoord.x), 0, int(-1)); } spirv-cross-2021.01.15/shaders-msl/frag/texel-fetch-offset.frag000066400000000000000000000004671400026215700240770ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uTexture; void main() { FragColor = texelFetchOffset(uTexture, ivec2(gl_FragCoord.xy), 0, ivec2(1, 1)); FragColor += texelFetchOffset(uTexture, ivec2(gl_FragCoord.xy), 0, ivec2(-1, 1)); } spirv-cross-2021.01.15/shaders-msl/frag/texture-cube-array.frag000066400000000000000000000007161400026215700241300ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform samplerCube cubeSampler; layout(set = 0, binding = 1) uniform samplerCubeArray cubeArraySampler; layout(set = 0, binding = 2) uniform sampler2DArray texArraySampler; layout(location = 0) in vec4 vUV; layout(location = 0) out vec4 FragColor; void main() { vec4 a = texture(cubeSampler, vUV.xyz); vec4 b = texture(cubeArraySampler, vUV); vec4 c = texture(texArraySampler, vUV.xyz); FragColor = a + b + c; } spirv-cross-2021.01.15/shaders-msl/frag/texture-cube-array.ios.emulate-cube-array.frag000066400000000000000000000007161400026215700304040ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform samplerCube cubeSampler; layout(set = 0, binding = 1) uniform samplerCubeArray cubeArraySampler; layout(set = 0, binding = 2) uniform sampler2DArray texArraySampler; layout(location = 0) in vec4 vUV; layout(location = 0) out vec4 FragColor; void main() { vec4 a = texture(cubeSampler, vUV.xyz); vec4 b = texture(cubeArraySampler, vUV); vec4 c = texture(texArraySampler, vUV.xyz); FragColor = a + b + c; } spirv-cross-2021.01.15/shaders-msl/frag/texture-multisample-array.msl21.frag000066400000000000000000000004071400026215700265000ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2DMSArray uTexture; layout(location = 0) flat in ivec3 vCoord; layout(location = 1) flat in int vSample; void main() { FragColor = texelFetch(uTexture, vCoord, vSample); } spirv-cross-2021.01.15/shaders-msl/frag/texture-proj-shadow.frag000066400000000000000000000011031400026215700243220ustar00rootroot00000000000000#version 450 layout(binding = 1) uniform sampler2DShadow uShadow2D; layout(binding = 2) uniform sampler1D uSampler1D; layout(binding = 3) uniform sampler2D uSampler2D; layout(binding = 4) uniform sampler3D uSampler3D; layout(location = 0) out float FragColor; layout(location = 0) in vec3 vClip3; layout(location = 1) in vec4 vClip4; layout(location = 2) in vec2 vClip2; void main() { FragColor = textureProj(uShadow2D, vClip4); FragColor = textureProj(uSampler1D, vClip2).x; FragColor = textureProj(uSampler2D, vClip3).x; FragColor = textureProj(uSampler3D, vClip4).x; } spirv-cross-2021.01.15/shaders-msl/frag/ubo_layout.frag000066400000000000000000000005371400026215700225630ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; struct Str { mat4 foo; }; layout(binding = 0, std140) uniform UBO1 { layout(row_major) Str foo; } ubo1; layout(binding = 1, std140) uniform UBO2 { layout(column_major) Str foo; } ubo0; void main() { FragColor = ubo1.foo.foo[0] + ubo0.foo.foo[0]; } spirv-cross-2021.01.15/shaders-msl/frag/unary-enclose.frag000066400000000000000000000003711400026215700231610ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vIn; layout(location = 1) flat in ivec4 vIn1; void main() { FragColor = +(-(-vIn)); ivec4 a = ~(~vIn1); bool b = false; b = !!b; } spirv-cross-2021.01.15/shaders-msl/frag/vecsize-mismatch.shader-inputs.frag000066400000000000000000000006211400026215700264330ustar00rootroot00000000000000#version 450 #extension GL_AMD_gpu_shader_int16 : require layout(location = 0) flat in int16_t a; layout(location = 1) flat in ivec2 b; layout(location = 2) flat in uint16_t c[2]; layout(location = 4) flat in uvec4 e[2]; layout(location = 6) in vec2 d; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(float(int(a)), float(b.x), vec2(uint(c[1]), float(e[0].w)) + d); } spirv-cross-2021.01.15/shaders-msl/frag/write-depth-in-function.frag000066400000000000000000000003021400026215700250520ustar00rootroot00000000000000#version 450 layout(location = 0) in float v; layout(location = 0) out float FragColor; void set_output_depth() { gl_FragDepth = 0.2; } void main() { FragColor = 1.0; set_output_depth(); } spirv-cross-2021.01.15/shaders-msl/intel/000077500000000000000000000000001400026215700177275ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/intel/shader-integer-functions2.asm.comp000066400000000000000000000137431400026215700263670ustar00rootroot00000000000000; SPIR-V ; Version: 1.4 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 97 ; Schema: 0 OpCapability Shader OpCapability IntegerFunctions2INTEL OpExtension "SPV_INTEL_shader_integer_functions2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %foo "foo" OpMemberName %foo 0 "a" OpMemberName %foo 1 "b" OpMemberName %foo 2 "c" OpMemberName %foo 3 "d" OpName %_ "" OpMemberDecorate %foo 0 Offset 0 OpMemberDecorate %foo 1 Offset 4 OpMemberDecorate %foo 2 Offset 8 OpMemberDecorate %foo 3 Offset 12 OpDecorate %foo Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %6 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %foo = OpTypeStruct %uint %uint %int %int %_ptr_StorageBuffer_foo = OpTypePointer StorageBuffer %foo %_ = OpVariable %_ptr_StorageBuffer_foo StorageBuffer %int_0 = OpConstant %int 0 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %int_3 = OpConstant %int 3 %main = OpFunction %void None %6 %15 = OpLabel %16 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 %17 = OpLoad %uint %16 %18 = OpUCountLeadingZerosINTEL %uint %17 %19 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 OpStore %19 %18 %20 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 %21 = OpLoad %uint %20 %22 = OpUCountTrailingZerosINTEL %uint %21 %23 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 OpStore %23 %22 %24 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 %25 = OpLoad %int %24 %26 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_3 %27 = OpLoad %int %26 %28 = OpAbsISubINTEL %uint %25 %27 %29 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 OpStore %29 %28 %30 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 %31 = OpLoad %uint %30 %32 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_1 %33 = OpLoad %uint %32 %34 = OpAbsUSubINTEL %uint %31 %33 %35 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 OpStore %35 %34 %37 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 %38 = OpLoad %int %37 %39 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_3 %40 = OpLoad %int %39 %41 = OpIAddSatINTEL %int %38 %40 %42 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 OpStore %42 %41 %43 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 %44 = OpLoad %uint %43 %45 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_1 %46 = OpLoad %uint %45 %47 = OpUAddSatINTEL %uint %44 %46 %48 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 OpStore %48 %47 %49 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 %50 = OpLoad %int %49 %51 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_3 %52 = OpLoad %int %51 %53 = OpIAverageINTEL %int %50 %52 %54 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 OpStore %54 %53 %55 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 %56 = OpLoad %uint %55 %57 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_1 %58 = OpLoad %uint %57 %59 = OpUAverageINTEL %uint %56 %58 %60 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 OpStore %60 %59 %61 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 %62 = OpLoad %int %61 %63 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_3 %64 = OpLoad %int %63 %65 = OpIAverageRoundedINTEL %int %62 %64 %66 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 OpStore %66 %65 %67 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 %68 = OpLoad %uint %67 %69 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_1 %70 = OpLoad %uint %69 %71 = OpUAverageRoundedINTEL %uint %68 %70 %72 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 OpStore %72 %71 %73 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 %74 = OpLoad %int %73 %75 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_3 %76 = OpLoad %int %75 %77 = OpISubSatINTEL %int %74 %76 %78 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 OpStore %78 %77 %79 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 %80 = OpLoad %uint %79 %81 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_1 %82 = OpLoad %uint %81 %83 = OpUSubSatINTEL %uint %80 %82 %84 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 OpStore %84 %83 %85 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 %86 = OpLoad %int %85 %87 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_3 %88 = OpLoad %int %87 %89 = OpIMul32x16INTEL %int %86 %88 %90 = OpAccessChain %_ptr_StorageBuffer_int %_ %int_2 OpStore %90 %89 %91 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 %92 = OpLoad %uint %91 %93 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_1 %94 = OpLoad %uint %93 %95 = OpUMul32x16INTEL %uint %92 %94 %96 = OpAccessChain %_ptr_StorageBuffer_uint %_ %int_0 OpStore %96 %95 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/legacy/000077500000000000000000000000001400026215700200605ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/legacy/vert/000077500000000000000000000000001400026215700210405ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/legacy/vert/transpose.legacy.vert000066400000000000000000000005731400026215700252300ustar00rootroot00000000000000#version 310 es uniform Buffer { layout(row_major) mat4 MVPRowMajor; layout(column_major) mat4 MVPColMajor; mat4 M; }; layout(location = 0) in vec4 Position; void main() { vec4 c0 = M * (MVPRowMajor * Position); vec4 c1 = M * (MVPColMajor * Position); vec4 c2 = M * (Position * MVPRowMajor); vec4 c3 = M * (Position * MVPColMajor); gl_Position = c0 + c1 + c2 + c3; } spirv-cross-2021.01.15/shaders-msl/tesc/000077500000000000000000000000001400026215700175525ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/tesc/basic.multi-patch.tesc000066400000000000000000000005551400026215700237460ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(location = 0) patch out vec3 vFoo; layout(vertices = 1) out; void main() { gl_TessLevelInner[0] = 8.9; gl_TessLevelInner[1] = 6.9; gl_TessLevelOuter[0] = 8.9; gl_TessLevelOuter[1] = 6.9; gl_TessLevelOuter[2] = 3.9; gl_TessLevelOuter[3] = 4.9; vFoo = vec3(1.0); } spirv-cross-2021.01.15/shaders-msl/tesc/basic.tesc000066400000000000000000000005551400026215700215200ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(location = 0) patch out vec3 vFoo; layout(vertices = 1) out; void main() { gl_TessLevelInner[0] = 8.9; gl_TessLevelInner[1] = 6.9; gl_TessLevelOuter[0] = 8.9; gl_TessLevelOuter[1] = 6.9; gl_TessLevelOuter[2] = 3.9; gl_TessLevelOuter[3] = 4.9; vFoo = vec3(1.0); } spirv-cross-2021.01.15/shaders-msl/tesc/load-control-point-array-of-matrix.multi-patch.tesc000066400000000000000000000003751400026215700314310ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; layout(location = 0) in mat4 vInputs[gl_MaxPatchVertices]; layout(location = 0) out mat4 vOutputs[4]; void main() { mat4 tmp[gl_MaxPatchVertices] = vInputs; vOutputs[gl_InvocationID] = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/shaders-msl/tesc/load-control-point-array-of-matrix.tesc000066400000000000000000000003751400026215700272030ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; layout(location = 0) in mat4 vInputs[gl_MaxPatchVertices]; layout(location = 0) out mat4 vOutputs[4]; void main() { mat4 tmp[gl_MaxPatchVertices] = vInputs; vOutputs[gl_InvocationID] = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/shaders-msl/tesc/load-control-point-array-of-struct.multi-patch.tesc000066400000000000000000000007001400026215700314410ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; struct VertexData { mat4 a; vec4 b[2]; vec4 c; }; layout(location = 0) in VertexData vInputs[gl_MaxPatchVertices]; layout(location = 0) out vec4 vOutputs[4]; void main() { VertexData tmp[gl_MaxPatchVertices] = vInputs; VertexData tmp_single = vInputs[gl_InvocationID ^ 1]; vOutputs[gl_InvocationID] = tmp[gl_InvocationID].a[1] + tmp[gl_InvocationID].b[1] + tmp[gl_InvocationID].c + tmp_single.c; } spirv-cross-2021.01.15/shaders-msl/tesc/load-control-point-array-of-struct.tesc000066400000000000000000000007001400026215700272130ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; struct VertexData { mat4 a; vec4 b[2]; vec4 c; }; layout(location = 0) in VertexData vInputs[gl_MaxPatchVertices]; layout(location = 0) out vec4 vOutputs[4]; void main() { VertexData tmp[gl_MaxPatchVertices] = vInputs; VertexData tmp_single = vInputs[gl_InvocationID ^ 1]; vOutputs[gl_InvocationID] = tmp[gl_InvocationID].a[1] + tmp[gl_InvocationID].b[1] + tmp[gl_InvocationID].c + tmp_single.c; } spirv-cross-2021.01.15/shaders-msl/tesc/load-control-point-array.multi-patch.tesc000066400000000000000000000003751400026215700275250ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; layout(location = 0) in vec4 vInputs[gl_MaxPatchVertices]; layout(location = 0) out vec4 vOutputs[4]; void main() { vec4 tmp[gl_MaxPatchVertices] = vInputs; vOutputs[gl_InvocationID] = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/shaders-msl/tesc/load-control-point-array.tesc000066400000000000000000000003751400026215700252770ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; layout(location = 0) in vec4 vInputs[gl_MaxPatchVertices]; layout(location = 0) out vec4 vOutputs[4]; void main() { vec4 tmp[gl_MaxPatchVertices] = vInputs; vOutputs[gl_InvocationID] = tmp[gl_InvocationID]; } spirv-cross-2021.01.15/shaders-msl/tesc/matrix-output.multi-patch.tesc000066400000000000000000000013651400026215700255270ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(vertices = 3) out; layout(location = 0) in highp float in_tc_attr[]; layout(location = 0) out highp float in_te_attr[]; layout(location = 1) out mediump mat4x3 in_te_data0[]; layout(location = 5) out mediump mat4x3 in_te_data1[]; void main (void) { mat4x3 d = mat4x3(gl_InvocationID); in_te_data0[gl_InvocationID] = d; barrier(); in_te_data1[gl_InvocationID] = d + in_te_data0[(gl_InvocationID + 1) % 3]; in_te_attr[gl_InvocationID] = in_tc_attr[gl_InvocationID]; gl_TessLevelInner[0] = 1.0; gl_TessLevelInner[1] = 1.0; gl_TessLevelOuter[0] = 1.0; gl_TessLevelOuter[1] = 1.0; gl_TessLevelOuter[2] = 1.0; gl_TessLevelOuter[3] = 1.0; } spirv-cross-2021.01.15/shaders-msl/tesc/reload-tess-level.multi-patch.tesc000066400000000000000000000006741400026215700262160ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; void main() { if (gl_InvocationID == 0) { gl_TessLevelOuter[0] = 2.0; gl_TessLevelOuter[1] = 3.0; gl_TessLevelOuter[2] = 4.0; gl_TessLevelOuter[3] = 5.0; gl_TessLevelInner[0] = mix(gl_TessLevelOuter[0], gl_TessLevelOuter[3], 0.5); gl_TessLevelInner[1] = mix(gl_TessLevelOuter[2], gl_TessLevelOuter[1], 0.5); } gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; } spirv-cross-2021.01.15/shaders-msl/tesc/reload-tess-level.tesc000066400000000000000000000006741400026215700237700ustar00rootroot00000000000000#version 450 layout(vertices = 4) out; void main() { if (gl_InvocationID == 0) { gl_TessLevelOuter[0] = 2.0; gl_TessLevelOuter[1] = 3.0; gl_TessLevelOuter[2] = 4.0; gl_TessLevelOuter[3] = 5.0; gl_TessLevelInner[0] = mix(gl_TessLevelOuter[0], gl_TessLevelOuter[3], 0.5); gl_TessLevelInner[1] = mix(gl_TessLevelOuter[2], gl_TessLevelOuter[1], 0.5); } gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; } spirv-cross-2021.01.15/shaders-msl/tesc/struct-output.multi-patch.tesc000066400000000000000000000016511400026215700255450ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(vertices = 3) out; layout(location = 0) in highp float in_tc_attr[]; layout(location = 0) out highp float in_te_attr[]; struct te_data { mediump float a; mediump float b; mediump uint c; }; layout(location = 1) out te_data in_te_data0[]; layout(location = 4) out te_data in_te_data1[]; void main (void) { te_data d = te_data(float(gl_InvocationID), float(gl_InvocationID + 1), uint(gl_InvocationID)); in_te_data0[gl_InvocationID] = d; barrier(); te_data e = in_te_data0[(gl_InvocationID + 1) % 3]; in_te_data1[gl_InvocationID] = te_data(d.a + e.a, d.b + e.b, d.c + e.c); in_te_attr[gl_InvocationID] = in_tc_attr[gl_InvocationID]; gl_TessLevelInner[0] = 1.0; gl_TessLevelInner[1] = 1.0; gl_TessLevelOuter[0] = 1.0; gl_TessLevelOuter[1] = 1.0; gl_TessLevelOuter[2] = 1.0; gl_TessLevelOuter[3] = 1.0; } spirv-cross-2021.01.15/shaders-msl/tesc/water_tess.multi-patch.tesc000066400000000000000000000063451400026215700250500ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(vertices = 1) out; layout(location = 0) in vec2 vPatchPosBase[]; layout(std140) uniform UBO { vec4 uScale; highp vec3 uCamPos; vec2 uPatchSize; vec2 uMaxTessLevel; float uDistanceMod; vec4 uFrustum[6]; }; layout(location = 1) patch out vec2 vOutPatchPosBase; layout(location = 2) patch out vec4 vPatchLods; float lod_factor(vec2 pos_) { vec2 pos = pos_ * uScale.xy; vec3 dist_to_cam = uCamPos - vec3(pos.x, 0.0, pos.y); float level = log2((length(dist_to_cam) + 0.0001) * uDistanceMod); return clamp(level, 0.0, uMaxTessLevel.x); } float tess_level(float lod) { return uMaxTessLevel.y * exp2(-lod); } vec4 tess_level(vec4 lod) { return uMaxTessLevel.y * exp2(-lod); } // Guard band for vertex displacement. #define GUARD_BAND 10.0 bool frustum_cull(vec2 p0) { vec2 min_xz = (p0 - GUARD_BAND) * uScale.xy; vec2 max_xz = (p0 + uPatchSize + GUARD_BAND) * uScale.xy; vec3 bb_min = vec3(min_xz.x, -GUARD_BAND, min_xz.y); vec3 bb_max = vec3(max_xz.x, +GUARD_BAND, max_xz.y); vec3 center = 0.5 * (bb_min + bb_max); float radius = 0.5 * length(bb_max - bb_min); vec3 f0 = vec3( dot(uFrustum[0], vec4(center, 1.0)), dot(uFrustum[1], vec4(center, 1.0)), dot(uFrustum[2], vec4(center, 1.0))); vec3 f1 = vec3( dot(uFrustum[3], vec4(center, 1.0)), dot(uFrustum[4], vec4(center, 1.0)), dot(uFrustum[5], vec4(center, 1.0))); return !(any(lessThanEqual(f0, vec3(-radius))) || any(lessThanEqual(f1, vec3(-radius)))); } void compute_tess_levels(vec2 p0) { vOutPatchPosBase = p0; float l00 = lod_factor(p0 + vec2(-0.5, -0.5) * uPatchSize); float l10 = lod_factor(p0 + vec2(+0.5, -0.5) * uPatchSize); float l20 = lod_factor(p0 + vec2(+1.5, -0.5) * uPatchSize); float l01 = lod_factor(p0 + vec2(-0.5, +0.5) * uPatchSize); float l11 = lod_factor(p0 + vec2(+0.5, +0.5) * uPatchSize); float l21 = lod_factor(p0 + vec2(+1.5, +0.5) * uPatchSize); float l02 = lod_factor(p0 + vec2(-0.5, +1.5) * uPatchSize); float l12 = lod_factor(p0 + vec2(+0.5, +1.5) * uPatchSize); float l22 = lod_factor(p0 + vec2(+1.5, +1.5) * uPatchSize); vec4 lods = vec4( dot(vec4(l01, l11, l02, l12), vec4(0.25)), dot(vec4(l00, l10, l01, l11), vec4(0.25)), dot(vec4(l10, l20, l11, l21), vec4(0.25)), dot(vec4(l11, l21, l12, l22), vec4(0.25))); vPatchLods = lods; vec4 outer_lods = min(lods.xyzw, lods.yzwx); vec4 levels = tess_level(outer_lods); gl_TessLevelOuter[0] = levels.x; gl_TessLevelOuter[1] = levels.y; gl_TessLevelOuter[2] = levels.z; gl_TessLevelOuter[3] = levels.w; float min_lod = min(min(lods.x, lods.y), min(lods.z, lods.w)); float inner = tess_level(min(min_lod, l11)); gl_TessLevelInner[0] = inner; gl_TessLevelInner[1] = inner; } void main() { vec2 p0 = vPatchPosBase[0]; if (!frustum_cull(p0)) { gl_TessLevelOuter[0] = -1.0; gl_TessLevelOuter[1] = -1.0; gl_TessLevelOuter[2] = -1.0; gl_TessLevelOuter[3] = -1.0; gl_TessLevelInner[0] = -1.0; gl_TessLevelInner[1] = -1.0; } else { compute_tess_levels(p0); } } spirv-cross-2021.01.15/shaders-msl/tesc/water_tess.tesc000066400000000000000000000063451400026215700226220ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(vertices = 1) out; layout(location = 0) in vec2 vPatchPosBase[]; layout(std140) uniform UBO { vec4 uScale; highp vec3 uCamPos; vec2 uPatchSize; vec2 uMaxTessLevel; float uDistanceMod; vec4 uFrustum[6]; }; layout(location = 1) patch out vec2 vOutPatchPosBase; layout(location = 2) patch out vec4 vPatchLods; float lod_factor(vec2 pos_) { vec2 pos = pos_ * uScale.xy; vec3 dist_to_cam = uCamPos - vec3(pos.x, 0.0, pos.y); float level = log2((length(dist_to_cam) + 0.0001) * uDistanceMod); return clamp(level, 0.0, uMaxTessLevel.x); } float tess_level(float lod) { return uMaxTessLevel.y * exp2(-lod); } vec4 tess_level(vec4 lod) { return uMaxTessLevel.y * exp2(-lod); } // Guard band for vertex displacement. #define GUARD_BAND 10.0 bool frustum_cull(vec2 p0) { vec2 min_xz = (p0 - GUARD_BAND) * uScale.xy; vec2 max_xz = (p0 + uPatchSize + GUARD_BAND) * uScale.xy; vec3 bb_min = vec3(min_xz.x, -GUARD_BAND, min_xz.y); vec3 bb_max = vec3(max_xz.x, +GUARD_BAND, max_xz.y); vec3 center = 0.5 * (bb_min + bb_max); float radius = 0.5 * length(bb_max - bb_min); vec3 f0 = vec3( dot(uFrustum[0], vec4(center, 1.0)), dot(uFrustum[1], vec4(center, 1.0)), dot(uFrustum[2], vec4(center, 1.0))); vec3 f1 = vec3( dot(uFrustum[3], vec4(center, 1.0)), dot(uFrustum[4], vec4(center, 1.0)), dot(uFrustum[5], vec4(center, 1.0))); return !(any(lessThanEqual(f0, vec3(-radius))) || any(lessThanEqual(f1, vec3(-radius)))); } void compute_tess_levels(vec2 p0) { vOutPatchPosBase = p0; float l00 = lod_factor(p0 + vec2(-0.5, -0.5) * uPatchSize); float l10 = lod_factor(p0 + vec2(+0.5, -0.5) * uPatchSize); float l20 = lod_factor(p0 + vec2(+1.5, -0.5) * uPatchSize); float l01 = lod_factor(p0 + vec2(-0.5, +0.5) * uPatchSize); float l11 = lod_factor(p0 + vec2(+0.5, +0.5) * uPatchSize); float l21 = lod_factor(p0 + vec2(+1.5, +0.5) * uPatchSize); float l02 = lod_factor(p0 + vec2(-0.5, +1.5) * uPatchSize); float l12 = lod_factor(p0 + vec2(+0.5, +1.5) * uPatchSize); float l22 = lod_factor(p0 + vec2(+1.5, +1.5) * uPatchSize); vec4 lods = vec4( dot(vec4(l01, l11, l02, l12), vec4(0.25)), dot(vec4(l00, l10, l01, l11), vec4(0.25)), dot(vec4(l10, l20, l11, l21), vec4(0.25)), dot(vec4(l11, l21, l12, l22), vec4(0.25))); vPatchLods = lods; vec4 outer_lods = min(lods.xyzw, lods.yzwx); vec4 levels = tess_level(outer_lods); gl_TessLevelOuter[0] = levels.x; gl_TessLevelOuter[1] = levels.y; gl_TessLevelOuter[2] = levels.z; gl_TessLevelOuter[3] = levels.w; float min_lod = min(min(lods.x, lods.y), min(lods.z, lods.w)); float inner = tess_level(min(min_lod, l11)); gl_TessLevelInner[0] = inner; gl_TessLevelInner[1] = inner; } void main() { vec2 p0 = vPatchPosBase[0]; if (!frustum_cull(p0)) { gl_TessLevelOuter[0] = -1.0; gl_TessLevelOuter[1] = -1.0; gl_TessLevelOuter[2] = -1.0; gl_TessLevelOuter[3] = -1.0; gl_TessLevelInner[0] = -1.0; gl_TessLevelInner[1] = -1.0; } else { compute_tess_levels(p0); } } spirv-cross-2021.01.15/shaders-msl/tese/000077500000000000000000000000001400026215700175545ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/tese/input-array.tese000066400000000000000000000004431400026215700227120ustar00rootroot00000000000000#version 450 layout(ccw, quads, fractional_odd_spacing) in; layout(location = 0) in vec4 Floats[]; layout(location = 2) in vec4 Floats2[gl_MaxPatchVertices]; void set_position() { gl_Position = Floats[0] * gl_TessCoord.x + Floats2[1] * gl_TessCoord.y; } void main() { set_position(); } spirv-cross-2021.01.15/shaders-msl/tese/input-types.tese000066400000000000000000000031571400026215700227450ustar00rootroot00000000000000#version 450 layout(ccw, quads, fractional_even_spacing) in; // Try to use the whole taxonomy of input methods. // Per-vertex vector. layout(location = 0) in vec4 vColor[]; // Per-patch vector. layout(location = 1) patch in vec4 vColors; // Per-patch vector array. layout(location = 2) patch in vec4 vColorsArray[2]; // I/O blocks, per patch and per control point. layout(location = 4) in Block { vec4 a; vec4 b; } blocks[]; layout(location = 6) patch in PatchBlock { vec4 a; vec4 b; } patch_block; // Composites. struct Foo { vec4 a; vec4 b; }; layout(location = 8) patch in Foo vFoo; //layout(location = 10) patch in Foo vFooArray[2]; // FIXME: Handling of array-of-struct input is broken! // Per-control point struct. layout(location = 14) in Foo vFoos[]; void set_from_function() { gl_Position = blocks[0].a; gl_Position += blocks[0].b; gl_Position += blocks[1].a; gl_Position += blocks[1].b; gl_Position += patch_block.a; gl_Position += patch_block.b; gl_Position += vColor[0]; gl_Position += vColor[1]; gl_Position += vColors; Foo foo = vFoo; gl_Position += foo.a; gl_Position += foo.b; /*foo = vFooArray[0]; gl_Position += foo.a; gl_Position += foo.b; foo = vFooArray[1]; gl_Position += foo.a; gl_Position += foo.b;*/ foo = vFoos[0]; gl_Position += foo.a; gl_Position += foo.b; foo = vFoos[1]; gl_Position += foo.a; gl_Position += foo.b; } void main() { set_from_function(); } spirv-cross-2021.01.15/shaders-msl/tese/load-control-point-array-of-matrix.tese000066400000000000000000000004601400026215700272020ustar00rootroot00000000000000#version 450 layout(cw, quads) in; layout(location = 0) in mat4 vInputs[gl_MaxPatchVertices]; layout(location = 4) patch in vec4 vBoo[4]; layout(location = 8) patch in int vIndex; void main() { mat4 tmp[gl_MaxPatchVertices] = vInputs; gl_Position = tmp[0][vIndex] + tmp[1][vIndex] + vBoo[vIndex]; } spirv-cross-2021.01.15/shaders-msl/tese/load-control-point-array.tese000066400000000000000000000004401400026215700252740ustar00rootroot00000000000000#version 450 layout(cw, quads) in; layout(location = 0) in vec4 vInputs[gl_MaxPatchVertices]; layout(location = 1) patch in vec4 vBoo[4]; layout(location = 5) patch in int vIndex; void main() { vec4 tmp[gl_MaxPatchVertices] = vInputs; gl_Position = tmp[0] + tmp[1] + vBoo[vIndex]; } spirv-cross-2021.01.15/shaders-msl/tese/quad.domain.tese000066400000000000000000000007171400026215700226430ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(cw, quads, fractional_even_spacing) in; void main() { gl_Position = vec4(gl_TessCoord.x * gl_TessLevelInner[0] * gl_TessLevelOuter[0] + (1.0 - gl_TessCoord.x) * gl_TessLevelInner[0] * gl_TessLevelOuter[2], gl_TessCoord.y * gl_TessLevelInner[1] * gl_TessLevelOuter[3] + (1.0 - gl_TessCoord.y) * gl_TessLevelInner[1] * gl_TessLevelOuter[1], 0, 1); } spirv-cross-2021.01.15/shaders-msl/tese/quad.tese000066400000000000000000000007711400026215700213750ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(cw, quads, fractional_even_spacing) in; void set_position() { gl_Position = vec4(gl_TessCoord.x * gl_TessLevelInner[0] * gl_TessLevelOuter[0] + (1.0 - gl_TessCoord.x) * gl_TessLevelInner[0] * gl_TessLevelOuter[2], gl_TessCoord.y * gl_TessLevelInner[1] * gl_TessLevelOuter[1] + (1.0 - gl_TessCoord.y) * gl_TessLevelInner[1] * gl_TessLevelOuter[3], 0, 1); } void main() { set_position(); } spirv-cross-2021.01.15/shaders-msl/tese/set-from-function.tese000066400000000000000000000012641400026215700240200ustar00rootroot00000000000000#version 450 layout(ccw, quads, fractional_even_spacing) in; layout(location = 0) in vec4 vColor[]; layout(location = 1) patch in vec4 vColors; layout(location = 2) in Block { vec4 a; vec4 b; } blocks[]; struct Foo { vec4 a; vec4 b; }; layout(location = 4) patch in Foo vFoo; void set_from_function() { gl_Position = blocks[0].a; gl_Position += blocks[0].b; gl_Position += blocks[1].a; gl_Position += blocks[1].b; gl_Position += vColor[0]; gl_Position += vColor[1]; gl_Position += vColors; gl_Position += vFoo.a; gl_Position += vFoo.b; } void main() { set_from_function(); } spirv-cross-2021.01.15/shaders-msl/tese/triangle-tess-level.tese000066400000000000000000000006241400026215700243260ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(cw, triangles, fractional_even_spacing) in; void main() { gl_Position = vec4(gl_TessCoord.x * gl_TessLevelInner[0] * gl_TessLevelOuter[0], gl_TessCoord.y * gl_TessLevelInner[0] * gl_TessLevelOuter[1], gl_TessCoord.z * gl_TessLevelInner[0] * gl_TessLevelOuter[2], 1); } spirv-cross-2021.01.15/shaders-msl/tese/triangle.tese000066400000000000000000000002421400026215700222410ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(cw, triangles, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders-msl/tese/water_tess.tese000066400000000000000000000034571400026215700226270ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require precision highp int; layout(cw, quads, fractional_even_spacing) in; layout(location = 0) patch in vec2 vOutPatchPosBase; layout(location = 1) patch in vec4 vPatchLods; layout(binding = 1, std140) uniform UBO { mat4 uMVP; vec4 uScale; vec2 uInvScale; vec3 uCamPos; vec2 uPatchSize; vec2 uInvHeightmapSize; }; layout(binding = 0) uniform mediump sampler2D uHeightmapDisplacement; layout(location = 0) highp out vec3 vWorld; layout(location = 1) highp out vec4 vGradNormalTex; vec2 lerp_vertex(vec2 tess_coord) { return vOutPatchPosBase + tess_coord * uPatchSize; } mediump vec2 lod_factor(vec2 tess_coord) { mediump vec2 x = mix(vPatchLods.yx, vPatchLods.zw, tess_coord.x); mediump float level = mix(x.x, x.y, tess_coord.y); mediump float floor_level = floor(level); mediump float fract_level = level - floor_level; return vec2(floor_level, fract_level); } mediump vec3 sample_height_displacement(vec2 uv, vec2 off, mediump vec2 lod) { return mix( textureLod(uHeightmapDisplacement, uv + 0.5 * off, lod.x).xyz, textureLod(uHeightmapDisplacement, uv + 1.0 * off, lod.x + 1.0).xyz, lod.y); } void main() { vec2 tess_coord = gl_TessCoord.xy; vec2 pos = lerp_vertex(tess_coord); mediump vec2 lod = lod_factor(tess_coord); vec2 tex = pos * uInvHeightmapSize.xy; pos *= uScale.xy; mediump float delta_mod = exp2(lod.x); vec2 off = uInvHeightmapSize.xy * delta_mod; vGradNormalTex = vec4(tex + 0.5 * uInvHeightmapSize.xy, tex * uScale.zw); vec3 height_displacement = sample_height_displacement(tex, off, lod); pos += height_displacement.yz; vWorld = vec3(pos.x, height_displacement.x, pos.y); gl_Position = uMVP * vec4(vWorld, 1.0); } spirv-cross-2021.01.15/shaders-msl/vert/000077500000000000000000000000001400026215700175745ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/vert/basic.capture.vert000066400000000000000000000004071400026215700232220ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { uniform mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders-msl/vert/basic.for-tess.vert000066400000000000000000000004071400026215700233210ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { uniform mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders-msl/vert/basic.vert000066400000000000000000000004071400026215700215600ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { uniform mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders-msl/vert/clip-distance-block.no-user-varying.vert000066400000000000000000000003601400026215700273500ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 Position; out gl_PerVertex { vec4 gl_Position; float gl_ClipDistance[2]; }; void main() { gl_Position = Position; gl_ClipDistance[0] = Position.x; gl_ClipDistance[1] = Position.y; } spirv-cross-2021.01.15/shaders-msl/vert/clip-distance-block.vert000066400000000000000000000003601400026215700243040ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 Position; out gl_PerVertex { vec4 gl_Position; float gl_ClipDistance[2]; }; void main() { gl_Position = Position; gl_ClipDistance[0] = Position.x; gl_ClipDistance[1] = Position.y; } spirv-cross-2021.01.15/shaders-msl/vert/copy.flatten.vert000066400000000000000000000011171400026215700231040ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; layout(std140) uniform UBO { mat4 uMVP; Light lights[4]; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec4 vColor; void main() { gl_Position = uMVP * aVertex; vColor = vec4(0.0); for (int i = 0; i < 4; ++i) { Light light = lights[i]; vec3 L = aVertex.xyz - light.Position; vColor += dot(aNormal, normalize(L)) * (clamp(1.0 - length(L) / light.Radius, 0.0, 1.0) * lights[i].Color); } } spirv-cross-2021.01.15/shaders-msl/vert/dynamic.flatten.vert000066400000000000000000000010661400026215700235610ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; layout(std140) uniform UBO { mat4 uMVP; Light lights[4]; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec4 vColor; void main() { gl_Position = uMVP * aVertex; vColor = vec4(0.0); for (int i = 0; i < 4; ++i) { vec3 L = aVertex.xyz - lights[i].Position; vColor += dot(aNormal, normalize(L)) * (clamp(1.0 - length(L) / lights[i].Radius, 0.0, 1.0) * lights[i].Color); } } spirv-cross-2021.01.15/shaders-msl/vert/float-math.invariant-float-math.vert000066400000000000000000000011111400026215700265500ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform Matrices { mat4 vpMatrix; mat4 wMatrix; mat4x3 wMatrix4x3; mat3x4 wMatrix3x4; }; layout(location = 0) in vec3 InPos; layout(location = 1) in vec3 InNormal; layout(location = 0) out vec3 OutNormal; layout(location = 1) out vec4 OutWorldPos[4]; void main() { gl_Position = vpMatrix * wMatrix * vec4(InPos, 1); OutWorldPos[0] = wMatrix * vec4(InPos, 1); OutWorldPos[1] = vec4(InPos, 1) * wMatrix; OutWorldPos[2] = wMatrix3x4 * InPos; OutWorldPos[3] = InPos * wMatrix4x3; OutNormal = (wMatrix * vec4(InNormal, 0)).xyz; } spirv-cross-2021.01.15/shaders-msl/vert/float-math.vert000066400000000000000000000011111400026215700225240ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform Matrices { mat4 vpMatrix; mat4 wMatrix; mat4x3 wMatrix4x3; mat3x4 wMatrix3x4; }; layout(location = 0) in vec3 InPos; layout(location = 1) in vec3 InNormal; layout(location = 0) out vec3 OutNormal; layout(location = 1) out vec4 OutWorldPos[4]; void main() { gl_Position = vpMatrix * wMatrix * vec4(InPos, 1); OutWorldPos[0] = wMatrix * vec4(InPos, 1); OutWorldPos[1] = vec4(InPos, 1) * wMatrix; OutWorldPos[2] = wMatrix3x4 * InPos; OutWorldPos[3] = InPos * wMatrix4x3; OutNormal = (wMatrix * vec4(InNormal, 0)).xyz; } spirv-cross-2021.01.15/shaders-msl/vert/functions.vert000066400000000000000000000011441400026215700225060ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { uniform mat4 uMVP; uniform vec3 rotDeg; uniform vec3 rotRad; uniform ivec2 bits; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; layout(location = 1) out vec3 vRotDeg; layout(location = 2) out vec3 vRotRad; layout(location = 3) out ivec2 vLSB; layout(location = 4) out ivec2 vMSB; void main() { gl_Position = inverse(uMVP) * aVertex; vNormal = aNormal; vRotDeg = degrees(rotRad); vRotRad = radians(rotDeg); vLSB = findLSB(bits); vMSB = findMSB(bits); } spirv-cross-2021.01.15/shaders-msl/vert/in_out_array_mat.vert000066400000000000000000000021011400026215700240240ustar00rootroot00000000000000#version 450 layout(binding = 0, std140) uniform UBO { mat4 projection; mat4 model; float lodBias; } ubo; layout(location = 0) in vec3 inPos; layout(location = 1) in vec4 colors[3]; layout(location = 4) in vec3 inNormal; layout(location = 5) in mat4 inViewMat; layout(location = 0) out vec3 outPos; layout(location = 1) out vec3 outNormal; layout(location = 2) out mat4 outTransModel; layout(location = 6) out float outLodBias; layout(location = 7) out vec4 color; void write_deeper_in_function() { outTransModel[1][1] = ubo.lodBias; color = colors[2]; } void write_in_function() { outTransModel[2] = vec4(inNormal, 1.0); write_deeper_in_function(); } void main() { gl_Position = (ubo.projection * ubo.model) * vec4(inPos, 1.0); outPos = vec3((ubo.model * vec4(inPos, 1.0)).xyz); outNormal = mat3(vec3(ubo.model[0].x, ubo.model[0].y, ubo.model[0].z), vec3(ubo.model[1].x, ubo.model[1].y, ubo.model[1].z), vec3(ubo.model[2].x, ubo.model[2].y, ubo.model[2].z)) * inNormal; outLodBias = ubo.lodBias; outTransModel = transpose(ubo.model) * inViewMat; write_in_function(); } spirv-cross-2021.01.15/shaders-msl/vert/interface-block-block-composites.frag000066400000000000000000000004451400026215700267430ustar00rootroot00000000000000#version 450 layout(location = 0) in mat3 vMatrix; layout(location = 4) in Vert { mat3 wMatrix; vec4 wTmp; float arr[4]; }; layout(location = 0) out vec4 FragColor; void main() { FragColor = wMatrix[0].xxyy + wTmp + vMatrix[1].yyzz; for (int i = 0; i < 4; i++) FragColor += arr[i]; } spirv-cross-2021.01.15/shaders-msl/vert/interface-block-block-composites.vert000066400000000000000000000005161400026215700270030ustar00rootroot00000000000000#version 450 layout(location = 0) out mat3 vMatrix; layout(location = 0) in mat3 Matrix; layout(location = 4) in vec4 Pos; layout(location = 4) out Vert { float arr[3]; mat3 wMatrix; vec4 wTmp; }; void main() { vMatrix = Matrix; wMatrix = Matrix; arr[0] = 1.0; arr[1] = 2.0; arr[2] = 3.0; wTmp = Pos; gl_Position = Pos; } spirv-cross-2021.01.15/shaders-msl/vert/interpolation-qualifiers-block.vert000066400000000000000000000007241400026215700266220ustar00rootroot00000000000000#version 450 layout(location=0) in vec4 Position; struct Output { vec2 v0; vec2 v1; vec3 v2; vec4 v3; float v4; float v5; float v6; }; layout(location=0) out centroid noperspective Output outp; void main() { outp.v0 = Position.xy; outp.v1 = Position.zw; outp.v2 = vec3(Position.x, Position.z * Position.y, Position.x); outp.v3 = Position.xxyy; outp.v4 = Position.w; outp.v5 = Position.y; outp.v6 = Position.x * Position.w; gl_Position = Position; } spirv-cross-2021.01.15/shaders-msl/vert/interpolation-qualifiers.vert000066400000000000000000000011131400026215700255230ustar00rootroot00000000000000#version 450 layout(location=0) in vec4 Position; layout(location=0) out vec2 v0; layout(location=1) out noperspective vec2 v1; layout(location=2) out centroid vec3 v2; layout(location=3) out centroid noperspective vec4 v3; layout(location=4) out sample float v4; layout(location=5) out sample noperspective float v5; layout(location=6) out flat float v6; void main() { v0 = Position.xy; v1 = Position.zw; v2 = vec3(Position.x, Position.z * Position.y, Position.x); v3 = Position.xxyy; v4 = Position.w; v5 = Position.y; v6 = Position.x * Position.w; gl_Position = Position; } spirv-cross-2021.01.15/shaders-msl/vert/invariant.msl21.vert000066400000000000000000000003271400026215700234300ustar00rootroot00000000000000#version 310 es invariant gl_Position; layout(location = 0) in vec4 vInput0; layout(location = 1) in vec4 vInput1; layout(location = 2) in vec4 vInput2; void main() { gl_Position = vInput0 + vInput1 * vInput2; } spirv-cross-2021.01.15/shaders-msl/vert/leaf-function.capture.vert000066400000000000000000000004601400026215700246720ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { uniform mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void set_output() { gl_Position = uMVP * aVertex; vNormal = aNormal; } void main() { set_output(); } spirv-cross-2021.01.15/shaders-msl/vert/leaf-function.for-tess.vert000066400000000000000000000004601400026215700247710ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { uniform mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void set_output() { gl_Position = uMVP * aVertex; vNormal = aNormal; } void main() { set_output(); } spirv-cross-2021.01.15/shaders-msl/vert/no-disable-vertex-out.frag-output.vert000066400000000000000000000006711400026215700271130ustar00rootroot00000000000000#version 400 #extension GL_ARB_separate_shader_objects : enable #extension GL_ARB_shading_language_420pack : enable layout(std140, binding = 0) uniform buf { mat4 MVP; vec4 position[12*3]; vec4 attr[12*3]; } ubuf; layout (location = 0) out vec4 texcoord; layout (location = 1) out vec3 frag_pos; void main() { texcoord = ubuf.attr[gl_VertexIndex]; gl_Position = ubuf.MVP * ubuf.position[gl_VertexIndex]; frag_pos = gl_Position.xyz; } spirv-cross-2021.01.15/shaders-msl/vert/no_stage_out.for-tess.vert000066400000000000000000000002631400026215700247260ustar00rootroot00000000000000#version 450 layout(binding = 0, std430) writeonly buffer _10_12 { uvec4 _m0[1024]; } _12; layout(location = 0) in uvec4 _19; void main() { _12._m0[gl_VertexIndex] = _19; } spirv-cross-2021.01.15/shaders-msl/vert/no_stage_out.vert000066400000000000000000000002631400026215700231650ustar00rootroot00000000000000#version 450 layout(binding = 0, std430) writeonly buffer _10_12 { uvec4 _m0[1024]; } _12; layout(location = 0) in uvec4 _19; void main() { _12._m0[gl_VertexIndex] = _19; } spirv-cross-2021.01.15/shaders-msl/vert/no_stage_out.write_buff.vert000066400000000000000000000004701400026215700253200ustar00rootroot00000000000000#version 450 layout(binding = 1, std430) writeonly buffer _33_35 { uvec4 _m0[1024]; } _35; layout(binding = 0, std140) uniform _38_40 { uvec4 _m0[1024]; } _40; layout(location = 0) in vec4 _14; void main() { gl_Position = _14; for (int _19 = 0; _19 < 1024; _19++) { _35._m0[_19] = _40._m0[_19]; } } spirv-cross-2021.01.15/shaders-msl/vert/no_stage_out.write_buff_atomic.vert000066400000000000000000000003021400026215700266460ustar00rootroot00000000000000#version 450 layout(binding = 0, std430) coherent buffer _19_21 { uint _m0; } _21; layout(location = 0) in vec4 _14; void main() { gl_Position = _14; uint _26 = atomicAdd(_21._m0, 1u); } spirv-cross-2021.01.15/shaders-msl/vert/no_stage_out.write_tex.vert000066400000000000000000000004441400026215700251770ustar00rootroot00000000000000#version 450 layout(binding = 1, r32ui) uniform writeonly uimage1D _32; layout(binding = 0, r32ui) uniform readonly uimage1D _35; layout(location = 0) in vec4 _14; void main() { gl_Position = _14; for (int _19 = 0; _19 < 128; _19++) { imageStore(_32, _19, imageLoad(_35, _19)); } } spirv-cross-2021.01.15/shaders-msl/vert/out_block.vert000066400000000000000000000005521400026215700224610ustar00rootroot00000000000000#version 450 uniform Transform { mat4 transform; } block; layout(location = 0) in vec3 position; layout(location = 1) in vec4 color; layout(location = 2) out VertexOut { vec4 color; vec4 color2; } outputs; void main() { gl_Position = block.transform * vec4(position, 1.0); outputs.color = color; outputs.color2 = color + vec4(1.0); } spirv-cross-2021.01.15/shaders-msl/vert/packed-bool-to-uint.vert000066400000000000000000000005671400026215700242630ustar00rootroot00000000000000#version 450 core struct Struct { bool flags[1]; }; layout(set=0, binding=0, std140) uniform defaultUniformsVS { Struct flags; vec2 uquad[4]; mat4 umatrix; }; layout (location = 0) in vec4 a_position; void main() { gl_Position = umatrix * vec4(uquad[gl_VertexIndex], a_position.z, a_position.w); if (flags.flags[0]) gl_Position.z = 0.0; } spirv-cross-2021.01.15/shaders-msl/vert/packed-bool2-to-packed_uint2.vert000066400000000000000000000005721400026215700257320ustar00rootroot00000000000000#version 450 core struct Struct { bvec2 flags[1]; }; layout(set=0, binding=0, std140) uniform defaultUniformsVS { Struct flags; vec2 uquad[4]; mat4 umatrix; }; layout (location = 0) in vec4 a_position; void main() { gl_Position = umatrix * vec4(uquad[gl_VertexIndex], a_position.z, a_position.w); if (flags.flags[0].x) gl_Position.z = 0.0; } spirv-cross-2021.01.15/shaders-msl/vert/packed_matrix.vert000066400000000000000000000014611400026215700233130ustar00rootroot00000000000000#version 450 layout(binding = 13, std140) uniform _1365_18812 { layout(row_major) mat4x3 _m0; layout(row_major) mat4x3 _m1; } _18812; layout(binding = 12, std140) uniform _1126_22044 { layout(row_major) mat4 _m0; layout(row_major) mat4 _m1; float _m9; vec3 _m10; float _m11; vec3 _m12; float _m17; float _m18; float _m19; vec2 _m20; } _22044; layout(location = 0) out vec3 _3976; layout(location = 0) in vec4 _5275; vec3 _2; void main() { vec3 _23783; do { _23783 = normalize(_18812._m1 * vec4(_5275.xyz, 0.0)); break; } while (false); vec4 _14995 = vec4(_22044._m10 + (_5275.xyz * (_22044._m17 + _22044._m18)), 1.0) * _22044._m0; _3976 = _23783; vec4 _6282 = _14995; _6282.y = -_14995.y; gl_Position = _6282; } spirv-cross-2021.01.15/shaders-msl/vert/pointsize.vert000066400000000000000000000004231400026215700225210ustar00rootroot00000000000000#version 450 uniform params { mat4 mvp; float psize; }; layout(location = 0) in vec4 position; layout(location = 1) in vec4 color0; layout(location = 0) out vec4 color; void main() { gl_Position = mvp * position; gl_PointSize = psize; color = color0; } spirv-cross-2021.01.15/shaders-msl/vert/read-from-row-major-array.vert000066400000000000000000000013741400026215700254060ustar00rootroot00000000000000#version 310 es layout(location = 0) in highp vec4 a_position; layout(location = 0) out mediump float v_vtxResult; layout(set = 0, binding = 0, std140, row_major) uniform Block { highp mat2x3 var[3][4]; }; mediump float compare_float (highp float a, highp float b) { return abs(a - b) < 0.05 ? 1.0 : 0.0; } mediump float compare_vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z); } mediump float compare_mat2x3 (highp mat2x3 a, highp mat2x3 b){ return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1]); } void main (void) { gl_Position = a_position; mediump float result = 1.0; result *= compare_mat2x3(var[0][0], mat2x3(2.0, 6.0, -6.0, 0.0, 5.0, 5.0)); v_vtxResult = result; } spirv-cross-2021.01.15/shaders-msl/vert/resource-arrays-leaf.ios.vert000066400000000000000000000007051400026215700253240ustar00rootroot00000000000000#version 450 layout(constant_id = 0) const int arraySize = 3; layout(binding = 0, rgba32i) uniform iimage2D images[arraySize]; layout(binding = 4) uniform constant_block { vec4 foo; int bar; } constants[4]; layout(binding = 8) buffer storage_block { uvec4 baz; ivec2 quux; } storage[2]; void doWork() { storage[0].baz = uvec4(constants[3].foo); storage[1].quux = imageLoad(images[2], ivec2(constants[1].bar)).xy; } void main() { doWork(); } spirv-cross-2021.01.15/shaders-msl/vert/resource-arrays.ios.vert000066400000000000000000000006501400026215700244160ustar00rootroot00000000000000#version 450 layout(constant_id = 0) const int arraySize = 3; layout(binding = 0, rgba32i) uniform iimage2D images[arraySize]; layout(binding = 4) uniform constant_block { vec4 foo; int bar; } constants[4]; layout(binding = 8) buffer storage_block { uvec4 baz; ivec2 quux; } storage[2]; void main() { storage[0].baz = uvec4(constants[3].foo); storage[1].quux = imageLoad(images[2], ivec2(constants[1].bar)).xy; } spirv-cross-2021.01.15/shaders-msl/vert/return-array.force-native-array.vert000066400000000000000000000004631400026215700266310ustar00rootroot00000000000000#version 310 es layout(location = 0) in vec4 vInput0; layout(location = 1) in vec4 vInput1; vec4[2] test() { return vec4[](vec4(10.0), vec4(20.0)); } vec4[2] test2() { vec4 foobar[2]; foobar[0] = vInput0; foobar[1] = vInput1; return foobar; } void main() { gl_Position = test()[0] + test2()[1]; } spirv-cross-2021.01.15/shaders-msl/vert/return-array.vert000066400000000000000000000004631400026215700231340ustar00rootroot00000000000000#version 310 es layout(location = 0) in vec4 vInput0; layout(location = 1) in vec4 vInput1; vec4[2] test() { return vec4[](vec4(10.0), vec4(20.0)); } vec4[2] test2() { vec4 foobar[2]; foobar[0] = vInput0; foobar[1] = vInput1; return foobar; } void main() { gl_Position = test()[0] + test2()[1]; } spirv-cross-2021.01.15/shaders-msl/vert/set_builtin_in_func.vert000066400000000000000000000002121400026215700245130ustar00rootroot00000000000000#version 450 void write_outblock() { gl_PointSize = 1.0; gl_Position = vec4(gl_PointSize); } void main() { write_outblock(); } spirv-cross-2021.01.15/shaders-msl/vert/sign-int-types.vert000066400000000000000000000017151400026215700233740ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { uniform mat4 uMVP; uniform vec4 uFloatVec4; uniform vec3 uFloatVec3; uniform vec2 uFloatVec2; uniform float uFloat; uniform ivec4 uIntVec4; uniform ivec3 uIntVec3; uniform ivec2 uIntVec2; uniform int uInt; }; layout(location = 0) in vec4 aVertex; layout(location = 0) out vec4 vFloatVec4; layout(location = 1) out vec3 vFloatVec3; layout(location = 2) out vec2 vFloatVec2; layout(location = 3) out float vFloat; layout(location = 4) flat out ivec4 vIntVec4; layout(location = 5) flat out ivec3 vIntVec3; layout(location = 6) flat out ivec2 vIntVec2; layout(location = 7) flat out int vInt; void main() { gl_Position = uMVP * aVertex; vFloatVec4 = sign(uFloatVec4); vFloatVec3 = sign(uFloatVec3); vFloatVec2 = sign(uFloatVec2); vFloat = sign(uFloat); vIntVec4 = sign(uIntVec4); vIntVec3 = sign(uIntVec3); vIntVec2 = sign(uIntVec2); vInt = sign(uInt); } spirv-cross-2021.01.15/shaders-msl/vert/signedness-mismatch.shader-inputs.vert000066400000000000000000000004621400026215700272320ustar00rootroot00000000000000#version 450 #extension GL_AMD_gpu_shader_int16 : require layout(location = 0) in int16_t a; layout(location = 1) in ivec2 b; layout(location = 2) in uint16_t c[2]; layout(location = 4) in uvec4 d[2]; void main() { gl_Position = vec4(float(int(a)), float(b.x), float(uint(c[1])), float(d[0].w)); } spirv-cross-2021.01.15/shaders-msl/vert/texture_buffer.texture-buffer-native.msl21.vert000066400000000000000000000004151400026215700307160ustar00rootroot00000000000000#version 310 es #extension GL_OES_texture_buffer : require layout(binding = 4) uniform highp samplerBuffer uSamp; layout(rgba32f, binding = 5) uniform readonly highp imageBuffer uSampo; void main() { gl_Position = texelFetch(uSamp, 10) + imageLoad(uSampo, 100); } spirv-cross-2021.01.15/shaders-msl/vert/texture_buffer.vert000066400000000000000000000004151400026215700235270ustar00rootroot00000000000000#version 310 es #extension GL_OES_texture_buffer : require layout(binding = 4) uniform highp samplerBuffer uSamp; layout(rgba32f, binding = 5) uniform readonly highp imageBuffer uSampo; void main() { gl_Position = texelFetch(uSamp, 10) + imageLoad(uSampo, 100); } spirv-cross-2021.01.15/shaders-msl/vert/ubo.alignment.vert000066400000000000000000000011211400026215700232330ustar00rootroot00000000000000#version 310 es layout(binding = 0, std140) uniform UBO { mat4 mvp; vec2 targSize; vec3 color; // vec3 following vec2 should cause MSL to add pad if float3 is packed float opacity; // Single float following vec3 should cause MSL float3 to pack }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; layout(location = 1) out vec3 vColor; layout(location = 2) out vec2 vSize; void main() { gl_Position = mvp * aVertex; vNormal = aNormal; vColor = color * opacity; vSize = targSize * opacity; } spirv-cross-2021.01.15/shaders-msl/vert/ubo.vert000066400000000000000000000004111400026215700212570ustar00rootroot00000000000000#version 310 es layout(binding = 0, std140) uniform UBO { mat4 mvp; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = mvp * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders-msl/vulkan/000077500000000000000000000000001400026215700201145ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/vulkan/frag/000077500000000000000000000000001400026215700210335ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/vulkan/frag/basic.multiview.no-layered.nocompat.vk.frag000066400000000000000000000004761400026215700313040ustar00rootroot00000000000000#version 310 es #extension GL_EXT_multiview : require precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex[4]; layout(binding = 0) uniform sampler2D uTex; layout(location = 0) out vec4 FragColor; void main() { FragColor = vColor * texture(uTex, vTex[gl_ViewIndex]); } spirv-cross-2021.01.15/shaders-msl/vulkan/frag/basic.multiview.nocompat.vk.frag000066400000000000000000000004761400026215700272460ustar00rootroot00000000000000#version 310 es #extension GL_EXT_multiview : require precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex[4]; layout(binding = 0) uniform sampler2D uTex; layout(location = 0) out vec4 FragColor; void main() { FragColor = vColor * texture(uTex, vTex[gl_ViewIndex]); } demote-to-helper-forwarding.asm.vk.nocompat.msl23.frag000066400000000000000000000030761400026215700331110ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/vulkan/frag; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 19 ; Schema: 0 OpCapability Shader OpCapability DemoteToHelperInvocationEXT OpExtension "SPV_EXT_demote_to_helper_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_demote_to_helper_invocation" OpName %main "main" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %19 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %main = OpFunction %void None %3 %5 = OpLabel %9 = OpIsHelperInvocationEXT %bool OpDemoteToHelperInvocationEXT %10 = OpLogicalNot %bool %9 OpSelectionMerge %12 None OpBranchConditional %10 %11 %12 %11 = OpLabel OpStore %FragColor %19 OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-msl/vulkan/frag/demote-to-helper.vk.nocompat.msl23.frag000066400000000000000000000002051400026215700302400ustar00rootroot00000000000000#version 450 #extension GL_EXT_demote_to_helper_invocation : require void main() { demote; bool helper = helperInvocationEXT(); } spirv-cross-2021.01.15/shaders-msl/vulkan/frag/demote-to-helper.vk.nocompat.msl23.ios.frag000066400000000000000000000002051400026215700310310ustar00rootroot00000000000000#version 450 #extension GL_EXT_demote_to_helper_invocation : require void main() { demote; bool helper = helperInvocationEXT(); } spirv-cross-2021.01.15/shaders-msl/vulkan/frag/push-constant.vk.frag000066400000000000000000000004331400026215700251210ustar00rootroot00000000000000#version 310 es precision mediump float; layout(push_constant, std430) uniform PushConstants { vec4 value0; vec4 value1; } push; layout(location = 0) in vec4 vColor; layout(location = 0) out vec4 FragColor; void main() { FragColor = vColor + push.value0 + push.value1; } spirv-cross-2021.01.15/shaders-msl/vulkan/frag/spec-constant.msl11.vk.frag000066400000000000000000000041701400026215700260320ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(constant_id = 1) const float a = 1.0; layout(constant_id = 2) const float b = 2.0; layout(constant_id = 3) const int c = 3; layout(constant_id = 4) const int d = 4; layout(constant_id = 5) const uint e = 5u; layout(constant_id = 6) const uint f = 6u; layout(constant_id = 7) const bool g = false; layout(constant_id = 8) const bool h = true; // glslang doesn't seem to support partial spec constants or composites yet, so only test the basics. void main() { float t0 = a; float t1 = b; uint c0 = uint(c); // OpIAdd with different types. // FConvert, float-to-double. int c1 = -c; // SNegate int c2 = ~c; // OpNot int c3 = c + d; // OpIAdd int c4 = c - d; // OpISub int c5 = c * d; // OpIMul int c6 = c / d; // OpSDiv uint c7 = e / f; // OpUDiv int c8 = c % d; // OpSMod uint c9 = e % f; // OpUMod // TODO: OpSRem, any way to access this in GLSL? int c10 = c >> d; // OpShiftRightArithmetic uint c11 = e >> f; // OpShiftRightLogical int c12 = c << d; // OpShiftLeftLogical int c13 = c | d; // OpBitwiseOr int c14 = c ^ d; // OpBitwiseXor int c15 = c & d; // OpBitwiseAnd // VectorShuffle, CompositeExtract, CompositeInsert, not testable atm. bool c16 = g || h; // OpLogicalOr bool c17 = g && h; // OpLogicalAnd bool c18 = !g; // OpLogicalNot bool c19 = g == h; // OpLogicalEqual bool c20 = g != h; // OpLogicalNotEqual // OpSelect not testable atm. bool c21 = c == d; // OpIEqual bool c22 = c != d; // OpINotEqual bool c23 = c < d; // OpSLessThan bool c24 = e < f; // OpULessThan bool c25 = c > d; // OpSGreaterThan bool c26 = e > f; // OpUGreaterThan bool c27 = c <= d; // OpSLessThanEqual bool c28 = e <= f; // OpULessThanEqual bool c29 = c >= d; // OpSGreaterThanEqual bool c30 = e >= f; // OpUGreaterThanEqual // OpQuantizeToF16 not testable atm. int c31 = c8 + c3; int c32 = int(e); // OpIAdd with different types. bool c33 = bool(c); // int -> bool bool c34 = bool(e); // uint -> bool int c35 = int(g); // bool -> int uint c36 = uint(g); // bool -> uint float c37 = float(g); // bool -> float FragColor = vec4(t0 + t1); } spirv-cross-2021.01.15/shaders-msl/vulkan/frag/spec-constant.vk.frag000066400000000000000000000041701400026215700250760ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(constant_id = 1) const float a = 1.0; layout(constant_id = 2) const float b = 2.0; layout(constant_id = 3) const int c = 3; layout(constant_id = 4) const int d = 4; layout(constant_id = 5) const uint e = 5u; layout(constant_id = 6) const uint f = 6u; layout(constant_id = 7) const bool g = false; layout(constant_id = 8) const bool h = true; // glslang doesn't seem to support partial spec constants or composites yet, so only test the basics. void main() { float t0 = a; float t1 = b; uint c0 = uint(c); // OpIAdd with different types. // FConvert, float-to-double. int c1 = -c; // SNegate int c2 = ~c; // OpNot int c3 = c + d; // OpIAdd int c4 = c - d; // OpISub int c5 = c * d; // OpIMul int c6 = c / d; // OpSDiv uint c7 = e / f; // OpUDiv int c8 = c % d; // OpSMod uint c9 = e % f; // OpUMod // TODO: OpSRem, any way to access this in GLSL? int c10 = c >> d; // OpShiftRightArithmetic uint c11 = e >> f; // OpShiftRightLogical int c12 = c << d; // OpShiftLeftLogical int c13 = c | d; // OpBitwiseOr int c14 = c ^ d; // OpBitwiseXor int c15 = c & d; // OpBitwiseAnd // VectorShuffle, CompositeExtract, CompositeInsert, not testable atm. bool c16 = g || h; // OpLogicalOr bool c17 = g && h; // OpLogicalAnd bool c18 = !g; // OpLogicalNot bool c19 = g == h; // OpLogicalEqual bool c20 = g != h; // OpLogicalNotEqual // OpSelect not testable atm. bool c21 = c == d; // OpIEqual bool c22 = c != d; // OpINotEqual bool c23 = c < d; // OpSLessThan bool c24 = e < f; // OpULessThan bool c25 = c > d; // OpSGreaterThan bool c26 = e > f; // OpUGreaterThan bool c27 = c <= d; // OpSLessThanEqual bool c28 = e <= f; // OpULessThanEqual bool c29 = c >= d; // OpSGreaterThanEqual bool c30 = e >= f; // OpUGreaterThanEqual // OpQuantizeToF16 not testable atm. int c31 = c8 + c3; int c32 = int(e); // OpIAdd with different types. bool c33 = bool(c); // int -> bool bool c34 = bool(e); // uint -> bool int c35 = int(g); // bool -> int uint c36 = uint(g); // bool -> uint float c37 = float(g); // bool -> float FragColor = vec4(t0 + t1); } spirv-cross-2021.01.15/shaders-msl/vulkan/vert/000077500000000000000000000000001400026215700210745ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-msl/vulkan/vert/device-group.multiview.viewfromdev.nocompat.vk.vert000066400000000000000000000002571400026215700332110ustar00rootroot00000000000000#version 450 core #extension GL_EXT_device_group : require #extension GL_EXT_multiview : require void main() { gl_Position = vec4(gl_DeviceIndex, gl_ViewIndex, 0.0, 1.0); } spirv-cross-2021.01.15/shaders-msl/vulkan/vert/device-group.nocompat.vk.vert000066400000000000000000000001611400026215700266230ustar00rootroot00000000000000#version 450 core #extension GL_EXT_device_group : require void main() { gl_Position = vec4(gl_DeviceIndex); } spirv-cross-2021.01.15/shaders-msl/vulkan/vert/multiview.multiview.no-layered.nocompat.vk.vert000066400000000000000000000003311400026215700323400ustar00rootroot00000000000000#version 310 es #extension GL_EXT_multiview : require layout(std140, binding = 0) uniform MVPs { mat4 MVP[2]; }; layout(location = 0) in vec4 Position; void main() { gl_Position = MVP[gl_ViewIndex] * Position; } spirv-cross-2021.01.15/shaders-msl/vulkan/vert/multiview.multiview.nocompat.vk.vert000066400000000000000000000003311400026215700303020ustar00rootroot00000000000000#version 310 es #extension GL_EXT_multiview : require layout(std140, binding = 0) uniform MVPs { mat4 MVP[2]; }; layout(location = 0) in vec4 Position; void main() { gl_Position = MVP[gl_ViewIndex] * Position; } spirv-cross-2021.01.15/shaders-msl/vulkan/vert/multiview.nocompat.vk.vert000066400000000000000000000003311400026215700262560ustar00rootroot00000000000000#version 310 es #extension GL_EXT_multiview : require layout(std140, binding = 0) uniform MVPs { mat4 MVP[2]; }; layout(location = 0) in vec4 Position; void main() { gl_Position = MVP[gl_ViewIndex] * Position; } spirv-cross-2021.01.15/shaders-msl/vulkan/vert/small-storage.vk.vert000066400000000000000000000017261400026215700251750ustar00rootroot00000000000000#version 450 core // GL_EXT_shader_16bit_storage doesn't support input/output. #extension GL_EXT_shader_8bit_storage : require #extension GL_AMD_gpu_shader_int16 : require #extension GL_AMD_gpu_shader_half_float : require layout(location = 0) in int16_t foo; layout(location = 1) in uint16_t bar; layout(location = 2) in float16_t baz; layout(binding = 0) uniform block { i16vec2 a; u16vec2 b; i8vec2 c; u8vec2 d; f16vec2 e; }; layout(binding = 1) readonly buffer storage { i16vec3 f; u16vec3 g; i8vec3 h; u8vec3 i; f16vec3 j; }; layout(location = 0) out i16vec4 p; layout(location = 1) out u16vec4 q; layout(location = 2) out f16vec4 r; void main() { p = i16vec4(int(foo) + ivec4(ivec2(a), ivec2(c)) - ivec4(ivec3(f) / ivec3(h), 1)); q = u16vec4(uint(bar) + uvec4(uvec2(b), uvec2(d)) - uvec4(uvec3(g) / uvec3(i), 1)); r = f16vec4(float(baz) + vec4(vec2(e), 0, 1) - vec4(vec3(j), 1)); gl_Position = vec4(0, 0, 0, 1); } spirv-cross-2021.01.15/shaders-msl/vulkan/vert/vulkan-vertex.vk.vert000066400000000000000000000001671400026215700252340ustar00rootroot00000000000000#version 310 es void main() { gl_Position = float(gl_VertexIndex + gl_InstanceIndex) * vec4(1.0, 2.0, 3.0, 4.0); } spirv-cross-2021.01.15/shaders-no-opt/000077500000000000000000000000001400026215700172355ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/000077500000000000000000000000001400026215700200155ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/comp/000077500000000000000000000000001400026215700207535ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/comp/access-chain-dominator-in-loop-body-2.asm.comp000066400000000000000000000040241400026215700313720ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 52 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "values" OpName %_ "" OpDecorate %_runtimearr_int ArrayStride 4 OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_100 = OpConstant %int 100 %bool = OpTypeBool %_runtimearr_int = OpTypeRuntimeArray %int %SSBO = OpTypeStruct %_runtimearr_int %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %_ptr_Uniform_int = OpTypePointer Uniform %int %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel OpBranch %32 %32 = OpLabel %51 = OpPhi %int %int_0 %5 %49 %loop_continue %38 = OpSLessThan %bool %51 %int_100 OpLoopMerge %loop_merge %loop_continue None OpBranchConditional %38 %loop_body %loop_merge %loop_body = OpLabel %40 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %51 OpBranch %loop_continue %loop_continue = OpLabel %41 = OpLoad %int %40 %44 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %41 OpStore %44 %51 %47 = OpIAdd %int %41 %int_1 %48 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %47 %49 = OpLoad %int %48 OpStore %40 %49 OpBranch %32 %loop_merge = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/access-chain-dominator-in-loop-body.asm.comp000066400000000000000000000040011400026215700312260ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 52 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "values" OpName %_ "" OpDecorate %_runtimearr_int ArrayStride 4 OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_100 = OpConstant %int 100 %bool = OpTypeBool %_runtimearr_int = OpTypeRuntimeArray %int %SSBO = OpTypeStruct %_runtimearr_int %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %_ptr_Uniform_int = OpTypePointer Uniform %int %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel OpBranch %32 %32 = OpLabel %51 = OpPhi %int %int_0 %5 %49 %loop_continue %38 = OpSLessThan %bool %51 %int_100 OpLoopMerge %loop_merge %loop_continue None OpBranchConditional %38 %loop_body %loop_merge %loop_body = OpLabel %40 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %51 OpBranch %loop_continue %loop_continue = OpLabel %41 = OpLoad %int %40 %44 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %41 OpStore %44 %51 %47 = OpIAdd %int %41 %int_1 %48 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %47 %49 = OpLoad %int %48 OpBranch %32 %loop_merge = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/access-tracking-function-call-result.asm.comp000066400000000000000000000035401400026215700315250ustar00rootroot00000000000000; SPIR-V ; Version: 1.5 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 25 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 460 OpName %main "main" OpName %foo_ "foo(" OpName %Output "Output" OpMemberName %Output 0 "myout" OpName %_ "" OpMemberDecorate %Output 0 Offset 0 OpDecorate %Output BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %7 = OpTypeFunction %void %int = OpTypeInt 32 1 %9 = OpTypeFunction %int %int_12 = OpConstant %int 12 %bool = OpTypeBool %true = OpConstantTrue %bool %Output = OpTypeStruct %int %_ptr_Uniform_Output = OpTypePointer Uniform %Output %_ = OpVariable %_ptr_Uniform_Output Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_int = OpTypePointer Uniform %int %main = OpFunction %void None %7 %16 = OpLabel %17 = OpFunctionCall %int %foo_ OpBranch %18 %18 = OpLabel OpLoopMerge %19 %20 None OpBranchConditional %true %21 %19 %21 = OpLabel %22 = OpAccessChain %_ptr_Uniform_int %_ %int_0 OpStore %22 %17 OpReturn %20 = OpLabel OpBranch %18 %19 = OpLabel %23 = OpAccessChain %_ptr_Uniform_int %_ %int_0 OpStore %23 %17 OpReturn OpFunctionEnd %foo_ = OpFunction %int None %9 %24 = OpLabel OpReturnValue %int_12 OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/aliased-struct-divergent-member-name.asm.comp000066400000000000000000000060021400026215700315040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 37 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %T "T" OpMemberName %T 0 "a" OpName %v "v" OpName %T_0 "T" OpMemberName %T_0 0 "b" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "foo" OpName %_ "" OpName %T_1 "T" OpMemberName %T_1 0 "c" OpName %SSBO2 "SSBO2" OpMemberName %SSBO2 0 "bar" OpName %__0 "" OpMemberDecorate %T_0 0 Offset 0 OpDecorate %_runtimearr_T_0 ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpMemberDecorate %T_1 0 Offset 0 OpDecorate %_runtimearr_T_1 ArrayStride 16 OpMemberDecorate %SSBO2 0 Offset 0 OpDecorate %SSBO2 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %T = OpTypeStruct %float %_ptr_Function_T = OpTypePointer Function %T %float_40 = OpConstant %float 40 %11 = OpConstantComposite %T %float_40 %T_0 = OpTypeStruct %float %_runtimearr_T_0 = OpTypeRuntimeArray %T_0 %SSBO1 = OpTypeStruct %_runtimearr_T_0 %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %_ptr_Uniform_T_0 = OpTypePointer Uniform %T_0 %_ptr_Uniform_float = OpTypePointer Uniform %float %T_1 = OpTypeStruct %float %_runtimearr_T_1 = OpTypeRuntimeArray %T_1 %SSBO2 = OpTypeStruct %_runtimearr_T_1 %_ptr_Uniform_SSBO2 = OpTypePointer Uniform %SSBO2 %__0 = OpVariable %_ptr_Uniform_SSBO2 Uniform %int_30 = OpConstant %int 30 %_ptr_Uniform_T_1 = OpTypePointer Uniform %T_1 %main = OpFunction %void None %3 %5 = OpLabel %v = OpVariable %_ptr_Function_T Function OpStore %v %11 %20 = OpLoad %T %v %22 = OpAccessChain %_ptr_Uniform_T_0 %_ %int_0 %int_10 %23 = OpCompositeExtract %float %20 0 %25 = OpAccessChain %_ptr_Uniform_float %22 %int_0 OpStore %25 %23 %32 = OpLoad %T %v %34 = OpAccessChain %_ptr_Uniform_T_1 %__0 %int_0 %int_30 %35 = OpCompositeExtract %float %32 0 %36 = OpAccessChain %_ptr_Uniform_float %34 %int_0 OpStore %36 %35 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/arithmetic-conversion-signs.asm.nocompat.vk.comp000066400000000000000000000122571400026215700323140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 76 ; Schema: 0 OpCapability Shader OpCapability Int16 OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_shader_explicit_arithmetic_types_int16" OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "s32" OpMemberName %SSBO 1 "u32" OpMemberName %SSBO 2 "s16" OpMemberName %SSBO 3 "u16" OpMemberName %SSBO 4 "f32" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpMemberDecorate %SSBO 2 Offset 8 OpMemberDecorate %SSBO 3 Offset 10 OpMemberDecorate %SSBO 4 Offset 12 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %short = OpTypeInt 16 1 %ushort = OpTypeInt 16 0 %float = OpTypeFloat 32 %SSBO = OpTypeStruct %int %uint %short %ushort %float %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %_ptr_Uniform_int = OpTypePointer Uniform %int %_ptr_Uniform_short = OpTypePointer Uniform %short %int_1 = OpConstant %int 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_3 = OpConstant %int 3 %_ptr_Uniform_ushort = OpTypePointer Uniform %ushort %int_4 = OpConstant %int 4 %_ptr_Uniform_float = OpTypePointer Uniform %float %main = OpFunction %void None %3 %5 = OpLabel %ptr_s32 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %ptr_u32 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %ptr_s16 = OpAccessChain %_ptr_Uniform_short %_ %int_2 %ptr_u16 = OpAccessChain %_ptr_Uniform_ushort %_ %int_3 %ptr_f32 = OpAccessChain %_ptr_Uniform_float %_ %int_4 %s32 = OpLoad %int %ptr_s32 %u32 = OpLoad %uint %ptr_u32 %s16 = OpLoad %short %ptr_s16 %u16 = OpLoad %ushort %ptr_u16 %f32 = OpLoad %float %ptr_f32 ; Sign-extend %s16_to_s32_signed = OpSConvert %int %s16 OpStore %ptr_s32 %s16_to_s32_signed %s16_to_u32_signed = OpSConvert %uint %s16 OpStore %ptr_u32 %s16_to_u32_signed %u16_to_s32_signed = OpSConvert %int %u16 OpStore %ptr_s32 %u16_to_s32_signed %u16_to_u32_signed = OpSConvert %uint %u16 OpStore %ptr_u32 %u16_to_u32_signed ; Zero-extend ; Result must be unsigned for OpUConvert. ;%s16_to_s32_unsigned = OpUConvert %int %s16 ;OpStore %ptr_s32 %s16_to_s32_unsigned %s16_to_u32_unsigned = OpUConvert %uint %s16 OpStore %ptr_u32 %s16_to_u32_unsigned ;%u16_to_s32_unsigned = OpUConvert %int %u16 ;OpStore %ptr_s32 %u16_to_s32_unsigned %u16_to_u32_unsigned = OpUConvert %uint %u16 OpStore %ptr_u32 %u16_to_u32_unsigned ; Truncate (SConvert == UConvert) %s32_to_s16_signed = OpSConvert %short %s32 OpStore %ptr_s16 %s32_to_s16_signed %s32_to_u16_signed = OpSConvert %ushort %s32 OpStore %ptr_u16 %s32_to_u16_signed %u32_to_s16_signed = OpSConvert %short %u32 OpStore %ptr_s16 %u32_to_s16_signed %u32_to_u16_signed = OpSConvert %ushort %u32 OpStore %ptr_u16 %u32_to_u16_signed ;%s32_to_s16_unsigned = OpUConvert %short %s32 ;OpStore %ptr_s16 %s32_to_s16_unsigned %s32_to_u16_unsigned = OpUConvert %ushort %s32 OpStore %ptr_u16 %s32_to_u16_unsigned ;%u32_to_s16_unsigned = OpUConvert %short %u32 ;OpStore %ptr_s16 %u32_to_s16_unsigned %u32_to_u16_unsigned = OpUConvert %ushort %u32 OpStore %ptr_u16 %u32_to_u16_unsigned ; SToF %s16_to_f32_signed = OpConvertSToF %float %s16 OpStore %ptr_f32 %s16_to_f32_signed %u16_to_f32_signed = OpConvertSToF %float %u16 OpStore %ptr_f32 %u16_to_f32_signed %s32_to_f32_signed = OpConvertSToF %float %s32 OpStore %ptr_f32 %s32_to_f32_signed %u32_to_f32_signed = OpConvertSToF %float %u32 OpStore %ptr_f32 %u32_to_f32_signed ; UToF %s16_to_f32_unsigned = OpConvertUToF %float %s16 OpStore %ptr_f32 %s16_to_f32_unsigned %u16_to_f32_unsigned = OpConvertUToF %float %u16 OpStore %ptr_f32 %u16_to_f32_unsigned %s32_to_f32_unsigned = OpConvertUToF %float %s32 OpStore %ptr_f32 %s32_to_f32_unsigned %u32_to_f32_unsigned = OpConvertUToF %float %u32 OpStore %ptr_f32 %u32_to_f32_unsigned ; FToS %f32_to_s16_signed = OpConvertFToS %short %f32 OpStore %ptr_s16 %f32_to_s16_signed %f32_to_u16_signed = OpConvertFToS %ushort %f32 OpStore %ptr_u16 %f32_to_u16_signed ; FToU %f32_to_u16_unsigned = OpConvertFToU %ushort %f32 OpStore %ptr_u16 %f32_to_u16_unsigned ; Result must be unsigned for FToU, so don't bother testing that. OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/atomic-load-store.asm.comp000066400000000000000000000035361400026215700257440ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 23 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %c "c" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a" OpMemberName %SSBO 1 "b" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %SSBO = OpTypeStruct %uint %uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_0 = OpConstant %int 0 %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %c = OpVariable %_ptr_Function_uint Function %15 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %16 = OpAtomicLoad %uint %15 %int_1 %int_0 OpStore %c %16 %18 = OpLoad %uint %c %19 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 OpAtomicStore %19 %int_1 %int_0 %18 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/atomic-result-temporary.asm.comp000066400000000000000000000045461400026215700272330ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "count" OpMemberName %SSBO 1 "data" OpName %_ "" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO = OpTypeStruct %uint %_runtimearr_uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %uint_1024 = OpConstant %uint 1024 %bool = OpTypeBool %int_1 = OpConstant %int 1 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %_ptr_Input_uint = OpTypePointer Input %uint %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %19 = OpAtomicIAdd %uint %16 %uint_1 %uint_0 %uint_1 %23 = OpULessThan %bool %19 %uint_1024 OpSelectionMerge %25 None OpBranchConditional %23 %24 %25 %24 = OpLabel %32 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %33 = OpLoad %uint %32 %34 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %19 OpStore %34 %33 OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/bitcast-fp16-fp32.asm.vk.comp000066400000000000000000000047531400026215700260150ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 33 ; Schema: 0 OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_shader_explicit_arithmetic_types" OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a" OpMemberName %SSBO 1 "b" OpMemberName %SSBO 2 "c" OpMemberName %SSBO 3 "d" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpMemberDecorate %SSBO 2 Offset 8 OpMemberDecorate %SSBO 3 Offset 12 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %half = OpTypeFloat 16 %v2half = OpTypeVector %half 2 %float = OpTypeFloat 32 %SSBO = OpTypeStruct %v2half %float %float %v2half %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_v2half = OpTypePointer Uniform %v2half %uint = OpTypeInt 32 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %int_3 = OpConstant %int 3 %int_2 = OpConstant %int 2 %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Uniform_v2half %_ %int_0 %17 = OpLoad %v2half %16 %20 = OpBitcast %float %17 %22 = OpAccessChain %_ptr_Uniform_float %_ %int_1 OpStore %22 %20 %25 = OpAccessChain %_ptr_Uniform_float %_ %int_2 %26 = OpLoad %float %25 %28 = OpBitcast %v2half %26 %29 = OpAccessChain %_ptr_Uniform_v2half %_ %int_3 OpStore %29 %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/bitfield-signed-operations.asm.comp000066400000000000000000000077351400026215700276400ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 26 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "ints" OpMemberName %SSBO 1 "uints" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 16 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %uint = OpTypeInt 32 0 %v4uint = OpTypeVector %uint 4 %int_1 = OpConstant %int 1 %uint_11 = OpConstant %uint 11 %SSBO = OpTypeStruct %v4int %v4uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_v4int = OpTypePointer Uniform %v4int %_ptr_Uniform_v4uint = OpTypePointer Uniform %v4uint %main = OpFunction %void None %3 %5 = OpLabel %ints_ptr = OpAccessChain %_ptr_Uniform_v4int %_ %int_0 %uints_ptr = OpAccessChain %_ptr_Uniform_v4uint %_ %int_1 %ints = OpLoad %v4int %ints_ptr %uints = OpLoad %v4uint %uints_ptr %ints_alt = OpVectorShuffle %v4int %ints %ints 3 2 1 0 %uints_alt = OpVectorShuffle %v4uint %uints %uints 3 2 1 0 %int_to_int_popcount = OpBitCount %v4int %ints %int_to_uint_popcount = OpBitCount %v4uint %ints %uint_to_int_popcount = OpBitCount %v4int %uints %uint_to_uint_popcount = OpBitCount %v4uint %uints ; BitReverse must have matching types w.r.t. sign, yay. %int_to_int_reverse = OpBitReverse %v4int %ints ;%int_to_uint_reverse = OpBitReverse %v4uint %ints ;%uint_to_int_reverse = OpBitReverse %v4int %uints %uint_to_uint_reverse = OpBitReverse %v4uint %uints ; Base and Result must match. %int_to_int_sbit = OpBitFieldSExtract %v4int %ints %int_1 %uint_11 ;%int_to_uint_sbit = OpBitFieldSExtract %v4uint %ints %offset %count ;%uint_to_int_sbit = OpBitFieldSExtract %v4int %uints %offset %count %uint_to_uint_sbit = OpBitFieldSExtract %v4uint %uints %uint_11 %int_1 ; Base and Result must match. %int_to_int_ubit = OpBitFieldUExtract %v4int %ints %int_1 %uint_11 ;%int_to_uint_ubit = OpBitFieldUExtract %v4uint %ints %offset %count ;%uint_to_int_ubit = OpBitFieldUExtract %v4int %uints %offset %count %uint_to_uint_ubit = OpBitFieldUExtract %v4uint %uints %uint_11 %int_1 %int_to_int_insert = OpBitFieldInsert %v4int %ints %ints_alt %int_1 %uint_11 %uint_to_uint_insert = OpBitFieldInsert %v4uint %uints %uints_alt %uint_11 %int_1 OpStore %ints_ptr %int_to_int_popcount OpStore %uints_ptr %int_to_uint_popcount OpStore %ints_ptr %uint_to_int_popcount OpStore %uints_ptr %uint_to_uint_popcount OpStore %ints_ptr %int_to_int_reverse ;OpStore %uints_ptr %int_to_uint_reverse ;OpStore %ints_ptr %uint_to_int_reverse OpStore %uints_ptr %uint_to_uint_reverse OpStore %ints_ptr %int_to_int_sbit ;OpStore %uints_ptr %int_to_uint_sbit ;OpStore %ints_ptr %uint_to_int_sbit OpStore %uints_ptr %uint_to_uint_sbit OpStore %ints_ptr %int_to_int_ubit ;OpStore %uints_ptr %int_to_uint_ubit ;OpStore %ints_ptr %uint_to_int_ubit OpStore %uints_ptr %uint_to_uint_ubit OpStore %ints_ptr %int_to_int_insert OpStore %uints_ptr %uint_to_uint_insert OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/bitscan.asm.comp000066400000000000000000000052741400026215700240450ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "u" OpMemberName %SSBO 1 "i" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 16 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %SSBO = OpTypeStruct %uvec4 %ivec4 %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_uvec4 = OpTypePointer Uniform %uvec4 %int_1 = OpConstant %int 1 %_ptr_Uniform_ivec4 = OpTypePointer Uniform %ivec4 %main = OpFunction %void None %3 %5 = OpLabel %uptr = OpAccessChain %_ptr_Uniform_uvec4 %_ %int_0 %iptr = OpAccessChain %_ptr_Uniform_ivec4 %_ %int_1 %uvalue = OpLoad %uvec4 %uptr %ivalue = OpLoad %ivec4 %iptr %lsb_uint_to_uint = OpExtInst %uvec4 %1 FindILsb %uvalue %lsb_uint_to_int = OpExtInst %ivec4 %1 FindILsb %uvalue %lsb_int_to_uint = OpExtInst %uvec4 %1 FindILsb %ivalue %lsb_int_to_int = OpExtInst %ivec4 %1 FindILsb %ivalue %umsb_uint_to_uint = OpExtInst %uvec4 %1 FindUMsb %uvalue %umsb_uint_to_int = OpExtInst %ivec4 %1 FindUMsb %uvalue %umsb_int_to_uint = OpExtInst %uvec4 %1 FindUMsb %ivalue %umsb_int_to_int = OpExtInst %ivec4 %1 FindUMsb %ivalue %smsb_uint_to_uint = OpExtInst %uvec4 %1 FindSMsb %uvalue %smsb_uint_to_int = OpExtInst %ivec4 %1 FindSMsb %uvalue %smsb_int_to_uint = OpExtInst %uvec4 %1 FindSMsb %ivalue %smsb_int_to_int = OpExtInst %ivec4 %1 FindSMsb %ivalue OpStore %uptr %lsb_uint_to_uint OpStore %iptr %lsb_uint_to_int OpStore %uptr %lsb_int_to_uint OpStore %iptr %lsb_int_to_int OpStore %uptr %umsb_uint_to_uint OpStore %iptr %umsb_uint_to_int OpStore %uptr %umsb_int_to_uint OpStore %iptr %umsb_int_to_int OpStore %uptr %smsb_uint_to_uint OpStore %iptr %smsb_uint_to_int OpStore %uptr %smsb_int_to_uint OpStore %iptr %smsb_int_to_int OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/buffer-atomic-nonuniform.vk.nocompat.asm.comp000066400000000000000000000043621400026215700315700ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 26 ; Schema: 0 OpCapability Shader OpCapability ShaderNonUniform OpCapability RuntimeDescriptorArray OpCapability StorageBufferArrayNonUniformIndexing OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "v" OpName %ssbos "ssbos" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %ssbos DescriptorSet 0 OpDecorate %ssbos Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %22 NonUniform %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %SSBO = OpTypeStruct %uint %_runtimearr_SSBO = OpTypeRuntimeArray %SSBO %_ptr_Uniform__runtimearr_SSBO = OpTypePointer Uniform %_runtimearr_SSBO %ssbos = OpVariable %_ptr_Uniform__runtimearr_SSBO Uniform %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_2 = OpConstant %uint 2 %_ptr_Input_uint = OpTypePointer Input %uint %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_2 %17 = OpLoad %uint %16 %18 = OpCopyObject %uint %17 %22 = OpAccessChain %_ptr_Uniform_uint %ssbos %18 %int_0 %25 = OpAtomicIAdd %uint %22 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd buffer-reference-aliased-block-name.nocompat.vk.asm.comp000066400000000000000000000134011400026215700334030ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/comp; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 59 ; Schema: 0 OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_EXT_physical_storage_buffer" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 64 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_buffer_reference" OpName %main "main" OpName %Registers "Registers" OpMemberName %Registers 0 "ro" OpMemberName %Registers 1 "rw" OpMemberName %Registers 2 "wo" OpName %RO "Alias" OpMemberName %RO 0 "v" OpName %RW "Alias" OpMemberName %RW 0 "v" OpName %WO "Alias" OpMemberName %WO 0 "v" OpName %registers "registers" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpMemberDecorate %Registers 0 Offset 0 OpMemberDecorate %Registers 1 Offset 8 OpMemberDecorate %Registers 2 Offset 16 OpDecorate %Registers Block OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %RO 0 NonWritable OpMemberDecorate %RO 0 Offset 0 OpDecorate %RO Block OpDecorate %_runtimearr_v4float_0 ArrayStride 16 OpMemberDecorate %RW 0 Restrict OpMemberDecorate %RW 0 Offset 0 OpDecorate %RW Block OpDecorate %_runtimearr_v4float_1 ArrayStride 16 OpMemberDecorate %WO 0 Coherent OpMemberDecorate %WO 0 NonReadable OpMemberDecorate %WO 0 Offset 0 OpDecorate %WO Block OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void OpTypeForwardPointer %_ptr_PhysicalStorageBuffer_RO PhysicalStorageBuffer OpTypeForwardPointer %_ptr_PhysicalStorageBuffer_RW PhysicalStorageBuffer OpTypeForwardPointer %_ptr_PhysicalStorageBuffer_WO PhysicalStorageBuffer %Registers = OpTypeStruct %_ptr_PhysicalStorageBuffer_RO %_ptr_PhysicalStorageBuffer_RW %_ptr_PhysicalStorageBuffer_WO %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %RO = OpTypeStruct %_runtimearr_v4float %_ptr_PhysicalStorageBuffer_RO = OpTypePointer PhysicalStorageBuffer %RO %_runtimearr_v4float_0 = OpTypeRuntimeArray %v4float %RW = OpTypeStruct %_runtimearr_v4float_0 %_ptr_PhysicalStorageBuffer_RW = OpTypePointer PhysicalStorageBuffer %RW %_runtimearr_v4float_1 = OpTypeRuntimeArray %v4float %WO = OpTypeStruct %_runtimearr_v4float_1 %_ptr_PhysicalStorageBuffer_WO = OpTypePointer PhysicalStorageBuffer %WO %_ptr_PushConstant_Registers = OpTypePointer PushConstant %Registers %registers = OpVariable %_ptr_PushConstant_Registers PushConstant %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_PushConstant__ptr_PhysicalStorageBuffer_RW = OpTypePointer PushConstant %_ptr_PhysicalStorageBuffer_RW %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_PushConstant__ptr_PhysicalStorageBuffer_RO = OpTypePointer PushConstant %_ptr_PhysicalStorageBuffer_RO %_ptr_PhysicalStorageBuffer_v4float = OpTypePointer PhysicalStorageBuffer %v4float %int_2 = OpConstant %int 2 %_ptr_PushConstant__ptr_PhysicalStorageBuffer_WO = OpTypePointer PushConstant %_ptr_PhysicalStorageBuffer_WO %uint_64 = OpConstant %uint 64 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_64 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %23 = OpAccessChain %_ptr_PushConstant__ptr_PhysicalStorageBuffer_RW %registers %int_1 %24 = OpLoad %_ptr_PhysicalStorageBuffer_RW %23 %32 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %33 = OpLoad %uint %32 %35 = OpAccessChain %_ptr_PushConstant__ptr_PhysicalStorageBuffer_RO %registers %int_0 %36 = OpLoad %_ptr_PhysicalStorageBuffer_RO %35 %37 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %38 = OpLoad %uint %37 %40 = OpAccessChain %_ptr_PhysicalStorageBuffer_v4float %36 %int_0 %38 %41 = OpLoad %v4float %40 Aligned 16 %42 = OpAccessChain %_ptr_PhysicalStorageBuffer_v4float %24 %int_0 %33 OpStore %42 %41 Aligned 16 %45 = OpAccessChain %_ptr_PushConstant__ptr_PhysicalStorageBuffer_WO %registers %int_2 %46 = OpLoad %_ptr_PhysicalStorageBuffer_WO %45 %47 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %48 = OpLoad %uint %47 %49 = OpAccessChain %_ptr_PushConstant__ptr_PhysicalStorageBuffer_RO %registers %int_0 %50 = OpLoad %_ptr_PhysicalStorageBuffer_RO %49 %51 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %52 = OpLoad %uint %51 %53 = OpAccessChain %_ptr_PhysicalStorageBuffer_v4float %50 %int_0 %52 %54 = OpLoad %v4float %53 Aligned 16 %55 = OpAccessChain %_ptr_PhysicalStorageBuffer_v4float %46 %int_0 %48 OpStore %55 %54 Aligned 16 OpReturn OpFunctionEnd buffer-reference-synthesized-pointer-2.asm.nocompat.vk.comp000066400000000000000000000037221400026215700341660ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/comp; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 27 ; Schema: 0 OpCapability Shader OpCapability Int64 OpCapability PhysicalStorageBufferAddressesEXT OpExtension "SPV_EXT_physical_storage_buffer" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel PhysicalStorageBuffer64EXT GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_ARB_gpu_shader_int64" OpSourceExtension "GL_EXT_buffer_reference" OpDecorate %ptr AliasedPointerEXT OpMemberDecorate %Registers 0 Offset 0 OpDecorate %Registers Block %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_PhysicalStorageBufferEXT_uint = OpTypePointer PhysicalStorageBufferEXT %uint %_ptr_Function__ptr_PhysicalStorageBufferEXT_uint = OpTypePointer Function %_ptr_PhysicalStorageBufferEXT_uint %ulong = OpTypeInt 64 0 %Registers = OpTypeStruct %ulong %_ptr_PushConstant_Registers = OpTypePointer PushConstant %Registers %registers = OpVariable %_ptr_PushConstant_Registers PushConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_PushConstant_ulong = OpTypePointer PushConstant %ulong %int_10 = OpConstant %int 10 %uint_20 = OpConstant %uint 20 %main = OpFunction %void None %3 %5 = OpLabel %ptr = OpVariable %_ptr_Function__ptr_PhysicalStorageBufferEXT_uint Function %19 = OpAccessChain %_ptr_PushConstant_ulong %registers %int_0 %20 = OpLoad %ulong %19 %21 = OpConvertUToPtr %_ptr_PhysicalStorageBufferEXT_uint %20 OpStore %ptr %21 %22 = OpLoad %_ptr_PhysicalStorageBufferEXT_uint %ptr OpStore %22 %uint_20 Aligned 4 OpReturn OpFunctionEnd buffer-reference-synthesized-pointer.asm.nocompat.vk.comp000066400000000000000000000046241400026215700340310ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/comp; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 27 ; Schema: 0 OpCapability Shader OpCapability Int64 OpCapability PhysicalStorageBufferAddressesEXT OpExtension "SPV_EXT_physical_storage_buffer" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel PhysicalStorageBuffer64EXT GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_ARB_gpu_shader_int64" OpSourceExtension "GL_EXT_buffer_reference" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %uintPtr 0 Offset 0 OpDecorate %uintPtr Block OpDecorate %ptr AliasedPointerEXT OpMemberDecorate %Registers 0 Offset 0 OpDecorate %Registers Block %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %uintPtr = OpTypeStruct %_runtimearr_uint %_ptr_PhysicalStorageBufferEXT_uint_array = OpTypePointer PhysicalStorageBufferEXT %_runtimearr_uint %_ptr_Function__ptr_PhysicalStorageBufferEXT_uint_array = OpTypePointer Function %_ptr_PhysicalStorageBufferEXT_uint_array %ulong = OpTypeInt 64 0 %Registers = OpTypeStruct %ulong %_ptr_PushConstant_Registers = OpTypePointer PushConstant %Registers %registers = OpVariable %_ptr_PushConstant_Registers PushConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_PushConstant_ulong = OpTypePointer PushConstant %ulong %int_10 = OpConstant %int 10 %uint_20 = OpConstant %uint 20 %_ptr_PhysicalStorageBufferEXT_uint = OpTypePointer PhysicalStorageBufferEXT %uint %main = OpFunction %void None %3 %5 = OpLabel %ptr = OpVariable %_ptr_Function__ptr_PhysicalStorageBufferEXT_uint_array Function %19 = OpAccessChain %_ptr_PushConstant_ulong %registers %int_0 %20 = OpLoad %ulong %19 %21 = OpConvertUToPtr %_ptr_PhysicalStorageBufferEXT_uint_array %20 OpStore %ptr %21 %22 = OpLoad %_ptr_PhysicalStorageBufferEXT_uint_array %ptr %26 = OpAccessChain %_ptr_PhysicalStorageBufferEXT_uint %22 %int_10 OpStore %26 %uint_20 Aligned 4 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/constant-composite-undef.asm.comp000066400000000000000000000030601400026215700273410ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Block "Block" OpMemberName %Block 0 "f" OpName %block "block" OpMemberDecorate %Block 0 Offset 0 OpDecorate %Block BufferBlock OpDecorate %block DescriptorSet 0 OpDecorate %block Binding 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Block = OpTypeStruct %v4float %_ptr_Uniform_Block = OpTypePointer Uniform %Block %block = OpVariable %_ptr_Uniform_Block Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_0_100000001 = OpConstant %float 0.100000001 %float_0_200000003 = OpConstant %float 0.200000003 %float_0_300000012 = OpConstant %float 0.300000012 %15 = OpUndef %float %16 = OpConstantComposite %v4float %float_0_100000001 %float_0_200000003 %float_0_300000012 %15 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %main = OpFunction %void None %6 %18 = OpLabel %19 = OpAccessChain %_ptr_Uniform_v4float %block %int_0 OpStore %19 %16 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/copy-logical.spv14.asm.comp000066400000000000000000000046771400026215700257660ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 48 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %ssbo OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %B1 "B1" OpName %A "A" OpName %C "C" OpName %B2 "B2" OpMemberName %A 0 "a" OpMemberName %A 1 "b1" OpMemberName %A 2 "b1_array" OpMemberName %C 0 "c" OpMemberName %C 1 "b2" OpMemberName %C 2 "b2_array" OpMemberName %B1 0 "elem1" OpMemberName %B2 0 "elem2" OpMemberName %SSBO 0 "a_block" OpMemberName %SSBO 1 "c_block" OpDecorate %B1Array ArrayStride 16 OpDecorate %B2Array ArrayStride 16 OpMemberDecorate %B1 0 Offset 0 OpMemberDecorate %A 0 Offset 0 OpMemberDecorate %A 1 Offset 16 OpMemberDecorate %A 2 Offset 32 OpMemberDecorate %B2 0 Offset 0 OpMemberDecorate %C 0 Offset 0 OpMemberDecorate %C 1 Offset 16 OpMemberDecorate %C 2 Offset 32 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 96 OpDecorate %SSBO Block OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %v4float = OpTypeVector %float 4 %B2 = OpTypeStruct %v4float %B2Array = OpTypeArray %B2 %uint_4 %C = OpTypeStruct %v4float %B2 %B2Array %B1 = OpTypeStruct %v4float %B1Array = OpTypeArray %B1 %uint_4 %A = OpTypeStruct %v4float %B1 %B1Array %SSBO = OpTypeStruct %A %C %_ptr_Uniform_SSBO = OpTypePointer StorageBuffer %SSBO %ssbo = OpVariable %_ptr_Uniform_SSBO StorageBuffer %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Uniform_C = OpTypePointer StorageBuffer %C %int_0 = OpConstant %int 0 %_ptr_Uniform_A = OpTypePointer StorageBuffer %A %main = OpFunction %void None %3 %5 = OpLabel %22 = OpAccessChain %_ptr_Uniform_C %ssbo %int_1 %39 = OpAccessChain %_ptr_Uniform_A %ssbo %int_0 %23 = OpLoad %C %22 %24 = OpCopyLogical %A %23 OpStore %39 %24 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/extended-debug-extinst.invalid.asm.comp000066400000000000000000000046101400026215700304200ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 37 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "DebugInfo" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %3 OpExecutionMode %2 LocalSize 1 1 1 %4 = OpString "negateInputs.comp" %5 = OpString "negateInputs" %6 = OpString "main" %7 = OpString "" OpSource GLSL 430 OpName %2 "main" OpName %3 "gl_GlobalInvocationID" OpDecorate %3 BuiltIn GlobalInvocationId OpDecorate %8 BufferBlock OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 1 OpDecorate %11 ArrayStride 4 OpMemberDecorate %8 0 Offset 0 OpLine %4 0 0 %12 = OpTypeBool %13 = OpTypeVoid %14 = OpTypeFunction %13 %15 = OpTypeInt 32 0 %16 = OpTypeInt 32 1 %17 = OpTypeFloat 32 %18 = OpTypeVector %15 3 %19 = OpTypeVector %17 3 %20 = OpTypePointer Input %18 %21 = OpTypePointer Uniform %16 %22 = OpTypePointer Uniform %17 %23 = OpTypeRuntimeArray %16 %11 = OpTypeRuntimeArray %17 %8 = OpTypeStruct %11 %24 = OpTypePointer Uniform %8 %9 = OpVariable %24 Uniform %10 = OpVariable %24 Uniform OpLine %4 0 1 OpLine %5 1 0 OpLine %4 1000 100000 %3 = OpVariable %20 Input %25 = OpConstant %16 0 OpNoLine OpLine %4 1 1 %26 = OpExtInst %13 %1 DebugInfoNone %27 = OpExtInst %13 %1 DebugTypeFunction %13 %28 = OpExtInst %13 %1 DebugFunction %6 %27 %4 1 1 %4 %7 FlagIsDefinition|FlagPrototyped|FlagIsOptimized 1 %26 %26 %2 = OpFunction %13 None %14 %29 = OpLabel %30 = OpExtInst %13 %1 DebugScope %28 OpLine %4 1 1 %31 = OpLoad %18 %3 %32 = OpCompositeExtract %15 %31 0 %33 = OpAccessChain %22 %9 %25 %32 %34 = OpLoad %17 %33 %35 = OpFNegate %17 %34 %36 = OpAccessChain %22 %10 %25 %32 OpStore %36 %35 OpNoLine OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/glsl-signed-operations.asm.comp000066400000000000000000000124761400026215700270150ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 26 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "ints" OpMemberName %SSBO 1 "uints" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 16 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %uint = OpTypeInt 32 0 %v4uint = OpTypeVector %uint 4 %SSBO = OpTypeStruct %v4int %v4uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_v4int = OpTypePointer Uniform %v4int %int_1 = OpConstant %int 1 %_ptr_Uniform_v4uint = OpTypePointer Uniform %v4uint %main = OpFunction %void None %3 %5 = OpLabel %ints_ptr = OpAccessChain %_ptr_Uniform_v4int %_ %int_0 %uints_ptr = OpAccessChain %_ptr_Uniform_v4uint %_ %int_1 %ints = OpLoad %v4int %ints_ptr %uints = OpLoad %v4uint %uints_ptr %int_to_int_sabs = OpExtInst %v4int %1 SAbs %ints %int_to_uint_sabs = OpExtInst %v4uint %1 SAbs %ints %uint_to_int_sabs = OpExtInst %v4int %1 SAbs %uints %uint_to_uint_sabs = OpExtInst %v4uint %1 SAbs %uints %int_to_int_ssign = OpExtInst %v4int %1 SSign %ints %int_to_uint_ssign = OpExtInst %v4uint %1 SSign %ints %uint_to_int_ssign = OpExtInst %v4int %1 SSign %uints %uint_to_uint_ssign = OpExtInst %v4uint %1 SSign %uints %int_to_int_smsb = OpExtInst %v4int %1 FindSMsb %uints %int_to_uint_smsb = OpExtInst %v4uint %1 FindSMsb %uints %uint_to_int_umsb = OpExtInst %v4int %1 FindUMsb %ints %uint_to_uint_umsb = OpExtInst %v4uint %1 FindUMsb %ints %int_to_int_smin = OpExtInst %v4int %1 SMin %ints %ints %int_to_uint_smin = OpExtInst %v4uint %1 SMin %ints %uints %uint_to_int_smin = OpExtInst %v4int %1 SMin %uints %uints %uint_to_uint_smin = OpExtInst %v4uint %1 SMin %uints %ints %int_to_int_umin = OpExtInst %v4int %1 UMin %ints %uints %int_to_uint_umin = OpExtInst %v4uint %1 UMin %ints %uints %uint_to_int_umin = OpExtInst %v4int %1 UMin %uints %ints %uint_to_uint_umin = OpExtInst %v4uint %1 UMin %uints %ints %int_to_int_smax = OpExtInst %v4int %1 SMax %ints %ints %int_to_uint_smax = OpExtInst %v4uint %1 SMax %ints %ints %uint_to_int_smax = OpExtInst %v4int %1 SMax %uints %ints %uint_to_uint_smax = OpExtInst %v4uint %1 SMax %uints %ints %int_to_int_umax = OpExtInst %v4int %1 UMax %ints %uints %int_to_uint_umax = OpExtInst %v4uint %1 UMax %ints %ints %uint_to_int_umax = OpExtInst %v4int %1 UMax %uints %ints %uint_to_uint_umax = OpExtInst %v4uint %1 UMax %uints %ints %int_to_int_sclamp = OpExtInst %v4int %1 SClamp %uints %uints %uints %int_to_uint_sclamp = OpExtInst %v4uint %1 SClamp %uints %uints %uints %uint_to_int_uclamp = OpExtInst %v4int %1 UClamp %ints %ints %ints %uint_to_uint_uclamp = OpExtInst %v4uint %1 UClamp %ints %ints %ints OpStore %ints_ptr %int_to_int_sabs OpStore %uints_ptr %int_to_uint_sabs OpStore %ints_ptr %uint_to_int_sabs OpStore %uints_ptr %uint_to_uint_sabs OpStore %ints_ptr %int_to_int_ssign OpStore %uints_ptr %int_to_uint_ssign OpStore %ints_ptr %uint_to_int_ssign OpStore %uints_ptr %uint_to_uint_ssign OpStore %ints_ptr %int_to_int_smsb OpStore %uints_ptr %int_to_uint_smsb OpStore %ints_ptr %uint_to_int_umsb OpStore %uints_ptr %uint_to_uint_umsb OpStore %ints_ptr %int_to_int_smin OpStore %uints_ptr %int_to_uint_smin OpStore %ints_ptr %uint_to_int_smin OpStore %uints_ptr %uint_to_uint_smin OpStore %ints_ptr %int_to_int_umin OpStore %uints_ptr %int_to_uint_umin OpStore %ints_ptr %uint_to_int_umin OpStore %uints_ptr %uint_to_uint_umin OpStore %ints_ptr %int_to_int_smax OpStore %uints_ptr %int_to_uint_smax OpStore %ints_ptr %uint_to_int_smax OpStore %uints_ptr %uint_to_uint_smax OpStore %ints_ptr %int_to_int_umax OpStore %uints_ptr %int_to_uint_umax OpStore %ints_ptr %uint_to_int_umax OpStore %uints_ptr %uint_to_uint_umax OpStore %ints_ptr %int_to_int_sclamp OpStore %uints_ptr %int_to_uint_sclamp OpStore %ints_ptr %uint_to_int_uclamp OpStore %uints_ptr %uint_to_uint_uclamp OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/glsl.std450.frexp-modf-struct.asm.comp000066400000000000000000000041771400026215700277760ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %ResTypeMod = OpTypeStruct %float %float %_ptr_Function_ResTypeMod = OpTypePointer Function %ResTypeMod %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_20 = OpConstant %float 20 %int_1 = OpConstant %int 1 %_ptr_Function_float = OpTypePointer Function %float %ResTypeFrexp = OpTypeStruct %float %int %_ptr_Function_ResTypeFrexp = OpTypePointer Function %ResTypeFrexp %float_40 = OpConstant %float 40 %_ptr_Function_int = OpTypePointer Function %int %SSBO = OpTypeStruct %float %int %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_int = OpTypePointer Uniform %int %main = OpFunction %void None %3 %5 = OpLabel %modres = OpExtInst %ResTypeMod %1 ModfStruct %float_20 %frexpres = OpExtInst %ResTypeFrexp %1 FrexpStruct %float_40 %modres_f = OpCompositeExtract %float %modres 0 %modres_i = OpCompositeExtract %float %modres 1 %frexpres_f = OpCompositeExtract %float %frexpres 0 %frexpres_i = OpCompositeExtract %int %frexpres 1 %float_ptr = OpAccessChain %_ptr_Uniform_float %_ %int_0 %int_ptr = OpAccessChain %_ptr_Uniform_int %_ %int_1 OpStore %float_ptr %modres_f OpStore %float_ptr %modres_i OpStore %float_ptr %frexpres_f OpStore %int_ptr %frexpres_i OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/image-atomic-nonuniform.vk.nocompat.asm.comp000066400000000000000000000046321400026215700314010ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 32 ; Schema: 0 OpCapability Shader OpCapability ShaderNonUniform OpCapability RuntimeDescriptorArray OpCapability StorageImageArrayNonUniformIndexing OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %uImage "uImage" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %uImage DescriptorSet 0 OpDecorate %uImage Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %30 NonUniform %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %7 = OpTypeImage %uint 2D 0 0 0 2 R32ui %_runtimearr_7 = OpTypeRuntimeArray %7 %_ptr_UniformConstant__runtimearr_7 = OpTypePointer UniformConstant %_runtimearr_7 %uImage = OpVariable %_ptr_UniformConstant__runtimearr_7 UniformConstant %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_2 = OpConstant %uint 2 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_UniformConstant_7 = OpTypePointer UniformConstant %7 %v2uint = OpTypeVector %uint 2 %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %_ptr_Image_uint = OpTypePointer Image %uint %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_2 %17 = OpLoad %uint %16 %18 = OpCopyObject %uint %17 %20 = OpAccessChain %_ptr_UniformConstant_7 %uImage %18 %22 = OpLoad %v3uint %gl_GlobalInvocationID %23 = OpVectorShuffle %v2uint %22 %22 0 1 %26 = OpBitcast %v2int %23 %30 = OpImageTexelPointer %_ptr_Image_uint %20 %26 %uint_0 %31 = OpAtomicIAdd %uint %30 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/loop-variable-with-initializer.asm.comp000066400000000000000000000016661400026215700304510ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos; 0 ; Bound: 62 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %i "i" %uint = OpTypeInt 32 0 %void = OpTypeVoid %11 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %_ptr_Function_uint = OpTypePointer Function %uint %31 = OpConstantNull %uint %main = OpFunction %void None %11 %14 = OpLabel %i = OpVariable %_ptr_Function_uint Function %31 OpStore %i %uint_0 OpBranch %32 %32 = OpLabel OpLoopMerge %33 %34 None OpBranch %33 %34 = OpLabel %57 = OpLoad %uint %i OpBranch %32 %33 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/nonuniform-bracket-handling.vk.nocompat.asm.comp000066400000000000000000000342761400026215700322510ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Unknown(30017); 21022 ; Bound: 233 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpCapability ImageQuery OpCapability StorageImageWriteWithoutFormat OpCapability GroupNonUniformBallot OpCapability RuntimeDescriptorArray OpCapability UniformTexelBufferArrayDynamicIndexing OpCapability StorageTexelBufferArrayDynamicIndexing OpCapability UniformTexelBufferArrayNonUniformIndexing OpCapability StorageTexelBufferArrayNonUniformIndexing OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %RootConstants "RootConstants" OpName %registers "registers" OpName %SSBO_Offsets "SSBO_Offsets" OpDecorate %RootConstants Block OpMemberDecorate %RootConstants 0 Offset 0 OpMemberDecorate %RootConstants 1 Offset 4 OpMemberDecorate %RootConstants 2 Offset 8 OpMemberDecorate %RootConstants 3 Offset 12 OpMemberDecorate %RootConstants 4 Offset 16 OpMemberDecorate %RootConstants 5 Offset 20 OpMemberDecorate %RootConstants 6 Offset 24 OpMemberDecorate %RootConstants 7 Offset 28 OpDecorate %_runtimearr_v2uint ArrayStride 8 OpMemberDecorate %SSBO_Offsets 0 Offset 0 OpDecorate %SSBO_Offsets Block OpDecorate %13 DescriptorSet 0 OpDecorate %13 Binding 0 OpDecorate %13 NonWritable OpDecorate %13 Restrict OpDecorate %18 DescriptorSet 1 OpDecorate %18 Binding 0 OpDecorate %22 DescriptorSet 4 OpDecorate %22 Binding 0 OpDecorate %26 DescriptorSet 4 OpDecorate %26 Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %148 NonUniform OpDecorate %149 NonUniform OpDecorate %172 NonUniform OpDecorate %173 NonUniform OpDecorate %196 NonUniform OpDecorate %197 NonUniform OpDecorate %205 NonUniform %void = OpTypeVoid %2 = OpTypeFunction %void %uint = OpTypeInt 32 0 %RootConstants = OpTypeStruct %uint %uint %uint %uint %uint %uint %uint %uint %_ptr_PushConstant_RootConstants = OpTypePointer PushConstant %RootConstants %registers = OpVariable %_ptr_PushConstant_RootConstants PushConstant %v2uint = OpTypeVector %uint 2 %_runtimearr_v2uint = OpTypeRuntimeArray %v2uint %SSBO_Offsets = OpTypeStruct %_runtimearr_v2uint %_ptr_StorageBuffer_SSBO_Offsets = OpTypePointer StorageBuffer %SSBO_Offsets %13 = OpVariable %_ptr_StorageBuffer_SSBO_Offsets StorageBuffer %float = OpTypeFloat 32 %15 = OpTypeImage %float Buffer 0 0 0 1 Unknown %_runtimearr_15 = OpTypeRuntimeArray %15 %_ptr_UniformConstant__runtimearr_15 = OpTypePointer UniformConstant %_runtimearr_15 %18 = OpVariable %_ptr_UniformConstant__runtimearr_15 UniformConstant %19 = OpTypeImage %float Buffer 0 0 0 2 R32f %_runtimearr_19 = OpTypeRuntimeArray %19 %_ptr_UniformConstant__runtimearr_19 = OpTypePointer UniformConstant %_runtimearr_19 %22 = OpVariable %_ptr_UniformConstant__runtimearr_19 UniformConstant %23 = OpTypeImage %uint Buffer 0 0 0 2 R32ui %_runtimearr_23 = OpTypeRuntimeArray %23 %_ptr_UniformConstant__runtimearr_23 = OpTypePointer UniformConstant %_runtimearr_23 %26 = OpVariable %_ptr_UniformConstant__runtimearr_23 UniformConstant %_ptr_UniformConstant_23 = OpTypePointer UniformConstant %23 %_ptr_PushConstant_uint = OpTypePointer PushConstant %uint %uint_4 = OpConstant %uint 4 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %_ptr_StorageBuffer_v2uint = OpTypePointer StorageBuffer %v2uint %uint_0 = OpConstant %uint 0 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %_ptr_UniformConstant_15 = OpTypePointer UniformConstant %15 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %_ptr_Input_uint = OpTypePointer Input %uint %bool = OpTypeBool %uint_4294967295 = OpConstant %uint 4294967295 %v4float = OpTypeVector %float 4 %uint_1024 = OpConstant %uint 1024 %uint_2048 = OpConstant %uint 2048 %_ptr_Image_uint = OpTypePointer Image %uint %uint_40 = OpConstant %uint 40 %uint_50 = OpConstant %uint 50 %uint_70 = OpConstant %uint 70 %main = OpFunction %void None %2 %4 = OpLabel OpBranch %231 %231 = OpLabel %30 = OpAccessChain %_ptr_PushConstant_uint %registers %uint_4 %32 = OpLoad %uint %30 %33 = OpIAdd %uint %32 %uint_2 %28 = OpAccessChain %_ptr_UniformConstant_23 %26 %33 %35 = OpLoad %23 %28 %36 = OpGroupNonUniformBroadcastFirst %uint %uint_3 %33 %39 = OpAccessChain %_ptr_StorageBuffer_v2uint %13 %uint_0 %36 %41 = OpLoad %v2uint %39 %44 = OpAccessChain %_ptr_PushConstant_uint %registers %uint_4 %45 = OpLoad %uint %44 %43 = OpAccessChain %_ptr_UniformConstant_19 %22 %45 %46 = OpLoad %19 %43 %47 = OpGroupNonUniformBroadcastFirst %uint %uint_3 %45 %48 = OpAccessChain %_ptr_StorageBuffer_v2uint %13 %uint_0 %47 %49 = OpLoad %v2uint %48 %52 = OpAccessChain %_ptr_PushConstant_uint %registers %uint_1 %54 = OpLoad %uint %52 %55 = OpIAdd %uint %54 %uint_1 %51 = OpAccessChain %_ptr_UniformConstant_15 %18 %55 %56 = OpLoad %15 %51 %57 = OpGroupNonUniformBroadcastFirst %uint %uint_3 %55 %58 = OpAccessChain %_ptr_StorageBuffer_v2uint %13 %uint_0 %57 %59 = OpLoad %v2uint %58 %64 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %65 = OpLoad %uint %64 %66 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_1 %67 = OpLoad %uint %66 %68 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_2 %69 = OpLoad %uint %68 %70 = OpIAdd %uint %65 %uint_4 %71 = OpCompositeExtract %uint %49 0 %72 = OpCompositeExtract %uint %49 1 %73 = OpIAdd %uint %70 %71 %75 = OpULessThan %bool %70 %72 %76 = OpSelect %uint %75 %73 %uint_4294967295 %79 = OpImageRead %v4float %46 %76 %80 = OpCompositeExtract %float %79 0 %81 = OpCompositeExtract %float %79 1 %82 = OpCompositeExtract %float %79 2 %83 = OpCompositeExtract %float %79 3 %84 = OpIAdd %uint %65 %uint_1024 %86 = OpCompositeExtract %uint %49 0 %87 = OpCompositeExtract %uint %49 1 %88 = OpIAdd %uint %84 %86 %89 = OpULessThan %bool %84 %87 %90 = OpSelect %uint %89 %88 %uint_4294967295 %91 = OpCompositeConstruct %v4float %80 %81 %82 %83 OpImageWrite %46 %90 %91 %92 = OpIAdd %uint %65 %uint_2 %93 = OpCompositeExtract %uint %59 0 %94 = OpCompositeExtract %uint %59 1 %95 = OpIAdd %uint %92 %93 %96 = OpULessThan %bool %92 %94 %97 = OpSelect %uint %96 %95 %uint_4294967295 %98 = OpImageFetch %v4float %56 %97 %99 = OpCompositeExtract %float %98 0 %100 = OpCompositeExtract %float %98 1 %101 = OpCompositeExtract %float %98 2 %102 = OpCompositeExtract %float %98 3 %103 = OpIAdd %uint %65 %uint_2048 %105 = OpCompositeExtract %uint %49 0 %106 = OpCompositeExtract %uint %49 1 %107 = OpIAdd %uint %103 %105 %108 = OpULessThan %bool %103 %106 %109 = OpSelect %uint %108 %107 %uint_4294967295 %110 = OpCompositeConstruct %v4float %99 %100 %101 %102 OpImageWrite %46 %109 %110 %111 = OpCompositeExtract %uint %41 0 %112 = OpCompositeExtract %uint %41 1 %113 = OpIAdd %uint %65 %111 %114 = OpULessThan %bool %65 %112 %115 = OpSelect %uint %114 %113 %uint_4294967295 %117 = OpImageTexelPointer %_ptr_Image_uint %28 %115 %uint_0 %118 = OpAtomicIAdd %uint %117 %uint_1 %uint_0 %uint_40 %120 = OpCompositeExtract %uint %41 0 %121 = OpCompositeExtract %uint %41 1 %122 = OpIAdd %uint %67 %120 %123 = OpULessThan %bool %67 %121 %124 = OpSelect %uint %123 %122 %uint_4294967295 %125 = OpImageTexelPointer %_ptr_Image_uint %28 %124 %uint_0 %126 = OpAtomicCompareExchange %uint %125 %uint_1 %uint_0 %uint_0 %uint_50 %uint_40 %128 = OpCompositeExtract %uint %49 1 %129 = OpConvertUToF %float %128 %130 = OpCompositeExtract %uint %49 0 %131 = OpCompositeExtract %uint %49 1 %132 = OpIAdd %uint %uint_0 %130 %133 = OpULessThan %bool %uint_0 %131 %134 = OpSelect %uint %133 %132 %uint_4294967295 %135 = OpCompositeConstruct %v4float %129 %129 %129 %129 OpImageWrite %46 %134 %135 %136 = OpCompositeExtract %uint %59 1 %137 = OpConvertUToF %float %136 %138 = OpCompositeExtract %uint %49 0 %139 = OpCompositeExtract %uint %49 1 %140 = OpIAdd %uint %uint_1 %138 %141 = OpULessThan %bool %uint_1 %139 %142 = OpSelect %uint %141 %140 %uint_4294967295 %143 = OpCompositeConstruct %v4float %137 %137 %137 %137 OpImageWrite %46 %142 %143 %144 = OpIAdd %uint %69 %uint_0 %146 = OpAccessChain %_ptr_PushConstant_uint %registers %uint_4 %147 = OpLoad %uint %146 %148 = OpIAdd %uint %147 %144 %145 = OpAccessChain %_ptr_UniformConstant_19 %22 %148 %149 = OpLoad %19 %145 %150 = OpAccessChain %_ptr_StorageBuffer_v2uint %13 %uint_0 %148 %151 = OpLoad %v2uint %150 %152 = OpCompositeExtract %uint %151 0 %153 = OpCompositeExtract %uint %151 1 %154 = OpIAdd %uint %70 %152 %155 = OpULessThan %bool %70 %153 %156 = OpSelect %uint %155 %154 %uint_4294967295 %157 = OpImageRead %v4float %149 %156 %158 = OpCompositeExtract %float %157 0 %159 = OpCompositeExtract %float %157 1 %160 = OpCompositeExtract %float %157 2 %161 = OpCompositeExtract %float %157 3 %162 = OpCompositeExtract %uint %151 0 %163 = OpCompositeExtract %uint %151 1 %164 = OpIAdd %uint %84 %162 %165 = OpULessThan %bool %84 %163 %166 = OpSelect %uint %165 %164 %uint_4294967295 %167 = OpCompositeConstruct %v4float %158 %159 %160 %161 OpImageWrite %149 %166 %167 %168 = OpIAdd %uint %69 %uint_0 %170 = OpAccessChain %_ptr_PushConstant_uint %registers %uint_1 %171 = OpLoad %uint %170 %172 = OpIAdd %uint %171 %168 %169 = OpAccessChain %_ptr_UniformConstant_15 %18 %172 %173 = OpLoad %15 %169 %174 = OpAccessChain %_ptr_StorageBuffer_v2uint %13 %uint_0 %172 %175 = OpLoad %v2uint %174 %176 = OpCompositeExtract %uint %175 0 %177 = OpCompositeExtract %uint %175 1 %178 = OpIAdd %uint %70 %176 %179 = OpULessThan %bool %70 %177 %180 = OpSelect %uint %179 %178 %uint_4294967295 %181 = OpImageFetch %v4float %173 %180 %182 = OpCompositeExtract %float %181 0 %183 = OpCompositeExtract %float %181 1 %184 = OpCompositeExtract %float %181 2 %185 = OpCompositeExtract %float %181 3 %186 = OpCompositeExtract %uint %151 0 %187 = OpCompositeExtract %uint %151 1 %188 = OpIAdd %uint %103 %186 %189 = OpULessThan %bool %103 %187 %190 = OpSelect %uint %189 %188 %uint_4294967295 %191 = OpCompositeConstruct %v4float %182 %183 %184 %185 OpImageWrite %149 %190 %191 %192 = OpIAdd %uint %69 %uint_0 %194 = OpAccessChain %_ptr_PushConstant_uint %registers %uint_4 %195 = OpLoad %uint %194 %196 = OpIAdd %uint %195 %192 %193 = OpAccessChain %_ptr_UniformConstant_23 %26 %196 %197 = OpLoad %23 %193 %198 = OpAccessChain %_ptr_StorageBuffer_v2uint %13 %uint_0 %196 %199 = OpLoad %v2uint %198 %200 = OpCompositeExtract %uint %199 0 %201 = OpCompositeExtract %uint %199 1 %202 = OpIAdd %uint %67 %200 %203 = OpULessThan %bool %67 %201 %204 = OpSelect %uint %203 %202 %uint_4294967295 %205 = OpImageTexelPointer %_ptr_Image_uint %193 %204 %uint_0 %206 = OpAtomicIAdd %uint %205 %uint_1 %uint_0 %uint_40 %207 = OpCompositeExtract %uint %199 0 %208 = OpCompositeExtract %uint %199 1 %209 = OpIAdd %uint %67 %207 %210 = OpULessThan %bool %67 %208 %211 = OpSelect %uint %210 %209 %uint_4294967295 %212 = OpImageTexelPointer %_ptr_Image_uint %193 %211 %uint_0 %213 = OpAtomicCompareExchange %uint %212 %uint_1 %uint_0 %uint_0 %uint_70 %uint_40 %215 = OpCompositeExtract %uint %151 1 %216 = OpConvertUToF %float %215 %217 = OpCompositeExtract %uint %49 0 %218 = OpCompositeExtract %uint %49 1 %219 = OpIAdd %uint %uint_2 %217 %220 = OpULessThan %bool %uint_2 %218 %221 = OpSelect %uint %220 %219 %uint_4294967295 %222 = OpCompositeConstruct %v4float %216 %216 %216 %216 OpImageWrite %46 %221 %222 %223 = OpCompositeExtract %uint %175 1 %224 = OpConvertUToF %float %223 %225 = OpCompositeExtract %uint %49 0 %226 = OpCompositeExtract %uint %49 1 %227 = OpIAdd %uint %uint_3 %225 %228 = OpULessThan %bool %uint_3 %226 %229 = OpSelect %uint %228 %227 %uint_4294967295 %230 = OpCompositeConstruct %v4float %224 %224 %224 %224 OpImageWrite %46 %229 %230 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/phi-temporary-copy-loop-variable.asm.invalid.comp000066400000000000000000000054001400026215700323400ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 42 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %cs_test "main" %gl_GlobalInvocationID %gl_LocalInvocationIndex OpExecutionMode %cs_test LocalSize 8 8 1 OpSource HLSL 600 OpName %type_2d_image "type.2d.image" OpName %outImageTexture "outImageTexture" OpName %cs_test "cs_test" OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationIndex BuiltIn LocalInvocationIndex OpDecorate %outImageTexture DescriptorSet 0 OpDecorate %outImageTexture Binding 1 %float = OpTypeFloat 32 %float_5 = OpConstant %float 5 %float_1 = OpConstant %float 1 %int = OpTypeInt 32 1 %int_7 = OpConstant %int 7 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %type_2d_image = OpTypeImage %float 2D 2 0 0 2 Rgba32f %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Input_uint = OpTypePointer Input %uint %void = OpTypeVoid %19 = OpTypeFunction %void %v2uint = OpTypeVector %uint 2 %v4float = OpTypeVector %float 4 %bool = OpTypeBool %outImageTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationIndex = OpVariable %_ptr_Input_uint Input %cs_test = OpFunction %void None %19 %23 = OpLabel %24 = OpLoad %v3uint %gl_GlobalInvocationID %25 = OpVectorShuffle %v2uint %24 %24 0 1 OpBranch %26 %26 = OpLabel %27 = OpPhi %int %int_7 %23 %28 %29 %30 = OpPhi %int %int_7 %23 %27 %29 %31 = OpSGreaterThanEqual %bool %27 %int_0 OpLoopMerge %32 %29 None OpBranchConditional %31 %33 %32 %33 = OpLabel %34 = OpConvertSToF %float %27 %35 = OpFOrdGreaterThan %bool %float_5 %34 OpSelectionMerge %29 None OpBranchConditional %35 %36 %29 %36 = OpLabel OpBranch %32 %29 = OpLabel %28 = OpISub %int %27 %int_1 OpBranch %26 %32 = OpLabel %37 = OpISub %int %30 %int_1 %38 = OpConvertSToF %float %37 %39 = OpConvertSToF %float %30 %40 = OpCompositeConstruct %v4float %38 %39 %float_1 %float_1 %41 = OpLoad %type_2d_image %outImageTexture OpImageWrite %41 %25 %40 None OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/spec-constant-op-convert-sign.asm.comp000066400000000000000000000053061400026215700302270ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 30 ; Schema: 0 OpCapability Shader OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_ARB_gpu_shader_int64" OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "s64" OpMemberName %SSBO 1 "u64" OpName %_ "" OpName %ConstantInt "ConstantInt" OpName %ConstantInt64_1 "ConstantInt64_1" OpName %ConstantUint "ConstantUint" OpName %ConstantInt64_2 "ConstantInt64_2" OpName %ConstantUint64_1 "ConstantUint64_1" OpName %ConstantUint64_2 "ConstantUint64_2" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %ConstantInt SpecId 0 OpDecorate %ConstantUint SpecId 1 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %long = OpTypeInt 64 1 %ulong = OpTypeInt 64 0 %SSBO = OpTypeStruct %int %uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int_0 = OpConstant %int 0 %ulong_0 = OpConstant %ulong 0 %ConstantInt = OpSpecConstant %int 1 %ConstantUint = OpSpecConstant %uint 2 %ConstantInt64_1 = OpSpecConstantOp %long SConvert %ConstantInt %ConstantInt64_2 = OpSpecConstantOp %long SConvert %ConstantUint %ConstantUint64_1 = OpSpecConstantOp %ulong SConvert %ConstantInt %ConstantUint64_2 = OpSpecConstantOp %ulong SConvert %ConstantUint %added_long = OpSpecConstantOp %long IAdd %ConstantInt64_1 %ConstantInt64_2 %added_ulong = OpSpecConstantOp %ulong IAdd %ConstantUint64_1 %ConstantUint64_2 %trunc_long = OpSpecConstantOp %int SConvert %added_long %trunc_ulong = OpSpecConstantOp %uint SConvert %added_ulong %_ptr_Uniform_int = OpTypePointer Uniform %int %int_1 = OpConstant %int 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %main = OpFunction %void None %3 %5 = OpLabel %22 = OpAccessChain %_ptr_Uniform_int %_ %int_0 OpStore %22 %trunc_long %29 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 OpStore %29 %trunc_ulong OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/comp/storage-buffer-basic.asm.comp000066400000000000000000000047031400026215700264100ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Codeplay; 0 ; Bound: 31 ; Schema: 0 OpCapability Shader ;OpCapability VariablePointers OpExtension "SPV_KHR_storage_buffer_storage_class" ;OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %22 "main" %gl_WorkGroupID OpSource OpenCL_C 120 OpDecorate %15 SpecId 0 ;OpDecorate %16 SpecId 1 OpDecorate %17 SpecId 2 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_4 0 Offset 0 OpDecorate %_struct_4 Block OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize OpDecorate %20 DescriptorSet 0 OpDecorate %20 Binding 0 OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 %float = OpTypeFloat 32 %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_runtimearr_float = OpTypeRuntimeArray %float %_struct_4 = OpTypeStruct %_runtimearr_float %_ptr_StorageBuffer__struct_4 = OpTypePointer StorageBuffer %_struct_4 %uint = OpTypeInt 32 0 %void = OpTypeVoid %8 = OpTypeFunction %void %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Private_v3uint = OpTypePointer Private %v3uint %uint_0 = OpConstant %uint 0 %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %15 = OpSpecConstant %uint 1 %16 = OpConstant %uint 2 %17 = OpSpecConstant %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %15 %16 %17 %19 = OpVariable %_ptr_Private_v3uint Private %gl_WorkGroupSize %20 = OpVariable %_ptr_StorageBuffer__struct_4 StorageBuffer %21 = OpVariable %_ptr_StorageBuffer__struct_4 StorageBuffer %22 = OpFunction %void None %8 %23 = OpLabel %24 = OpAccessChain %_ptr_Input_uint %gl_WorkGroupID %uint_0 %25 = OpLoad %uint %24 %26 = OpAccessChain %_ptr_StorageBuffer_float %21 %uint_0 %25 %27 = OpLoad %float %26 %28 = OpAccessChain %_ptr_StorageBuffer_float %20 %uint_0 %25 %29 = OpLoad %float %28 %30 = OpFAdd %float %27 %29 OpStore %28 %30 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/000077500000000000000000000000001400026215700207345ustar00rootroot00000000000000combined-image-sampler-dxc-min16float.asm.invalid.frag000066400000000000000000000103561400026215700327620ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/frag; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 48 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "main" %in_var_COLOR %in_var_TEXCOORD0 %out_var_SV_TARGET OpExecutionMode %PSMain OriginUpperLeft ; Not actually ESSL, but makes testing easier. OpSource ESSL 310 OpName %type_2d_image "type.2d.image" OpName %tex "tex" OpName %type_sampler "type.sampler" OpName %Samp "Samp" OpName %in_var_COLOR "in.var.COLOR" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %PSMain "PSMain" OpName %PSInput "PSInput" OpMemberName %PSInput 0 "color" OpMemberName %PSInput 1 "uv" OpName %param_var_input "param.var.input" OpName %src_PSMain "src.PSMain" OpName %input "input" OpName %bb_entry "bb.entry" OpName %a "a" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_COLOR Location 0 OpDecorate %in_var_TEXCOORD0 Location 1 OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %tex DescriptorSet 0 OpDecorate %tex Binding 0 OpDecorate %Samp DescriptorSet 0 OpDecorate %Samp Binding 1 OpDecorate %tex RelaxedPrecision OpDecorate %a RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %47 RelaxedPrecision %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %21 = OpTypeFunction %void %PSInput = OpTypeStruct %v4float %v2float %_ptr_Function_PSInput = OpTypePointer Function %PSInput %31 = OpTypeFunction %v4float %_ptr_Function_PSInput %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_v2float = OpTypePointer Function %v2float %type_sampled_image = OpTypeSampledImage %type_2d_image %tex = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %Samp = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %PSMain = OpFunction %void None %21 %22 = OpLabel %param_var_input = OpVariable %_ptr_Function_PSInput Function %26 = OpLoad %v4float %in_var_COLOR %27 = OpLoad %v2float %in_var_TEXCOORD0 %28 = OpCompositeConstruct %PSInput %26 %27 OpStore %param_var_input %28 %29 = OpFunctionCall %v4float %src_PSMain %param_var_input OpStore %out_var_SV_TARGET %29 OpReturn OpFunctionEnd %src_PSMain = OpFunction %v4float None %31 %input = OpFunctionParameter %_ptr_Function_PSInput %bb_entry = OpLabel %a = OpVariable %_ptr_Function_v4float Function %36 = OpAccessChain %_ptr_Function_v4float %input %int_0 %37 = OpLoad %v4float %36 %38 = OpLoad %type_2d_image %tex %39 = OpLoad %type_sampler %Samp %41 = OpAccessChain %_ptr_Function_v2float %input %int_1 %42 = OpLoad %v2float %41 %44 = OpSampledImage %type_sampled_image %38 %39 %45 = OpImageSampleImplicitLod %v4float %44 %42 None %46 = OpFMul %v4float %37 %45 OpStore %a %46 %47 = OpLoad %v4float %a OpReturnValue %47 OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/demote-impure-function-call.vk.nocompat.asm.frag000066400000000000000000000047041400026215700321270ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 33 ; Schema: 0 OpCapability Shader OpCapability DemoteToHelperInvocationEXT OpExtension "SPV_EXT_demote_to_helper_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vA %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_demote_to_helper_invocation" OpName %main "main" OpName %foobar_i1_ "foobar(i1;" OpName %a "a" OpName %a_0 "a" OpName %vA "vA" OpName %param "param" OpName %FragColor "FragColor" OpDecorate %vA Flat OpDecorate %vA Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %10 = OpTypeFunction %v4float %_ptr_Function_int %int_0 = OpConstant %int 0 %bool = OpTypeBool %float_10 = OpConstant %float 10 %21 = OpConstantComposite %v4float %float_10 %float_10 %float_10 %float_10 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_int = OpTypePointer Input %int %vA = OpVariable %_ptr_Input_int Input %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %a_0 = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_int Function %29 = OpLoad %int %vA OpStore %param %29 %30 = OpFunctionCall %v4float %foobar_i1_ %param OpStore %FragColor %21 OpReturn OpFunctionEnd %foobar_i1_ = OpFunction %v4float None %10 %a = OpFunctionParameter %_ptr_Function_int %13 = OpLabel %14 = OpLoad %int %a %17 = OpSLessThan %bool %14 %int_0 OpSelectionMerge %19 None OpBranchConditional %17 %18 %19 %18 = OpLabel OpDemoteToHelperInvocationEXT OpBranch %19 %19 = OpLabel OpReturnValue %21 OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/discard-impure-function-call.asm.frag000066400000000000000000000043221400026215700300210ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 34 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vA %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %foobar_i1_ "foobar(i1;" OpName %a "a" OpName %a_0 "a" OpName %vA "vA" OpName %param "param" OpName %FragColor "FragColor" OpDecorate %vA Flat OpDecorate %vA Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %10 = OpTypeFunction %v4float %_ptr_Function_int %int_0 = OpConstant %int 0 %bool = OpTypeBool %float_10 = OpConstant %float 10 %22 = OpConstantComposite %v4float %float_10 %float_10 %float_10 %float_10 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_int = OpTypePointer Input %int %vA = OpVariable %_ptr_Input_int Input %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %a_0 = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_int Function %30 = OpLoad %int %vA OpStore %param %30 %31 = OpFunctionCall %v4float %foobar_i1_ %param OpStore %FragColor %22 OpReturn OpFunctionEnd %foobar_i1_ = OpFunction %v4float None %10 %a = OpFunctionParameter %_ptr_Function_int %13 = OpLabel %14 = OpLoad %int %a %17 = OpSLessThan %bool %14 %int_0 OpSelectionMerge %19 None OpBranchConditional %17 %18 %19 %18 = OpLabel OpKill %19 = OpLabel OpReturnValue %22 OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/do-while-continue-phi.asm.invalid.frag000066400000000000000000000044601400026215700301150ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 42 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %_GLF_color OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %gl_FragCoord "gl_FragCoord" OpName %_GLF_color "_GLF_color" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_GLF_color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %bool = OpTypeBool %false = OpConstantFalse %bool %_ptr_Output_v4float = OpTypePointer Output %v4float %_GLF_color = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %31 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %true = OpConstantTrue %bool %main = OpFunction %void None %3 %5 = OpLabel OpBranch %33 %33 = OpLabel OpLoopMerge %32 %35 None OpBranch %6 %6 = OpLabel OpLoopMerge %8 %24 None OpBranch %7 %7 = OpLabel %17 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %18 = OpLoad %float %17 %22 = OpFOrdNotEqual %bool %18 %18 OpSelectionMerge %24 None OpBranchConditional %22 %23 %24 %23 = OpLabel OpBranch %8 %24 = OpLabel OpBranchConditional %false %6 %8 %8 = OpLabel %41 = OpPhi %bool %true %23 %false %24 OpSelectionMerge %39 None OpBranchConditional %41 %32 %39 %39 = OpLabel OpStore %_GLF_color %31 OpBranch %32 %35 = OpLabel OpBranch %33 %32 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/do-while-loop-inverted-test.asm.frag000066400000000000000000000032111400026215700276230ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %i "i" OpName %j "j" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_20 = OpConstant %int 20 %bool = OpTypeBool %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpStore %j %int_0 OpBranch %11 %11 = OpLabel OpLoopMerge %13 %14 None OpBranch %12 %12 = OpLabel %15 = OpLoad %int %j %16 = OpLoad %int %i %17 = OpIAdd %int %15 %16 %19 = OpIAdd %int %17 %int_1 %20 = OpLoad %int %j %21 = OpIMul %int %19 %20 OpStore %j %21 %22 = OpLoad %int %i %23 = OpIAdd %int %22 %int_1 OpStore %i %23 OpBranch %14 %14 = OpLabel %24 = OpLoad %int %i %27 = OpIEqual %bool %24 %int_20 OpBranchConditional %27 %13 %11 %13 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/early-conditional-return-switch.asm.frag000066400000000000000000000140111400026215700306020ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Google spiregg; 0 ; Bound: 81 ; Schema: 0 OpCapability Shader OpCapability Sampled1D OpCapability Image1D OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PsTextureLoadArray "main" %gl_FragCoord %out_var_SV_TARGET OpExecutionMode %PsTextureLoadArray OriginUpperLeft OpSource HLSL 500 OpName %type_2d_image "type.2d.image" OpName %type_gCBuffarrayIndex "type.gCBuffarrayIndex" OpMemberName %type_gCBuffarrayIndex 0 "gArrayIndex" OpName %gCBuffarrayIndex "gCBuffarrayIndex" OpName %g_textureArray0 "g_textureArray0" OpName %g_textureArray1 "g_textureArray1" OpName %g_textureArray2 "g_textureArray2" OpName %g_textureArray3 "g_textureArray3" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %PsTextureLoadArray "PsTextureLoadArray" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %gCBuffarrayIndex DescriptorSet 0 OpDecorate %gCBuffarrayIndex Binding 0 OpDecorate %g_textureArray0 DescriptorSet 0 OpDecorate %g_textureArray0 Binding 0 OpDecorate %g_textureArray1 DescriptorSet 0 OpDecorate %g_textureArray1 Binding 1 OpDecorate %g_textureArray2 DescriptorSet 0 OpDecorate %g_textureArray2 Binding 2 OpDecorate %g_textureArray3 DescriptorSet 0 OpDecorate %g_textureArray3 Binding 3 OpMemberDecorate %type_gCBuffarrayIndex 0 Offset 0 OpDecorate %type_gCBuffarrayIndex Block %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %v4float = OpTypeVector %float 4 %18 = OpConstantComposite %v4float %float_0 %float_1 %float_0 %float_1 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_gCBuffarrayIndex = OpTypeStruct %uint %_ptr_Uniform_type_gCBuffarrayIndex = OpTypePointer Uniform %type_gCBuffarrayIndex %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %24 = OpTypeFunction %void %_ptr_Uniform_uint = OpTypePointer Uniform %uint %v3int = OpTypeVector %int 3 %v2int = OpTypeVector %int 2 %gCBuffarrayIndex = OpVariable %_ptr_Uniform_type_gCBuffarrayIndex Uniform %g_textureArray0 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_textureArray1 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_textureArray2 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_textureArray3 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %false = OpConstantFalse %bool %true = OpConstantTrue %bool %32 = OpUndef %v4float %PsTextureLoadArray = OpFunction %void None %24 %33 = OpLabel %34 = OpLoad %v4float %gl_FragCoord OpSelectionMerge %35 None OpSwitch %uint_0 %36 %36 = OpLabel %37 = OpAccessChain %_ptr_Uniform_uint %gCBuffarrayIndex %int_0 %38 = OpLoad %uint %37 OpSelectionMerge %39 None OpSwitch %38 %40 0 %41 1 %42 2 %43 3 %44 %41 = OpLabel %45 = OpCompositeExtract %float %34 0 %46 = OpCompositeExtract %float %34 1 %47 = OpConvertFToS %int %45 %48 = OpConvertFToS %int %46 %49 = OpCompositeConstruct %v3int %47 %48 %int_0 %50 = OpVectorShuffle %v2int %49 %49 0 1 %51 = OpLoad %type_2d_image %g_textureArray0 %52 = OpImageFetch %v4float %51 %50 Lod %int_0 OpBranch %39 %42 = OpLabel %53 = OpCompositeExtract %float %34 0 %54 = OpCompositeExtract %float %34 1 %55 = OpConvertFToS %int %53 %56 = OpConvertFToS %int %54 %57 = OpCompositeConstruct %v3int %55 %56 %int_0 %58 = OpVectorShuffle %v2int %57 %57 0 1 %59 = OpLoad %type_2d_image %g_textureArray1 %60 = OpImageFetch %v4float %59 %58 Lod %int_0 OpBranch %39 %43 = OpLabel %61 = OpCompositeExtract %float %34 0 %62 = OpCompositeExtract %float %34 1 %63 = OpConvertFToS %int %61 %64 = OpConvertFToS %int %62 %65 = OpCompositeConstruct %v3int %63 %64 %int_0 %66 = OpVectorShuffle %v2int %65 %65 0 1 %67 = OpLoad %type_2d_image %g_textureArray2 %68 = OpImageFetch %v4float %67 %66 Lod %int_0 OpBranch %39 %44 = OpLabel %69 = OpCompositeExtract %float %34 0 %70 = OpCompositeExtract %float %34 1 %71 = OpConvertFToS %int %69 %72 = OpConvertFToS %int %70 %73 = OpCompositeConstruct %v3int %71 %72 %int_0 %74 = OpVectorShuffle %v2int %73 %73 0 1 %75 = OpLoad %type_2d_image %g_textureArray3 %76 = OpImageFetch %v4float %75 %74 Lod %int_0 OpBranch %39 %40 = OpLabel OpBranch %39 %39 = OpLabel %77 = OpPhi %v4float %52 %41 %60 %42 %68 %43 %76 %44 %32 %40 %78 = OpPhi %bool %true %41 %true %42 %true %43 %true %44 %false %40 OpSelectionMerge %79 None OpBranchConditional %78 %35 %79 %79 = OpLabel OpBranch %35 %35 = OpLabel %80 = OpPhi %v4float %77 %39 %18 %79 OpStore %out_var_SV_TARGET %80 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/empty-struct-in-struct.asm.frag000066400000000000000000000046141400026215700267670ustar00rootroot00000000000000; SPIR-V ; Version: 1.2 ; Generator: Khronos; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %EntryPoint_Main "main" OpExecutionMode %EntryPoint_Main OriginUpperLeft OpSource Unknown 100 OpName %EmptyStructTest "EmptyStructTest" OpName %EmptyStruct2Test "EmptyStruct2Test" OpName %GetValue "GetValue" OpName %GetValue2 "GetValue" OpName %self "self" OpName %self2 "self" OpName %emptyStruct "emptyStruct" OpName %value "value" OpName %EntryPoint_Main "EntryPoint_Main" %EmptyStructTest = OpTypeStruct %EmptyStruct2Test = OpTypeStruct %EmptyStructTest %_ptr_Function_EmptyStruct2Test = OpTypePointer Function %EmptyStruct2Test %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %5 = OpTypeFunction %float %_ptr_Function_EmptyStruct2Test %6 = OpTypeFunction %float %EmptyStruct2Test %void = OpTypeVoid %_ptr_Function_void = OpTypePointer Function %void %8 = OpTypeFunction %void %_ptr_Function_EmptyStruct2Test %9 = OpTypeFunction %void %float_0 = OpConstant %float 0 %value4 = OpConstantNull %EmptyStruct2Test %GetValue = OpFunction %float None %5 %self = OpFunctionParameter %_ptr_Function_EmptyStruct2Test %13 = OpLabel OpReturnValue %float_0 OpFunctionEnd %GetValue2 = OpFunction %float None %6 %self2 = OpFunctionParameter %EmptyStruct2Test %14 = OpLabel OpReturnValue %float_0 OpFunctionEnd %EntryPoint_Main = OpFunction %void None %9 %37 = OpLabel %emptyStruct = OpVariable %_ptr_Function_EmptyStruct2Test Function %18 = OpVariable %_ptr_Function_EmptyStruct2Test Function %value = OpVariable %_ptr_Function_float Function %value2 = OpCompositeConstruct %EmptyStructTest %value3 = OpCompositeConstruct %EmptyStruct2Test %value2 %22 = OpFunctionCall %float %GetValue %emptyStruct %23 = OpFunctionCall %float %GetValue2 %value3 %24 = OpFunctionCall %float %GetValue2 %value4 OpStore %value %22 OpStore %value %23 OpStore %value %24 OpReturn OpFunctionEnd for-loop-dedicated-merge-block-inverted.asm.invalid.frag000066400000000000000000000022561400026215700333730ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/frag OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel %10 = OpPhi %int %12 %7 %int_0 %5 OpLoopMerge %6 %7 None OpBranch %11 %11 = OpLabel %16 = OpIEqual %bool %10 %int_16 OpBranchConditional %16 %18 %19 %18 = OpLabel OpBranch %6 %19 = OpLabel OpBranch %17 %17 = OpLabel %21 = OpIAdd %int %10 %int_1 OpBranch %7 %7 = OpLabel %12 = OpPhi %int %21 %17 OpBranch %8 %6 = OpLabel OpReturn OpFunctionEnd for-loop-dedicated-merge-block-non-inverted.asm.invalid.frag000066400000000000000000000022611400026215700341570ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/frag OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel %10 = OpPhi %int %12 %7 %int_0 %5 OpLoopMerge %6 %7 None OpBranch %11 %11 = OpLabel %16 = OpINotEqual %bool %10 %int_16 OpBranchConditional %16 %19 %18 %18 = OpLabel OpBranch %6 %19 = OpLabel OpBranch %17 %17 = OpLabel %21 = OpIAdd %int %10 %int_1 OpBranch %7 %7 = OpLabel %12 = OpPhi %int %21 %17 OpBranch %8 %6 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/for-loop-inverted-test.asm.frag000066400000000000000000000021731400026215700267070ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel %10 = OpPhi %int %12 %7 %int_0 %5 OpLoopMerge %6 %7 None OpBranch %11 %11 = OpLabel %16 = OpIEqual %bool %10 %int_16 OpBranchConditional %16 %6 %19 %19 = OpLabel OpBranch %17 %17 = OpLabel %21 = OpIAdd %int %10 %int_1 OpBranch %7 %7 = OpLabel %12 = OpPhi %int %21 %17 OpBranch %8 %6 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/image-fetch-uint-coord.asm.frag000066400000000000000000000035171400026215700266140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 29 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_TEXCOORD0 %out_var_SV_Target0 OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_2d_image "type.2d.image" OpName %Tex "Tex" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %main "main" OpDecorate %in_var_TEXCOORD0 Flat OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %Tex DescriptorSet 0 OpDecorate %Tex Binding 0 %int = OpTypeInt 32 1 %int_2 = OpConstant %int 2 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %16 = OpTypeFunction %void %Tex = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v3uint Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %16 %19 = OpLabel %20 = OpLoad %v3uint %in_var_TEXCOORD0 %21 = OpCompositeExtract %uint %20 2 %27 = OpLoad %type_2d_image %Tex %28 = OpImageFetch %v4float %27 %20 Lod %21 OpStore %out_var_SV_Target0 %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/inliner-dominator-inside-loop.asm.frag000066400000000000000000001006141400026215700302300ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 1532 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %IN_HPosition %IN_Uv_EdgeDistance1 %IN_UvStuds_EdgeDistance2 %IN_Color %IN_LightPosition_Fog %IN_View_Depth %IN_Normal_SpecPower %IN_Tangent %IN_PosLightSpace_Reflectance %IN_studIndex %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %VertexOutput "VertexOutput" OpMemberName %VertexOutput 0 "HPosition" OpMemberName %VertexOutput 1 "Uv_EdgeDistance1" OpMemberName %VertexOutput 2 "UvStuds_EdgeDistance2" OpMemberName %VertexOutput 3 "Color" OpMemberName %VertexOutput 4 "LightPosition_Fog" OpMemberName %VertexOutput 5 "View_Depth" OpMemberName %VertexOutput 6 "Normal_SpecPower" OpMemberName %VertexOutput 7 "Tangent" OpMemberName %VertexOutput 8 "PosLightSpace_Reflectance" OpMemberName %VertexOutput 9 "studIndex" OpName %Surface "Surface" OpMemberName %Surface 0 "albedo" OpMemberName %Surface 1 "normal" OpMemberName %Surface 2 "specular" OpMemberName %Surface 3 "gloss" OpMemberName %Surface 4 "reflectance" OpMemberName %Surface 5 "opacity" OpName %SurfaceInput "SurfaceInput" OpMemberName %SurfaceInput 0 "Color" OpMemberName %SurfaceInput 1 "Uv" OpMemberName %SurfaceInput 2 "UvStuds" OpName %Globals "Globals" OpMemberName %Globals 0 "ViewProjection" OpMemberName %Globals 1 "ViewRight" OpMemberName %Globals 2 "ViewUp" OpMemberName %Globals 3 "ViewDir" OpMemberName %Globals 4 "CameraPosition" OpMemberName %Globals 5 "AmbientColor" OpMemberName %Globals 6 "Lamp0Color" OpMemberName %Globals 7 "Lamp0Dir" OpMemberName %Globals 8 "Lamp1Color" OpMemberName %Globals 9 "FogParams" OpMemberName %Globals 10 "FogColor" OpMemberName %Globals 11 "LightBorder" OpMemberName %Globals 12 "LightConfig0" OpMemberName %Globals 13 "LightConfig1" OpMemberName %Globals 14 "LightConfig2" OpMemberName %Globals 15 "LightConfig3" OpMemberName %Globals 16 "RefractionBias_FadeDistance_GlowFactor" OpMemberName %Globals 17 "OutlineBrightness_ShadowInfo" OpMemberName %Globals 18 "ShadowMatrix0" OpMemberName %Globals 19 "ShadowMatrix1" OpMemberName %Globals 20 "ShadowMatrix2" OpName %CB0 "CB0" OpMemberName %CB0 0 "CB0" OpName %_ "" OpName %LightMapTexture "LightMapTexture" OpName %LightMapSampler "LightMapSampler" OpName %ShadowMapSampler "ShadowMapSampler" OpName %ShadowMapTexture "ShadowMapTexture" OpName %EnvironmentMapTexture "EnvironmentMapTexture" OpName %EnvironmentMapSampler "EnvironmentMapSampler" OpName %IN_HPosition "IN.HPosition" OpName %IN_Uv_EdgeDistance1 "IN.Uv_EdgeDistance1" OpName %IN_UvStuds_EdgeDistance2 "IN.UvStuds_EdgeDistance2" OpName %IN_Color "IN.Color" OpName %IN_LightPosition_Fog "IN.LightPosition_Fog" OpName %IN_View_Depth "IN.View_Depth" OpName %IN_Normal_SpecPower "IN.Normal_SpecPower" OpName %IN_Tangent "IN.Tangent" OpName %IN_PosLightSpace_Reflectance "IN.PosLightSpace_Reflectance" OpName %IN_studIndex "IN.studIndex" OpName %_entryPointOutput "@entryPointOutput" OpName %DiffuseMapSampler "DiffuseMapSampler" OpName %DiffuseMapTexture "DiffuseMapTexture" OpName %NormalMapSampler "NormalMapSampler" OpName %NormalMapTexture "NormalMapTexture" OpName %NormalDetailMapTexture "NormalDetailMapTexture" OpName %NormalDetailMapSampler "NormalDetailMapSampler" OpName %StudsMapTexture "StudsMapTexture" OpName %StudsMapSampler "StudsMapSampler" OpName %SpecularMapSampler "SpecularMapSampler" OpName %SpecularMapTexture "SpecularMapTexture" OpName %Params "Params" OpMemberName %Params 0 "LqmatFarTilingFactor" OpName %CB2 "CB2" OpMemberName %CB2 0 "CB2" OpMemberDecorate %Globals 0 ColMajor OpMemberDecorate %Globals 0 Offset 0 OpMemberDecorate %Globals 0 MatrixStride 16 OpMemberDecorate %Globals 1 Offset 64 OpMemberDecorate %Globals 2 Offset 80 OpMemberDecorate %Globals 3 Offset 96 OpMemberDecorate %Globals 4 Offset 112 OpMemberDecorate %Globals 5 Offset 128 OpMemberDecorate %Globals 6 Offset 144 OpMemberDecorate %Globals 7 Offset 160 OpMemberDecorate %Globals 8 Offset 176 OpMemberDecorate %Globals 9 Offset 192 OpMemberDecorate %Globals 10 Offset 208 OpMemberDecorate %Globals 11 Offset 224 OpMemberDecorate %Globals 12 Offset 240 OpMemberDecorate %Globals 13 Offset 256 OpMemberDecorate %Globals 14 Offset 272 OpMemberDecorate %Globals 15 Offset 288 OpMemberDecorate %Globals 16 Offset 304 OpMemberDecorate %Globals 17 Offset 320 OpMemberDecorate %Globals 18 Offset 336 OpMemberDecorate %Globals 19 Offset 352 OpMemberDecorate %Globals 20 Offset 368 OpMemberDecorate %CB0 0 Offset 0 OpDecorate %CB0 Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %LightMapTexture DescriptorSet 1 OpDecorate %LightMapTexture Binding 6 OpDecorate %LightMapSampler DescriptorSet 1 OpDecorate %LightMapSampler Binding 6 OpDecorate %ShadowMapSampler DescriptorSet 1 OpDecorate %ShadowMapSampler Binding 1 OpDecorate %ShadowMapTexture DescriptorSet 1 OpDecorate %ShadowMapTexture Binding 1 OpDecorate %EnvironmentMapTexture DescriptorSet 1 OpDecorate %EnvironmentMapTexture Binding 2 OpDecorate %EnvironmentMapSampler DescriptorSet 1 OpDecorate %EnvironmentMapSampler Binding 2 OpDecorate %IN_HPosition BuiltIn FragCoord OpDecorate %IN_Uv_EdgeDistance1 Location 0 OpDecorate %IN_UvStuds_EdgeDistance2 Location 1 OpDecorate %IN_Color Location 2 OpDecorate %IN_LightPosition_Fog Location 3 OpDecorate %IN_View_Depth Location 4 OpDecorate %IN_Normal_SpecPower Location 5 OpDecorate %IN_Tangent Location 6 OpDecorate %IN_PosLightSpace_Reflectance Location 7 OpDecorate %IN_studIndex Location 8 OpDecorate %_entryPointOutput Location 0 OpDecorate %DiffuseMapSampler DescriptorSet 1 OpDecorate %DiffuseMapSampler Binding 3 OpDecorate %DiffuseMapTexture DescriptorSet 1 OpDecorate %DiffuseMapTexture Binding 3 OpDecorate %NormalMapSampler DescriptorSet 1 OpDecorate %NormalMapSampler Binding 4 OpDecorate %NormalMapTexture DescriptorSet 1 OpDecorate %NormalMapTexture Binding 4 OpDecorate %NormalDetailMapTexture DescriptorSet 1 OpDecorate %NormalDetailMapTexture Binding 8 OpDecorate %NormalDetailMapSampler DescriptorSet 1 OpDecorate %NormalDetailMapSampler Binding 8 OpDecorate %StudsMapTexture DescriptorSet 1 OpDecorate %StudsMapTexture Binding 0 OpDecorate %StudsMapSampler DescriptorSet 1 OpDecorate %StudsMapSampler Binding 0 OpDecorate %SpecularMapSampler DescriptorSet 1 OpDecorate %SpecularMapSampler Binding 5 OpDecorate %SpecularMapTexture DescriptorSet 1 OpDecorate %SpecularMapTexture Binding 5 OpMemberDecorate %Params 0 Offset 0 OpMemberDecorate %CB2 0 Offset 0 OpDecorate %CB2 Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %8 = OpTypeFunction %float %_ptr_Function_float %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %v3float = OpTypeVector %float 3 %18 = OpTypeFunction %v3float %_ptr_Function_v4float %_ptr_Function_v3float = OpTypePointer Function %v3float %23 = OpTypeFunction %v4float %_ptr_Function_v3float %27 = OpTypeFunction %float %_ptr_Function_v3float %31 = OpTypeFunction %float %_ptr_Function_float %_ptr_Function_float %36 = OpTypeSampler %_ptr_Function_36 = OpTypePointer Function %36 %38 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_Function_38 = OpTypePointer Function %38 %40 = OpTypeFunction %float %_ptr_Function_36 %_ptr_Function_38 %_ptr_Function_v3float %_ptr_Function_float %VertexOutput = OpTypeStruct %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v3float %v4float %float %_ptr_Function_VertexOutput = OpTypePointer Function %VertexOutput %Surface = OpTypeStruct %v3float %v3float %float %float %float %float %50 = OpTypeFunction %Surface %_ptr_Function_VertexOutput %54 = OpTypeFunction %v4float %_ptr_Function_VertexOutput %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %60 = OpTypeFunction %v4float %_ptr_Function_36 %_ptr_Function_38 %_ptr_Function_v2float %_ptr_Function_float %_ptr_Function_float %SurfaceInput = OpTypeStruct %v4float %v2float %v2float %_ptr_Function_SurfaceInput = OpTypePointer Function %SurfaceInput %70 = OpTypeFunction %Surface %_ptr_Function_SurfaceInput %_ptr_Function_v2float %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %mat4v4float = OpTypeMatrix %v4float 4 %Globals = OpTypeStruct %mat4v4float %v4float %v4float %v4float %v3float %v3float %v3float %v3float %v3float %v4float %v3float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %CB0 = OpTypeStruct %Globals %_ptr_Uniform_CB0 = OpTypePointer Uniform %CB0 %_ = OpVariable %_ptr_Uniform_CB0 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_15 = OpConstant %int 15 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_14 = OpConstant %int 14 %128 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %133 = OpTypeImage %float 3D 0 0 0 1 Unknown %_ptr_UniformConstant_133 = OpTypePointer UniformConstant %133 %LightMapTexture = OpVariable %_ptr_UniformConstant_133 UniformConstant %_ptr_UniformConstant_36 = OpTypePointer UniformConstant %36 %LightMapSampler = OpVariable %_ptr_UniformConstant_36 UniformConstant %140 = OpTypeSampledImage %133 %int_11 = OpConstant %int 11 %uint = OpTypeInt 32 0 %float_9 = OpConstant %float 9 %float_20 = OpConstant %float 20 %float_0_5 = OpConstant %float 0.5 %183 = OpTypeSampledImage %38 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %int_17 = OpConstant %int 17 %uint_3 = OpConstant %uint 3 %_ptr_Uniform_float = OpTypePointer Uniform %float %float_0_25 = OpConstant %float 0.25 %int_5 = OpConstant %int 5 %float_0_00333333 = OpConstant %float 0.00333333 %int_16 = OpConstant %int 16 %_ptr_Function_Surface = OpTypePointer Function %Surface %int_6 = OpConstant %int 6 %int_7 = OpConstant %int 7 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %int_8 = OpConstant %int 8 %ShadowMapSampler = OpVariable %_ptr_UniformConstant_36 UniformConstant %_ptr_UniformConstant_38 = OpTypePointer UniformConstant %38 %ShadowMapTexture = OpVariable %_ptr_UniformConstant_38 UniformConstant %367 = OpTypeImage %float Cube 0 0 0 1 Unknown %_ptr_UniformConstant_367 = OpTypePointer UniformConstant %367 %EnvironmentMapTexture = OpVariable %_ptr_UniformConstant_367 UniformConstant %EnvironmentMapSampler = OpVariable %_ptr_UniformConstant_36 UniformConstant %373 = OpTypeSampledImage %367 %float_1_5 = OpConstant %float 1.5 %int_10 = OpConstant %int 10 %_ptr_Input_v4float = OpTypePointer Input %v4float %IN_HPosition = OpVariable %_ptr_Input_v4float Input %IN_Uv_EdgeDistance1 = OpVariable %_ptr_Input_v4float Input %IN_UvStuds_EdgeDistance2 = OpVariable %_ptr_Input_v4float Input %IN_Color = OpVariable %_ptr_Input_v4float Input %IN_LightPosition_Fog = OpVariable %_ptr_Input_v4float Input %IN_View_Depth = OpVariable %_ptr_Input_v4float Input %IN_Normal_SpecPower = OpVariable %_ptr_Input_v4float Input %_ptr_Input_v3float = OpTypePointer Input %v3float %IN_Tangent = OpVariable %_ptr_Input_v3float Input %IN_PosLightSpace_Reflectance = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %IN_studIndex = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %bool = OpTypeBool %DiffuseMapSampler = OpVariable %_ptr_UniformConstant_36 UniformConstant %DiffuseMapTexture = OpVariable %_ptr_UniformConstant_38 UniformConstant %NormalMapSampler = OpVariable %_ptr_UniformConstant_36 UniformConstant %NormalMapTexture = OpVariable %_ptr_UniformConstant_38 UniformConstant %NormalDetailMapTexture = OpVariable %_ptr_UniformConstant_38 UniformConstant %NormalDetailMapSampler = OpVariable %_ptr_UniformConstant_36 UniformConstant %float_0_3 = OpConstant %float 0.3 %StudsMapTexture = OpVariable %_ptr_UniformConstant_38 UniformConstant %StudsMapSampler = OpVariable %_ptr_UniformConstant_36 UniformConstant %SpecularMapSampler = OpVariable %_ptr_UniformConstant_36 UniformConstant %SpecularMapTexture = OpVariable %_ptr_UniformConstant_38 UniformConstant %float_0_75 = OpConstant %float 0.75 %float_256 = OpConstant %float 256 %689 = OpConstantComposite %v2float %float_2 %float_256 %float_0_01 = OpConstant %float 0.01 %692 = OpConstantComposite %v2float %float_0 %float_0_01 %float_0_8 = OpConstant %float 0.8 %float_120 = OpConstant %float 120 %697 = OpConstantComposite %v2float %float_0_8 %float_120 %Params = OpTypeStruct %v4float %CB2 = OpTypeStruct %Params %_ptr_Uniform_CB2 = OpTypePointer Uniform %CB2 %false = OpConstantFalse %bool %1509 = OpUndef %VertexOutput %1510 = OpUndef %SurfaceInput %1511 = OpUndef %v2float %1512 = OpUndef %v4float %1531 = OpUndef %Surface %main = OpFunction %void None %3 %5 = OpLabel %501 = OpLoad %v4float %IN_HPosition %1378 = OpCompositeInsert %VertexOutput %501 %1509 0 %504 = OpLoad %v4float %IN_Uv_EdgeDistance1 %1380 = OpCompositeInsert %VertexOutput %504 %1378 1 %507 = OpLoad %v4float %IN_UvStuds_EdgeDistance2 %1382 = OpCompositeInsert %VertexOutput %507 %1380 2 %510 = OpLoad %v4float %IN_Color %1384 = OpCompositeInsert %VertexOutput %510 %1382 3 %513 = OpLoad %v4float %IN_LightPosition_Fog %1386 = OpCompositeInsert %VertexOutput %513 %1384 4 %516 = OpLoad %v4float %IN_View_Depth %1388 = OpCompositeInsert %VertexOutput %516 %1386 5 %519 = OpLoad %v4float %IN_Normal_SpecPower %1390 = OpCompositeInsert %VertexOutput %519 %1388 6 %523 = OpLoad %v3float %IN_Tangent %1392 = OpCompositeInsert %VertexOutput %523 %1390 7 %526 = OpLoad %v4float %IN_PosLightSpace_Reflectance %1394 = OpCompositeInsert %VertexOutput %526 %1392 8 %530 = OpLoad %float %IN_studIndex %1396 = OpCompositeInsert %VertexOutput %530 %1394 9 %1400 = OpCompositeInsert %SurfaceInput %510 %1510 0 %954 = OpVectorShuffle %v2float %504 %504 0 1 %1404 = OpCompositeInsert %SurfaceInput %954 %1400 1 %958 = OpVectorShuffle %v2float %507 %507 0 1 %1408 = OpCompositeInsert %SurfaceInput %958 %1404 2 %1410 = OpCompositeExtract %float %1408 2 1 %962 = OpExtInst %float %1 Fract %1410 %965 = OpFAdd %float %962 %530 %966 = OpFMul %float %965 %float_0_25 %1414 = OpCompositeInsert %SurfaceInput %966 %1408 2 1 %1416 = OpCompositeExtract %float %1396 5 3 %970 = OpFMul %float %1416 %float_0_00333333 %971 = OpFSub %float %float_1 %970 %987 = OpExtInst %float %1 FClamp %971 %float_0 %float_1 %976 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %int_16 %uint_1 %977 = OpLoad %float %976 %978 = OpFMul %float %1416 %977 %979 = OpFSub %float %float_1 %978 %990 = OpExtInst %float %1 FClamp %979 %float_0 %float_1 %1024 = OpVectorTimesScalar %v2float %954 %float_1 %1029 = OpLoad %36 %DiffuseMapSampler %1030 = OpLoad %38 %DiffuseMapTexture OpBranch %1119 %1119 = OpLabel OpLoopMerge %1120 %1121 None OpBranch %1122 %1122 = OpLabel %1124 = OpFOrdEqual %bool %float_0 %float_0 OpSelectionMerge %1125 None OpBranchConditional %1124 %1126 %1127 %1126 = OpLabel %1130 = OpSampledImage %183 %1030 %1029 %1132 = OpImageSampleImplicitLod %v4float %1130 %1024 OpBranch %1120 %1127 = OpLabel %1134 = OpFSub %float %float_1 %float_0 %1135 = OpFDiv %float %float_1 %1134 %1138 = OpSampledImage %183 %1030 %1029 %1140 = OpVectorTimesScalar %v2float %1024 %float_0_25 %1141 = OpImageSampleImplicitLod %v4float %1138 %1140 %1144 = OpSampledImage %183 %1030 %1029 %1146 = OpImageSampleImplicitLod %v4float %1144 %1024 %1149 = OpFMul %float %987 %1135 %1152 = OpFMul %float %float_0 %1135 %1153 = OpFSub %float %1149 %1152 %1161 = OpExtInst %float %1 FClamp %1153 %float_0 %float_1 %1155 = OpCompositeConstruct %v4float %1161 %1161 %1161 %1161 %1156 = OpExtInst %v4float %1 FMix %1141 %1146 %1155 OpBranch %1120 %1125 = OpLabel %1157 = OpUndef %v4float OpBranch %1120 %1121 = OpLabel OpBranchConditional %false %1119 %1120 %1120 = OpLabel %1517 = OpPhi %v4float %1132 %1126 %1156 %1127 %1157 %1125 %1512 %1121 %1035 = OpVectorTimesScalar %v4float %1517 %float_1 %1036 = OpLoad %36 %NormalMapSampler %1037 = OpLoad %38 %NormalMapTexture OpBranch %1165 %1165 = OpLabel OpLoopMerge %1166 %1167 None OpBranch %1168 %1168 = OpLabel OpSelectionMerge %1171 None OpBranchConditional %1124 %1172 %1173 %1172 = OpLabel %1176 = OpSampledImage %183 %1037 %1036 %1178 = OpImageSampleImplicitLod %v4float %1176 %1024 OpBranch %1166 %1173 = OpLabel %1180 = OpFSub %float %float_1 %float_0 %1181 = OpFDiv %float %float_1 %1180 %1184 = OpSampledImage %183 %1037 %1036 %1186 = OpVectorTimesScalar %v2float %1024 %float_0_25 %1187 = OpImageSampleImplicitLod %v4float %1184 %1186 %1190 = OpSampledImage %183 %1037 %1036 %1192 = OpImageSampleImplicitLod %v4float %1190 %1024 %1195 = OpFMul %float %990 %1181 %1198 = OpFMul %float %float_0 %1181 %1199 = OpFSub %float %1195 %1198 %1206 = OpExtInst %float %1 FClamp %1199 %float_0 %float_1 %1201 = OpCompositeConstruct %v4float %1206 %1206 %1206 %1206 %1202 = OpExtInst %v4float %1 FMix %1187 %1192 %1201 OpBranch %1166 %1171 = OpLabel %1203 = OpUndef %v4float OpBranch %1166 %1167 = OpLabel OpBranchConditional %false %1165 %1166 %1166 = OpLabel %1523 = OpPhi %v4float %1178 %1172 %1202 %1173 %1203 %1171 %1512 %1167 %1210 = OpVectorShuffle %v2float %1523 %1523 3 1 %1211 = OpVectorTimesScalar %v2float %1210 %float_2 %1212 = OpCompositeConstruct %v2float %float_1 %float_1 %1213 = OpFSub %v2float %1211 %1212 %1216 = OpFNegate %v2float %1213 %1218 = OpDot %float %1216 %1213 %1219 = OpFAdd %float %float_1 %1218 %1220 = OpExtInst %float %1 FClamp %1219 %float_0 %float_1 %1221 = OpExtInst %float %1 Sqrt %1220 %1222 = OpCompositeExtract %float %1213 0 %1223 = OpCompositeExtract %float %1213 1 %1224 = OpCompositeConstruct %v3float %1222 %1223 %1221 %1042 = OpLoad %38 %NormalDetailMapTexture %1043 = OpLoad %36 %NormalDetailMapSampler %1044 = OpSampledImage %183 %1042 %1043 %1046 = OpVectorTimesScalar %v2float %1024 %float_0 %1047 = OpImageSampleImplicitLod %v4float %1044 %1046 %1228 = OpVectorShuffle %v2float %1047 %1047 3 1 %1229 = OpVectorTimesScalar %v2float %1228 %float_2 %1231 = OpFSub %v2float %1229 %1212 %1234 = OpFNegate %v2float %1231 %1236 = OpDot %float %1234 %1231 %1237 = OpFAdd %float %float_1 %1236 %1238 = OpExtInst %float %1 FClamp %1237 %float_0 %float_1 %1239 = OpExtInst %float %1 Sqrt %1238 %1240 = OpCompositeExtract %float %1231 0 %1241 = OpCompositeExtract %float %1231 1 %1242 = OpCompositeConstruct %v3float %1240 %1241 %1239 %1050 = OpVectorShuffle %v2float %1242 %1242 0 1 %1051 = OpVectorTimesScalar %v2float %1050 %float_0 %1053 = OpVectorShuffle %v2float %1224 %1224 0 1 %1054 = OpFAdd %v2float %1053 %1051 %1056 = OpVectorShuffle %v3float %1224 %1054 3 4 2 %1059 = OpVectorShuffle %v2float %1056 %1056 0 1 %1060 = OpVectorTimesScalar %v2float %1059 %990 %1062 = OpVectorShuffle %v3float %1056 %1060 3 4 2 %1430 = OpCompositeExtract %float %1062 0 %1065 = OpFMul %float %1430 %float_0_3 %1066 = OpFAdd %float %float_1 %1065 %1069 = OpVectorShuffle %v3float %510 %510 0 1 2 %1071 = OpVectorShuffle %v3float %1035 %1035 0 1 2 %1072 = OpFMul %v3float %1069 %1071 %1074 = OpVectorTimesScalar %v3float %1072 %1066 %1075 = OpLoad %38 %StudsMapTexture %1076 = OpLoad %36 %StudsMapSampler %1077 = OpSampledImage %183 %1075 %1076 %1434 = OpCompositeExtract %v2float %1414 2 %1080 = OpImageSampleImplicitLod %v4float %1077 %1434 %1436 = OpCompositeExtract %float %1080 0 %1083 = OpFMul %float %1436 %float_2 %1085 = OpVectorTimesScalar %v3float %1074 %1083 %1086 = OpLoad %36 %SpecularMapSampler %1087 = OpLoad %38 %SpecularMapTexture OpBranch %1246 %1246 = OpLabel OpLoopMerge %1247 %1248 None OpBranch %1249 %1249 = OpLabel %1251 = OpFOrdEqual %bool %float_0_75 %float_0 OpSelectionMerge %1252 None OpBranchConditional %1251 %1253 %1254 %1253 = OpLabel %1257 = OpSampledImage %183 %1087 %1086 %1259 = OpImageSampleImplicitLod %v4float %1257 %1024 OpBranch %1247 %1254 = OpLabel %1261 = OpFSub %float %float_1 %float_0_75 %1262 = OpFDiv %float %float_1 %1261 %1265 = OpSampledImage %183 %1087 %1086 %1267 = OpVectorTimesScalar %v2float %1024 %float_0_25 %1268 = OpImageSampleImplicitLod %v4float %1265 %1267 %1271 = OpSampledImage %183 %1087 %1086 %1273 = OpImageSampleImplicitLod %v4float %1271 %1024 %1276 = OpFMul %float %990 %1262 %1279 = OpFMul %float %float_0_75 %1262 %1280 = OpFSub %float %1276 %1279 %1287 = OpExtInst %float %1 FClamp %1280 %float_0 %float_1 %1282 = OpCompositeConstruct %v4float %1287 %1287 %1287 %1287 %1283 = OpExtInst %v4float %1 FMix %1268 %1273 %1282 OpBranch %1247 %1252 = OpLabel %1284 = OpUndef %v4float OpBranch %1247 %1248 = OpLabel OpBranchConditional %false %1246 %1247 %1247 = OpLabel %1530 = OpPhi %v4float %1259 %1253 %1283 %1254 %1284 %1252 %1512 %1248 %1091 = OpVectorShuffle %v2float %1530 %1530 0 1 %1093 = OpFMul %v2float %1091 %689 %1094 = OpFAdd %v2float %1093 %692 %1097 = OpCompositeConstruct %v2float %990 %990 %1098 = OpExtInst %v2float %1 FMix %697 %1094 %1097 %1438 = OpCompositeInsert %Surface %1085 %1531 0 %1440 = OpCompositeInsert %Surface %1062 %1438 1 %1442 = OpCompositeExtract %float %1098 0 %1444 = OpCompositeInsert %Surface %1442 %1440 2 %1446 = OpCompositeExtract %float %1098 1 %1448 = OpCompositeInsert %Surface %1446 %1444 3 %1450 = OpCompositeExtract %float %1091 1 %1112 = OpFMul %float %1450 %990 %1113 = OpFMul %float %1112 %float_0 %1452 = OpCompositeInsert %Surface %1113 %1448 4 %1456 = OpCompositeExtract %float %1396 3 3 %764 = OpCompositeExtract %float %1085 0 %765 = OpCompositeExtract %float %1085 1 %766 = OpCompositeExtract %float %1085 2 %767 = OpCompositeConstruct %v4float %764 %765 %766 %1456 %770 = OpVectorShuffle %v3float %519 %519 0 1 2 %773 = OpExtInst %v3float %1 Cross %770 %523 %1462 = OpCompositeExtract %float %1452 1 0 %778 = OpVectorTimesScalar %v3float %523 %1462 %1466 = OpCompositeExtract %float %1452 1 1 %782 = OpVectorTimesScalar %v3float %773 %1466 %783 = OpFAdd %v3float %778 %782 %1468 = OpCompositeExtract %float %1452 1 2 %789 = OpVectorTimesScalar %v3float %770 %1468 %790 = OpFAdd %v3float %783 %789 %791 = OpExtInst %v3float %1 Normalize %790 %793 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 %int_7 %794 = OpLoad %v3float %793 %795 = OpFNegate %v3float %794 %796 = OpDot %float %791 %795 %1290 = OpExtInst %float %1 FClamp %796 %float_0 %float_1 %799 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 %int_6 %800 = OpLoad %v3float %799 %801 = OpVectorTimesScalar %v3float %800 %1290 %803 = OpFNegate %float %796 %804 = OpExtInst %float %1 FMax %803 %float_0 %805 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 %int_8 %806 = OpLoad %v3float %805 %807 = OpVectorTimesScalar %v3float %806 %804 %808 = OpFAdd %v3float %801 %807 %810 = OpExtInst %float %1 Step %float_0 %796 %813 = OpFMul %float %810 %1442 %820 = OpVectorShuffle %v3float %513 %513 0 1 2 %1296 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %int_15 %1297 = OpLoad %v4float %1296 %1298 = OpVectorShuffle %v3float %1297 %1297 0 1 2 %1300 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %int_14 %1301 = OpLoad %v4float %1300 %1302 = OpVectorShuffle %v3float %1301 %1301 0 1 2 %1303 = OpFSub %v3float %820 %1302 %1304 = OpExtInst %v3float %1 FAbs %1303 %1305 = OpExtInst %v3float %1 Step %1298 %1304 %1307 = OpDot %float %1305 %128 %1328 = OpExtInst %float %1 FClamp %1307 %float_0 %float_1 %1309 = OpLoad %133 %LightMapTexture %1310 = OpLoad %36 %LightMapSampler %1311 = OpSampledImage %140 %1309 %1310 %1313 = OpVectorShuffle %v3float %820 %820 1 2 0 %1317 = OpVectorTimesScalar %v3float %1313 %1328 %1318 = OpFSub %v3float %1313 %1317 %1319 = OpImageSampleImplicitLod %v4float %1311 %1318 %1321 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %int_11 %1322 = OpLoad %v4float %1321 %1324 = OpCompositeConstruct %v4float %1328 %1328 %1328 %1328 %1325 = OpExtInst %v4float %1 FMix %1319 %1322 %1324 %822 = OpLoad %36 %ShadowMapSampler %823 = OpLoad %38 %ShadowMapTexture %826 = OpVectorShuffle %v3float %526 %526 0 1 2 %1482 = OpCompositeExtract %float %1325 3 %1337 = OpSampledImage %183 %823 %822 %1339 = OpVectorShuffle %v2float %826 %826 0 1 %1340 = OpImageSampleImplicitLod %v4float %1337 %1339 %1341 = OpVectorShuffle %v2float %1340 %1340 0 1 %1484 = OpCompositeExtract %float %826 2 %1486 = OpCompositeExtract %float %1341 0 %1363 = OpExtInst %float %1 Step %1486 %1484 %1365 = OpFSub %float %1484 %float_0_5 %1366 = OpExtInst %float %1 FAbs %1365 %1367 = OpFMul %float %float_20 %1366 %1368 = OpFSub %float %float_9 %1367 %1369 = OpExtInst %float %1 FClamp %1368 %float_0 %float_1 %1370 = OpFMul %float %1363 %1369 %1488 = OpCompositeExtract %float %1341 1 %1350 = OpFMul %float %1370 %1488 %1351 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %int_17 %uint_3 %1352 = OpLoad %float %1351 %1353 = OpFMul %float %1350 %1352 %1354 = OpFSub %float %float_1 %1353 %1356 = OpFMul %float %1354 %1482 %830 = OpLoad %367 %EnvironmentMapTexture %831 = OpLoad %36 %EnvironmentMapSampler %832 = OpSampledImage %373 %830 %831 %835 = OpVectorShuffle %v3float %516 %516 0 1 2 %836 = OpFNegate %v3float %835 %838 = OpExtInst %v3float %1 Reflect %836 %791 %839 = OpImageSampleImplicitLod %v4float %832 %838 %840 = OpVectorShuffle %v3float %839 %839 0 1 2 %842 = OpVectorShuffle %v3float %767 %767 0 1 2 %845 = OpCompositeConstruct %v3float %1113 %1113 %1113 %846 = OpExtInst %v3float %1 FMix %842 %840 %845 %848 = OpVectorShuffle %v4float %767 %846 4 5 6 3 %849 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 %int_5 %850 = OpLoad %v3float %849 %853 = OpVectorTimesScalar %v3float %808 %1356 %854 = OpFAdd %v3float %850 %853 %856 = OpVectorShuffle %v3float %1325 %1325 0 1 2 %857 = OpFAdd %v3float %854 %856 %859 = OpVectorShuffle %v3float %848 %848 0 1 2 %860 = OpFMul %v3float %857 %859 %865 = OpFMul %float %813 %1356 %873 = OpExtInst %v3float %1 Normalize %835 %874 = OpFAdd %v3float %795 %873 %875 = OpExtInst %v3float %1 Normalize %874 %876 = OpDot %float %791 %875 %877 = OpExtInst %float %1 FClamp %876 %float_0 %float_1 %879 = OpExtInst %float %1 Pow %877 %1446 %880 = OpFMul %float %865 %879 %881 = OpVectorTimesScalar %v3float %800 %880 %884 = OpFAdd %v3float %860 %881 %886 = OpVectorShuffle %v4float %1512 %884 4 5 6 3 %1494 = OpCompositeExtract %float %848 3 %1496 = OpCompositeInsert %v4float %1494 %886 3 %896 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %int_17 %uint_0 %897 = OpLoad %float %896 %898 = OpFMul %float %978 %897 %899 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %int_17 %uint_1 %900 = OpLoad %float %899 %901 = OpFAdd %float %898 %900 %1373 = OpExtInst %float %1 FClamp %901 %float_0 %float_1 %905 = OpVectorShuffle %v2float %504 %504 3 2 %908 = OpVectorShuffle %v2float %507 %507 3 2 %909 = OpExtInst %v2float %1 FMin %905 %908 %1504 = OpCompositeExtract %float %909 0 %1506 = OpCompositeExtract %float %909 1 %914 = OpExtInst %float %1 FMin %1504 %1506 %916 = OpFDiv %float %914 %978 %919 = OpFSub %float %float_1_5 %916 %920 = OpFMul %float %1373 %919 %922 = OpFAdd %float %920 %916 %1376 = OpExtInst %float %1 FClamp %922 %float_0 %float_1 %925 = OpVectorShuffle %v3float %1496 %1496 0 1 2 %926 = OpVectorTimesScalar %v3float %925 %1376 %928 = OpVectorShuffle %v4float %1496 %926 4 5 6 3 %1508 = OpCompositeExtract %float %1396 4 3 %931 = OpExtInst %float %1 FClamp %1508 %float_0 %float_1 %932 = OpAccessChain %_ptr_Uniform_v3float %_ %int_0 %int_10 %933 = OpLoad %v3float %932 %935 = OpVectorShuffle %v3float %928 %928 0 1 2 %937 = OpCompositeConstruct %v3float %931 %931 %931 %938 = OpExtInst %v3float %1 FMix %933 %935 %937 %940 = OpVectorShuffle %v4float %928 %938 4 5 6 3 OpStore %_entryPointOutput %940 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/ldexp-uint-exponent.asm.frag000066400000000000000000000025531400026215700263100ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_GLF_color OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %_GLF_color "_GLF_color" OpDecorate %_GLF_color Location 0 OpDecorate %18 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_GLF_color = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %11 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %uint = OpTypeInt 32 0 %v4uint = OpTypeVector %uint 4 %uint_1 = OpConstant %uint 1 %15 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %main = OpFunction %void None %3 %5 = OpLabel %18 = OpBitCount %v4uint %15 %19 = OpExtInst %v4float %1 Ldexp %11 %18 OpStore %_GLF_color %19 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/loop-merge-to-continue.asm.invalid.frag000066400000000000000000000057251400026215700303220ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 51 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %v0 OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %i "i" OpName %j "j" OpName %v0 "v0" OpDecorate %FragColor Location 0 OpDecorate %v0 Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %11 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %_ptr_Input_v4float = OpTypePointer Input %v4float %v0 = OpVariable %_ptr_Input_v4float Input %int_3 = OpConstant %int 3 %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function OpStore %FragColor %11 OpStore %i %int_0 OpBranch %16 %16 = OpLabel OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel %21 = OpLoad %int %i %24 = OpSLessThan %bool %21 %int_4 OpBranchConditional %24 %17 %18 %17 = OpLabel OpStore %j %int_0 OpBranch %26 %26 = OpLabel OpLoopMerge %19 %29 None OpBranch %30 %30 = OpLabel %31 = OpLoad %int %j %32 = OpSLessThan %bool %31 %int_4 OpBranchConditional %32 %27 %19 %27 = OpLabel %35 = OpLoad %int %i %36 = OpLoad %int %j %37 = OpIAdd %int %35 %36 %39 = OpBitwiseAnd %int %37 %int_3 %41 = OpAccessChain %_ptr_Input_float %v0 %39 %42 = OpLoad %float %41 %43 = OpLoad %v4float %FragColor %44 = OpCompositeConstruct %v4float %42 %42 %42 %42 %45 = OpFAdd %v4float %43 %44 OpStore %FragColor %45 OpBranch %29 %29 = OpLabel %46 = OpLoad %int %j %48 = OpIAdd %int %46 %int_1 OpStore %j %48 OpBranch %26 %19 = OpLabel %49 = OpLoad %int %i %50 = OpIAdd %int %49 %int_1 OpStore %i %50 OpBranch %16 %18 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/nonuniform-bracket-handling-2.vk.nocompat.asm.frag000066400000000000000000000102231400026215700323340ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 53 ; Schema: 0 OpCapability Shader OpCapability ShaderNonUniform OpCapability RuntimeDescriptorArray OpCapability SampledImageArrayNonUniformIndexing OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vUV %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %FragColor "FragColor" OpName %uSamplers "uSamplers" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "indices" OpName %_ "" OpName %vUV "vUV" OpName %uSampler "uSampler" OpName %gl_FragCoord "gl_FragCoord" OpDecorate %FragColor Location 0 OpDecorate %uSamplers DescriptorSet 0 OpDecorate %uSamplers Binding 0 OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO 0 NonWritable OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %26 NonUniform OpDecorate %28 NonUniform OpDecorate %29 NonUniform OpDecorate %vUV Location 0 OpDecorate %uSampler DescriptorSet 1 OpDecorate %uSampler Binding 0 OpDecorate %38 NonUniform OpDecorate %gl_FragCoord BuiltIn FragCoord %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_runtimearr_11 = OpTypeRuntimeArray %11 %_ptr_UniformConstant__runtimearr_11 = OpTypePointer UniformConstant %_runtimearr_11 %uSamplers = OpVariable %_ptr_UniformConstant__runtimearr_11 UniformConstant %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %float_0 = OpConstant %float 0 %uSampler = OpVariable %_ptr_UniformConstant_11 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_1 = OpConstant %uint 1 %_ptr_Input_float = OpTypePointer Input %float %main = OpFunction %void None %3 %5 = OpLabel %24 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %int_10 %26 = OpLoad %uint %24 %28 = OpAccessChain %_ptr_UniformConstant_11 %uSamplers %26 %29 = OpLoad %11 %28 %33 = OpLoad %v2float %vUV %35 = OpImageSampleExplicitLod %v4float %29 %33 Lod %float_0 OpStore %FragColor %35 %37 = OpLoad %11 %uSampler %38 = OpCopyObject %11 %37 %39 = OpLoad %v2float %vUV %44 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_1 %45 = OpLoad %float %44 %46 = OpConvertFToS %int %45 %47 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %46 %48 = OpLoad %uint %47 %49 = OpConvertUToF %float %48 %50 = OpImageSampleExplicitLod %v4float %38 %39 Lod %49 %51 = OpLoad %v4float %FragColor %52 = OpFAdd %v4float %51 %50 OpStore %FragColor %52 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/nonuniform-qualifier-propagation.vk.nocompat.asm.frag000066400000000000000000000160611400026215700333100ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 93 ; Schema: 0 OpCapability Shader OpCapability ShaderNonUniformEXT OpCapability RuntimeDescriptorArrayEXT OpCapability UniformBufferArrayNonUniformIndexingEXT OpCapability SampledImageArrayNonUniformIndexingEXT OpCapability StorageBufferArrayNonUniformIndexingEXT OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vIndex %FragColor %vUV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %i "i" OpName %vIndex "vIndex" OpName %FragColor "FragColor" OpName %uSamplers "uSamplers" OpName %uSamps "uSamps" OpName %vUV "vUV" OpName %uCombinedSamplers "uCombinedSamplers" OpName %UBO "UBO" OpMemberName %UBO 0 "v" OpName %ubos "ubos" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "v" OpName %ssbos "ssbos" OpDecorate %vIndex Flat OpDecorate %vIndex Location 0 OpDecorate %FragColor Location 0 OpDecorate %uSamplers DescriptorSet 0 OpDecorate %uSamplers Binding 0 OpDecorate %sampled_image NonUniformEXT OpDecorate %combined_sampler NonUniformEXT OpDecorate %ubo_ptr_copy NonUniformEXT OpDecorate %ssbo_ptr_copy NonUniformEXT OpDecorate %uSamps DescriptorSet 0 OpDecorate %uSamps Binding 1 OpDecorate %vUV Location 1 OpDecorate %uCombinedSamplers DescriptorSet 0 OpDecorate %uCombinedSamplers Binding 4 OpDecorate %_arr_v4float_uint_64 ArrayStride 16 OpMemberDecorate %UBO 0 Offset 0 OpDecorate %UBO Block OpDecorate %ubos DescriptorSet 0 OpDecorate %ubos Binding 2 OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %SSBO 0 NonWritable OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %ssbos DescriptorSet 0 OpDecorate %ssbos Binding 3 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_int = OpTypePointer Input %int %vIndex = OpVariable %_ptr_Input_int Input %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %16 = OpTypeImage %float 2D 0 0 0 1 Unknown %_runtimearr_16 = OpTypeRuntimeArray %16 %_ptr_UniformConstant__runtimearr_16 = OpTypePointer UniformConstant %_runtimearr_16 %uSamplers = OpVariable %_ptr_UniformConstant__runtimearr_16 UniformConstant %int_10 = OpConstant %int 10 %_ptr_UniformConstant_16 = OpTypePointer UniformConstant %16 %27 = OpTypeSampler %_runtimearr_27 = OpTypeRuntimeArray %27 %_ptr_UniformConstant__runtimearr_27 = OpTypePointer UniformConstant %_runtimearr_27 %uSamps = OpVariable %_ptr_UniformConstant__runtimearr_27 UniformConstant %int_40 = OpConstant %int 40 %_ptr_UniformConstant_27 = OpTypePointer UniformConstant %27 %38 = OpTypeSampledImage %16 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %_runtimearr_38 = OpTypeRuntimeArray %38 %_ptr_UniformConstant__runtimearr_38 = OpTypePointer UniformConstant %_runtimearr_38 %uCombinedSamplers = OpVariable %_ptr_UniformConstant__runtimearr_38 UniformConstant %_ptr_UniformConstant_38 = OpTypePointer UniformConstant %38 %uint = OpTypeInt 32 0 %uint_64 = OpConstant %uint 64 %_arr_v4float_uint_64 = OpTypeArray %v4float %uint_64 %UBO = OpTypeStruct %_arr_v4float_uint_64 %_runtimearr_UBO = OpTypeRuntimeArray %UBO %_ptr_Uniform__runtimearr_UBO = OpTypePointer Uniform %_runtimearr_UBO %ubos = OpVariable %_ptr_Uniform__runtimearr_UBO Uniform %int_20 = OpConstant %int 20 %int_0 = OpConstant %int 0 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_runtimearr_v4float = OpTypeRuntimeArray %v4float %SSBO = OpTypeStruct %_runtimearr_v4float %_runtimearr_SSBO = OpTypeRuntimeArray %SSBO %_ptr_Uniform__runtimearr_SSBO = OpTypePointer Uniform %_runtimearr_SSBO %ssbos = OpVariable %_ptr_Uniform__runtimearr_SSBO Uniform %int_50 = OpConstant %int 50 %int_60 = OpConstant %int 60 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function %11 = OpLoad %int %vIndex OpStore %i %11 %20 = OpLoad %int %i %22 = OpIAdd %int %20 %int_10 %23 = OpCopyObject %int %22 %25 = OpAccessChain %_ptr_UniformConstant_16 %uSamplers %23 %26 = OpLoad %16 %25 %31 = OpLoad %int %i %33 = OpIAdd %int %31 %int_40 %34 = OpCopyObject %int %33 %36 = OpAccessChain %_ptr_UniformConstant_27 %uSamps %34 %37 = OpLoad %27 %36 %sampled_image = OpSampledImage %38 %26 %37 %43 = OpLoad %v2float %vUV %44 = OpImageSampleImplicitLod %v4float %sampled_image %43 OpStore %FragColor %44 %48 = OpLoad %int %i %49 = OpIAdd %int %48 %int_10 %50 = OpCopyObject %int %49 %52 = OpAccessChain %_ptr_UniformConstant_38 %uCombinedSamplers %50 %combined_sampler = OpLoad %38 %52 %54 = OpLoad %v2float %vUV %55 = OpImageSampleImplicitLod %v4float %combined_sampler %54 OpStore %FragColor %55 %63 = OpLoad %int %i %65 = OpIAdd %int %63 %int_20 %66 = OpCopyObject %int %65 %68 = OpLoad %int %i %69 = OpIAdd %int %68 %int_40 %70 = OpCopyObject %int %69 %ubo_ptr = OpAccessChain %_ptr_Uniform_v4float %ubos %66 %int_0 %70 %ubo_ptr_copy = OpCopyObject %_ptr_Uniform_v4float %ubo_ptr %73 = OpLoad %v4float %ubo_ptr_copy %74 = OpLoad %v4float %FragColor %75 = OpFAdd %v4float %74 %73 OpStore %FragColor %75 %81 = OpLoad %int %i %83 = OpIAdd %int %81 %int_50 %84 = OpCopyObject %int %83 %85 = OpLoad %int %i %87 = OpIAdd %int %85 %int_60 %88 = OpCopyObject %int %87 %ssbo_ptr = OpAccessChain %_ptr_Uniform_v4float %ssbos %84 %int_0 %88 %ssbo_ptr_copy = OpCopyObject %_ptr_Uniform_v4float %ssbo_ptr %90 = OpLoad %v4float %ssbo_ptr_copy %91 = OpLoad %v4float %FragColor %92 = OpFAdd %v4float %91 %90 OpStore %FragColor %92 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/only-initializer-frag-depth.asm.frag000066400000000000000000000016431400026215700277010ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 10 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragDepth OpExecutionMode %main OriginUpperLeft OpExecutionMode %main DepthReplacing OpSource GLSL 450 OpName %main "main" OpName %gl_FragDepth "gl_FragDepth" OpDecorate %gl_FragDepth BuiltIn FragDepth %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %float_0_5 = OpConstant %float 0.5 %gl_FragDepth = OpVariable %_ptr_Output_float Output %float_0_5 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/opaque-id-literal-alias.preserve.asm.frag000066400000000000000000000060641400026215700306210ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 50 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %gl_FragCoord %vUV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %gl_FragCoord "gl_FragCoord" OpName %uSampled "uSampled" OpName %vUV "vUV" OpDecorate %FragColor Location 0 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %uSampled DescriptorSet 0 OpDecorate %uSampled Binding 0 OpDecorate %vUV Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %11 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_10 = OpConstant %float 10 %bool = OpTypeBool %24 = OpTypeImage %float 2D 0 0 1 1 Unknown %25 = OpTypeSampledImage %24 %_ptr_UniformConstant_25 = OpTypePointer UniformConstant %25 %uSampled = OpVariable %_ptr_UniformConstant_25 UniformConstant %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel OpStore %FragColor %11 %17 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %18 = OpLoad %float %17 %21 = OpFOrdLessThan %bool %18 %float_10 OpSelectionMerge %23 None OpBranchConditional %21 %22 %41 %22 = OpLabel %28 = OpLoad %25 %uSampled %32 = OpLoad %v2float %vUV %35 = OpConvertFToS %v2int %32 %64 = OpImage %24 %28 %38 = OpImageFetch %v4float %64 %35 Sample %int_0 %39 = OpLoad %v4float %FragColor %40 = OpFAdd %v4float %39 %38 OpStore %FragColor %40 OpBranch %23 %41 = OpLabel %42 = OpLoad %25 %uSampled %43 = OpLoad %v2float %vUV %44 = OpConvertFToS %v2int %43 %46 = OpImage %24 %42 %47 = OpImageFetch %v4float %46 %44 Sample %int_1 %48 = OpLoad %v4float %FragColor %49 = OpFAdd %v4float %48 %47 OpStore %FragColor %49 OpBranch %23 %23 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/out-of-order-struct-id.asm.frag000066400000000000000000000040631400026215700266150ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 24 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %80 "Foo" OpMemberName %80 0 "a" OpName %79 "Bar" OpMemberName %79 0 "foo" OpMemberName %79 1 "foo2" OpName %UBO "UBO" OpMemberName %UBO 0 "bar" OpName %_ "" OpDecorate %FragColor Location 0 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %79 0 Offset 0 OpMemberDecorate %79 1 Offset 16 OpMemberDecorate %UBO 0 Offset 0 OpDecorate %UBO Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %80 = OpTypeStruct %v4float %79 = OpTypeStruct %80 %80 %UBO = OpTypeStruct %79 %_ptr_Uniform_UBO = OpTypePointer Uniform %UBO %_ = OpVariable %_ptr_Uniform_UBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %int_0 %int_0 %19 = OpLoad %v4float %18 %21 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %int_1 %int_0 %22 = OpLoad %v4float %21 %23 = OpFAdd %v4float %19 %22 OpStore %FragColor %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/phi.zero-initialize.asm.frag000066400000000000000000000052031400026215700262510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 40 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vColor %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %vColor "vColor" OpName %uninit_function_int "uninit_function_int" OpName %FragColor "FragColor" OpName %uninit_int "uninit_int" OpName %uninit_vector "uninit_vector" OpName %uninit_matrix "uninit_matrix" OpName %Foo "Foo" OpMemberName %Foo 0 "a" OpName %uninit_foo "uninit_foo" OpDecorate %vColor Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %vColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_10 = OpConstant %float 10 %bool = OpTypeBool %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_10 = OpConstant %int 10 %int_20 = OpConstant %int 20 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Private_int = OpTypePointer Private %int %uninit_int = OpUndef %int %v4int = OpTypeVector %int 4 %_ptr_Private_v4int = OpTypePointer Private %v4int %uninit_vector = OpUndef %v4int %mat4v4float = OpTypeMatrix %v4float 4 %_ptr_Private_mat4v4float = OpTypePointer Private %mat4v4float %uninit_matrix = OpUndef %mat4v4float %Foo = OpTypeStruct %int %_ptr_Private_Foo = OpTypePointer Private %Foo %uninit_foo = OpUndef %Foo %main = OpFunction %void None %3 %5 = OpLabel %uninit_function_int = OpVariable %_ptr_Function_int Function %13 = OpAccessChain %_ptr_Input_float %vColor %uint_0 %14 = OpLoad %float %13 %17 = OpFOrdGreaterThan %bool %14 %float_10 OpSelectionMerge %19 None OpBranchConditional %17 %18 %24 %18 = OpLabel OpBranch %19 %24 = OpLabel OpBranch %19 %19 = OpLabel %27 = OpPhi %int %int_10 %18 %int_20 %24 %28 = OpLoad %v4float %vColor OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/pixel-interlock-callstack.asm.frag000066400000000000000000000072021400026215700274250ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpSource GLSL 450 OpSourceExtension "GL_ARB_fragment_shader_interlock" OpName %main "main" OpName %callee2_ "callee2(" OpName %callee_ "callee(" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "values1" OpName %_ "" OpName %gl_FragCoord "gl_FragCoord" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "values0" OpName %__0 "" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_runtimearr_uint_0 ArrayStride 4 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO1 = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_runtimearr_uint_0 = OpTypeRuntimeArray %uint %SSBO0 = OpTypeStruct %_runtimearr_uint_0 %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %__0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %44 = OpFunctionCall %void %callee_ OpReturn OpFunctionEnd %callee2_ = OpFunction %void None %3 %7 = OpLabel %23 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %24 = OpLoad %float %23 %25 = OpConvertFToS %int %24 %28 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 %29 = OpLoad %uint %28 %30 = OpIAdd %uint %29 %uint_1 %31 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 OpStore %31 %30 OpReturn OpFunctionEnd %callee_ = OpFunction %void None %3 %9 = OpLabel %36 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %37 = OpLoad %float %36 %38 = OpConvertFToS %int %37 %39 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpIAdd %uint %40 %uint_1 %42 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 OpStore %42 %41 OpBeginInvocationInterlockEXT %43 = OpFunctionCall %void %callee2_ OpEndInvocationInterlockEXT OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/pixel-interlock-control-flow.asm.frag000066400000000000000000000112201400026215700301040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpSource GLSL 450 OpSourceExtension "GL_ARB_fragment_shader_interlock" OpName %main "main" OpName %callee2_ "callee2(" OpName %callee_ "callee(" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "values1" OpName %_ "" OpName %gl_FragCoord "gl_FragCoord" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "values0" OpName %__0 "" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_runtimearr_uint_0 ArrayStride 4 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 OpMemberDecorate %SSBO2 0 Offset 0 OpDecorate %SSBO2 BufferBlock OpDecorate %ssbo2 DescriptorSet 0 OpDecorate %ssbo2 Binding 2 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO1 = OpTypeStruct %_runtimearr_uint %SSBO2 = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ptr_Uniform_SSBO2 = OpTypePointer Uniform %SSBO2 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %ssbo2 = OpVariable %_ptr_Uniform_SSBO2 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_4 = OpConstant %uint 4 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %bool = OpTypeBool %true = OpConstantTrue %bool %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_runtimearr_uint_0 = OpTypeRuntimeArray %uint %SSBO0 = OpTypeStruct %_runtimearr_uint_0 %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %__0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %44 = OpFunctionCall %void %callee_ %callee3_res = OpFunctionCall %void %callee3_ OpReturn OpFunctionEnd %callee3_ = OpFunction %void None %3 %calle3_block = OpLabel %frag_coord_x_ptr = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %frag_coord_x = OpLoad %float %frag_coord_x_ptr %frag_coord_int = OpConvertFToS %int %frag_coord_x %ssbo_ptr = OpAccessChain %_ptr_Uniform_uint %ssbo2 %int_0 %frag_coord_int OpStore %ssbo_ptr %uint_4 OpReturn OpFunctionEnd %callee2_ = OpFunction %void None %3 %7 = OpLabel %23 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %24 = OpLoad %float %23 %25 = OpConvertFToS %int %24 %28 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 %29 = OpLoad %uint %28 %30 = OpIAdd %uint %29 %uint_1 %31 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 OpStore %31 %30 OpReturn OpFunctionEnd %callee_ = OpFunction %void None %3 %9 = OpLabel %36 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %37 = OpLoad %float %36 %38 = OpConvertFToS %int %37 %39 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpIAdd %uint %40 %uint_1 %42 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 OpStore %42 %41 %43 = OpFunctionCall %void %callee2_ OpSelectionMerge %merged_block None OpBranchConditional %true %dummy_block %merged_block %dummy_block = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpBranch %merged_block %merged_block = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/pixel-interlock-split-functions.asm.frag000066400000000000000000000077011400026215700306310ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 45 ; Schema: 0 OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpSource GLSL 450 OpSourceExtension "GL_ARB_fragment_shader_interlock" OpName %main "main" OpName %callee2_ "callee2(" OpName %callee_ "callee(" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "values1" OpName %_ "" OpName %gl_FragCoord "gl_FragCoord" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "values0" OpName %__0 "" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_runtimearr_uint_0 ArrayStride 4 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %SSBO1 = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %_ = OpVariable %_ptr_Uniform_SSBO1 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_runtimearr_uint_0 = OpTypeRuntimeArray %uint %SSBO0 = OpTypeStruct %_runtimearr_uint_0 %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %__0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %44 = OpFunctionCall %void %callee_ %call3res = OpFunctionCall %void %callee3_ %call4res = OpFunctionCall %void %callee4_ OpReturn OpFunctionEnd %callee3_ = OpFunction %void None %3 %begin3 = OpLabel OpBeginInvocationInterlockEXT OpReturn OpFunctionEnd %callee4_ = OpFunction %void None %3 %begin4 = OpLabel OpEndInvocationInterlockEXT OpReturn OpFunctionEnd %callee2_ = OpFunction %void None %3 %7 = OpLabel %23 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %24 = OpLoad %float %23 %25 = OpConvertFToS %int %24 %28 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 %29 = OpLoad %uint %28 %30 = OpIAdd %uint %29 %uint_1 %31 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %25 OpStore %31 %30 OpReturn OpFunctionEnd %callee_ = OpFunction %void None %3 %9 = OpLabel %36 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %37 = OpLoad %float %36 %38 = OpConvertFToS %int %37 %39 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpIAdd %uint %40 %uint_1 %42 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %38 OpStore %42 %41 %43 = OpFunctionCall %void %callee2_ OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/reserved-function-identifier.asm.frag000066400000000000000000000043741400026215700301460ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 37 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %ACOS_f1_ "mat3" OpName %a "a" OpName %ACOS_i1_ "gl_Foo" OpName %a_0 "a" OpName %FragColor "FragColor" OpName %param "param" OpName %param_0 "param" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %8 = OpTypeFunction %float %_ptr_Function_float %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %14 = OpTypeFunction %float %_ptr_Function_int %float_1 = OpConstant %float 1 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %float_2 = OpConstant %float 2 %int_4 = OpConstant %int 4 %main = OpFunction %void None %3 %5 = OpLabel %param = OpVariable %_ptr_Function_float Function %param_0 = OpVariable %_ptr_Function_int Function OpStore %param %float_2 %32 = OpFunctionCall %float %ACOS_f1_ %param OpStore %param_0 %int_4 %35 = OpFunctionCall %float %ACOS_i1_ %param_0 %36 = OpFAdd %float %32 %35 OpStore %FragColor %36 OpReturn OpFunctionEnd %ACOS_f1_ = OpFunction %float None %8 %a = OpFunctionParameter %_ptr_Function_float %11 = OpLabel %18 = OpLoad %float %a %20 = OpFAdd %float %18 %float_1 OpReturnValue %20 OpFunctionEnd %ACOS_i1_ = OpFunction %float None %14 %a_0 = OpFunctionParameter %_ptr_Function_int %17 = OpLabel %23 = OpLoad %int %a_0 %24 = OpConvertSToF %float %23 %25 = OpFAdd %float %24 %float_1 OpReturnValue %25 OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/reserved-identifiers.asm.frag000066400000000000000000000044141400026215700265010ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 24 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %spvFoo %SPIRV_Cross_blah %_40 %_m40 %_underscore_foo_bar_meep OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %spvFoo "spvFoo" OpName %SPIRV_Cross_blah "SPIRV_Cross_blah" OpName %_40 "_40Bar" OpName %_m40 "_m40" OpName %_underscore_foo_bar_meep "__underscore_foo__bar_meep__" OpDecorate %spvFoo Location 0 OpDecorate %SPIRV_Cross_blah Location 1 OpDecorate %_40 Location 2 OpDecorate %_m40 Location 3 OpDecorate %_underscore_foo_bar_meep Location 4 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %spvFoo = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %11 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %SPIRV_Cross_blah = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_40 = OpVariable %_ptr_Output_v4float Output %float_2 = OpConstant %float 2 %17 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_m40 = OpVariable %_ptr_Output_v4float Output %float_3 = OpConstant %float 3 %20 = OpConstantComposite %v4float %float_3 %float_3 %float_3 %float_3 %_underscore_foo_bar_meep = OpVariable %_ptr_Output_v4float Output %float_4 = OpConstant %float 4 %23 = OpConstantComposite %v4float %float_4 %float_4 %float_4 %float_4 %main = OpFunction %void None %3 %5 = OpLabel OpStore %spvFoo %11 OpStore %SPIRV_Cross_blah %14 OpStore %_40 %17 OpStore %_m40 %20 OpStore %_underscore_foo_bar_meep %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/selection-merge-to-continue.asm.invalid.frag000066400000000000000000000061241400026215700313300ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 55 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %v0 OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %i "i" OpName %v0 "v0" OpDecorate %FragColor Location 0 OpDecorate %v0 Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %11 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %_ptr_Input_v4float = OpTypePointer Input %v4float %v0 = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_20 = OpConstant %float 20 %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %FragColor %11 OpStore %i %int_0 OpBranch %16 %16 = OpLabel OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel %21 = OpLoad %int %i %24 = OpSLessThan %bool %21 %int_4 OpBranchConditional %24 %17 %18 %17 = OpLabel %30 = OpAccessChain %_ptr_Input_float %v0 %uint_0 %31 = OpLoad %float %30 %33 = OpFOrdEqual %bool %31 %float_20 OpSelectionMerge %19 None OpBranchConditional %33 %34 %44 %34 = OpLabel %36 = OpLoad %int %i %38 = OpBitwiseAnd %int %36 %int_3 %39 = OpAccessChain %_ptr_Input_float %v0 %38 %40 = OpLoad %float %39 %41 = OpLoad %v4float %FragColor %42 = OpCompositeConstruct %v4float %40 %40 %40 %40 %43 = OpFAdd %v4float %41 %42 OpStore %FragColor %43 OpBranch %19 %44 = OpLabel %45 = OpLoad %int %i %47 = OpBitwiseAnd %int %45 %int_1 %48 = OpAccessChain %_ptr_Input_float %v0 %47 %49 = OpLoad %float %48 %50 = OpLoad %v4float %FragColor %51 = OpCompositeConstruct %v4float %49 %49 %49 %49 %52 = OpFAdd %v4float %50 %51 OpStore %FragColor %52 OpBranch %19 %19 = OpLabel %53 = OpLoad %int %i %54 = OpIAdd %int %53 %int_1 OpStore %i %54 OpBranch %16 %18 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/sparse-texture-feedback-uint-code.asm.desktop.frag000066400000000000000000000044741400026215700324370ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 30 ; Schema: 0 OpCapability Shader OpCapability SparseResidency %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vUV %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_ARB_sparse_texture2" OpSourceExtension "GL_ARB_sparse_texture_clamp" OpName %main "main" OpName %ret "ret" OpName %uSamp "uSamp" OpName %vUV "vUV" OpName %texel "texel" OpName %ResType "ResType" OpName %FragColor "FragColor" OpDecorate %uSamp DescriptorSet 0 OpDecorate %uSamp Binding 0 OpDecorate %vUV Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %float = OpTypeFloat 32 %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %uSamp = OpVariable %_ptr_UniformConstant_11 UniformConstant %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %uint = OpTypeInt 32 0 %ResType = OpTypeStruct %uint %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %ret = OpVariable %_ptr_Function_bool Function %texel = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %11 %uSamp %18 = OpLoad %v2float %vUV %24 = OpImageSparseSampleImplicitLod %ResType %14 %18 %25 = OpCompositeExtract %v4float %24 1 OpStore %texel %25 %26 = OpCompositeExtract %uint %24 0 %27 = OpImageSparseTexelsResident %bool %26 OpStore %ret %27 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/subgroup-arithmetic-cast.nocompat.vk.asm.frag000066400000000000000000000056211400026215700315430ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 78 ; Schema: 0 OpCapability Shader OpCapability GroupNonUniform OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %index %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_KHR_shader_subgroup_arithmetic" OpSourceExtension "GL_KHR_shader_subgroup_basic" OpSourceExtension "GL_KHR_shader_subgroup_clustered" OpName %main "main" OpName %index "index" OpName %FragColor "FragColor" OpDecorate %index Flat OpDecorate %index Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %index = OpVariable %_ptr_Input_int Input %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %_ptr_Output_uint = OpTypePointer Output %uint %FragColor = OpVariable %_ptr_Output_uint Output %main = OpFunction %void None %3 %5 = OpLabel %i = OpLoad %int %index %u = OpBitcast %uint %i %res0 = OpGroupNonUniformSMin %uint %uint_3 Reduce %i %res1 = OpGroupNonUniformSMax %uint %uint_3 Reduce %u %res2 = OpGroupNonUniformUMin %uint %uint_3 Reduce %i %res3 = OpGroupNonUniformUMax %uint %uint_3 Reduce %u %res4 = OpGroupNonUniformSMax %uint %uint_3 InclusiveScan %i %res5 = OpGroupNonUniformSMin %uint %uint_3 InclusiveScan %u %res6 = OpGroupNonUniformUMax %uint %uint_3 ExclusiveScan %i %res7 = OpGroupNonUniformUMin %uint %uint_3 ExclusiveScan %u %res8 = OpGroupNonUniformSMin %uint %uint_3 ClusteredReduce %i %uint_4 %res9 = OpGroupNonUniformSMax %uint %uint_3 ClusteredReduce %u %uint_4 %res10 = OpGroupNonUniformUMin %uint %uint_3 ClusteredReduce %i %uint_4 %res11 = OpGroupNonUniformUMax %uint %uint_3 ClusteredReduce %u %uint_4 OpStore %FragColor %res0 OpStore %FragColor %res1 OpStore %FragColor %res2 OpStore %FragColor %res3 OpStore %FragColor %res4 OpStore %FragColor %res5 OpStore %FragColor %res6 OpStore %FragColor %res7 OpStore %FragColor %res8 OpStore %FragColor %res9 OpStore %FragColor %res10 OpStore %FragColor %res11 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/subgroup-ballot-only.vk.asm.frag000066400000000000000000000037601400026215700271010ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Unknown(30017); 21022 ; Bound: 31 ; Schema: 0 OpCapability Shader OpCapability GroupNonUniformBallot OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %INDEX %SV_Target OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %INDEX "INDEX" OpName %SV_Target "SV_Target" OpDecorate %INDEX Flat OpDecorate %INDEX Location 0 OpDecorate %SV_Target Location 0 %void = OpTypeVoid %2 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Input_uint = OpTypePointer Input %uint %INDEX = OpVariable %_ptr_Input_uint Input %v4uint = OpTypeVector %uint 4 %_ptr_Output_v4uint = OpTypePointer Output %v4uint %SV_Target = OpVariable %_ptr_Output_v4uint Output %bool = OpTypeBool %uint_100 = OpConstant %uint 100 %uint_3 = OpConstant %uint 3 %_ptr_Output_uint = OpTypePointer Output %uint %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %main = OpFunction %void None %2 %4 = OpLabel OpBranch %29 %29 = OpLabel %11 = OpLoad %uint %INDEX %13 = OpULessThan %bool %11 %uint_100 %15 = OpGroupNonUniformBallot %v4uint %uint_3 %13 %17 = OpCompositeExtract %uint %15 0 %18 = OpCompositeExtract %uint %15 1 %19 = OpCompositeExtract %uint %15 2 %20 = OpCompositeExtract %uint %15 3 %22 = OpAccessChain %_ptr_Output_uint %SV_Target %uint_0 OpStore %22 %17 %24 = OpAccessChain %_ptr_Output_uint %SV_Target %uint_1 OpStore %24 %18 %26 = OpAccessChain %_ptr_Output_uint %SV_Target %uint_2 OpStore %26 %19 %28 = OpAccessChain %_ptr_Output_uint %SV_Target %uint_3 OpStore %28 %20 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/switch-block-case-fallthrough.asm.invalid.frag000066400000000000000000000056741400026215700316340ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vIndex %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %vIndex "vIndex" OpName %FragColor "FragColor" OpName %i "i" OpName %j "j" OpDecorate %vIndex Flat OpDecorate %vIndex Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %_ptr_Input_int = OpTypePointer Input %int %vIndex = OpVariable %_ptr_Input_int Input %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Function_int = OpTypePointer Function %int %main = OpFunction %void None %3 %header = OpLabel %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function %9 = OpLoad %int %vIndex OpSelectionMerge %switch_merge None OpSwitch %9 %default_case 100 %default_case 0 %case_0 1 %case_1 11 %case_1 2 %case_2 3 %case_3 4 %case_4 5 %case_5 %case_0 = OpLabel OpBranch %default_case %default_case = OpLabel %default_case_phi = OpPhi %int %int_2 %header %int_3 %case_0 ; Test what happens when a case block dominates access to a variable. OpStore %j %default_case_phi OpBranch %case_1 %case_1 = OpLabel ; Test phi nodes between case labels. %case_1_phi = OpPhi %int %int_0 %default_case %int_1 %header OpStore %j %case_1_phi OpBranch %case_2 %case_2 = OpLabel OpBranch %switch_merge %case_3 = OpLabel ; Conditionally branch to another case block. This is really dumb, but it is apparently legal. %case_3_cond = OpSGreaterThan %bool %9 %int_3 OpBranchConditional %case_3_cond %case_4 %switch_merge %case_4 = OpLabel ; When emitted from case 3, we should *not* see fallthrough behavior. OpBranch %case_5 %case_5 = OpLabel OpStore %i %int_0 OpBranch %switch_merge %switch_merge = OpLabel %26 = OpLoad %int %i %27 = OpConvertSToF %float %26 %28 = OpCompositeConstruct %v4float %27 %27 %27 %27 OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/switch-merge-to-continue.asm.invalid.frag000066400000000000000000000061371400026215700306500ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 57 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %v0 OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %i "i" OpName %v0 "v0" OpDecorate %FragColor Location 0 OpDecorate %v0 Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %11 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Output_float = OpTypePointer Output %float %float_3 = OpConstant %float 3 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %v0 = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %FragColor %11 OpStore %i %int_0 OpBranch %16 %16 = OpLabel OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel %21 = OpLoad %int %i %24 = OpSLessThan %bool %21 %int_4 OpBranchConditional %24 %17 %18 %17 = OpLabel %25 = OpLoad %int %i OpSelectionMerge %19 None OpSwitch %25 %28 0 %26 1 %27 %28 = OpLabel %46 = OpAccessChain %_ptr_Output_float %FragColor %uint_2 %47 = OpLoad %float %46 %48 = OpFAdd %float %47 %float_3 %49 = OpAccessChain %_ptr_Output_float %FragColor %uint_2 OpStore %49 %48 OpBranch %19 %26 = OpLabel %33 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 %34 = OpLoad %float %33 %35 = OpFAdd %float %34 %float_1 %36 = OpAccessChain %_ptr_Output_float %FragColor %uint_0 OpStore %36 %35 OpBranch %19 %27 = OpLabel %40 = OpAccessChain %_ptr_Output_float %FragColor %uint_1 %41 = OpLoad %float %40 %42 = OpFAdd %float %41 %float_3 %43 = OpAccessChain %_ptr_Output_float %FragColor %uint_1 OpStore %43 %42 OpBranch %19 %19 = OpLabel %52 = OpLoad %int %i %54 = OpIAdd %int %52 %int_1 OpStore %i %54 OpBranch %16 %18 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/switch-single-case-multiple-exit-cfg.asm.frag000066400000000000000000000042171400026215700314060ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 54 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %_GLF_color OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %gl_FragCoord "gl_FragCoord" OpName %_GLF_color "_GLF_color" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_GLF_color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %bool = OpTypeBool %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %_GLF_color = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %52 = OpUndef %v2float %main = OpFunction %void None %3 %5 = OpLabel OpSelectionMerge %9 None OpSwitch %int_0 %8 %8 = OpLabel %17 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %18 = OpLoad %float %17 %22 = OpFOrdNotEqual %bool %18 %18 OpSelectionMerge %24 None OpBranchConditional %22 %23 %24 %23 = OpLabel OpBranch %9 %24 = OpLabel %33 = OpCompositeExtract %float %52 1 %51 = OpCompositeInsert %v2float %33 %52 1 OpBranch %9 %9 = OpLabel %53 = OpPhi %v2float %52 %23 %51 %24 %42 = OpCompositeExtract %float %53 0 %43 = OpCompositeExtract %float %53 1 %48 = OpCompositeConstruct %v4float %42 %43 %float_1 %float_1 OpStore %_GLF_color %48 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/unordered-compare.asm.frag000066400000000000000000000162031400026215700257710ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 132 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %A %B %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %test_vector_ "test_vector(" OpName %test_scalar_ "test_scalar(" OpName %le "le" OpName %A "A" OpName %B "B" OpName %leq "leq" OpName %ge "ge" OpName %geq "geq" OpName %eq "eq" OpName %neq "neq" OpName %le_0 "le" OpName %leq_0 "leq" OpName %ge_0 "ge" OpName %geq_0 "geq" OpName %eq_0 "eq" OpName %neq_0 "neq" OpName %FragColor "FragColor" OpDecorate %A Location 0 OpDecorate %B Location 1 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %11 = OpTypeFunction %float %bool = OpTypeBool %v4bool = OpTypeVector %bool 4 %_ptr_Function_v4bool = OpTypePointer Function %v4bool %_ptr_Input_v4float = OpTypePointer Input %v4float %A = OpVariable %_ptr_Input_v4float Input %B = OpVariable %_ptr_Input_v4float Input %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %47 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %48 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Function_bool = OpTypePointer Function %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %128 = OpFunctionCall %v4float %test_vector_ %129 = OpFunctionCall %float %test_scalar_ %130 = OpCompositeConstruct %v4float %129 %129 %129 %129 %131 = OpFAdd %v4float %128 %130 OpStore %FragColor %131 OpReturn OpFunctionEnd %test_vector_ = OpFunction %v4float None %8 %10 = OpLabel %le = OpVariable %_ptr_Function_v4bool Function %leq = OpVariable %_ptr_Function_v4bool Function %ge = OpVariable %_ptr_Function_v4bool Function %geq = OpVariable %_ptr_Function_v4bool Function %eq = OpVariable %_ptr_Function_v4bool Function %neq = OpVariable %_ptr_Function_v4bool Function %20 = OpLoad %v4float %A %22 = OpLoad %v4float %B %23 = OpFUnordLessThan %v4bool %20 %22 OpStore %le %23 %25 = OpLoad %v4float %A %26 = OpLoad %v4float %B %27 = OpFUnordLessThanEqual %v4bool %25 %26 OpStore %leq %27 %29 = OpLoad %v4float %A %30 = OpLoad %v4float %B %31 = OpFUnordGreaterThan %v4bool %29 %30 OpStore %ge %31 %33 = OpLoad %v4float %A %34 = OpLoad %v4float %B %35 = OpFUnordGreaterThanEqual %v4bool %33 %34 OpStore %geq %35 %37 = OpLoad %v4float %A %38 = OpLoad %v4float %B %39 = OpFUnordEqual %v4bool %37 %38 OpStore %eq %39 %41 = OpLoad %v4float %A %42 = OpLoad %v4float %B %43 = OpFUnordNotEqual %v4bool %41 %42 OpStore %neq %43 %44 = OpLoad %v4bool %le %49 = OpSelect %v4float %44 %48 %47 %50 = OpLoad %v4bool %leq %51 = OpSelect %v4float %50 %48 %47 %52 = OpFAdd %v4float %49 %51 %53 = OpLoad %v4bool %ge %54 = OpSelect %v4float %53 %48 %47 %55 = OpFAdd %v4float %52 %54 %56 = OpLoad %v4bool %geq %57 = OpSelect %v4float %56 %48 %47 %58 = OpFAdd %v4float %55 %57 %59 = OpLoad %v4bool %eq %60 = OpSelect %v4float %59 %48 %47 %61 = OpFAdd %v4float %58 %60 %62 = OpLoad %v4bool %neq %63 = OpSelect %v4float %62 %48 %47 %64 = OpFAdd %v4float %61 %63 OpReturnValue %64 OpFunctionEnd %test_scalar_ = OpFunction %float None %11 %13 = OpLabel %le_0 = OpVariable %_ptr_Function_bool Function %leq_0 = OpVariable %_ptr_Function_bool Function %ge_0 = OpVariable %_ptr_Function_bool Function %geq_0 = OpVariable %_ptr_Function_bool Function %eq_0 = OpVariable %_ptr_Function_bool Function %neq_0 = OpVariable %_ptr_Function_bool Function %72 = OpAccessChain %_ptr_Input_float %A %uint_0 %73 = OpLoad %float %72 %74 = OpAccessChain %_ptr_Input_float %B %uint_0 %75 = OpLoad %float %74 %76 = OpFUnordLessThan %bool %73 %75 OpStore %le_0 %76 %78 = OpAccessChain %_ptr_Input_float %A %uint_0 %79 = OpLoad %float %78 %80 = OpAccessChain %_ptr_Input_float %B %uint_0 %81 = OpLoad %float %80 %82 = OpFUnordLessThanEqual %bool %79 %81 OpStore %leq_0 %82 %84 = OpAccessChain %_ptr_Input_float %A %uint_0 %85 = OpLoad %float %84 %86 = OpAccessChain %_ptr_Input_float %B %uint_0 %87 = OpLoad %float %86 %88 = OpFUnordGreaterThan %bool %85 %87 OpStore %ge_0 %88 %90 = OpAccessChain %_ptr_Input_float %A %uint_0 %91 = OpLoad %float %90 %92 = OpAccessChain %_ptr_Input_float %B %uint_0 %93 = OpLoad %float %92 %94 = OpFUnordGreaterThanEqual %bool %91 %93 OpStore %geq_0 %94 %96 = OpAccessChain %_ptr_Input_float %A %uint_0 %97 = OpLoad %float %96 %98 = OpAccessChain %_ptr_Input_float %B %uint_0 %99 = OpLoad %float %98 %100 = OpFUnordEqual %bool %97 %99 OpStore %eq_0 %100 %102 = OpAccessChain %_ptr_Input_float %A %uint_0 %103 = OpLoad %float %102 %104 = OpAccessChain %_ptr_Input_float %B %uint_0 %105 = OpLoad %float %104 %106 = OpFUnordNotEqual %bool %103 %105 OpStore %neq_0 %106 %107 = OpLoad %bool %le_0 %108 = OpSelect %float %107 %float_1 %float_0 %109 = OpLoad %bool %leq_0 %110 = OpSelect %float %109 %float_1 %float_0 %111 = OpFAdd %float %108 %110 %112 = OpLoad %bool %ge_0 %113 = OpSelect %float %112 %float_1 %float_0 %114 = OpFAdd %float %111 %113 %115 = OpLoad %bool %geq_0 %116 = OpSelect %float %115 %float_1 %float_0 %117 = OpFAdd %float %114 %116 %118 = OpLoad %bool %eq_0 %119 = OpSelect %float %118 %float_1 %float_0 %120 = OpFAdd %float %117 %119 %121 = OpLoad %bool %neq_0 %122 = OpSelect %float %121 %float_1 %float_0 %123 = OpFAdd %float %120 %122 OpReturnValue %123 OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/vector-extract-dynamic-spec-constant.asm.frag000066400000000000000000000036721400026215700315370ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 27 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %vColor "vColor" OpName %omap_r "omap_r" OpName %omap_g "omap_g" OpName %omap_b "omap_b" OpName %omap_a "omap_a" OpDecorate %FragColor Location 0 OpDecorate %vColor Location 0 OpDecorate %omap_r SpecId 0 OpDecorate %omap_g SpecId 1 OpDecorate %omap_b SpecId 2 OpDecorate %omap_a SpecId 3 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %vColor = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %omap_r = OpSpecConstant %int 0 %_ptr_Input_float = OpTypePointer Input %float %omap_g = OpSpecConstant %int 1 %omap_b = OpSpecConstant %int 2 %omap_a = OpSpecConstant %int 3 %main = OpFunction %void None %3 %5 = OpLabel %loaded = OpLoad %v4float %vColor %r = OpVectorExtractDynamic %float %loaded %omap_r %g = OpVectorExtractDynamic %float %loaded %omap_g %b = OpVectorExtractDynamic %float %loaded %omap_b %a = OpVectorExtractDynamic %float %loaded %omap_a %rgba = OpCompositeConstruct %v4float %r %g %b %a OpStore %FragColor %rgba OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/vector-shuffle-undef-index.asm.frag000066400000000000000000000031661400026215700275220ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vFloat OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %vFloat "vFloat" OpName %undef "undef" OpDecorate %FragColor Location 0 OpDecorate %vFloat Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %vFloat = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %_ptr_Private_v4float = OpTypePointer Private %v4float %undef = OpUndef %v4float %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_Private_float = OpTypePointer Private %float %uint_3 = OpConstant %uint 3 %_ptr_Input_float = OpTypePointer Input %float %main = OpFunction %void None %3 %5 = OpLabel %13 = OpLoad %v4float %vFloat %26 = OpVectorShuffle %v4float %13 %undef 4 1 0xffffffff 3 %27 = OpVectorShuffle %v4float %13 %13 2 1 0xffffffff 3 %28 = OpFAdd %v4float %26 %27 OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/frag/while-loop-inverted-test.asm.frag000066400000000000000000000032741400026215700272340ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %i "i" OpName %j "j" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_20 = OpConstant %int 20 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpStore %j %int_0 OpBranch %11 %11 = OpLabel OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %16 = OpLoad %int %i %19 = OpIEqual %bool %16 %int_20 OpBranchConditional %19 %13 %12 %12 = OpLabel %20 = OpLoad %int %j %21 = OpLoad %int %i %22 = OpIAdd %int %20 %21 %24 = OpIAdd %int %22 %int_1 %25 = OpLoad %int %j %26 = OpIMul %int %24 %25 OpStore %j %26 %27 = OpLoad %int %i %28 = OpIAdd %int %27 %int_1 OpStore %i %28 OpBranch %14 %14 = OpLabel OpBranch %11 %13 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/geom/000077500000000000000000000000001400026215700207445ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/geom/store-uint-layer.invalid.asm.geom000066400000000000000000000135321400026215700272500ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 74 ; Schema: 0 OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %stream_pos %stream_layer %input_pos OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 3 OpSource HLSL 500 OpName %main "main" OpName %VertexOutput "VertexOutput" OpMemberName %VertexOutput 0 "pos" OpName %GeometryOutput "GeometryOutput" OpMemberName %GeometryOutput 0 "pos" OpMemberName %GeometryOutput 1 "layer" OpName %_main_struct_VertexOutput_vf41_3__struct_GeometryOutput_vf4_u11_ "@main(struct-VertexOutput-vf41[3];struct-GeometryOutput-vf4-u11;" OpName %input "input" OpName %stream "stream" OpName %output "output" OpName %v "v" OpName %stream_pos "stream.pos" OpName %stream_layer "stream.layer" OpName %input_0 "input" OpName %input_pos "input.pos" OpName %stream_0 "stream" OpName %param "param" OpName %param_0 "param" OpDecorate %stream_pos BuiltIn Position OpDecorate %stream_layer BuiltIn Layer OpDecorate %input_pos BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %VertexOutput = OpTypeStruct %v4float %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_VertexOutput_uint_3 = OpTypeArray %VertexOutput %uint_3 %_ptr_Function__arr_VertexOutput_uint_3 = OpTypePointer Function %_arr_VertexOutput_uint_3 %GeometryOutput = OpTypeStruct %v4float %uint %_ptr_Function_GeometryOutput = OpTypePointer Function %GeometryOutput %15 = OpTypeFunction %void %_ptr_Function__arr_VertexOutput_uint_3 %_ptr_Function_GeometryOutput %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %uint_1 = OpConstant %uint 1 %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_3 = OpConstant %int 3 %bool = OpTypeBool %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %stream_pos = OpVariable %_ptr_Output_v4float Output %_ptr_Output_uint = OpTypePointer Output %uint %stream_layer = OpVariable %_ptr_Output_uint Output %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %input_pos = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %int_2 = OpConstant %int 2 %main = OpFunction %void None %3 %5 = OpLabel %input_0 = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %stream_0 = OpVariable %_ptr_Function_GeometryOutput Function %param = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %param_0 = OpVariable %_ptr_Function_GeometryOutput Function %58 = OpAccessChain %_ptr_Input_v4float %input_pos %int_0 %59 = OpLoad %v4float %58 %60 = OpAccessChain %_ptr_Function_v4float %input_0 %int_0 %int_0 OpStore %60 %59 %61 = OpAccessChain %_ptr_Input_v4float %input_pos %int_1 %62 = OpLoad %v4float %61 %63 = OpAccessChain %_ptr_Function_v4float %input_0 %int_1 %int_0 OpStore %63 %62 %65 = OpAccessChain %_ptr_Input_v4float %input_pos %int_2 %66 = OpLoad %v4float %65 %67 = OpAccessChain %_ptr_Function_v4float %input_0 %int_2 %int_0 OpStore %67 %66 %70 = OpLoad %_arr_VertexOutput_uint_3 %input_0 OpStore %param %70 %72 = OpFunctionCall %void %_main_struct_VertexOutput_vf41_3__struct_GeometryOutput_vf4_u11_ %param %param_0 %73 = OpLoad %GeometryOutput %param_0 OpStore %stream_0 %73 OpReturn OpFunctionEnd %_main_struct_VertexOutput_vf41_3__struct_GeometryOutput_vf4_u11_ = OpFunction %void None %15 %input = OpFunctionParameter %_ptr_Function__arr_VertexOutput_uint_3 %stream = OpFunctionParameter %_ptr_Function_GeometryOutput %19 = OpLabel %output = OpVariable %_ptr_Function_GeometryOutput Function %v = OpVariable %_ptr_Function_int Function %25 = OpAccessChain %_ptr_Function_uint %output %int_1 OpStore %25 %uint_1 OpStore %v %int_0 OpBranch %29 %29 = OpLabel OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %34 = OpLoad %int %v %37 = OpSLessThan %bool %34 %int_3 OpBranchConditional %37 %30 %31 %30 = OpLabel %38 = OpLoad %int %v %40 = OpAccessChain %_ptr_Function_v4float %input %38 %int_0 %41 = OpLoad %v4float %40 %42 = OpAccessChain %_ptr_Function_v4float %output %int_0 OpStore %42 %41 %45 = OpAccessChain %_ptr_Function_v4float %output %int_0 %46 = OpLoad %v4float %45 OpStore %stream_pos %46 %49 = OpAccessChain %_ptr_Function_uint %output %int_1 %50 = OpLoad %uint %49 OpStore %stream_layer %50 OpEmitVertex OpBranch %32 %32 = OpLabel %51 = OpLoad %int %v %52 = OpIAdd %int %51 %int_1 OpStore %v %52 OpBranch %29 %31 = OpLabel OpEndPrimitive OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/loop-header-self-continue-break.asm.comp000066400000000000000000000107431400026215700275130ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google Clspv; 0 ; Bound: 83 ; Schema: 0 OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %19 "main" %gl_GlobalInvocationID OpSource OpenCL_C 120 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_struct_3 Block OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 0 OpDecorate %16 DescriptorSet 0 OpDecorate %16 Binding 1 OpDecorate %10 SpecId 0 OpDecorate %11 SpecId 1 OpDecorate %12 SpecId 2 %float = OpTypeFloat 32 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_3 = OpTypeStruct %_runtimearr_float %_ptr_StorageBuffer__struct_3 = OpTypePointer StorageBuffer %_struct_3 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Private_v3uint = OpTypePointer Private %v3uint %10 = OpSpecConstant %uint 1 %11 = OpSpecConstant %uint 1 %12 = OpSpecConstant %uint 1 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %10 %11 %12 %void = OpTypeVoid %18 = OpTypeFunction %void %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %uint_35 = OpConstant %uint 35 %uint_1 = OpConstant %uint 1 %float_3 = OpConstant %float 3 %bool = OpTypeBool %uint_34 = OpConstant %uint 34 %uint_5 = OpConstant %uint 5 %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %14 = OpVariable %_ptr_Private_v3uint Private %gl_WorkGroupSize %15 = OpVariable %_ptr_StorageBuffer__struct_3 StorageBuffer %16 = OpVariable %_ptr_StorageBuffer__struct_3 StorageBuffer %19 = OpFunction %void None %18 %20 = OpLabel %23 = OpAccessChain %_ptr_StorageBuffer_float %15 %uint_0 %uint_0 %25 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %26 = OpLoad %uint %25 %27 = OpLoad %float %23 %29 = OpAccessChain %_ptr_StorageBuffer_float %15 %uint_0 %uint_35 OpBranch %31 %31 = OpLabel %32 = OpPhi %float %27 %20 %67 %58 %33 = OpPhi %uint %uint_0 %20 %63 %58 %34 = OpLoad %float %29 OpLoopMerge %69 %58 None OpBranch %37 %37 = OpLabel %38 = OpPhi %float %46 %37 %32 %31 %39 = OpPhi %float %38 %37 %34 %31 %40 = OpPhi %uint %44 %37 %uint_0 %31 %41 = OpAccessChain %_ptr_StorageBuffer_float %15 %uint_0 %40 %42 = OpFAdd %float %39 %38 %44 = OpIAdd %uint %40 %uint_1 %45 = OpAccessChain %_ptr_StorageBuffer_float %15 %uint_0 %44 %46 = OpLoad %float %45 %47 = OpFAdd %float %42 %46 %49 = OpFDiv %float %47 %float_3 OpStore %41 %49 %52 = OpULessThan %bool %40 %uint_34 %53 = OpLogicalNot %bool %52 OpLoopMerge %56 %37 None OpBranchConditional %53 %56 %37 %56 = OpLabel OpBranch %58 %58 = OpLabel %59 = OpLoad %float %29 %60 = OpFAdd %float %38 %59 %61 = OpFAdd %float %32 %60 %62 = OpFDiv %float %61 %float_3 OpStore %29 %62 %63 = OpIAdd %uint %33 %uint_1 %65 = OpULessThan %bool %33 %uint_5 %66 = OpLogicalNot %bool %65 %67 = OpLoad %float %23 OpBranchConditional %66 %69 %31 %69 = OpLabel %70 = OpPhi %float %75 %69 %67 %58 %71 = OpPhi %uint %76 %69 %uint_1 %58 %72 = OpAccessChain %_ptr_StorageBuffer_float %15 %uint_0 %71 %73 = OpLoad %float %72 %74 = OpFOrdLessThan %bool %70 %73 %75 = OpSelect %float %74 %73 %70 %76 = OpIAdd %uint %71 %uint_1 %77 = OpULessThan %bool %71 %uint_35 %78 = OpLogicalNot %bool %77 OpLoopMerge %81 %69 None OpBranchConditional %78 %81 %69 %81 = OpLabel %82 = OpAccessChain %_ptr_StorageBuffer_float %16 %uint_0 %26 OpStore %82 %75 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/temporary.zero-initialize.asm.frag000066400000000000000000000067461400026215700266110ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 65 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vA %vB OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %vA "vA" OpName %vB "vB" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %vA RelaxedPrecision OpDecorate %vA Flat OpDecorate %vA Location 0 OpDecorate %25 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %vB RelaxedPrecision OpDecorate %vB Flat OpDecorate %vB Location 1 OpDecorate %38 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %51 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %64 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %60 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %11 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_int = OpTypePointer Input %int %vA = OpVariable %_ptr_Input_int Input %bool = OpTypeBool %int_20 = OpConstant %int 20 %int_50 = OpConstant %int 50 %vB = OpVariable %_ptr_Input_int Input %int_40 = OpConstant %int 40 %int_60 = OpConstant %int 60 %int_10 = OpConstant %int 10 %float_1 = OpConstant %float 1 %63 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %main = OpFunction %void None %3 %5 = OpLabel OpStore %FragColor %11 OpBranch %17 %17 = OpLabel %60 = OpPhi %int %int_0 %5 %58 %20 %57 = OpPhi %int %int_0 %5 %56 %20 %25 = OpLoad %int %vA %27 = OpSLessThan %bool %57 %25 OpLoopMerge %19 %20 None OpBranchConditional %27 %18 %19 %18 = OpLabel %30 = OpIAdd %int %25 %57 %32 = OpIEqual %bool %30 %int_20 OpSelectionMerge %34 None OpBranchConditional %32 %33 %36 %33 = OpLabel OpBranch %34 %36 = OpLabel %38 = OpLoad %int %vB %40 = OpIAdd %int %38 %57 %42 = OpIEqual %bool %40 %int_40 %64 = OpSelect %int %42 %int_60 %60 OpBranch %34 %34 = OpLabel %58 = OpPhi %int %int_50 %33 %64 %36 %49 = OpIAdd %int %58 %int_10 %51 = OpLoad %v4float %FragColor %53 = OpFAdd %v4float %51 %63 OpStore %FragColor %53 OpBranch %20 %20 = OpLabel %56 = OpIAdd %int %57 %49 OpBranch %17 %19 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/tesc/000077500000000000000000000000001400026215700207535ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/tesc/array-of-block-output-initializer.asm.tesc000066400000000000000000000112701400026215700311020ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 42 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_out %gl_InvocationID %_ %patches %v2 %v3 %verts OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpName %gl_InvocationID "gl_InvocationID" OpName %vert "vert" OpMemberName %vert 0 "v0" OpMemberName %vert 1 "v1" OpName %_ "" OpName %vert_patch "vert_patch" OpMemberName %vert_patch 0 "v2" OpMemberName %vert_patch 1 "v3" OpName %patches "patches" OpName %v2 "v2" OpName %v3 "v3" OpName %vert2 "vert2" OpMemberName %vert2 0 "v4" OpMemberName %vert2 1 "v5" OpName %verts "verts" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpMemberDecorate %vert 0 Patch OpMemberDecorate %vert 1 Patch OpDecorate %vert Block OpDecorate %_ Location 0 OpMemberDecorate %vert_patch 0 Patch OpMemberDecorate %vert_patch 1 Patch OpDecorate %vert_patch Block OpDecorate %patches Location 2 OpDecorate %v2 Patch OpDecorate %v2 Location 6 OpDecorate %v3 Location 7 OpDecorate %vert2 Block OpDecorate %verts Location 8 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out_zero = OpConstantNull %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %gl_out_zero %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %22 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %vert = OpTypeStruct %float %float %_ptr_Output_vert = OpTypePointer Output %vert %__zero = OpConstantNull %vert %_ = OpVariable %_ptr_Output_vert Output %__zero %vert_patch = OpTypeStruct %float %float %uint_2 = OpConstant %uint 2 %_arr_vert_patch_uint_2 = OpTypeArray %vert_patch %uint_2 %_ptr_Output__arr_vert_patch_uint_2 = OpTypePointer Output %_arr_vert_patch_uint_2 %patches_zero = OpConstantNull %_arr_vert_patch_uint_2 %patches = OpVariable %_ptr_Output__arr_vert_patch_uint_2 Output %patches_zero %_ptr_Output_float = OpTypePointer Output %float %v2_zero = OpConstantNull %float %v2 = OpVariable %_ptr_Output_float Output %v2_zero %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %v3_zero = OpConstantNull %_arr_float_uint_4 %v3 = OpVariable %_ptr_Output__arr_float_uint_4 Output %v3_zero %vert2 = OpTypeStruct %float %float %_arr_vert2_uint_4 = OpTypeArray %vert2 %uint_4 %_ptr_Output__arr_vert2_uint_4 = OpTypePointer Output %_arr_vert2_uint_4 %verts_zero = OpConstantNull %_arr_vert2_uint_4 %verts = OpVariable %_ptr_Output__arr_vert2_uint_4 Output %verts_zero %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Output_v4float %gl_out %19 %int_0 OpStore %24 %22 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/tesc/tess-fixed-input-array-builtin-array.invalid.asm.tesc000066400000000000000000000307671400026215700331600ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 162 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %hs_main "main" %p_pos %p_1 %i_1 %_entryPointOutput_pos %_entryPointOutput %_patchConstantOutput_EdgeTess %_patchConstantOutput_InsideTess OpExecutionMode %hs_main OutputVertices 3 OpExecutionMode %hs_main Triangles OpExecutionMode %hs_main SpacingFractionalOdd OpExecutionMode %hs_main VertexOrderCw OpSource HLSL 500 OpName %hs_main "hs_main" OpName %VertexOutput "VertexOutput" OpMemberName %VertexOutput 0 "pos" OpMemberName %VertexOutput 1 "uv" OpName %HSOut "HSOut" OpMemberName %HSOut 0 "pos" OpMemberName %HSOut 1 "uv" OpName %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ "@hs_main(struct-VertexOutput-vf4-vf21[3];u1;" OpName %p "p" OpName %i "i" OpName %HSConstantOut "HSConstantOut" OpMemberName %HSConstantOut 0 "EdgeTess" OpMemberName %HSConstantOut 1 "InsideTess" OpName %PatchHS_struct_VertexOutput_vf4_vf21_3__ "PatchHS(struct-VertexOutput-vf4-vf21[3];" OpName %patch "patch" OpName %output "output" OpName %p_0 "p" OpName %p_pos "p.pos" OpName %VertexOutput_0 "VertexOutput" OpMemberName %VertexOutput_0 0 "uv" OpName %p_1 "p" OpName %i_0 "i" OpName %i_1 "i" OpName %flattenTemp "flattenTemp" OpName %param "param" OpName %param_0 "param" OpName %_entryPointOutput_pos "@entryPointOutput.pos" OpName %HSOut_0 "HSOut" OpMemberName %HSOut_0 0 "uv" OpName %_entryPointOutput "@entryPointOutput" OpName %_patchConstantResult "@patchConstantResult" OpName %param_1 "param" OpName %_patchConstantOutput_EdgeTess "@patchConstantOutput.EdgeTess" OpName %_patchConstantOutput_InsideTess "@patchConstantOutput.InsideTess" OpName %output_0 "output" OpDecorate %p_pos BuiltIn Position OpDecorate %p_1 Location 0 OpDecorate %i_1 BuiltIn InvocationId OpDecorate %_entryPointOutput_pos BuiltIn Position OpDecorate %_entryPointOutput Location 0 OpDecorate %_patchConstantOutput_EdgeTess Patch OpDecorate %_patchConstantOutput_EdgeTess BuiltIn TessLevelOuter OpDecorate %_patchConstantOutput_InsideTess Patch OpDecorate %_patchConstantOutput_InsideTess BuiltIn TessLevelInner %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %VertexOutput = OpTypeStruct %v4float %v2float %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_VertexOutput_uint_3 = OpTypeArray %VertexOutput %uint_3 %_ptr_Function__arr_VertexOutput_uint_3 = OpTypePointer Function %_arr_VertexOutput_uint_3 %_ptr_Function_uint = OpTypePointer Function %uint %HSOut = OpTypeStruct %v4float %v2float %16 = OpTypeFunction %HSOut %_ptr_Function__arr_VertexOutput_uint_3 %_ptr_Function_uint %_arr_float_uint_3 = OpTypeArray %float %uint_3 %HSConstantOut = OpTypeStruct %_arr_float_uint_3 %float %23 = OpTypeFunction %HSConstantOut %_ptr_Function__arr_VertexOutput_uint_3 %_ptr_Function_HSOut = OpTypePointer Function %HSOut %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %int_1 = OpConstant %int 1 %_ptr_Function_v2float = OpTypePointer Function %v2float %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %p_pos = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %VertexOutput_0 = OpTypeStruct %v2float %_arr_VertexOutput_0_uint_3 = OpTypeArray %VertexOutput_0 %uint_3 %_ptr_Input__arr_VertexOutput_0_uint_3 = OpTypePointer Input %_arr_VertexOutput_0_uint_3 %p_1 = OpVariable %_ptr_Input__arr_VertexOutput_0_uint_3 Input %_ptr_Input_v2float = OpTypePointer Input %v2float %int_2 = OpConstant %int 2 %_ptr_Input_uint = OpTypePointer Input %uint %i_1 = OpVariable %_ptr_Input_uint Input %_ptr_Output__arr_v4float_uint_3 = OpTypePointer Output %_arr_v4float_uint_3 %_entryPointOutput_pos = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %_ptr_Output_v4float = OpTypePointer Output %v4float %HSOut_0 = OpTypeStruct %v2float %_arr_HSOut_0_uint_3 = OpTypeArray %HSOut_0 %uint_3 %_ptr_Output__arr_HSOut_0_uint_3 = OpTypePointer Output %_arr_HSOut_0_uint_3 %_entryPointOutput = OpVariable %_ptr_Output__arr_HSOut_0_uint_3 Output %_ptr_Output_v2float = OpTypePointer Output %v2float %uint_2 = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %_ptr_Function_HSConstantOut = OpTypePointer Function %HSConstantOut %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %_patchConstantOutput_EdgeTess = OpVariable %_ptr_Output__arr_float_uint_4 Output %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_float = OpTypePointer Output %float %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %_patchConstantOutput_InsideTess = OpVariable %_ptr_Output__arr_float_uint_2 Output %float_1 = OpConstant %float 1 %hs_main = OpFunction %void None %3 %5 = OpLabel %p_0 = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %i_0 = OpVariable %_ptr_Function_uint Function %flattenTemp = OpVariable %_ptr_Function_HSOut Function %param = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %param_0 = OpVariable %_ptr_Function_uint Function %_patchConstantResult = OpVariable %_ptr_Function_HSConstantOut Function %param_1 = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function %50 = OpAccessChain %_ptr_Input_v4float %p_pos %int_0 %51 = OpLoad %v4float %50 %52 = OpAccessChain %_ptr_Function_v4float %p_0 %int_0 %int_0 OpStore %52 %51 %58 = OpAccessChain %_ptr_Input_v2float %p_1 %int_0 %int_0 %59 = OpLoad %v2float %58 %60 = OpAccessChain %_ptr_Function_v2float %p_0 %int_0 %int_1 OpStore %60 %59 %61 = OpAccessChain %_ptr_Input_v4float %p_pos %int_1 %62 = OpLoad %v4float %61 %63 = OpAccessChain %_ptr_Function_v4float %p_0 %int_1 %int_0 OpStore %63 %62 %64 = OpAccessChain %_ptr_Input_v2float %p_1 %int_1 %int_0 %65 = OpLoad %v2float %64 %66 = OpAccessChain %_ptr_Function_v2float %p_0 %int_1 %int_1 OpStore %66 %65 %68 = OpAccessChain %_ptr_Input_v4float %p_pos %int_2 %69 = OpLoad %v4float %68 %70 = OpAccessChain %_ptr_Function_v4float %p_0 %int_2 %int_0 OpStore %70 %69 %71 = OpAccessChain %_ptr_Input_v2float %p_1 %int_2 %int_0 %72 = OpLoad %v2float %71 %73 = OpAccessChain %_ptr_Function_v2float %p_0 %int_2 %int_1 OpStore %73 %72 %77 = OpLoad %uint %i_1 OpStore %i_0 %77 %80 = OpLoad %_arr_VertexOutput_uint_3 %p_0 OpStore %param %80 %82 = OpLoad %uint %i_0 OpStore %param_0 %82 %83 = OpFunctionCall %HSOut %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ %param %param_0 OpStore %flattenTemp %83 %86 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0 %87 = OpLoad %v4float %86 %94 = OpLoad %uint %i_1 %89 = OpAccessChain %_ptr_Output_v4float %_entryPointOutput_pos %94 OpStore %89 %87 %95 = OpAccessChain %_ptr_Function_v2float %flattenTemp %int_1 %96 = OpLoad %v2float %95 %98 = OpAccessChain %_ptr_Output_v2float %_entryPointOutput %94 %int_0 OpStore %98 %96 OpControlBarrier %uint_2 %uint_1 %uint_0 %102 = OpLoad %uint %i_1 %104 = OpIEqual %bool %102 %int_0 OpSelectionMerge %106 None OpBranchConditional %104 %105 %106 %105 = OpLabel %110 = OpLoad %_arr_VertexOutput_uint_3 %p_0 OpStore %param_1 %110 %111 = OpFunctionCall %HSConstantOut %PatchHS_struct_VertexOutput_vf4_vf21_3__ %param_1 OpStore %_patchConstantResult %111 %117 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_0 %118 = OpLoad %float %117 %120 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_0 OpStore %120 %118 %121 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_1 %122 = OpLoad %float %121 %123 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_1 OpStore %123 %122 %124 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_2 %125 = OpLoad %float %124 %126 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_2 OpStore %126 %125 %130 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_1 %131 = OpLoad %float %130 %132 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_InsideTess %int_0 OpStore %132 %131 OpBranch %106 %106 = OpLabel OpReturn OpFunctionEnd %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ = OpFunction %HSOut None %16 %p = OpFunctionParameter %_ptr_Function__arr_VertexOutput_uint_3 %i = OpFunctionParameter %_ptr_Function_uint %20 = OpLabel %output = OpVariable %_ptr_Function_HSOut Function %31 = OpLoad %uint %i %33 = OpAccessChain %_ptr_Function_v4float %p %31 %int_0 %34 = OpLoad %v4float %33 %35 = OpAccessChain %_ptr_Function_v4float %output %int_0 OpStore %35 %34 %37 = OpLoad %uint %i %39 = OpAccessChain %_ptr_Function_v2float %p %37 %int_1 %40 = OpLoad %v2float %39 %41 = OpAccessChain %_ptr_Function_v2float %output %int_1 OpStore %41 %40 %42 = OpLoad %HSOut %output OpReturnValue %42 OpFunctionEnd %PatchHS_struct_VertexOutput_vf4_vf21_3__ = OpFunction %HSConstantOut None %23 %patch = OpFunctionParameter %_ptr_Function__arr_VertexOutput_uint_3 %26 = OpLabel %output_0 = OpVariable %_ptr_Function_HSConstantOut Function %135 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %136 = OpLoad %v2float %135 %137 = OpCompositeConstruct %v2float %float_1 %float_1 %138 = OpFAdd %v2float %137 %136 %139 = OpCompositeExtract %float %138 0 %140 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_0 OpStore %140 %139 %141 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %142 = OpLoad %v2float %141 %143 = OpCompositeConstruct %v2float %float_1 %float_1 %144 = OpFAdd %v2float %143 %142 %145 = OpCompositeExtract %float %144 0 %146 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_1 OpStore %146 %145 %147 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %148 = OpLoad %v2float %147 %149 = OpCompositeConstruct %v2float %float_1 %float_1 %150 = OpFAdd %v2float %149 %148 %151 = OpCompositeExtract %float %150 0 %152 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_2 OpStore %152 %151 %153 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1 %154 = OpLoad %v2float %153 %155 = OpCompositeConstruct %v2float %float_1 %float_1 %156 = OpFAdd %v2float %155 %154 %157 = OpCompositeExtract %float %156 0 %158 = OpAccessChain %_ptr_Function_float %output_0 %int_1 OpStore %158 %157 %159 = OpLoad %HSConstantOut %output_0 OpReturnValue %159 OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/tesc/tess-level-initializer.asm.tesc000066400000000000000000000103031400026215700270130ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 47 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_out %gl_InvocationID %gl_TessLevelInner %gl_TessLevelOuter OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpName %gl_InvocationID "gl_InvocationID" OpName %gl_TessLevelInner "gl_TessLevelInner" OpName %gl_TessLevelOuter "gl_TessLevelOuter" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %gl_TessLevelInner Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %22 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %inner_zero = OpConstantNull %_arr_float_uint_2 %gl_TessLevelInner = OpVariable %_ptr_Output__arr_float_uint_2 Output %inner_zero %_ptr_Output_float = OpTypePointer Output %float %int_1 = OpConstant %int 1 %float_2 = OpConstant %float 2 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %outer_zero = OpConstantNull %_arr_float_uint_4 %gl_TessLevelOuter = OpVariable %_ptr_Output__arr_float_uint_4 Output %outer_zero %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %int_2 = OpConstant %int 2 %float_5 = OpConstant %float 5 %int_3 = OpConstant %int 3 %float_6 = OpConstant %float 6 %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Output_v4float %gl_out %19 %int_0 OpStore %24 %22 %30 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_0 OpStore %30 %float_1 %33 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %int_1 OpStore %33 %float_2 %38 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_0 OpStore %38 %float_3 %40 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_1 OpStore %40 %float_4 %43 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_2 OpStore %43 %float_5 %46 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %int_3 OpStore %46 %float_6 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/vert/000077500000000000000000000000001400026215700207755ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/vert/block-struct-initializer.asm.vert000066400000000000000000000024641400026215700274210ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 13 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %foo OpSource GLSL 450 OpName %main "main" OpName %Vert "Vert" OpMemberName %Vert 0 "a" OpMemberName %Vert 1 "b" OpName %_ "" OpName %Foo "Foo" OpMemberName %Foo 0 "c" OpMemberName %Foo 1 "d" OpName %foo "foo" OpDecorate %Vert Block OpDecorate %_ Location 0 OpDecorate %foo Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Vert = OpTypeStruct %float %float %_ptr_Output_Vert = OpTypePointer Output %Vert %zero_vert = OpConstantNull %Vert %_ = OpVariable %_ptr_Output_Vert Output %zero_vert %Foo = OpTypeStruct %float %float %_ptr_Output_Foo = OpTypePointer Output %Foo %zero_foo = OpConstantNull %Foo %foo = OpVariable %_ptr_Output_Foo Output %zero_foo %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/vert/builtin-output-initializer.asm.vert000066400000000000000000000035651400026215700300140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %zero = OpConstantNull %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %zero %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %17 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/vert/complex-link-by-name.asm.vert000066400000000000000000000124731400026215700264150ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 59 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %output_location_0 %output_location_2 %output_location_3 OpSource GLSL 450 OpName %main "main" OpName %Foo "Struct_vec4" OpMemberName %Foo 0 "m0" OpName %c "c" OpName %Foo_0 "Struct_vec4" OpMemberName %Foo_0 0 "m0" OpName %Bar "Struct_vec4" OpMemberName %Bar 0 "m0" OpName %UBO "UBO" OpMemberName %UBO 0 "m0" OpMemberName %UBO 1 "m1" OpName %ubo_binding_0 "ubo_binding_0" OpName %Bar_0 "Struct_vec4" OpMemberName %Bar_0 0 "m0" OpName %b "b" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %VertexOut "VertexOut" OpMemberName %VertexOut 0 "m0" OpMemberName %VertexOut 1 "m1" OpName %output_location_0 "output_location_0" OpName %output_location_2 "output_location_2" OpName %output_location_3 "output_location_3" OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %Bar 0 Offset 0 OpMemberDecorate %UBO 0 Offset 0 OpMemberDecorate %UBO 1 Offset 16 OpDecorate %UBO Block OpDecorate %ubo_binding_0 DescriptorSet 0 OpDecorate %ubo_binding_0 Binding 0 OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %VertexOut Block OpDecorate %output_location_0 Location 0 OpDecorate %output_location_2 Location 2 OpDecorate %output_location_3 Location 3 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Foo = OpTypeStruct %v4float %_ptr_Function_Foo = OpTypePointer Function %Foo %Foo_0 = OpTypeStruct %v4float %Bar = OpTypeStruct %v4float %UBO = OpTypeStruct %Foo_0 %Bar %_ptr_Uniform_UBO = OpTypePointer Uniform %UBO %ubo_binding_0 = OpVariable %_ptr_Uniform_UBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Function_v4float = OpTypePointer Function %v4float %Bar_0 = OpTypeStruct %v4float %_ptr_Function_Bar_0 = OpTypePointer Function %Bar_0 %int_1 = OpConstant %int 1 %_ptr_Uniform_Bar = OpTypePointer Uniform %Bar %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %_ptr_Output_v4float = OpTypePointer Output %v4float %VertexOut = OpTypeStruct %Foo %Bar_0 %_ptr_Output_VertexOut = OpTypePointer Output %VertexOut %output_location_0 = OpVariable %_ptr_Output_VertexOut Output %_ptr_Output_Foo = OpTypePointer Output %Foo %_ptr_Output_Bar_0 = OpTypePointer Output %Bar_0 %output_location_2 = OpVariable %_ptr_Output_Foo Output %output_location_3 = OpVariable %_ptr_Output_Bar_0 Output %main = OpFunction %void None %3 %5 = OpLabel %c = OpVariable %_ptr_Function_Foo Function %b = OpVariable %_ptr_Function_Bar_0 Function %19 = OpAccessChain %_ptr_Uniform_Foo_0 %ubo_binding_0 %int_0 %20 = OpLoad %Foo_0 %19 %21 = OpCompositeExtract %v4float %20 0 %23 = OpAccessChain %_ptr_Function_v4float %c %int_0 OpStore %23 %21 %29 = OpAccessChain %_ptr_Uniform_Bar %ubo_binding_0 %int_1 %30 = OpLoad %Bar %29 %31 = OpCompositeExtract %v4float %30 0 %32 = OpAccessChain %_ptr_Function_v4float %b %int_0 OpStore %32 %31 %39 = OpAccessChain %_ptr_Function_v4float %c %int_0 %40 = OpLoad %v4float %39 %41 = OpAccessChain %_ptr_Function_v4float %b %int_0 %42 = OpLoad %v4float %41 %43 = OpFAdd %v4float %40 %42 %45 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %45 %43 %49 = OpLoad %Foo %c %51 = OpAccessChain %_ptr_Output_Foo %output_location_0 %int_0 OpStore %51 %49 %52 = OpLoad %Bar_0 %b %54 = OpAccessChain %_ptr_Output_Bar_0 %output_location_0 %int_1 OpStore %54 %52 %56 = OpLoad %Foo %c OpStore %output_location_2 %56 %58 = OpLoad %Bar_0 %b OpStore %output_location_3 %58 OpReturn OpFunctionEnd complex-link-by-name.force-flattened-io.legacy.asm.vert000066400000000000000000000124731400026215700332470ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/asm/vert; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 59 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %output_location_0 %output_location_2 %output_location_3 OpSource GLSL 450 OpName %main "main" OpName %Foo "Struct_vec4" OpMemberName %Foo 0 "m0" OpName %c "c" OpName %Foo_0 "Struct_vec4" OpMemberName %Foo_0 0 "m0" OpName %Bar "Struct_vec4" OpMemberName %Bar 0 "m0" OpName %UBO "UBO" OpMemberName %UBO 0 "m0" OpMemberName %UBO 1 "m1" OpName %ubo_binding_0 "ubo_binding_0" OpName %Bar_0 "Struct_vec4" OpMemberName %Bar_0 0 "m0" OpName %b "b" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %VertexOut "VertexOut" OpMemberName %VertexOut 0 "m0" OpMemberName %VertexOut 1 "m1" OpName %output_location_0 "output_location_0" OpName %output_location_2 "output_location_2" OpName %output_location_3 "output_location_3" OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %Bar 0 Offset 0 OpMemberDecorate %UBO 0 Offset 0 OpMemberDecorate %UBO 1 Offset 16 OpDecorate %UBO Block OpDecorate %ubo_binding_0 DescriptorSet 0 OpDecorate %ubo_binding_0 Binding 0 OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %VertexOut Block OpDecorate %output_location_0 Location 0 OpDecorate %output_location_2 Location 2 OpDecorate %output_location_3 Location 3 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Foo = OpTypeStruct %v4float %_ptr_Function_Foo = OpTypePointer Function %Foo %Foo_0 = OpTypeStruct %v4float %Bar = OpTypeStruct %v4float %UBO = OpTypeStruct %Foo_0 %Bar %_ptr_Uniform_UBO = OpTypePointer Uniform %UBO %ubo_binding_0 = OpVariable %_ptr_Uniform_UBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Function_v4float = OpTypePointer Function %v4float %Bar_0 = OpTypeStruct %v4float %_ptr_Function_Bar_0 = OpTypePointer Function %Bar_0 %int_1 = OpConstant %int 1 %_ptr_Uniform_Bar = OpTypePointer Uniform %Bar %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %_ptr_Output_v4float = OpTypePointer Output %v4float %VertexOut = OpTypeStruct %Foo %Bar_0 %_ptr_Output_VertexOut = OpTypePointer Output %VertexOut %output_location_0 = OpVariable %_ptr_Output_VertexOut Output %_ptr_Output_Foo = OpTypePointer Output %Foo %_ptr_Output_Bar_0 = OpTypePointer Output %Bar_0 %output_location_2 = OpVariable %_ptr_Output_Foo Output %output_location_3 = OpVariable %_ptr_Output_Bar_0 Output %main = OpFunction %void None %3 %5 = OpLabel %c = OpVariable %_ptr_Function_Foo Function %b = OpVariable %_ptr_Function_Bar_0 Function %19 = OpAccessChain %_ptr_Uniform_Foo_0 %ubo_binding_0 %int_0 %20 = OpLoad %Foo_0 %19 %21 = OpCompositeExtract %v4float %20 0 %23 = OpAccessChain %_ptr_Function_v4float %c %int_0 OpStore %23 %21 %29 = OpAccessChain %_ptr_Uniform_Bar %ubo_binding_0 %int_1 %30 = OpLoad %Bar %29 %31 = OpCompositeExtract %v4float %30 0 %32 = OpAccessChain %_ptr_Function_v4float %b %int_0 OpStore %32 %31 %39 = OpAccessChain %_ptr_Function_v4float %c %int_0 %40 = OpLoad %v4float %39 %41 = OpAccessChain %_ptr_Function_v4float %b %int_0 %42 = OpLoad %v4float %41 %43 = OpFAdd %v4float %40 %42 %45 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %45 %43 %49 = OpLoad %Foo %c %51 = OpAccessChain %_ptr_Output_Foo %output_location_0 %int_0 OpStore %51 %49 %52 = OpLoad %Bar_0 %b %54 = OpAccessChain %_ptr_Output_Bar_0 %output_location_0 %int_1 OpStore %54 %52 %56 = OpLoad %Foo %c OpStore %output_location_2 %56 %58 = OpLoad %Bar_0 %b OpStore %output_location_3 %58 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/vert/empty-struct-composite.asm.vert000066400000000000000000000022461400026215700271420ustar00rootroot00000000000000; SPIR-V ; Version: 1.1 ; Generator: Google rspirv; 0 ; Bound: 17 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %2 "main" OpName %Test "Test" OpName %t "t" OpName %retvar "retvar" OpName %main "main" OpName %retvar_0 "retvar" %void = OpTypeVoid %6 = OpTypeFunction %void %Test = OpTypeStruct %_ptr_Function_Test = OpTypePointer Function %Test %_ptr_Function_void = OpTypePointer Function %void %2 = OpFunction %void None %6 %7 = OpLabel %t = OpVariable %_ptr_Function_Test Function %retvar = OpVariable %_ptr_Function_void Function OpBranch %4 %4 = OpLabel %13 = OpCompositeConstruct %Test OpStore %t %13 OpReturn OpFunctionEnd %main = OpFunction %void None %6 %15 = OpLabel %retvar_0 = OpVariable %_ptr_Function_void Function OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/asm/vert/semantic-decoration.asm.vert000066400000000000000000000060461400026215700264140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 36 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_decorate_string" OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_entryPointOutput_p %_entryPointOutput_c OpSource HLSL 500 OpName %main "main" OpName %VOut "VOut" OpMemberName %VOut 0 "p" OpMemberName %VOut 1 "c" OpName %_main_ "@main(" OpName %v "v" OpName %flattenTemp "flattenTemp" OpName %_entryPointOutput_p "@entryPointOutput.p" OpName %_entryPointOutput_c "@entryPointOutput.c" OpMemberDecorateStringGOOGLE %VOut 0 HlslSemanticGOOGLE "SV_POSITION" OpMemberDecorateStringGOOGLE %VOut 1 HlslSemanticGOOGLE "COLOR" OpDecorate %_entryPointOutput_p BuiltIn Position OpDecorateStringGOOGLE %_entryPointOutput_p HlslSemanticGOOGLE "SV_POSITION" OpDecorate %_entryPointOutput_c Location 0 OpDecorateStringGOOGLE %_entryPointOutput_c HlslSemanticGOOGLE "COLOR" %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %VOut = OpTypeStruct %v4float %v4float %9 = OpTypeFunction %VOut %_ptr_Function_VOut = OpTypePointer Function %VOut %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %17 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Function_v4float = OpTypePointer Function %v4float %int_1 = OpConstant %int 1 %float_2 = OpConstant %float 2 %22 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_p = OpVariable %_ptr_Output_v4float Output %_entryPointOutput_c = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %flattenTemp = OpVariable %_ptr_Function_VOut Function %28 = OpFunctionCall %VOut %_main_ OpStore %flattenTemp %28 %31 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0 %32 = OpLoad %v4float %31 OpStore %_entryPointOutput_p %32 %34 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_1 %35 = OpLoad %v4float %34 OpStore %_entryPointOutput_c %35 OpReturn OpFunctionEnd %_main_ = OpFunction %VOut None %9 %11 = OpLabel %v = OpVariable %_ptr_Function_VOut Function %19 = OpAccessChain %_ptr_Function_v4float %v %int_0 OpStore %19 %17 %23 = OpAccessChain %_ptr_Function_v4float %v %int_1 OpStore %23 %22 %24 = OpLoad %VOut %v OpReturnValue %24 OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/comp/000077500000000000000000000000001400026215700201735ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/comp/bitcast-16bit-1.invalid.comp000066400000000000000000000010721400026215700252120ustar00rootroot00000000000000#version 450 core #extension GL_AMD_gpu_shader_half_float : require #extension GL_AMD_gpu_shader_int16 : require layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO0 { i16vec4 inputs[]; }; layout(binding = 1, std430) buffer SSBO1 { ivec4 outputs[]; }; void main() { uint ident = gl_GlobalInvocationID.x; f16vec2 a = int16BitsToFloat16(inputs[ident].xy); outputs[ident].x = int(packFloat2x16(a + f16vec2(1, 1))); outputs[ident].y = packInt2x16(inputs[ident].zw); outputs[ident].z = int(packUint2x16(u16vec2(inputs[ident].xy))); } spirv-cross-2021.01.15/shaders-no-opt/comp/bitcast-16bit-2.invalid.comp000066400000000000000000000011071400026215700252120ustar00rootroot00000000000000#version 450 core #extension GL_AMD_gpu_shader_half_float : require #extension GL_AMD_gpu_shader_int16 : require layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO0 { ivec4 inputs[]; }; layout(binding = 1, std430) buffer SSBO1 { i16vec4 outputs[]; }; layout(binding = 2) uniform UBO { f16vec4 const0; }; void main() { uint ident = gl_GlobalInvocationID.x; outputs[ident].xy = unpackInt2x16(inputs[ident].x) + float16BitsToInt16(const0.xy); outputs[ident].zw = i16vec2(unpackUint2x16(uint(inputs[ident].y)) - float16BitsToUint16(const0.zw)); } spirv-cross-2021.01.15/shaders-no-opt/comp/bitfield.comp000066400000000000000000000006411400026215700226360ustar00rootroot00000000000000#version 310 es void main() { int signed_value = 0; uint unsigned_value = 0u; int s = bitfieldExtract(signed_value, 5, 20); uint u = bitfieldExtract(unsigned_value, 6, 21); s = bitfieldInsert(s, 40, 5, 4); u = bitfieldInsert(u, 60u, 5, 4); u = bitfieldReverse(u); s = bitfieldReverse(s); int v0 = bitCount(u); int v1 = bitCount(s); int v2 = findMSB(u); int v3 = findLSB(s); } spirv-cross-2021.01.15/shaders-no-opt/comp/glsl.std450.comp000066400000000000000000000046651400026215700230510ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO { float res; int ires; uint ures; vec4 f32; ivec4 s32; uvec4 u32; mat2 m2; mat3 m3; mat4 m4; }; void main() { float tmp; vec2 v2; vec3 v3; vec4 v4; int itmp; res = round(f32.x); res = roundEven(f32.x); res = trunc(f32.x); res = abs(f32.x); ires = abs(s32.x); res = sign(f32.x); ires = sign(s32.x); res = floor(f32.x); res = ceil(f32.x); res = fract(f32.x); res = radians(f32.x); res = degrees(f32.x); res = sin(f32.x); res = cos(f32.x); res = tan(f32.x); res = asin(f32.x); res = acos(f32.x); res = atan(f32.x); res = sinh(f32.x); res = cosh(f32.x); res = tanh(f32.x); res = asinh(f32.x); res = acosh(f32.x); res = atanh(f32.x); res = atan(f32.x, f32.y); res = pow(f32.x, f32.y); res = exp(f32.x); res = log(f32.x); res = exp2(f32.x); res = log2(f32.x); res = sqrt(f32.x); res = inversesqrt(f32.x); res = length(f32.x); res = distance(f32.x, f32.y); res = normalize(f32.x); res = faceforward(f32.x, f32.y, f32.z); res = reflect(f32.x, f32.y); res = refract(f32.x, f32.y, f32.z); res = length(f32.xy); res = distance(f32.xy, f32.zw); v2 = normalize(f32.xy); v2 = faceforward(f32.xy, f32.yz, f32.zw); v2 = reflect(f32.xy, f32.zw); v2 = refract(f32.xy, f32.yz, f32.w); v3 = cross(f32.xyz, f32.yzw); res = determinant(m2); res = determinant(m3); res = determinant(m4); m2 = inverse(m2); m3 = inverse(m3); m4 = inverse(m4); res = modf(f32.x, tmp); // ModfStruct res = min(f32.x, f32.y); ures = min(u32.x, u32.y); ires = min(s32.x, s32.y); res = max(f32.x, f32.y); ures = max(u32.x, u32.y); ires = max(s32.x, s32.y); res = clamp(f32.x, f32.y, f32.z); ures = clamp(u32.x, u32.y, u32.z); ires = clamp(s32.x, s32.y, s32.z); res = mix(f32.x, f32.y, f32.z); res = step(f32.x, f32.y); res = smoothstep(f32.x, f32.y, f32.z); res = fma(f32.x, f32.y, f32.z); res = frexp(f32.x, itmp); // FrexpStruct res = ldexp(f32.x, itmp); ures = packSnorm4x8(f32); ures = packUnorm4x8(f32); ures = packSnorm2x16(f32.xy); ures = packUnorm2x16(f32.xy); ures = packHalf2x16(f32.xy); // packDouble2x32 v2 = unpackSnorm2x16(u32.x); v2 = unpackUnorm2x16(u32.x); v2 = unpackHalf2x16(u32.x); v4 = unpackSnorm4x8(u32.x); v4 = unpackUnorm4x8(u32.x); // unpackDouble2x32 s32 = findLSB(s32); s32 = findLSB(u32); s32 = findMSB(s32); s32 = findMSB(u32); // interpolateAtSample // interpolateAtOffset // NMin, NMax, NClamp } spirv-cross-2021.01.15/shaders-no-opt/comp/illegal-struct-name.asm.comp000066400000000000000000000046201400026215700255050ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 31 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Foo "Foo" OpMemberName %Foo 0 "abs" OpName %f "f" OpName %Foo_0 "Foo" OpMemberName %Foo_0 0 "abs" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "foo" OpMemberName %SSBO 1 "foo2" OpName %_ "" OpName %linear "abs" OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 4 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Foo = OpTypeStruct %float %_ptr_Function_Foo = OpTypePointer Function %Foo %Foo_0 = OpTypeStruct %float %SSBO = OpTypeStruct %Foo_0 %Foo_0 %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Function_int = OpTypePointer Function %int %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %main = OpFunction %void None %3 %5 = OpLabel %f = OpVariable %_ptr_Function_Foo Function %linear = OpVariable %_ptr_Function_int Function %17 = OpAccessChain %_ptr_Uniform_Foo_0 %_ %int_0 %18 = OpLoad %Foo_0 %17 %19 = OpCompositeExtract %float %18 0 %21 = OpAccessChain %_ptr_Function_float %f %int_0 OpStore %21 %19 OpStore %linear %int_10 %26 = OpLoad %Foo %f %27 = OpAccessChain %_ptr_Uniform_Foo_0 %_ %int_1 %28 = OpCompositeExtract %float %26 0 %30 = OpAccessChain %_ptr_Uniform_float %27 %int_0 OpStore %30 %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/comp/inout-struct.invalid.comp000066400000000000000000000016231400026215700251620ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) writeonly buffer SSBO { vec4 data[]; } outdata; layout(std430, binding = 1) readonly buffer SSBO2 { vec4 data[]; } indata; struct Foo { vec4 a; vec4 b; vec4 c; vec4 d; }; layout(std430, binding = 2) readonly buffer SSBO3 { Foo foos[]; } foobar; vec4 bar(Foo foo) { return foo.a + foo.b + foo.c + foo.d; } void baz(out Foo foo) { uint ident = gl_GlobalInvocationID.x; foo.a = indata.data[4u * ident + 0u]; foo.b = indata.data[4u * ident + 1u]; foo.c = indata.data[4u * ident + 2u]; foo.d = indata.data[4u * ident + 3u]; } void meow(inout Foo foo) { foo.a += 10.0; foo.b += 20.0; foo.c += 30.0; foo.d += 40.0; } void main() { Foo foo; baz(foo); meow(foo); outdata.data[gl_GlobalInvocationID.x] = bar(foo) + bar(foobar.foos[gl_GlobalInvocationID.x]); } spirv-cross-2021.01.15/shaders-no-opt/comp/loop.comp000066400000000000000000000026201400026215700220240ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 idat = in_data[ident]; int k = 0; uint i = 0u; if (idat.y == 20.0) { do { k = k * 2; i++; } while (i < ident); } switch (k) { case 10: for (;;) { i++; if (i > 10u) break; } break; default: for (;;) { i += 2u; if (i > 20u) break; } break; } while (k < 10) { idat *= 2.0; k++; } for (uint i = 0u; i < 16u; i++, k++) for (uint j = 0u; j < 30u; j++) idat = mvp * idat; k = 0; for (;;) { k++; if (k > 10) { k += 2; } else { k += 3; continue; } k += 10; } k = 0; do { k++; } while (k > 10); int l = 0; for (;; l++) { if (l == 5) { continue; } idat += 1.0; } out_data[ident] = idat; } spirv-cross-2021.01.15/shaders-no-opt/comp/return.comp000066400000000000000000000007451400026215700224000ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; if (ident == 2u) { out_data[ident] = vec4(20.0); } else if (ident == 4u) { out_data[ident] = vec4(10.0); return; } for (int i = 0; i < 20; i++) { if (i == 10) break; return; } out_data[ident] = vec4(10.0); } spirv-cross-2021.01.15/shaders-no-opt/comp/shader_ballot_nonuniform_invocations.invalid.comp000066400000000000000000000003711400026215700321720ustar00rootroot00000000000000#version 450 #extension GL_AMD_shader_ballot : require void main () { float addInvocations = addInvocationsNonUniformAMD(0.0); int minInvocations = minInvocationsNonUniformAMD(1); uint maxInvocations = maxInvocationsNonUniformAMD(4); } spirv-cross-2021.01.15/shaders-no-opt/comp/specialization-constant-evaluation.comp000066400000000000000000000076641400026215700301020ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(constant_id = 0) const bool TRUE = true; layout(constant_id = 1) const bool FALSE = false; layout(constant_id = 2) const int SONE = 1; layout(constant_id = 3) const int STWO = 2; layout(constant_id = 4) const int SNEG_TWO = -2; layout(constant_id = 5) const uint UONE = 1; layout(constant_id = 6) const uint UTWO = 2; layout(constant_id = 7) const int SNEG_THREE = -3; const uint IADD = SONE + STWO + UONE + UTWO; // 6 const uint ISUB = UTWO - SONE; // 1 const uint IMUL = UTWO * UTWO; // 4 const uint UDIV = UTWO / UTWO; // 1 const int SDIV = STWO / SNEG_TWO; // -1 //const int SREM = STWO % SNEG_THREE; // 1 const int SREM = 1; const int SMOD = STWO % SNEG_THREE; // -1 const uint UMOD = IADD % IMUL; // 2 const uint LSHL = IADD << ISUB; // 12 const uint RSHL = IADD >> ISUB; // 3 const int RSHA = (-int(IADD)) >> (-SDIV); // -3 const bool IEQ = IADD == ISUB; // false const bool INEQ = IADD != ISUB; // true const bool ULT = IADD < ISUB; // false const bool ULE = IADD <= ISUB; // false const bool UGT = IADD > ISUB; // true const bool UGE = IADD >= ISUB; // true const bool SLT = SMOD < SREM; // true const bool SLE = SMOD <= SREM; // true const bool SGT = SMOD > SREM; // false const bool SGE = SMOD >= SREM; // false const bool LOR = IEQ || SLT; // true const bool LAND = IEQ && SLT; // false const bool LNOT = !LOR; // false const uint AND = IADD & IADD; // 6 const uint OR = IADD | ISUB; // 7 const uint XOR = IADD ^ IADD; // 0 const uint NOT = ~XOR; // UINT_MAX const bool LEQ = LAND == LNOT; // true const bool LNEQ = LAND != LNOT; // false const uint SEL = IEQ ? IADD : ISUB; // 1 #define DUMMY_SSBO(name, bind, size) layout(std430, set = 0, binding = bind) buffer SSBO_##name { float val[size]; float dummy; } name // Normalize all sizes to 1 element so that the default offsets in glslang matches up with what we should be computing. // If we do it right, we should get no layout(offset = N) expressions. DUMMY_SSBO(IAdd, 0, IADD - 5); DUMMY_SSBO(ISub, 1, ISUB); DUMMY_SSBO(IMul, 2, IMUL - 3); DUMMY_SSBO(UDiv, 3, UDIV); DUMMY_SSBO(SDiv, 4, SDIV + 2); DUMMY_SSBO(SRem, 5, SREM); DUMMY_SSBO(SMod, 6, SMOD + 2); DUMMY_SSBO(UMod, 7, UMOD - 1); DUMMY_SSBO(LShl, 8, LSHL - 11); DUMMY_SSBO(RShl, 9, RSHL - 2); DUMMY_SSBO(RSha, 10, RSHA + 4); DUMMY_SSBO(IEq, 11, IEQ ? 2 : 1); DUMMY_SSBO(INeq, 12, INEQ ? 1 : 2); DUMMY_SSBO(Ult, 13, ULT ? 2 : 1); DUMMY_SSBO(Ule, 14, ULE ? 2 : 1); DUMMY_SSBO(Ugt, 15, UGT ? 1 : 2); DUMMY_SSBO(Uge, 16, UGE ? 1 : 2); DUMMY_SSBO(Slt, 17, SLT ? 1 : 2); DUMMY_SSBO(Sle, 18, SLE ? 1 : 2); DUMMY_SSBO(Sgt, 19, SGT ? 2 : 1); DUMMY_SSBO(Sge, 20, SGE ? 2 : 1); DUMMY_SSBO(Lor, 21, LOR ? 1 : 2); DUMMY_SSBO(Land, 22, LAND ? 2 : 1); DUMMY_SSBO(Lnot, 23, LNOT ? 2 : 1); DUMMY_SSBO(And, 24, AND - 5); DUMMY_SSBO(Or, 24, OR - 6); DUMMY_SSBO(Xor, 24, XOR + 1); DUMMY_SSBO(Not, 25, NOT - 0xfffffffeu); DUMMY_SSBO(Leq, 26, LEQ ? 1 : 2); DUMMY_SSBO(Lneq, 27, LNEQ ? 2 : 1); DUMMY_SSBO(Sel, 28, SEL); void main() { IAdd.val[0] = 0.0; ISub.val[0] = 0.0; IMul.val[0] = 0.0; UDiv.val[0] = 0.0; SDiv.val[0] = 0.0; SRem.val[0] = 0.0; SMod.val[0] = 0.0; UMod.val[0] = 0.0; LShl.val[0] = 0.0; RShl.val[0] = 0.0; RSha.val[0] = 0.0; IEq.val[0] = 0.0; INeq.val[0] = 0.0; Ult.val[0] = 0.0; Ule.val[0] = 0.0; Ugt.val[0] = 0.0; Uge.val[0] = 0.0; Slt.val[0] = 0.0; Sle.val[0] = 0.0; Sgt.val[0] = 0.0; Sge.val[0] = 0.0; Lor.val[0] = 0.0; Land.val[0] = 0.0; Lnot.val[0] = 0.0; And.val[0] = 0.0; Or.val[0] = 0.0; Xor.val[0] = 0.0; Not.val[0] = 0.0; Leq.val[0] = 0.0; Lneq.val[0] = 0.0; Sel.val[0] = 0.0; } spirv-cross-2021.01.15/shaders-no-opt/comp/struct-packing-scalar.nocompat.invalid.vk.comp000066400000000000000000000025101400026215700311350ustar00rootroot00000000000000#version 310 es #extension GL_EXT_scalar_block_layout : require layout(local_size_x = 1) in; struct S0 { vec2 a[1]; float b; }; struct S1 { vec3 a; float b; }; struct S2 { vec3 a[1]; float b; }; struct S3 { vec2 a; float b; }; struct S4 { vec2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; S4 m3s[8]; }; layout(binding = 1, scalar) restrict buffer SSBO1 { Content content; Content content1[2]; Content content2; layout(column_major) mat2 m0; layout(column_major) mat2 m1; layout(column_major) mat2x3 m2[4]; layout(column_major) mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_430; layout(binding = 0, std140) restrict buffer SSBO0 { Content content; Content content1[2]; Content content2; layout(column_major) mat2 m0; layout(column_major) mat2 m1; layout(column_major) mat2x3 m2[4]; layout(column_major) mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_140; void main() { ssbo_430.content = ssbo_140.content; } spirv-cross-2021.01.15/shaders-no-opt/comp/subgroups.nocompat.invalid.vk.comp000066400000000000000000000104271400026215700267730ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_vote : require #extension GL_KHR_shader_subgroup_shuffle : require #extension GL_KHR_shader_subgroup_shuffle_relative : require #extension GL_KHR_shader_subgroup_arithmetic : require #extension GL_KHR_shader_subgroup_clustered : require #extension GL_KHR_shader_subgroup_quad : require layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float FragColor; }; void main() { // basic FragColor = float(gl_NumSubgroups); FragColor = float(gl_SubgroupID); FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); // ballot FragColor = float(gl_SubgroupEqMask); FragColor = float(gl_SubgroupGeMask); FragColor = float(gl_SubgroupGtMask); FragColor = float(gl_SubgroupLeMask); FragColor = float(gl_SubgroupLtMask); vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); // shuffle uint shuffled = subgroupShuffle(10u, 8u); uint shuffled_xor = subgroupShuffleXor(30u, 8u); // shuffle relative uint shuffled_up = subgroupShuffleUp(20u, 4u); uint shuffled_down = subgroupShuffleDown(20u, 4u); // vote bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal = subgroupAllEqual(true); // arithmetic vec4 added = subgroupAdd(vec4(20.0)); ivec4 iadded = subgroupAdd(ivec4(20)); vec4 multiplied = subgroupMul(vec4(20.0)); ivec4 imultiplied = subgroupMul(ivec4(20)); vec4 lo = subgroupMin(vec4(20.0)); vec4 hi = subgroupMax(vec4(20.0)); ivec4 slo = subgroupMin(ivec4(20)); ivec4 shi = subgroupMax(ivec4(20)); uvec4 ulo = subgroupMin(uvec4(20)); uvec4 uhi = subgroupMax(uvec4(20)); uvec4 anded = subgroupAnd(ballot_value); uvec4 ored = subgroupOr(ballot_value); uvec4 xored = subgroupXor(ballot_value); added = subgroupInclusiveAdd(added); iadded = subgroupInclusiveAdd(iadded); multiplied = subgroupInclusiveMul(multiplied); imultiplied = subgroupInclusiveMul(imultiplied); lo = subgroupInclusiveMin(lo); hi = subgroupInclusiveMax(hi); slo = subgroupInclusiveMin(slo); shi = subgroupInclusiveMax(shi); ulo = subgroupInclusiveMin(ulo); uhi = subgroupInclusiveMax(uhi); anded = subgroupInclusiveAnd(anded); ored = subgroupInclusiveOr(ored); xored = subgroupInclusiveXor(ored); added = subgroupExclusiveAdd(lo); added = subgroupExclusiveAdd(multiplied); multiplied = subgroupExclusiveMul(multiplied); iadded = subgroupExclusiveAdd(imultiplied); imultiplied = subgroupExclusiveMul(imultiplied); lo = subgroupExclusiveMin(lo); hi = subgroupExclusiveMax(hi); ulo = subgroupExclusiveMin(ulo); uhi = subgroupExclusiveMax(uhi); slo = subgroupExclusiveMin(slo); shi = subgroupExclusiveMax(shi); anded = subgroupExclusiveAnd(anded); ored = subgroupExclusiveOr(ored); xored = subgroupExclusiveXor(ored); // clustered added = subgroupClusteredAdd(added, 4u); multiplied = subgroupClusteredMul(multiplied, 4u); iadded = subgroupClusteredAdd(iadded, 4u); imultiplied = subgroupClusteredMul(imultiplied, 4u); lo = subgroupClusteredMin(lo, 4u); hi = subgroupClusteredMax(hi, 4u); ulo = subgroupClusteredMin(ulo, 4u); uhi = subgroupClusteredMax(uhi, 4u); slo = subgroupClusteredMin(slo, 4u); shi = subgroupClusteredMax(shi, 4u); anded = subgroupClusteredAnd(anded, 4u); ored = subgroupClusteredOr(ored, 4u); xored = subgroupClusteredXor(xored, 4u); // quad vec4 swap_horiz = subgroupQuadSwapHorizontal(vec4(20.0)); vec4 swap_vertical = subgroupQuadSwapVertical(vec4(20.0)); vec4 swap_diagonal = subgroupQuadSwapDiagonal(vec4(20.0)); vec4 quad_broadcast = subgroupQuadBroadcast(vec4(20.0), 3u); } spirv-cross-2021.01.15/shaders-no-opt/comp/subgroups_basicvoteballot.vk.comp000066400000000000000000000030511400026215700267570ustar00rootroot00000000000000#version 450 #extension GL_KHR_shader_subgroup_basic : require #extension GL_KHR_shader_subgroup_ballot : require #extension GL_KHR_shader_subgroup_vote : require layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float FragColor; }; void main() { // basic FragColor = float(gl_NumSubgroups); FragColor = float(gl_SubgroupID); FragColor = float(gl_SubgroupSize); FragColor = float(gl_SubgroupInvocationID); subgroupBarrier(); subgroupMemoryBarrier(); subgroupMemoryBarrierBuffer(); subgroupMemoryBarrierShared(); subgroupMemoryBarrierImage(); bool elected = subgroupElect(); // ballot FragColor = float(gl_SubgroupEqMask); FragColor = float(gl_SubgroupGeMask); FragColor = float(gl_SubgroupGtMask); FragColor = float(gl_SubgroupLeMask); FragColor = float(gl_SubgroupLtMask); vec4 broadcasted = subgroupBroadcast(vec4(10.0), 8u); vec3 first = subgroupBroadcastFirst(vec3(20.0)); uvec4 ballot_value = subgroupBallot(true); bool inverse_ballot_value = subgroupInverseBallot(ballot_value); bool bit_extracted = subgroupBallotBitExtract(uvec4(10u), 8u); uint bit_count = subgroupBallotBitCount(ballot_value); uint inclusive_bit_count = subgroupBallotInclusiveBitCount(ballot_value); uint exclusive_bit_count = subgroupBallotExclusiveBitCount(ballot_value); uint lsb = subgroupBallotFindLSB(ballot_value); uint msb = subgroupBallotFindMSB(ballot_value); // vote bool has_all = subgroupAll(true); bool has_any = subgroupAny(true); bool has_equal_bool = subgroupAllEqual(true); bool has_equal_T = subgroupAllEqual(uvec3(5u)); }spirv-cross-2021.01.15/shaders-no-opt/frag/000077500000000000000000000000001400026215700201545ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/frag/16bit-constants.invalid.frag000066400000000000000000000004361400026215700254040ustar00rootroot00000000000000#version 450 core #extension GL_AMD_gpu_shader_int16 : require #extension GL_AMD_gpu_shader_half_float : require layout(location = 0) out float16_t foo; layout(location = 1) out int16_t bar; layout(location = 2) out uint16_t baz; void main() { foo = 1.0hf; bar = 2s; baz = 3us; } spirv-cross-2021.01.15/shaders-no-opt/frag/fp16.invalid.desktop.frag000066400000000000000000000062271400026215700246750ustar00rootroot00000000000000#version 450 #extension GL_AMD_gpu_shader_half_float : require layout(location = 0) in float16_t v1; layout(location = 1) in f16vec2 v2; layout(location = 2) in f16vec3 v3; layout(location = 3) in f16vec4 v4; layout(location = 0) out float o1; layout(location = 1) out vec2 o2; layout(location = 2) out vec3 o3; layout(location = 3) out vec4 o4; f16mat2 test_mat2(f16vec2 a, f16vec2 b, f16vec2 c, f16vec2 d) { return f16mat2(a, b) * f16mat2(c, d); } f16mat3 test_mat3(f16vec3 a, f16vec3 b, f16vec3 c, f16vec3 d, f16vec3 e, f16vec3 f) { return f16mat3(a, b, c) * f16mat3(d, e, f); } void test_constants() { float16_t a = 1.0hf; float16_t b = 1.5hf; float16_t c = -1.5hf; // Negatives float16_t d = (0.0hf / 0.0hf); // NaN float16_t e = (1.0hf / 0.0hf); // +Inf float16_t f = (-1.0hf / 0.0hf); // -Inf float16_t g = 1014.0hf; // Large. float16_t h = 0.000001hf; // Denormal } float16_t test_result() { return 1.0hf; } void test_conversions() { float16_t one = test_result(); int a = int(one); uint b = uint(one); bool c = bool(one); float d = float(one); double e = double(one); float16_t a2 = float16_t(a); float16_t b2 = float16_t(b); float16_t c2 = float16_t(c); float16_t d2 = float16_t(d); float16_t e2 = float16_t(e); } void test_builtins() { f16vec4 res; res = radians(v4); res = degrees(v4); res = sin(v4); res = cos(v4); res = tan(v4); res = asin(v4); res = atan(v4, v3.xyzz); res = atan(v4); res = sinh(v4); res = cosh(v4); res = tanh(v4); res = asinh(v4); res = acosh(v4); res = atanh(v4); res = pow(v4, v4); res = exp(v4); res = log(v4); res = exp2(v4); res = log2(v4); res = sqrt(v4); res = inversesqrt(v4); res = abs(v4); res = sign(v4); res = floor(v4); res = trunc(v4); res = round(v4); res = roundEven(v4); res = ceil(v4); res = fract(v4); res = mod(v4, v4); f16vec4 tmp; res = modf(v4, tmp); res = min(v4, v4); res = max(v4, v4); res = clamp(v4, v4, v4); res = mix(v4, v4, v4); res = mix(v4, v4, lessThan(v4, v4)); res = step(v4, v4); res = smoothstep(v4, v4, v4); bvec4 btmp = isnan(v4); btmp = isinf(v4); res = fma(v4, v4, v4); ivec4 itmp; res = frexp(v4, itmp); res = ldexp(res, itmp); uint pack0 = packFloat2x16(v4.xy); uint pack1 = packFloat2x16(v4.zw); res = f16vec4(unpackFloat2x16(pack0), unpackFloat2x16(pack1)); float16_t t0 = length(v4); t0 = distance(v4, v4); t0 = dot(v4, v4); f16vec3 res3 = cross(v3, v3); res = normalize(v4); res = faceforward(v4, v4, v4); res = reflect(v4, v4); res = refract(v4, v4, v1); btmp = lessThan(v4, v4); btmp = lessThanEqual(v4, v4); btmp = greaterThan(v4, v4); btmp = greaterThanEqual(v4, v4); btmp = equal(v4, v4); btmp = notEqual(v4, v4); res = dFdx(v4); res = dFdy(v4); res = dFdxFine(v4); res = dFdyFine(v4); res = dFdxCoarse(v4); res = dFdyCoarse(v4); res = fwidth(v4); res = fwidthFine(v4); res = fwidthCoarse(v4); //res = interpolateAtCentroid(v4); //res = interpolateAtSample(v4, 0); //res = interpolateAtOffset(v4, f16vec2(0.1hf)); } void main() { // Basic matrix tests. f16mat2 m0 = test_mat2(v2, v2, v3.xy, v3.xy); f16mat3 m1 = test_mat3(v3, v3, v3, v4.xyz, v4.xyz, v4.yzw); test_constants(); test_conversions(); test_builtins(); } spirv-cross-2021.01.15/shaders-no-opt/frag/fragmentMaskFetch_subpassInput.vk.nocompat.invalid.frag000066400000000000000000000003571400026215700330560ustar00rootroot00000000000000#version 450 #extension GL_AMD_shader_fragment_mask : require layout(input_attachment_index = 0, binding = 0) uniform subpassInputMS t; void main () { vec4 test2 = fragmentFetchAMD(t, 4); uint testi2 = fragmentMaskFetchAMD(t); } spirv-cross-2021.01.15/shaders-no-opt/frag/fs.invalid.frag000066400000000000000000000006371400026215700230600ustar00rootroot00000000000000#version 450 #extension GL_AMD_shader_fragment_mask : require #extension GL_AMD_shader_explicit_vertex_parameter : require layout(binding = 0) uniform sampler2DMS texture1; layout(location = 0) __explicitInterpAMD in vec4 vary; void main() { uint testi1 = fragmentMaskFetchAMD(texture1, ivec2(0)); vec4 test1 = fragmentFetchAMD(texture1, ivec2(1), 2); vec4 pos = interpolateAtVertexAMD(vary, 0u); } spirv-cross-2021.01.15/shaders-no-opt/frag/image-gather.frag000066400000000000000000000005711400026215700233520ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 0) uniform sampler2D uSamp; layout(set = 0, binding = 1) uniform sampler2DShadow uSampShadow; layout(location = 0) in vec3 vUV; void main() { FragColor = textureGather(uSamp, vUV.xy, 0); FragColor += textureGather(uSamp, vUV.xy, 1); FragColor += textureGather(uSampShadow, vUV.xy, vUV.z); } spirv-cross-2021.01.15/shaders-no-opt/frag/multi-dimensional.desktop.invalid.flatten_dim.frag000066400000000000000000000007451400026215700320370ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uTextures[2][3][1]; layout(location = 0) flat in int vIndex; layout(location = 1) in vec2 vUV; void main() { vec4 values3[2][3][1]; for (int z = 0; z < 2; z++) for (int y = 0; y < 3; y++) for (int x = 0; x < 1; x++) values3[z][y][x] = texture(uTextures[z][y][x], vUV); FragColor = values3[1][2][0] + values3[0][2][0] + values3[vIndex + 1][2][vIndex]; } spirv-cross-2021.01.15/shaders-no-opt/frag/nonuniform-constructor.vk.nocompat.frag000066400000000000000000000005721400026215700300340ustar00rootroot00000000000000#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; layout(location = 1) flat in int vIndex; layout(set = 0, binding = 0) uniform texture2D uTex[]; layout(set = 1, binding = 0) uniform sampler Immut; void main() { FragColor = texture(nonuniformEXT(sampler2D(uTex[vIndex], Immut)), vUV); } spirv-cross-2021.01.15/shaders-no-opt/frag/pixel-interlock-simple-callstack.frag000066400000000000000000000007161400026215700273600ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(set = 0, binding = 0, std430) buffer SSBO0 { uint values0[]; }; layout(set = 0, binding = 1, std430) buffer SSBO1 { uint values1[]; }; void callee2() { values1[int(gl_FragCoord.x)] += 1; } void callee() { values0[int(gl_FragCoord.x)] += 1; callee2(); } void main() { beginInvocationInterlockARB(); callee(); endInvocationInterlockARB(); } spirv-cross-2021.01.15/shaders-no-opt/frag/scalar-block-layout-ubo-std430.vk.nocompat.invalid.frag000066400000000000000000000006151400026215700323540ustar00rootroot00000000000000#version 450 #extension GL_EXT_scalar_block_layout : require layout(std430, binding = 0) uniform UBO { float a[1024]; vec3 b[2]; }; layout(std430, binding = 1) uniform UBOEnhancedLayout { float c[1024]; vec3 d[2]; layout(offset = 10000) float e; }; layout(location = 0) flat in int vIndex; layout(location = 0) out float FragColor; void main() { FragColor = a[vIndex] + c[vIndex] + e; } spirv-cross-2021.01.15/shaders-no-opt/frag/sparse-texture-clamp.desktop.frag000066400000000000000000000015531400026215700265560ustar00rootroot00000000000000#version 450 #extension GL_ARB_sparse_texture2 : require #extension GL_ARB_sparse_texture_clamp : require layout(set = 0, binding = 0) uniform sampler2D uSamp; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; void main() { vec4 texel; int code; code = sparseTextureClampARB(uSamp, vUV, 1.0, texel, 2.0); texel = textureClampARB(uSamp, vUV, 1.0, 2.0); code = sparseTextureOffsetClampARB(uSamp, vUV, ivec2(1, 2), 1.0, texel, 2.0); texel = textureOffsetClampARB(uSamp, vUV, ivec2(1, 2), 1.0, 2.0); code = sparseTextureGradClampARB(uSamp, vUV, vec2(1.0), vec2(2.0), 1.0, texel); texel = textureGradClampARB(uSamp, vUV, vec2(1.0), vec2(2.0), 1.0); code = sparseTextureGradOffsetClampARB(uSamp, vUV, vec2(1.0), vec2(2.0), ivec2(-1, -2), 1.0, texel); texel = textureGradOffsetClampARB(uSamp, vUV, vec2(1.0), vec2(2.0), ivec2(-1, -2), 1.0); } spirv-cross-2021.01.15/shaders-no-opt/frag/sparse-texture-feedback.desktop.frag000066400000000000000000000032751400026215700272110ustar00rootroot00000000000000#version 450 #extension GL_ARB_sparse_texture2 : require #extension GL_ARB_sparse_texture_clamp : require layout(set = 0, binding = 0) uniform sampler2D uSamp; layout(set = 0, binding = 1) uniform sampler2DMS uSampMS; layout(set = 0, binding = 2, rgba8) uniform image2D uImage; layout(set = 0, binding = 3, rgba8) uniform image2DMS uImageMS; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; void main() { vec4 texel; bool ret; ret = sparseTexelsResidentARB(sparseTextureARB(uSamp, vUV, texel)); ret = sparseTexelsResidentARB(sparseTextureARB(uSamp, vUV, texel, 1.1)); ret = sparseTexelsResidentARB(sparseTextureLodARB(uSamp, vUV, 1.0, texel)); ret = sparseTexelsResidentARB(sparseTextureOffsetARB(uSamp, vUV, ivec2(1, 1), texel)); ret = sparseTexelsResidentARB(sparseTextureOffsetARB(uSamp, vUV, ivec2(2, 2), texel, 0.5)); ret = sparseTexelsResidentARB(sparseTexelFetchARB(uSamp, ivec2(vUV), 1, texel)); ret = sparseTexelsResidentARB(sparseTexelFetchARB(uSampMS, ivec2(vUV), 2, texel)); ret = sparseTexelsResidentARB(sparseTexelFetchOffsetARB(uSamp, ivec2(vUV), 1, ivec2(2, 3), texel)); ret = sparseTexelsResidentARB(sparseTextureLodOffsetARB(uSamp, vUV, 1.5, ivec2(2, 3), texel)); ret = sparseTexelsResidentARB(sparseTextureGradARB(uSamp, vUV, vec2(1.0), vec2(3.0), texel)); ret = sparseTexelsResidentARB(sparseTextureGradOffsetARB(uSamp, vUV, vec2(1.0), vec2(3.0), ivec2(-2, -3), texel)); ret = sparseTexelsResidentARB(sparseTextureClampARB(uSamp, vUV, 4.0, texel)); ret = sparseTexelsResidentARB(sparseImageLoadARB(uImage, ivec2(vUV), texel)); ret = sparseTexelsResidentARB(sparseImageLoadARB(uImageMS, ivec2(vUV), 1, texel)); } spirv-cross-2021.01.15/shaders-no-opt/frag/subpass-input.framebuffer-fetch.nocompat.frag000066400000000000000000000006351400026215700310270ustar00rootroot00000000000000#version 310 es precision mediump float; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec3 FragColor; layout(location = 1) out vec4 FragColor2; void main() { FragColor.rgb = subpassLoad(uSubpass0).rgb + subpassLoad(uSubpass1).rgb; } spirv-cross-2021.01.15/shaders-no-opt/frag/subpass-input.framebuffer-fetch.nocompat.legacy.frag000066400000000000000000000006351400026215700322720ustar00rootroot00000000000000#version 310 es precision mediump float; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec3 FragColor; layout(location = 1) out vec4 FragColor2; void main() { FragColor.rgb = subpassLoad(uSubpass0).rgb + subpassLoad(uSubpass1).rgb; } spirv-cross-2021.01.15/shaders-no-opt/frag/variables.zero-initialize.frag000066400000000000000000000005221400026215700261010ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 vColor; layout(location = 0) out vec4 FragColor; int uninit_int; ivec4 uninit_vector; mat4 uninit_matrix; struct Foo { int a; }; Foo uninit_foo; void main() { int uninit_function_int; if (vColor.x > 10.0) uninit_function_int = 10; else uninit_function_int = 20; FragColor = vColor; } spirv-cross-2021.01.15/shaders-no-opt/legacy/000077500000000000000000000000001400026215700205015ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/legacy/frag/000077500000000000000000000000001400026215700214205ustar00rootroot00000000000000switch-single-case-multiple-exit-cfg.legacy.asm.frag000066400000000000000000000042171400026215700332560ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/legacy/frag; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 54 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %_GLF_color OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %gl_FragCoord "gl_FragCoord" OpName %_GLF_color "_GLF_color" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_GLF_color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %bool = OpTypeBool %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %_GLF_color = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %52 = OpUndef %v2float %main = OpFunction %void None %3 %5 = OpLabel OpSelectionMerge %9 None OpSwitch %int_0 %8 %8 = OpLabel %17 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %18 = OpLoad %float %17 %22 = OpFOrdNotEqual %bool %18 %18 OpSelectionMerge %24 None OpBranchConditional %22 %23 %24 %23 = OpLabel OpBranch %9 %24 = OpLabel %33 = OpCompositeExtract %float %52 1 %51 = OpCompositeInsert %v2float %33 %52 1 OpBranch %9 %9 = OpLabel %53 = OpPhi %v2float %52 %23 %51 %24 %42 = OpCompositeExtract %float %53 0 %43 = OpCompositeExtract %float %53 1 %48 = OpCompositeConstruct %v4float %42 %43 %float_1 %float_1 OpStore %_GLF_color %48 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-no-opt/vert/000077500000000000000000000000001400026215700202155ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/vert/io-blocks.force-flattened-io.vert000066400000000000000000000005041400026215700264460ustar00rootroot00000000000000#version 450 struct Foo { vec4 bar[2]; vec4 baz[2]; }; layout(location = 0) out Vertex { Foo foo; Foo foo2; }; layout(location = 8) out Foo foo3; void main() { foo.bar[0] = vec4(1.0); foo.baz[1] = vec4(2.0); foo2.bar[0] = vec4(3.0); foo2.baz[1] = vec4(4.0); foo3.bar[0] = vec4(5.0); foo3.baz[1] = vec4(6.0); } spirv-cross-2021.01.15/shaders-no-opt/vert/pass-array-by-value.vert000066400000000000000000000011461400026215700247250ustar00rootroot00000000000000#version 310 es layout(location = 0) in int Index1; layout(location = 1) in int Index2; vec4 consume_constant_arrays2(const vec4 positions[4], const vec4 positions2[4]) { return positions[Index1] + positions2[Index2]; } vec4 consume_constant_arrays(const vec4 positions[4], const vec4 positions2[4]) { return consume_constant_arrays2(positions, positions2); } const vec4 LUT1[] = vec4[](vec4(0.0), vec4(1.0), vec4(2.0), vec4(3.0)); void main() { vec4 LUT2[4]; LUT2[0] = vec4(10.0); LUT2[1] = vec4(11.0); LUT2[2] = vec4(12.0); LUT2[3] = vec4(13.0); gl_Position = consume_constant_arrays(LUT1, LUT2); } spirv-cross-2021.01.15/shaders-no-opt/vulkan/000077500000000000000000000000001400026215700205355ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/vulkan/frag/000077500000000000000000000000001400026215700214545ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-no-opt/vulkan/frag/spec-constant.vk.frag000066400000000000000000000044771400026215700255310ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(constant_id = 1) const float a = 1.0; layout(constant_id = 2) const float b = 2.0; layout(constant_id = 3) const int c = 3; layout(constant_id = 4) const int d = 4; layout(constant_id = 5) const uint e = 5u; layout(constant_id = 6) const uint f = 6u; layout(constant_id = 7) const bool g = false; layout(constant_id = 8) const bool h = true; // glslang doesn't seem to support partial spec constants or composites yet, so only test the basics. struct Foo { float elems[d + 2]; }; void main() { float t0 = a; float t1 = b; uint c0 = uint(c); // OpIAdd with different types. // FConvert, float-to-double. int c1 = -c; // SNegate int c2 = ~c; // OpNot int c3 = c + d; // OpIAdd int c4 = c - d; // OpISub int c5 = c * d; // OpIMul int c6 = c / d; // OpSDiv uint c7 = e / f; // OpUDiv int c8 = c % d; // OpSMod uint c9 = e % f; // OpUMod // TODO: OpSRem, any way to access this in GLSL? int c10 = c >> d; // OpShiftRightArithmetic uint c11 = e >> f; // OpShiftRightLogical int c12 = c << d; // OpShiftLeftLogical int c13 = c | d; // OpBitwiseOr int c14 = c ^ d; // OpBitwiseXor int c15 = c & d; // OpBitwiseAnd // VectorShuffle, CompositeExtract, CompositeInsert, not testable atm. bool c16 = g || h; // OpLogicalOr bool c17 = g && h; // OpLogicalAnd bool c18 = !g; // OpLogicalNot bool c19 = g == h; // OpLogicalEqual bool c20 = g != h; // OpLogicalNotEqual // OpSelect not testable atm. bool c21 = c == d; // OpIEqual bool c22 = c != d; // OpINotEqual bool c23 = c < d; // OpSLessThan bool c24 = e < f; // OpULessThan bool c25 = c > d; // OpSGreaterThan bool c26 = e > f; // OpUGreaterThan bool c27 = c <= d; // OpSLessThanEqual bool c28 = e <= f; // OpULessThanEqual bool c29 = c >= d; // OpSGreaterThanEqual bool c30 = e >= f; // OpUGreaterThanEqual // OpQuantizeToF16 not testable atm. int c31 = c8 + c3; int c32 = int(e); // OpIAdd with different types. bool c33 = bool(c); // int -> bool bool c34 = bool(e); // uint -> bool int c35 = int(g); // bool -> int uint c36 = uint(g); // bool -> uint float c37 = float(g); // bool -> float // Flexible sized arrays with spec constants and spec constant ops. float vec0[c + 3][8]; float vec1[c + 2]; Foo foo; FragColor = vec4(t0 + t1) + vec0[0][0] + vec1[0] + foo.elems[c]; } spirv-cross-2021.01.15/shaders-no-opt/vulkan/frag/ubo-offset-out-of-order.vk.nocompat.frag000066400000000000000000000003621400026215700311450ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(std140, binding = 0) uniform UBO { layout(offset = 16) mat4 m; layout(offset = 0) vec4 v; }; layout(location = 0) in vec4 vColor; void main() { FragColor = m * vColor + v; } spirv-cross-2021.01.15/shaders-other/000077500000000000000000000000001400026215700171425ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-other/README.md000066400000000000000000000003511400026215700204200ustar00rootroot00000000000000These shaders are not actually run yet as part of any test suite, but are kept here because they have been used to manually test various aspects of SPIRV-Cross in the past. These would ideally be part of the test suite in some way. spirv-cross-2021.01.15/shaders-other/aliased-entry-point-names.asm000066400000000000000000000045241400026215700246420ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ OpEntryPoint Vertex %main2 "main2" %_ OpEntryPoint Fragment %main3 "main" %FragColor OpEntryPoint Fragment %main4 "main2" %FragColor OpSource GLSL 450 OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %FragColor Location 0 OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v4floatptr = OpTypePointer Output %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %FragColor = OpVariable %v4floatptr Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %17 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_2 = OpConstant %float 2 %18 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd %main2 = OpFunction %void None %3 %6 = OpLabel %20 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %20 %18 OpReturn OpFunctionEnd %main3 = OpFunction %void None %3 %7 = OpLabel OpStore %FragColor %17 OpReturn OpFunctionEnd %main4 = OpFunction %void None %3 %8 = OpLabel OpStore %FragColor %18 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/000077500000000000000000000000001400026215700201535ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-reflection/asm/000077500000000000000000000000001400026215700207335ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-reflection/asm/aliased-entry-point-names.asm.multi000066400000000000000000000045221400026215700275620ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ OpEntryPoint Vertex %main2 "maim" %_ OpEntryPoint Fragment %main3 "main" %FragColor OpEntryPoint Fragment %main4 "maim" %FragColor OpSource GLSL 450 OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %FragColor Location 0 OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v4floatptr = OpTypePointer Output %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %FragColor = OpVariable %v4floatptr Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %17 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_2 = OpConstant %float 2 %18 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd %main2 = OpFunction %void None %3 %6 = OpLabel %20 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %20 %18 OpReturn OpFunctionEnd %main3 = OpFunction %void None %3 %7 = OpLabel OpStore %FragColor %17 OpReturn OpFunctionEnd %main4 = OpFunction %void None %3 %8 = OpLabel OpStore %FragColor %18 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/asm/comp/000077500000000000000000000000001400026215700216715ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-reflection/asm/comp/pointer-to-array-of-physical-pointer.asm.comp000066400000000000000000000044431400026215700324430ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 8 ; Bound: 17 ; Schema: 0 OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_EXT_physical_storage_buffer" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 460 OpSourceExtension "GL_EXT_buffer_reference" OpSourceExtension "GL_EXT_buffer_reference2" OpSourceExtension "GL_EXT_shader_explicit_arithmetic_types_int64" OpName %main "main" OpName %Params "Params" OpMemberName %Params 0 "x" OpMemberName %Params 1 "y" OpName %IntBuf "IntBuf" OpMemberName %IntBuf 0 "v" OpName %_ "" OpDecorate %_arr_7_uint_3 ArrayStride 16 OpMemberDecorate %Params 0 Offset 0 OpMemberDecorate %Params 1 Offset 16 OpDecorate %Params Block OpMemberDecorate %IntBuf 0 Offset 0 OpDecorate %IntBuf Block OpDecorate %_arr__ptr_PhysicalStorageBuffer_IntBuf_uint_3 ArrayStride 16 OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 OpTypeForwardPointer %_ptr_PhysicalStorageBuffer_IntBuf PhysicalStorageBuffer %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_7_uint_3 = OpTypeArray %_ptr_PhysicalStorageBuffer_IntBuf %uint_3 %ptr_array_ptr = OpTypePointer PhysicalStorageBuffer %_arr_7_uint_3 %Params = OpTypeStruct %float %ptr_array_ptr %int = OpTypeInt 32 1 %IntBuf = OpTypeStruct %int %_ptr_PhysicalStorageBuffer_IntBuf = OpTypePointer PhysicalStorageBuffer %IntBuf %_arr__ptr_PhysicalStorageBuffer_IntBuf_uint_3 = OpTypeArray %_ptr_PhysicalStorageBuffer_IntBuf %uint_3 %_ptr_Uniform_Params = OpTypePointer Uniform %Params %_ = OpVariable %_ptr_Uniform_Params Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/asm/op-source-glsl-ssbo-1.asm.comp000066400000000000000000000043631400026215700263550ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID %_ OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "a" OpName %_ "" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %_runtimearr_v4float_0 ArrayStride 16 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %SSBO0 = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %_ = OpVariable %_ptr_Uniform_SSBO0 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %float_1 = OpConstant %float 1 %23 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_runtimearr_v4float_0 = OpTypeRuntimeArray %v4float %float_2 = OpConstant %float 2 %33 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %21 = OpLoad %uint %20 %25 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %21 OpStore %25 %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/asm/op-source-glsl-ssbo-2.asm.comp000066400000000000000000000054211400026215700263520ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "a" OpName %_ "" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "b" OpName %__0 "" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %_runtimearr_v4float_0 ArrayStride 16 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %SSBO0 = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %_ = OpVariable %_ptr_Uniform_SSBO0 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %float_1 = OpConstant %float 1 %23 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_runtimearr_v4float_0 = OpTypeRuntimeArray %v4float %SSBO1 = OpTypeStruct %_runtimearr_v4float_0 %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %__0 = OpVariable %_ptr_Uniform_SSBO1 Uniform %float_2 = OpConstant %float 2 %33 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %21 = OpLoad %uint %20 %25 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %21 OpStore %25 %23 %34 = OpAccessChain %_ptr_Uniform_v4float %__0 %int_0 %21 OpStore %34 %33 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/asm/op-source-hlsl-uav-1.asm.comp000066400000000000000000000037071400026215700262040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 48 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %threadId OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 500 OpName %main "main" OpName %UAV0 "UAV0" OpMemberName %UAV0 0 "@data" OpName %UAV0_0 "UAV0" OpName %threadId "threadId" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %UAV0 0 Offset 0 OpDecorate %UAV0 BufferBlock OpDecorate %UAV0_0 DescriptorSet 0 OpDecorate %UAV0_0 Binding 0 OpDecorate %threadId BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %UAV0 = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_UAV0 = OpTypePointer Uniform %UAV0 %UAV0_0 = OpVariable %_ptr_Uniform_UAV0 Uniform %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %26 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %float_2 = OpConstant %float 2 %33 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Input_v3int = OpTypePointer Input %v3int %threadId = OpVariable %_ptr_Input_v3int Input %main = OpFunction %void None %3 %5 = OpLabel %38 = OpLoad %v3int %threadId %43 = OpCompositeExtract %int %38 0 %44 = OpAccessChain %_ptr_Uniform_v4float %UAV0_0 %int_0 %43 OpStore %44 %26 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/asm/op-source-hlsl-uav-2.asm.comp000066400000000000000000000043341400026215700262020ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 48 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %threadId OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 500 OpName %main "main" OpName %UAV0 "UAV0" OpMemberName %UAV0 0 "@data" OpName %UAV0_0 "UAV0" OpName %UAV1 "UAV1" OpName %threadId "threadId" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %UAV0 0 Offset 0 OpDecorate %UAV0 BufferBlock OpDecorate %UAV0_0 DescriptorSet 0 OpDecorate %UAV0_0 Binding 0 OpDecorate %UAV1 DescriptorSet 0 OpDecorate %UAV1 Binding 1 OpDecorate %threadId BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %UAV0 = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_UAV0 = OpTypePointer Uniform %UAV0 %UAV0_0 = OpVariable %_ptr_Uniform_UAV0 Uniform %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %26 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %UAV1 = OpVariable %_ptr_Uniform_UAV0 Uniform %float_2 = OpConstant %float 2 %33 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Input_v3int = OpTypePointer Input %v3int %threadId = OpVariable %_ptr_Input_v3int Input %main = OpFunction %void None %3 %5 = OpLabel %38 = OpLoad %v3int %threadId %43 = OpCompositeExtract %int %38 0 %44 = OpAccessChain %_ptr_Uniform_v4float %UAV0_0 %int_0 %43 OpStore %44 %26 %47 = OpAccessChain %_ptr_Uniform_v4float %UAV1 %int_0 %43 OpStore %47 %33 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/asm/op-source-none-ssbo-1.asm.comp000066400000000000000000000043221400026215700263460ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID %_ OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "a" OpName %_ "" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %_runtimearr_v4float_0 ArrayStride 16 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %SSBO0 = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %_ = OpVariable %_ptr_Uniform_SSBO0 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %float_1 = OpConstant %float 1 %23 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_runtimearr_v4float_0 = OpTypeRuntimeArray %v4float %float_2 = OpConstant %float 2 %33 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %21 = OpLoad %uint %20 %25 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %21 OpStore %25 %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/asm/op-source-none-ssbo-2.asm.comp000066400000000000000000000053601400026215700263520ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "a" OpName %_ "" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "b" OpName %__0 "" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %SSBO0 0 Offset 0 OpDecorate %SSBO0 BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %_runtimearr_v4float_0 ArrayStride 16 OpMemberDecorate %SSBO1 0 Offset 0 OpDecorate %SSBO1 BufferBlock OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %SSBO0 = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %_ = OpVariable %_ptr_Uniform_SSBO0 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %float_1 = OpConstant %float 1 %23 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_runtimearr_v4float_0 = OpTypeRuntimeArray %v4float %SSBO1 = OpTypeStruct %_runtimearr_v4float_0 %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %__0 = OpVariable %_ptr_Uniform_SSBO1 Uniform %float_2 = OpConstant %float 2 %33 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %21 = OpLoad %uint %20 %25 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %21 OpStore %25 %23 %34 = OpAccessChain %_ptr_Uniform_v4float %__0 %int_0 %21 OpStore %34 %33 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/asm/op-source-none-uav-1.asm.comp000066400000000000000000000036461400026215700262030ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 48 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %threadId OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %UAV0 "UAV0" OpMemberName %UAV0 0 "@data" OpName %UAV0_0 "UAV0" OpName %threadId "threadId" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %UAV0 0 Offset 0 OpDecorate %UAV0 BufferBlock OpDecorate %UAV0_0 DescriptorSet 0 OpDecorate %UAV0_0 Binding 0 OpDecorate %threadId BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %UAV0 = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_UAV0 = OpTypePointer Uniform %UAV0 %UAV0_0 = OpVariable %_ptr_Uniform_UAV0 Uniform %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %26 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %float_2 = OpConstant %float 2 %33 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Input_v3int = OpTypePointer Input %v3int %threadId = OpVariable %_ptr_Input_v3int Input %main = OpFunction %void None %3 %5 = OpLabel %38 = OpLoad %v3int %threadId %43 = OpCompositeExtract %int %38 0 %44 = OpAccessChain %_ptr_Uniform_v4float %UAV0_0 %int_0 %43 OpStore %44 %26 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/asm/op-source-none-uav-2.asm.comp000066400000000000000000000042731400026215700262010ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 48 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %threadId OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %UAV0 "UAV0" OpMemberName %UAV0 0 "@data" OpName %UAV0_0 "UAV0" OpName %UAV1 "UAV1" OpName %threadId "threadId" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %UAV0 0 Offset 0 OpDecorate %UAV0 BufferBlock OpDecorate %UAV0_0 DescriptorSet 0 OpDecorate %UAV0_0 Binding 0 OpDecorate %UAV1 DescriptorSet 0 OpDecorate %UAV1 Binding 1 OpDecorate %threadId BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %UAV0 = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_UAV0 = OpTypePointer Uniform %UAV0 %UAV0_0 = OpVariable %_ptr_Uniform_UAV0 Uniform %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %26 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %UAV1 = OpVariable %_ptr_Uniform_UAV0 Uniform %float_2 = OpConstant %float 2 %33 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Input_v3int = OpTypePointer Input %v3int %threadId = OpVariable %_ptr_Input_v3int Input %main = OpFunction %void None %3 %5 = OpLabel %38 = OpLoad %v3int %threadId %43 = OpCompositeExtract %int %38 0 %44 = OpAccessChain %_ptr_Uniform_v4float %UAV0_0 %int_0 %43 OpStore %44 %26 %47 = OpAccessChain %_ptr_Uniform_v4float %UAV1 %int_0 %43 OpStore %47 %33 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/comp/000077500000000000000000000000001400026215700211115ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-reflection/comp/array-of-physical-pointer.comp000066400000000000000000000004541400026215700270040ustar00rootroot00000000000000#version 460 #extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable #extension GL_EXT_buffer_reference2 : enable layout(buffer_reference, std430, buffer_reference_align = 4) buffer IntBuf { int v; }; layout(std140, binding = 0) uniform Params { float x; IntBuf y[3]; }; void main() { } spirv-cross-2021.01.15/shaders-reflection/comp/function-pointer.invalid.asm.comp000066400000000000000000000006371400026215700275060ustar00rootroot00000000000000; SPIR-V ; Version: 1.5 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 7 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypePointer Private %4 %2 = OpFunction %3 None %4 %6 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/comp/physical-pointer.comp000066400000000000000000000004511400026215700252630ustar00rootroot00000000000000#version 460 #extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable #extension GL_EXT_buffer_reference2 : enable layout(buffer_reference, std430, buffer_reference_align = 4) buffer IntBuf { int v; }; layout(std140, binding = 0) uniform Params { float x; IntBuf y; }; void main() { } spirv-cross-2021.01.15/shaders-reflection/comp/struct-layout.comp000066400000000000000000000005321400026215700246300ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; struct Foo { mat4 m; }; layout(std430, binding = 0) readonly buffer SSBO { Foo in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { Foo out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; out_data[ident].m = in_data[ident].m * in_data[ident].m; } spirv-cross-2021.01.15/shaders-reflection/comp/struct-packing.comp000066400000000000000000000024331400026215700247310ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; struct S0 { vec2 a[1]; float b; }; struct S1 { vec3 a; float b; }; struct S2 { vec3 a[1]; float b; }; struct S3 { vec2 a; float b; }; struct S4 { vec2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; S4 m3s[8]; }; layout(binding = 1, std430) restrict buffer SSBO1 { Content content; Content content1[2]; Content content2; layout(column_major) mat2 m0; layout(column_major) mat2 m1; layout(column_major) mat2x3 m2[4]; layout(column_major) mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_430; layout(binding = 0, std140) restrict buffer SSBO0 { Content content; Content content1[2]; Content content2; layout(column_major) mat2 m0; layout(column_major) mat2 m1; layout(column_major) mat2x3 m2[4]; layout(column_major) mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_140; void main() { ssbo_430.content = ssbo_140.content; } spirv-cross-2021.01.15/shaders-reflection/comp/workgroup-size-spec-constant.comp000066400000000000000000000002751400026215700275630ustar00rootroot00000000000000#version 450 layout(local_size_x_id = 10, local_size_y_id = 40, local_size_z_id = 60) in; layout(std430, set = 0, binding = 0) buffer SSBO { vec4 v; }; void main() { v = vec4(10.0); } spirv-cross-2021.01.15/shaders-reflection/frag/000077500000000000000000000000001400026215700210725ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-reflection/frag/combined-texture-sampler-shadow.vk.frag000066400000000000000000000012651400026215700305600ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump samplerShadow uSampler; layout(set = 0, binding = 1) uniform mediump sampler uSampler1; layout(set = 0, binding = 2) uniform texture2D uDepth; layout(location = 0) out float FragColor; float samp2(texture2D t, mediump samplerShadow s) { return texture(sampler2DShadow(t, s), vec3(1.0)); } float samp3(texture2D t, mediump sampler s) { return texture(sampler2D(t, s), vec2(1.0)).x; } float samp(texture2D t, mediump samplerShadow s, mediump sampler s1) { float r0 = samp2(t, s); float r1 = samp3(t, s1); return r0 + r1; } void main() { FragColor = samp(uDepth, uSampler, uSampler1); } spirv-cross-2021.01.15/shaders-reflection/frag/combined-texture-sampler.vk.frag000066400000000000000000000023201400026215700272660ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump sampler uSampler0; layout(set = 0, binding = 1) uniform mediump sampler uSampler1; layout(set = 0, binding = 2) uniform mediump texture2D uTexture0; layout(set = 0, binding = 3) uniform mediump texture2D uTexture1; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTex; vec4 sample_dual(mediump sampler samp, mediump texture2D tex) { return texture(sampler2D(tex, samp), vTex); } vec4 sample_global_tex(mediump sampler samp) { vec4 a = texture(sampler2D(uTexture0, samp), vTex); vec4 b = sample_dual(samp, uTexture1); return a + b; } vec4 sample_global_sampler(mediump texture2D tex) { vec4 a = texture(sampler2D(tex, uSampler0), vTex); vec4 b = sample_dual(uSampler1, tex); return a + b; } vec4 sample_duals() { vec4 a = sample_dual(uSampler0, uTexture0); vec4 b = sample_dual(uSampler1, uTexture1); return a + b; } void main() { vec4 c0 = sample_duals(); vec4 c1 = sample_global_tex(uSampler0); vec4 c2 = sample_global_tex(uSampler1); vec4 c3 = sample_global_sampler(uTexture0); vec4 c4 = sample_global_sampler(uTexture1); FragColor = c0 + c1 + c2 + c3 + c4; } spirv-cross-2021.01.15/shaders-reflection/frag/image-load-store-uint-coord.asm.frag000066400000000000000000000103761400026215700277330ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 63 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %storeTemp "storeTemp" OpName %RWIm "RWIm" OpName %v "v" OpName %RWBuf "RWBuf" OpName %ROIm "ROIm" OpName %ROBuf "ROBuf" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %RWIm DescriptorSet 0 OpDecorate %RWIm Binding 1 OpDecorate %RWBuf DescriptorSet 0 OpDecorate %RWBuf Binding 0 OpDecorate %ROIm DescriptorSet 0 OpDecorate %ROIm Binding 1 OpDecorate %ROBuf DescriptorSet 0 OpDecorate %ROBuf Binding 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %float_10 = OpConstant %float 10 %float_0_5 = OpConstant %float 0.5 %float_8 = OpConstant %float 8 %float_2 = OpConstant %float 2 %17 = OpConstantComposite %v4float %float_10 %float_0_5 %float_8 %float_2 %18 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %RWIm = OpVariable %_ptr_UniformConstant_18 UniformConstant %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %uint_10 = OpConstant %uint 10 %25 = OpConstantComposite %v2uint %uint_10 %uint_10 %uint_30 = OpConstant %uint 30 %30 = OpConstantComposite %v2uint %uint_30 %uint_30 %32 = OpTypeImage %float Buffer 0 0 0 2 Rgba32f %_ptr_UniformConstant_32 = OpTypePointer UniformConstant %32 %RWBuf = OpVariable %_ptr_UniformConstant_32 UniformConstant %uint_80 = OpConstant %uint 80 %38 = OpTypeImage %float 2D 0 0 0 1 Unknown %SampledImage = OpTypeSampledImage %38 %_ptr_UniformConstant_38 = OpTypePointer UniformConstant %SampledImage %ROIm = OpVariable %_ptr_UniformConstant_38 UniformConstant %uint_50 = OpConstant %uint 50 %uint_60 = OpConstant %uint 60 %44 = OpConstantComposite %v2uint %uint_50 %uint_60 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %50 = OpTypeImage %float Buffer 0 0 0 1 Rgba32f %_ptr_UniformConstant_50 = OpTypePointer UniformConstant %50 %ROBuf = OpVariable %_ptr_UniformConstant_50 UniformConstant %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %62 = OpFunctionCall %v4float %_main_ OpStore %_entryPointOutput %62 OpReturn OpFunctionEnd %_main_ = OpFunction %v4float None %8 %10 = OpLabel %storeTemp = OpVariable %_ptr_Function_v4float Function %v = OpVariable %_ptr_Function_v4float Function OpStore %storeTemp %17 %21 = OpLoad %18 %RWIm %26 = OpLoad %v4float %storeTemp OpImageWrite %21 %25 %26 %28 = OpLoad %18 %RWIm %31 = OpImageRead %v4float %28 %30 OpStore %v %31 %35 = OpLoad %32 %RWBuf %37 = OpLoad %v4float %v OpImageWrite %35 %uint_80 %37 %41 = OpLoad %SampledImage %ROIm %ROImage = OpImage %38 %41 %47 = OpImageFetch %v4float %ROImage %44 Lod %int_0 %48 = OpLoad %v4float %v %49 = OpFAdd %v4float %48 %47 OpStore %v %49 %53 = OpLoad %50 %ROBuf %54 = OpImageFetch %v4float %53 %uint_80 %55 = OpLoad %v4float %v %56 = OpFAdd %v4float %55 %54 OpStore %v %56 %57 = OpLoad %v4float %v OpReturnValue %57 OpFunctionEnd spirv-cross-2021.01.15/shaders-reflection/frag/input-attachment-ms.vk.frag000066400000000000000000000005531400026215700262570ustar00rootroot00000000000000#version 450 layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInputMS uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform subpassInputMS uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = subpassLoad(uSubpass0, 1) + subpassLoad(uSubpass1, 2) + subpassLoad(uSubpass0, gl_SampleID); } spirv-cross-2021.01.15/shaders-reflection/frag/input-attachment.vk.frag000066400000000000000000000005471400026215700256450ustar00rootroot00000000000000#version 310 es precision mediump float; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = subpassLoad(uSubpass0) + subpassLoad(uSubpass1); } spirv-cross-2021.01.15/shaders-reflection/frag/push-constant.vk.frag000066400000000000000000000004331400026215700251600ustar00rootroot00000000000000#version 310 es precision mediump float; layout(push_constant, std430) uniform PushConstants { vec4 value0; vec4 value1; } push; layout(location = 0) in vec4 vColor; layout(location = 0) out vec4 FragColor; void main() { FragColor = vColor + push.value0 + push.value1; } spirv-cross-2021.01.15/shaders-reflection/frag/separate-sampler-texture-array.vk.frag000066400000000000000000000027551400026215700304420ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump sampler uSampler; layout(set = 0, binding = 1) uniform mediump texture2D uTexture[4]; layout(set = 0, binding = 2) uniform mediump texture3D uTexture3D[4]; layout(set = 0, binding = 3) uniform mediump textureCube uTextureCube[4]; layout(set = 0, binding = 4) uniform mediump texture2DArray uTextureArray[4]; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; vec4 sample_func(mediump sampler samp, vec2 uv) { return texture(sampler2D(uTexture[2], samp), uv); } vec4 sample_func_dual(mediump sampler samp, mediump texture2D tex, vec2 uv) { return texture(sampler2D(tex, samp), uv); } vec4 sample_func_dual_array(mediump sampler samp, mediump texture2D tex[4], vec2 uv) { return texture(sampler2D(tex[1], samp), uv); } void main() { vec2 off = 1.0 / vec2(textureSize(sampler2D(uTexture[1], uSampler), 0)); vec2 off2 = 1.0 / vec2(textureSize(sampler2D(uTexture[2], uSampler), 1)); vec4 c0 = sample_func(uSampler, vTex + off + off2); vec4 c1 = sample_func_dual(uSampler, uTexture[1], vTex + off + off2); vec4 c2 = sample_func_dual_array(uSampler, uTexture, vTex + off + off2); vec4 c3 = texture(sampler2DArray(uTextureArray[3], uSampler), vTex3); vec4 c4 = texture(samplerCube(uTextureCube[1], uSampler), vTex3); vec4 c5 = texture(sampler3D(uTexture3D[2], uSampler), vTex3); FragColor = c0 + c1 + c2 + c3 + c4 + c5; } spirv-cross-2021.01.15/shaders-reflection/frag/spec-constant.vk.frag000066400000000000000000000045001400026215700251320ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(constant_id = 1) const float a = 1.5; layout(constant_id = 2) const float b = 2.5; layout(constant_id = 3) const int c = 3; layout(constant_id = 4) const int d = 4; layout(constant_id = 5) const uint e = 5u; layout(constant_id = 6) const uint f = 6u; layout(constant_id = 7) const bool g = false; layout(constant_id = 8) const bool h = true; // glslang doesn't seem to support partial spec constants or composites yet, so only test the basics. struct Foo { float elems[d + 2]; }; void main() { float t0 = a; float t1 = b; uint c0 = uint(c); // OpIAdd with different types. // FConvert, float-to-double. int c1 = -c; // SNegate int c2 = ~c; // OpNot int c3 = c + d; // OpIAdd int c4 = c - d; // OpISub int c5 = c * d; // OpIMul int c6 = c / d; // OpSDiv uint c7 = e / f; // OpUDiv int c8 = c % d; // OpSMod uint c9 = e % f; // OpUMod // TODO: OpSRem, any way to access this in GLSL? int c10 = c >> d; // OpShiftRightArithmetic uint c11 = e >> f; // OpShiftRightLogical int c12 = c << d; // OpShiftLeftLogical int c13 = c | d; // OpBitwiseOr int c14 = c ^ d; // OpBitwiseXor int c15 = c & d; // OpBitwiseAnd // VectorShuffle, CompositeExtract, CompositeInsert, not testable atm. bool c16 = g || h; // OpLogicalOr bool c17 = g && h; // OpLogicalAnd bool c18 = !g; // OpLogicalNot bool c19 = g == h; // OpLogicalEqual bool c20 = g != h; // OpLogicalNotEqual // OpSelect not testable atm. bool c21 = c == d; // OpIEqual bool c22 = c != d; // OpINotEqual bool c23 = c < d; // OpSLessThan bool c24 = e < f; // OpULessThan bool c25 = c > d; // OpSGreaterThan bool c26 = e > f; // OpUGreaterThan bool c27 = c <= d; // OpSLessThanEqual bool c28 = e <= f; // OpULessThanEqual bool c29 = c >= d; // OpSGreaterThanEqual bool c30 = e >= f; // OpUGreaterThanEqual // OpQuantizeToF16 not testable atm. int c31 = c8 + c3; int c32 = int(e); // OpIAdd with different types. bool c33 = bool(c); // int -> bool bool c34 = bool(e); // uint -> bool int c35 = int(g); // bool -> int uint c36 = uint(g); // bool -> uint float c37 = float(g); // bool -> float // Flexible sized arrays with spec constants and spec constant ops. float vec0[c + 3][8]; float vec1[c + 2]; Foo foo; FragColor = vec4(t0 + t1) + vec0[0][0] + vec1[0] + foo.elems[c]; } spirv-cross-2021.01.15/shaders-reflection/rgen/000077500000000000000000000000001400026215700211065ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-reflection/rgen/acceleration_structure.vk.rgen000066400000000000000000000003241400026215700271520ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureNV as; void main() { traceNV(as, 0u, 255u, 0u, 1u, 0u, vec3(0.0), 0.0, vec3(1.0), 1000.0, 0); } spirv-cross-2021.01.15/shaders-reflection/vert/000077500000000000000000000000001400026215700211335ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-reflection/vert/array-size-reflection.vert000066400000000000000000000002611400026215700262520ustar00rootroot00000000000000#version 450 layout(constant_id = 0) const int ARR_SIZE = 1; layout(binding = 0, set = 1, std140) uniform u_ { vec4 u_0[ARR_SIZE]; }; void main() { gl_Position = u_0[0]; } spirv-cross-2021.01.15/shaders-reflection/vert/read-from-row-major-array.vert000066400000000000000000000013741400026215700267450ustar00rootroot00000000000000#version 310 es layout(location = 0) in highp vec4 a_position; layout(location = 0) out mediump float v_vtxResult; layout(set = 0, binding = 0, std140, row_major) uniform Block { highp mat2x3 var[3][4]; }; mediump float compare_float (highp float a, highp float b) { return abs(a - b) < 0.05 ? 1.0 : 0.0; } mediump float compare_vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z); } mediump float compare_mat2x3 (highp mat2x3 a, highp mat2x3 b){ return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1]); } void main (void) { gl_Position = a_position; mediump float result = 1.0; result *= compare_mat2x3(var[0][0], mat2x3(2.0, 6.0, -6.0, 0.0, 5.0, 5.0)); v_vtxResult = result; } spirv-cross-2021.01.15/shaders-reflection/vert/stride-reflection.vert000066400000000000000000000002371400026215700254610ustar00rootroot00000000000000#version 450 layout(binding = 0, set = 0, std140) uniform U { vec4 v[4]; mat4 c[4]; layout(row_major) mat4 r[4]; }; void main() { gl_Position = v[0]; } spirv-cross-2021.01.15/shaders-reflection/vert/texture_buffer.vert000066400000000000000000000004151400026215700250660ustar00rootroot00000000000000#version 310 es #extension GL_OES_texture_buffer : require layout(binding = 4) uniform highp samplerBuffer uSamp; layout(rgba32f, binding = 5) uniform readonly highp imageBuffer uSampo; void main() { gl_Position = texelFetch(uSamp, 10) + imageLoad(uSampo, 100); } spirv-cross-2021.01.15/shaders-ue4-no-opt/000077500000000000000000000000001400026215700177305ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4-no-opt/asm/000077500000000000000000000000001400026215700205105ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4-no-opt/asm/frag/000077500000000000000000000000001400026215700214275ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4-no-opt/asm/frag/accesschain-invalid-expression.asm.invalid.frag000066400000000000000000001723041400026215700325700ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 572 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %Main "main" %in_var_TEXCOORD0 %in_var_TEXCOORD7 %in_var_TEXCOORD8 %gl_FragCoord %gl_FrontFacing %out_var_SV_Target0 OpExecutionMode %Main OriginUpperLeft OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_TranslatedWorldToView" OpMemberName %type_View 3 "View_ViewToTranslatedWorld" OpMemberName %type_View 4 "View_TranslatedWorldToCameraView" OpMemberName %type_View 5 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 6 "View_ViewToClip" OpMemberName %type_View 7 "View_ViewToClipNoAA" OpMemberName %type_View 8 "View_ClipToView" OpMemberName %type_View 9 "View_ClipToTranslatedWorld" OpMemberName %type_View 10 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 11 "View_ScreenToWorld" OpMemberName %type_View 12 "View_ScreenToTranslatedWorld" OpMemberName %type_View 13 "View_ViewForward" OpMemberName %type_View 14 "PrePadding_View_844" OpMemberName %type_View 15 "View_ViewUp" OpMemberName %type_View 16 "PrePadding_View_860" OpMemberName %type_View 17 "View_ViewRight" OpMemberName %type_View 18 "PrePadding_View_876" OpMemberName %type_View 19 "View_HMDViewNoRollUp" OpMemberName %type_View 20 "PrePadding_View_892" OpMemberName %type_View 21 "View_HMDViewNoRollRight" OpMemberName %type_View 22 "PrePadding_View_908" OpMemberName %type_View 23 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 24 "View_ScreenPositionScaleBias" OpMemberName %type_View 25 "View_WorldCameraOrigin" OpMemberName %type_View 26 "PrePadding_View_956" OpMemberName %type_View 27 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 28 "PrePadding_View_972" OpMemberName %type_View 29 "View_WorldViewOrigin" OpMemberName %type_View 30 "PrePadding_View_988" OpMemberName %type_View 31 "View_PreViewTranslation" OpMemberName %type_View 32 "PrePadding_View_1004" OpMemberName %type_View 33 "View_PrevProjection" OpMemberName %type_View 34 "View_PrevViewProj" OpMemberName %type_View 35 "View_PrevViewRotationProj" OpMemberName %type_View 36 "View_PrevViewToClip" OpMemberName %type_View 37 "View_PrevClipToView" OpMemberName %type_View 38 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 39 "View_PrevTranslatedWorldToView" OpMemberName %type_View 40 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 41 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 42 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 43 "View_PrevWorldCameraOrigin" OpMemberName %type_View 44 "PrePadding_View_1660" OpMemberName %type_View 45 "View_PrevWorldViewOrigin" OpMemberName %type_View 46 "PrePadding_View_1676" OpMemberName %type_View 47 "View_PrevPreViewTranslation" OpMemberName %type_View 48 "PrePadding_View_1692" OpMemberName %type_View 49 "View_PrevInvViewProj" OpMemberName %type_View 50 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 51 "View_ClipToPrevClip" OpMemberName %type_View 52 "View_TemporalAAJitter" OpMemberName %type_View 53 "View_GlobalClippingPlane" OpMemberName %type_View 54 "View_FieldOfViewWideAngles" OpMemberName %type_View 55 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 56 "View_ViewRectMin" OpMemberName %type_View 57 "View_ViewSizeAndInvSize" OpMemberName %type_View 58 "View_BufferSizeAndInvSize" OpMemberName %type_View 59 "View_BufferBilinearUVMinMax" OpMemberName %type_View 60 "View_NumSceneColorMSAASamples" OpMemberName %type_View 61 "View_PreExposure" OpMemberName %type_View 62 "View_OneOverPreExposure" OpMemberName %type_View 63 "PrePadding_View_2012" OpMemberName %type_View 64 "View_DiffuseOverrideParameter" OpMemberName %type_View 65 "View_SpecularOverrideParameter" OpMemberName %type_View 66 "View_NormalOverrideParameter" OpMemberName %type_View 67 "View_RoughnessOverrideParameter" OpMemberName %type_View 68 "View_PrevFrameGameTime" OpMemberName %type_View 69 "View_PrevFrameRealTime" OpMemberName %type_View 70 "View_OutOfBoundsMask" OpMemberName %type_View 71 "PrePadding_View_2084" OpMemberName %type_View 72 "PrePadding_View_2088" OpMemberName %type_View 73 "PrePadding_View_2092" OpMemberName %type_View 74 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 75 "View_CullingSign" OpMemberName %type_View 76 "View_NearPlane" OpMemberName %type_View 77 "View_AdaptiveTessellationFactor" OpMemberName %type_View 78 "View_GameTime" OpMemberName %type_View 79 "View_RealTime" OpMemberName %type_View 80 "View_DeltaTime" OpMemberName %type_View 81 "View_MaterialTextureMipBias" OpMemberName %type_View 82 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 83 "View_Random" OpMemberName %type_View 84 "View_FrameNumber" OpMemberName %type_View 85 "View_StateFrameIndexMod8" OpMemberName %type_View 86 "View_StateFrameIndex" OpMemberName %type_View 87 "View_CameraCut" OpMemberName %type_View 88 "View_UnlitViewmodeMask" OpMemberName %type_View 89 "PrePadding_View_2164" OpMemberName %type_View 90 "PrePadding_View_2168" OpMemberName %type_View 91 "PrePadding_View_2172" OpMemberName %type_View 92 "View_DirectionalLightColor" OpMemberName %type_View 93 "View_DirectionalLightDirection" OpMemberName %type_View 94 "PrePadding_View_2204" OpMemberName %type_View 95 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 97 "View_TemporalAAParams" OpMemberName %type_View 98 "View_CircleDOFParams" OpMemberName %type_View 99 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 100 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 101 "View_DepthOfFieldScale" OpMemberName %type_View 102 "View_DepthOfFieldFocalLength" OpMemberName %type_View 103 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 104 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 105 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 106 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 107 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 108 "View_GeneralPurposeTweak" OpMemberName %type_View 109 "View_DemosaicVposOffset" OpMemberName %type_View 110 "PrePadding_View_2348" OpMemberName %type_View 111 "View_IndirectLightingColorScale" OpMemberName %type_View 112 "View_HDR32bppEncodingMode" OpMemberName %type_View 113 "View_AtmosphericFogSunDirection" OpMemberName %type_View 114 "View_AtmosphericFogSunPower" OpMemberName %type_View 115 "View_AtmosphericFogPower" OpMemberName %type_View 116 "View_AtmosphericFogDensityScale" OpMemberName %type_View 117 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 118 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 119 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 120 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 121 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 122 "View_AtmosphericFogStartDistance" OpMemberName %type_View 123 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 124 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 125 "View_AtmosphericFogRenderMask" OpMemberName %type_View 126 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 127 "View_AtmosphericFogSunColor" OpMemberName %type_View 128 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 129 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 130 "View_AmbientCubemapTint" OpMemberName %type_View 131 "View_AmbientCubemapIntensity" OpMemberName %type_View 132 "View_SkyLightParameters" OpMemberName %type_View 133 "PrePadding_View_2488" OpMemberName %type_View 134 "PrePadding_View_2492" OpMemberName %type_View 135 "View_SkyLightColor" OpMemberName %type_View 136 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 137 "View_MobilePreviewMode" OpMemberName %type_View 138 "View_HMDEyePaddingOffset" OpMemberName %type_View 139 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 140 "View_ShowDecalsMask" OpMemberName %type_View 141 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 142 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 143 "PrePadding_View_2648" OpMemberName %type_View 144 "PrePadding_View_2652" OpMemberName %type_View 145 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 146 "View_StereoPassIndex" OpMemberName %type_View 147 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 148 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 149 "View_GlobalVolumeDimension" OpMemberName %type_View 150 "View_GlobalVolumeTexelSize" OpMemberName %type_View 151 "View_MaxGlobalDistance" OpMemberName %type_View 152 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 153 "View_VolumetricFogInvGridSize" OpMemberName %type_View 154 "PrePadding_View_2828" OpMemberName %type_View 155 "View_VolumetricFogGridZParams" OpMemberName %type_View 156 "PrePadding_View_2844" OpMemberName %type_View 157 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 158 "View_VolumetricFogMaxDistance" OpMemberName %type_View 159 "PrePadding_View_2860" OpMemberName %type_View 160 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 161 "PrePadding_View_2876" OpMemberName %type_View 162 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 163 "PrePadding_View_2892" OpMemberName %type_View 164 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 165 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 166 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 167 "View_StereoIPD" OpMemberName %type_View 168 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 169 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_MobileDirectionalLight "type.MobileDirectionalLight" OpMemberName %type_MobileDirectionalLight 0 "MobileDirectionalLight_DirectionalLightColor" OpMemberName %type_MobileDirectionalLight 1 "MobileDirectionalLight_DirectionalLightDirectionAndShadowTransition" OpMemberName %type_MobileDirectionalLight 2 "MobileDirectionalLight_DirectionalLightShadowSize" OpMemberName %type_MobileDirectionalLight 3 "MobileDirectionalLight_DirectionalLightDistanceFadeMAD" OpMemberName %type_MobileDirectionalLight 4 "MobileDirectionalLight_DirectionalLightShadowDistances" OpMemberName %type_MobileDirectionalLight 5 "MobileDirectionalLight_DirectionalLightScreenToShadow" OpName %MobileDirectionalLight "MobileDirectionalLight" OpName %type_2d_image "type.2d.image" OpName %MobileDirectionalLight_DirectionalLightShadowTexture "MobileDirectionalLight_DirectionalLightShadowTexture" OpName %type_sampler "type.sampler" OpName %MobileDirectionalLight_DirectionalLightShadowSampler "MobileDirectionalLight_DirectionalLightShadowSampler" OpName %Material_Texture2D_0 "Material_Texture2D_0" OpName %Material_Texture2D_0Sampler "Material_Texture2D_0Sampler" OpName %Material_Texture2D_1 "Material_Texture2D_1" OpName %Material_Texture2D_1Sampler "Material_Texture2D_1Sampler" OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "NumDynamicPointLights" OpMemberName %type__Globals 1 "LightPositionAndInvRadius" OpMemberName %type__Globals 2 "LightColorAndFalloffExponent" OpMemberName %type__Globals 3 "MobileReflectionParams" OpName %_Globals "$Globals" OpName %type_cube_image "type.cube.image" OpName %ReflectionCubemap "ReflectionCubemap" OpName %ReflectionCubemapSampler "ReflectionCubemapSampler" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %in_var_TEXCOORD7 "in.var.TEXCOORD7" OpName %in_var_TEXCOORD8 "in.var.TEXCOORD8" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %Main "Main" OpName %type_sampled_image "type.sampled.image" OpName %type_sampled_image_0 "type.sampled.image" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %in_var_TEXCOORD7 UserSemantic "TEXCOORD7" OpDecorateString %in_var_TEXCOORD8 UserSemantic "TEXCOORD8" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_Position" OpDecorate %gl_FrontFacing BuiltIn FrontFacing OpDecorateString %gl_FrontFacing UserSemantic "SV_IsFrontFace" OpDecorate %gl_FrontFacing Flat OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %in_var_TEXCOORD7 Location 1 OpDecorate %in_var_TEXCOORD8 Location 2 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %MobileDirectionalLight DescriptorSet 0 OpDecorate %MobileDirectionalLight Binding 1 OpDecorate %MobileDirectionalLight_DirectionalLightShadowTexture DescriptorSet 0 OpDecorate %MobileDirectionalLight_DirectionalLightShadowTexture Binding 0 OpDecorate %MobileDirectionalLight_DirectionalLightShadowSampler DescriptorSet 0 OpDecorate %MobileDirectionalLight_DirectionalLightShadowSampler Binding 0 OpDecorate %Material_Texture2D_0 DescriptorSet 0 OpDecorate %Material_Texture2D_0 Binding 1 OpDecorate %Material_Texture2D_0Sampler DescriptorSet 0 OpDecorate %Material_Texture2D_0Sampler Binding 1 OpDecorate %Material_Texture2D_1 DescriptorSet 0 OpDecorate %Material_Texture2D_1 Binding 2 OpDecorate %Material_Texture2D_1Sampler DescriptorSet 0 OpDecorate %Material_Texture2D_1Sampler Binding 2 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 2 OpDecorate %ReflectionCubemap DescriptorSet 0 OpDecorate %ReflectionCubemap Binding 3 OpDecorate %ReflectionCubemapSampler DescriptorSet 0 OpDecorate %ReflectionCubemapSampler Binding 3 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 14 Offset 844 OpMemberDecorate %type_View 15 Offset 848 OpMemberDecorate %type_View 16 Offset 860 OpMemberDecorate %type_View 17 Offset 864 OpMemberDecorate %type_View 18 Offset 876 OpMemberDecorate %type_View 19 Offset 880 OpMemberDecorate %type_View 20 Offset 892 OpMemberDecorate %type_View 21 Offset 896 OpMemberDecorate %type_View 22 Offset 908 OpMemberDecorate %type_View 23 Offset 912 OpMemberDecorate %type_View 24 Offset 928 OpMemberDecorate %type_View 25 Offset 944 OpMemberDecorate %type_View 26 Offset 956 OpMemberDecorate %type_View 27 Offset 960 OpMemberDecorate %type_View 28 Offset 972 OpMemberDecorate %type_View 29 Offset 976 OpMemberDecorate %type_View 30 Offset 988 OpMemberDecorate %type_View 31 Offset 992 OpMemberDecorate %type_View 32 Offset 1004 OpMemberDecorate %type_View 33 Offset 1008 OpMemberDecorate %type_View 33 MatrixStride 16 OpMemberDecorate %type_View 33 ColMajor OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 44 Offset 1660 OpMemberDecorate %type_View 45 Offset 1664 OpMemberDecorate %type_View 46 Offset 1676 OpMemberDecorate %type_View 47 Offset 1680 OpMemberDecorate %type_View 48 Offset 1692 OpMemberDecorate %type_View 49 Offset 1696 OpMemberDecorate %type_View 49 MatrixStride 16 OpMemberDecorate %type_View 49 ColMajor OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 53 Offset 1904 OpMemberDecorate %type_View 54 Offset 1920 OpMemberDecorate %type_View 55 Offset 1928 OpMemberDecorate %type_View 56 Offset 1936 OpMemberDecorate %type_View 57 Offset 1952 OpMemberDecorate %type_View 58 Offset 1968 OpMemberDecorate %type_View 59 Offset 1984 OpMemberDecorate %type_View 60 Offset 2000 OpMemberDecorate %type_View 61 Offset 2004 OpMemberDecorate %type_View 62 Offset 2008 OpMemberDecorate %type_View 63 Offset 2012 OpMemberDecorate %type_View 64 Offset 2016 OpMemberDecorate %type_View 65 Offset 2032 OpMemberDecorate %type_View 66 Offset 2048 OpMemberDecorate %type_View 67 Offset 2064 OpMemberDecorate %type_View 68 Offset 2072 OpMemberDecorate %type_View 69 Offset 2076 OpMemberDecorate %type_View 70 Offset 2080 OpMemberDecorate %type_View 71 Offset 2084 OpMemberDecorate %type_View 72 Offset 2088 OpMemberDecorate %type_View 73 Offset 2092 OpMemberDecorate %type_View 74 Offset 2096 OpMemberDecorate %type_View 75 Offset 2108 OpMemberDecorate %type_View 76 Offset 2112 OpMemberDecorate %type_View 77 Offset 2116 OpMemberDecorate %type_View 78 Offset 2120 OpMemberDecorate %type_View 79 Offset 2124 OpMemberDecorate %type_View 80 Offset 2128 OpMemberDecorate %type_View 81 Offset 2132 OpMemberDecorate %type_View 82 Offset 2136 OpMemberDecorate %type_View 83 Offset 2140 OpMemberDecorate %type_View 84 Offset 2144 OpMemberDecorate %type_View 85 Offset 2148 OpMemberDecorate %type_View 86 Offset 2152 OpMemberDecorate %type_View 87 Offset 2156 OpMemberDecorate %type_View 88 Offset 2160 OpMemberDecorate %type_View 89 Offset 2164 OpMemberDecorate %type_View 90 Offset 2168 OpMemberDecorate %type_View 91 Offset 2172 OpMemberDecorate %type_View 92 Offset 2176 OpMemberDecorate %type_View 93 Offset 2192 OpMemberDecorate %type_View 94 Offset 2204 OpMemberDecorate %type_View 95 Offset 2208 OpMemberDecorate %type_View 96 Offset 2240 OpMemberDecorate %type_View 97 Offset 2272 OpMemberDecorate %type_View 98 Offset 2288 OpMemberDecorate %type_View 99 Offset 2304 OpMemberDecorate %type_View 100 Offset 2308 OpMemberDecorate %type_View 101 Offset 2312 OpMemberDecorate %type_View 102 Offset 2316 OpMemberDecorate %type_View 103 Offset 2320 OpMemberDecorate %type_View 104 Offset 2324 OpMemberDecorate %type_View 105 Offset 2328 OpMemberDecorate %type_View 106 Offset 2332 OpMemberDecorate %type_View 107 Offset 2336 OpMemberDecorate %type_View 108 Offset 2340 OpMemberDecorate %type_View 109 Offset 2344 OpMemberDecorate %type_View 110 Offset 2348 OpMemberDecorate %type_View 111 Offset 2352 OpMemberDecorate %type_View 112 Offset 2364 OpMemberDecorate %type_View 113 Offset 2368 OpMemberDecorate %type_View 114 Offset 2380 OpMemberDecorate %type_View 115 Offset 2384 OpMemberDecorate %type_View 116 Offset 2388 OpMemberDecorate %type_View 117 Offset 2392 OpMemberDecorate %type_View 118 Offset 2396 OpMemberDecorate %type_View 119 Offset 2400 OpMemberDecorate %type_View 120 Offset 2404 OpMemberDecorate %type_View 121 Offset 2408 OpMemberDecorate %type_View 122 Offset 2412 OpMemberDecorate %type_View 123 Offset 2416 OpMemberDecorate %type_View 124 Offset 2420 OpMemberDecorate %type_View 125 Offset 2424 OpMemberDecorate %type_View 126 Offset 2428 OpMemberDecorate %type_View 127 Offset 2432 OpMemberDecorate %type_View 128 Offset 2448 OpMemberDecorate %type_View 129 Offset 2460 OpMemberDecorate %type_View 130 Offset 2464 OpMemberDecorate %type_View 131 Offset 2480 OpMemberDecorate %type_View 132 Offset 2484 OpMemberDecorate %type_View 133 Offset 2488 OpMemberDecorate %type_View 134 Offset 2492 OpMemberDecorate %type_View 135 Offset 2496 OpMemberDecorate %type_View 136 Offset 2512 OpMemberDecorate %type_View 137 Offset 2624 OpMemberDecorate %type_View 138 Offset 2628 OpMemberDecorate %type_View 139 Offset 2632 OpMemberDecorate %type_View 140 Offset 2636 OpMemberDecorate %type_View 141 Offset 2640 OpMemberDecorate %type_View 142 Offset 2644 OpMemberDecorate %type_View 143 Offset 2648 OpMemberDecorate %type_View 144 Offset 2652 OpMemberDecorate %type_View 145 Offset 2656 OpMemberDecorate %type_View 146 Offset 2668 OpMemberDecorate %type_View 147 Offset 2672 OpMemberDecorate %type_View 148 Offset 2736 OpMemberDecorate %type_View 149 Offset 2800 OpMemberDecorate %type_View 150 Offset 2804 OpMemberDecorate %type_View 151 Offset 2808 OpMemberDecorate %type_View 152 Offset 2812 OpMemberDecorate %type_View 153 Offset 2816 OpMemberDecorate %type_View 154 Offset 2828 OpMemberDecorate %type_View 155 Offset 2832 OpMemberDecorate %type_View 156 Offset 2844 OpMemberDecorate %type_View 157 Offset 2848 OpMemberDecorate %type_View 158 Offset 2856 OpMemberDecorate %type_View 159 Offset 2860 OpMemberDecorate %type_View 160 Offset 2864 OpMemberDecorate %type_View 161 Offset 2876 OpMemberDecorate %type_View 162 Offset 2880 OpMemberDecorate %type_View 163 Offset 2892 OpMemberDecorate %type_View 164 Offset 2896 OpMemberDecorate %type_View 165 Offset 2908 OpMemberDecorate %type_View 166 Offset 2912 OpMemberDecorate %type_View 167 Offset 2924 OpMemberDecorate %type_View 168 Offset 2928 OpMemberDecorate %type_View 169 Offset 2932 OpDecorate %type_View Block OpDecorate %_arr_mat4v4float_uint_4 ArrayStride 64 OpMemberDecorate %type_MobileDirectionalLight 0 Offset 0 OpMemberDecorate %type_MobileDirectionalLight 1 Offset 16 OpMemberDecorate %type_MobileDirectionalLight 2 Offset 32 OpMemberDecorate %type_MobileDirectionalLight 3 Offset 48 OpMemberDecorate %type_MobileDirectionalLight 4 Offset 64 OpMemberDecorate %type_MobileDirectionalLight 5 Offset 80 OpMemberDecorate %type_MobileDirectionalLight 5 MatrixStride 16 OpMemberDecorate %type_MobileDirectionalLight 5 ColMajor OpDecorate %type_MobileDirectionalLight Block OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 80 OpMemberDecorate %type__Globals 3 Offset 144 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_4 = OpConstant %int 4 %float_0 = OpConstant %float 0 %int_3 = OpConstant %int 3 %47 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %int_0 = OpConstant %int 0 %bool = OpTypeBool %int_5 = OpConstant %int 5 %52 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_0_999989986 = OpConstant %float 0.999989986 %float_65000 = OpConstant %float 65000 %55 = OpConstantComposite %v3float %float_65000 %float_65000 %float_65000 %float_0_318309873 = OpConstant %float 0.318309873 %57 = OpConstantComposite %v3float %float_0_318309873 %float_0_318309873 %float_0_318309873 %float_65500 = OpConstant %float 65500 %float_0_5 = OpConstant %float 0.5 %60 = OpConstantComposite %v2float %float_0_5 %float_0_5 %float_2 = OpConstant %float 2 %float_n2 = OpConstant %float -2 %63 = OpConstantComposite %v2float %float_2 %float_n2 %64 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_0_119999997 = OpConstant %float 0.119999997 %float_n1 = OpConstant %float -1 %float_n0_0274999999 = OpConstant %float -0.0274999999 %68 = OpConstantComposite %v2float %float_n1 %float_n0_0274999999 %float_0_0425000004 = OpConstant %float 0.0425000004 %70 = OpConstantComposite %v2float %float_1 %float_0_0425000004 %float_n9_27999973 = OpConstant %float -9.27999973 %72 = OpConstantComposite %v2float %float_1 %float_1 %float_0_25 = OpConstant %float 0.25 %float_16 = OpConstant %float 16 %int_31 = OpConstant %int 31 %int_56 = OpConstant %int 56 %int_57 = OpConstant %int 57 %int_64 = OpConstant %int 64 %int_65 = OpConstant %int 65 %int_66 = OpConstant %int 66 %int_67 = OpConstant %int 67 %int_88 = OpConstant %int 88 %int_135 = OpConstant %int 135 %int_139 = OpConstant %int 139 %mat3v3float = OpTypeMatrix %v3float 3 %86 = OpConstantComposite %v2float %float_2 %float_2 %float_0_300000012 = OpConstant %float 0.300000012 %88 = OpConstantComposite %v3float %float_0_300000012 %float_0_300000012 %float_1 %float_20 = OpConstant %float 20 %90 = OpConstantComposite %v2float %float_20 %float_20 %float_0_400000006 = OpConstant %float 0.400000006 %float_24 = OpConstant %float 24 %float_0_294999987 = OpConstant %float 0.294999987 %float_0_660000026 = OpConstant %float 0.660000026 %float_0_699999988 = OpConstant %float 0.699999988 %float_65504 = OpConstant %float 65504 %float_1_20000005 = OpConstant %float 1.20000005 %98 = OpConstantComposite %v3float %float_2 %float_2 %float_2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %_arr_mat4v4float_uint_4 = OpTypeArray %mat4v4float %uint_4 %type_MobileDirectionalLight = OpTypeStruct %v4float %v4float %v4float %v4float %v4float %_arr_mat4v4float_uint_4 %_ptr_Uniform_type_MobileDirectionalLight = OpTypePointer Uniform %type_MobileDirectionalLight %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %type__Globals = OpTypeStruct %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %v4float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %type_cube_image = OpTypeImage %float Cube 2 0 0 1 Unknown %_ptr_UniformConstant_type_cube_image = OpTypePointer UniformConstant %type_cube_image %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_bool = OpTypePointer Input %bool %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %110 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_int = OpTypePointer Uniform %int %type_sampled_image = OpTypeSampledImage %type_cube_image %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %type_sampled_image_0 = OpTypeSampledImage %type_2d_image %View = OpVariable %_ptr_Uniform_type_View Uniform %MobileDirectionalLight = OpVariable %_ptr_Uniform_type_MobileDirectionalLight Uniform %MobileDirectionalLight_DirectionalLightShadowTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %MobileDirectionalLight_DirectionalLightShadowSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %Material_Texture2D_0 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %Material_Texture2D_0Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %Material_Texture2D_1 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %Material_Texture2D_1Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %ReflectionCubemap = OpVariable %_ptr_UniformConstant_type_cube_image UniformConstant %ReflectionCubemapSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %in_var_TEXCOORD7 = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD8 = OpVariable %_ptr_Input_v4float Input %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %gl_FrontFacing = OpVariable %_ptr_Input_bool Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %117 = OpConstantComposite %v3float %float_1 %float_0 %float_0 %118 = OpConstantComposite %v3float %float_0 %float_1 %float_0 %119 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %120 = OpConstantComposite %mat3v3float %117 %118 %119 %float_10 = OpConstant %float 10 %122 = OpConstantComposite %v2float %float_10 %float_10 %float_5 = OpConstant %float 5 %124 = OpConstantComposite %v2float %float_5 %float_5 %float_0_00066666666 = OpConstant %float 0.00066666666 %float_n0_5 = OpConstant %float -0.5 %127 = OpConstantComposite %v2float %float_n0_5 %float_n0_5 %128 = OpConstantComposite %v2float %float_0_5 %float_n0_5 %float_1_5 = OpConstant %float 1.5 %130 = OpConstantComposite %v2float %float_1_5 %float_n0_5 %131 = OpConstantComposite %v2float %float_n0_5 %float_0_5 %132 = OpConstantComposite %v2float %float_1_5 %float_0_5 %133 = OpConstantComposite %v2float %float_n0_5 %float_1_5 %134 = OpConstantComposite %v2float %float_0_5 %float_1_5 %135 = OpConstantComposite %v2float %float_1_5 %float_1_5 %136 = OpUndef %v3float %137 = OpUndef %v4float %138 = OpUndef %float %139 = OpUndef %v3float %Main = OpFunction %void None %110 %140 = OpLabel %141 = OpLoad %v2float %in_var_TEXCOORD0 %142 = OpLoad %v4float %in_var_TEXCOORD7 %143 = OpLoad %v4float %in_var_TEXCOORD8 %144 = OpLoad %v4float %gl_FragCoord %145 = OpAccessChain %_ptr_Uniform_v3float %View %int_31 %146 = OpLoad %v3float %145 %147 = OpAccessChain %_ptr_Uniform_v4float %View %int_56 %148 = OpLoad %v4float %147 %149 = OpAccessChain %_ptr_Uniform_v4float %View %int_57 %150 = OpLoad %v4float %149 %151 = OpAccessChain %_ptr_Uniform_v4float %View %int_64 %152 = OpLoad %v4float %151 %153 = OpAccessChain %_ptr_Uniform_v4float %View %int_65 %154 = OpLoad %v4float %153 %155 = OpAccessChain %_ptr_Uniform_v4float %View %int_66 %156 = OpLoad %v4float %155 %157 = OpAccessChain %_ptr_Uniform_v2float %View %int_67 %158 = OpLoad %v2float %157 %159 = OpAccessChain %_ptr_Uniform_float %View %int_88 %160 = OpLoad %float %159 %161 = OpAccessChain %_ptr_Uniform_v4float %View %int_135 %162 = OpLoad %v4float %161 %163 = OpAccessChain %_ptr_Uniform_float %View %int_139 %164 = OpLoad %float %163 %165 = OpVectorShuffle %v2float %144 %144 0 1 %166 = OpVectorShuffle %v2float %148 %148 0 1 %167 = OpFSub %v2float %165 %166 %168 = OpVectorShuffle %v2float %150 %150 2 3 %169 = OpFMul %v2float %167 %168 %170 = OpFSub %v2float %169 %60 %171 = OpFMul %v2float %170 %63 %172 = OpCompositeExtract %float %171 0 %173 = OpCompositeExtract %float %171 1 %174 = OpCompositeConstruct %v4float %172 %173 %138 %float_1 %175 = OpCompositeExtract %float %144 3 %176 = OpCompositeConstruct %v4float %175 %175 %175 %175 %177 = OpFMul %v4float %174 %176 %178 = OpVectorShuffle %v3float %143 %143 0 1 2 %179 = OpFSub %v3float %178 %146 %180 = OpFNegate %v3float %178 %181 = OpExtInst %v3float %1 Normalize %180 %182 = OpFMul %v2float %141 %60 %183 = OpFMul %v2float %141 %122 %184 = OpLoad %type_2d_image %Material_Texture2D_0 %185 = OpLoad %type_sampler %Material_Texture2D_0Sampler %186 = OpSampledImage %type_sampled_image_0 %184 %185 %187 = OpImageSampleImplicitLod %v4float %186 %183 None %188 = OpVectorShuffle %v2float %187 %187 0 1 %189 = OpFMul %v2float %188 %86 %190 = OpFSub %v2float %189 %72 %191 = OpDot %float %190 %190 %192 = OpFSub %float %float_1 %191 %193 = OpExtInst %float %1 FClamp %192 %float_0 %float_1 %194 = OpExtInst %float %1 Sqrt %193 %195 = OpCompositeExtract %float %190 0 %196 = OpCompositeExtract %float %190 1 %197 = OpCompositeConstruct %v4float %195 %196 %194 %float_1 %198 = OpVectorShuffle %v3float %197 %197 0 1 2 %199 = OpFMul %v3float %198 %88 %200 = OpVectorShuffle %v3float %156 %156 0 1 2 %201 = OpCompositeExtract %float %156 3 %202 = OpCompositeConstruct %v3float %201 %201 %201 %203 = OpFMul %v3float %199 %202 %204 = OpFAdd %v3float %203 %200 %205 = OpMatrixTimesVector %v3float %120 %204 %206 = OpExtInst %v3float %1 Normalize %205 %207 = OpFNegate %v3float %181 %208 = OpDot %float %206 %181 %209 = OpCompositeConstruct %v3float %208 %208 %208 %210 = OpFMul %v3float %206 %209 %211 = OpFMul %v3float %210 %98 %212 = OpFAdd %v3float %207 %211 %213 = OpFMul %v2float %141 %90 %214 = OpLoad %type_2d_image %Material_Texture2D_1 %215 = OpLoad %type_sampler %Material_Texture2D_1Sampler %216 = OpSampledImage %type_sampled_image_0 %214 %215 %217 = OpImageSampleImplicitLod %v4float %216 %213 None %218 = OpCompositeExtract %float %217 0 %219 = OpExtInst %float %1 FMix %float_0_400000006 %float_1 %218 %220 = OpFSub %float %float_1 %219 %221 = OpFMul %v2float %141 %124 %222 = OpSampledImage %type_sampled_image_0 %214 %215 %223 = OpImageSampleImplicitLod %v4float %222 %221 None %224 = OpCompositeExtract %float %177 3 %225 = OpFSub %float %224 %float_24 %226 = OpFMul %float %225 %float_0_00066666666 %227 = OpExtInst %float %1 FMax %226 %float_0 %228 = OpExtInst %float %1 FMin %227 %float_1 %229 = OpCompositeExtract %float %223 1 %230 = OpExtInst %float %1 FMix %229 %float_1 %228 %231 = OpExtInst %float %1 FMix %219 %220 %230 %232 = OpSampledImage %type_sampled_image_0 %214 %215 %233 = OpImageSampleImplicitLod %v4float %232 %182 None %234 = OpExtInst %float %1 FMix %229 %float_0 %228 %235 = OpCompositeExtract %float %233 1 %236 = OpFAdd %float %235 %234 %237 = OpExtInst %float %1 FMix %236 %float_0_5 %float_0_5 %238 = OpExtInst %float %1 FMix %float_0_294999987 %float_0_660000026 %237 %239 = OpFMul %float %238 %float_0_5 %240 = OpFMul %float %231 %239 %241 = OpExtInst %float %1 FMix %float_0 %float_0_5 %235 %242 = OpExtInst %float %1 FMix %float_0_699999988 %float_1 %229 %243 = OpExtInst %float %1 FMix %242 %float_1 %228 %244 = OpFAdd %float %241 %243 %245 = OpExtInst %float %1 FMax %244 %float_0 %246 = OpExtInst %float %1 FMin %245 %float_1 %247 = OpCompositeConstruct %v3float %240 %240 %240 %248 = OpExtInst %v3float %1 FClamp %247 %47 %64 %249 = OpCompositeExtract %float %158 1 %250 = OpFMul %float %246 %249 %251 = OpCompositeExtract %float %158 0 %252 = OpFAdd %float %250 %251 %253 = OpExtInst %float %1 FClamp %252 %float_0_119999997 %float_1 %254 = OpExtInst %float %1 FMax %208 %float_0 %255 = OpCompositeConstruct %v2float %253 %253 %256 = OpFMul %v2float %255 %68 %257 = OpFAdd %v2float %256 %70 %258 = OpCompositeExtract %float %257 0 %259 = OpFMul %float %258 %258 %260 = OpFMul %float %float_n9_27999973 %254 %261 = OpExtInst %float %1 Exp2 %260 %262 = OpExtInst %float %1 FMin %259 %261 %263 = OpFMul %float %262 %258 %264 = OpCompositeExtract %float %257 1 %265 = OpFAdd %float %263 %264 %266 = OpCompositeExtract %float %152 3 %267 = OpCompositeConstruct %v3float %266 %266 %266 %268 = OpFMul %v3float %248 %267 %269 = OpVectorShuffle %v3float %152 %152 0 1 2 %270 = OpFAdd %v3float %268 %269 %271 = OpCompositeExtract %float %154 3 %272 = OpFMul %float %265 %271 %273 = OpCompositeConstruct %v3float %272 %272 %272 %274 = OpVectorShuffle %v3float %154 %154 0 1 2 %275 = OpFAdd %v3float %273 %274 %276 = OpCompositeExtract %float %275 0 %277 = OpExtInst %float %1 FClamp %float_1 %float_0 %float_1 %278 = OpLoad %type_2d_image %MobileDirectionalLight_DirectionalLightShadowTexture %279 = OpLoad %type_sampler %MobileDirectionalLight_DirectionalLightShadowSampler %280 = OpAccessChain %_ptr_Uniform_v4float %MobileDirectionalLight %int_1 %281 = OpAccessChain %_ptr_Uniform_float %MobileDirectionalLight %int_1 %int_3 %282 = OpLoad %float %281 %283 = OpAccessChain %_ptr_Uniform_v4float %MobileDirectionalLight %int_2 %284 = OpLoad %v4float %283 OpBranch %285 %285 = OpLabel %286 = OpPhi %int %int_0 %140 %287 %288 %289 = OpSLessThan %bool %286 %int_2 OpLoopMerge %290 %288 None OpBranchConditional %289 %291 %290 %291 = OpLabel %292 = OpBitcast %uint %286 %293 = OpAccessChain %_ptr_Uniform_float %MobileDirectionalLight %int_4 %292 %294 = OpLoad %float %293 %295 = OpFOrdLessThan %bool %224 %294 OpSelectionMerge %288 None OpBranchConditional %295 %296 %288 %296 = OpLabel %297 = OpCompositeExtract %float %177 0 %298 = OpCompositeExtract %float %177 1 %299 = OpCompositeConstruct %v4float %297 %298 %224 %float_1 %300 = OpAccessChain %_ptr_Uniform_mat4v4float %MobileDirectionalLight %int_5 %286 %301 = OpLoad %mat4v4float %300 %302 = OpMatrixTimesVector %v4float %301 %299 OpBranch %290 %288 = OpLabel %287 = OpIAdd %int %286 %int_1 OpBranch %285 %290 = OpLabel %303 = OpPhi %v4float %52 %285 %302 %296 %304 = OpCompositeExtract %float %303 2 %305 = OpFOrdGreaterThan %bool %304 %float_0 OpSelectionMerge %306 None OpBranchConditional %305 %307 %306 %307 = OpLabel %308 = OpExtInst %float %1 FMin %304 %float_0_999989986 %309 = OpVectorShuffle %v2float %303 %303 0 1 %310 = OpVectorShuffle %v2float %284 %284 0 1 %311 = OpFMul %v2float %309 %310 %312 = OpExtInst %v2float %1 Fract %311 %313 = OpExtInst %v2float %1 Floor %311 %314 = OpFAdd %v2float %313 %127 %315 = OpVectorShuffle %v2float %284 %284 2 3 %316 = OpFMul %v2float %314 %315 %317 = OpSampledImage %type_sampled_image_0 %278 %279 %318 = OpImageSampleExplicitLod %v4float %317 %316 Lod %float_0 %319 = OpCompositeExtract %float %318 0 %320 = OpCompositeInsert %v3float %319 %139 0 %321 = OpFAdd %v2float %313 %128 %322 = OpFMul %v2float %321 %315 %323 = OpSampledImage %type_sampled_image_0 %278 %279 %324 = OpImageSampleExplicitLod %v4float %323 %322 Lod %float_0 %325 = OpCompositeExtract %float %324 0 %326 = OpCompositeInsert %v3float %325 %320 1 %327 = OpFAdd %v2float %313 %130 %328 = OpFMul %v2float %327 %315 %329 = OpSampledImage %type_sampled_image_0 %278 %279 %330 = OpImageSampleExplicitLod %v4float %329 %328 Lod %float_0 %331 = OpCompositeExtract %float %330 0 %332 = OpCompositeInsert %v3float %331 %326 2 %333 = OpFMul %float %308 %282 %334 = OpFSub %float %333 %float_1 %335 = OpCompositeConstruct %v3float %282 %282 %282 %336 = OpFMul %v3float %332 %335 %337 = OpCompositeConstruct %v3float %334 %334 %334 %338 = OpFSub %v3float %336 %337 %339 = OpExtInst %v3float %1 FClamp %338 %47 %64 %340 = OpFAdd %v2float %313 %131 %341 = OpFMul %v2float %340 %315 %342 = OpSampledImage %type_sampled_image_0 %278 %279 %343 = OpImageSampleExplicitLod %v4float %342 %341 Lod %float_0 %344 = OpCompositeExtract %float %343 0 %345 = OpCompositeInsert %v3float %344 %139 0 %346 = OpFAdd %v2float %313 %60 %347 = OpFMul %v2float %346 %315 %348 = OpSampledImage %type_sampled_image_0 %278 %279 %349 = OpImageSampleExplicitLod %v4float %348 %347 Lod %float_0 %350 = OpCompositeExtract %float %349 0 %351 = OpCompositeInsert %v3float %350 %345 1 %352 = OpFAdd %v2float %313 %132 %353 = OpFMul %v2float %352 %315 %354 = OpSampledImage %type_sampled_image_0 %278 %279 %355 = OpImageSampleExplicitLod %v4float %354 %353 Lod %float_0 %356 = OpCompositeExtract %float %355 0 %357 = OpCompositeInsert %v3float %356 %351 2 %358 = OpFMul %v3float %357 %335 %359 = OpFSub %v3float %358 %337 %360 = OpExtInst %v3float %1 FClamp %359 %47 %64 %361 = OpFAdd %v2float %313 %133 %362 = OpFMul %v2float %361 %315 %363 = OpSampledImage %type_sampled_image_0 %278 %279 %364 = OpImageSampleExplicitLod %v4float %363 %362 Lod %float_0 %365 = OpCompositeExtract %float %364 0 %366 = OpCompositeInsert %v3float %365 %139 0 %367 = OpFAdd %v2float %313 %134 %368 = OpFMul %v2float %367 %315 %369 = OpSampledImage %type_sampled_image_0 %278 %279 %370 = OpImageSampleExplicitLod %v4float %369 %368 Lod %float_0 %371 = OpCompositeExtract %float %370 0 %372 = OpCompositeInsert %v3float %371 %366 1 %373 = OpFAdd %v2float %313 %135 %374 = OpFMul %v2float %373 %315 %375 = OpSampledImage %type_sampled_image_0 %278 %279 %376 = OpImageSampleExplicitLod %v4float %375 %374 Lod %float_0 %377 = OpCompositeExtract %float %376 0 %378 = OpCompositeInsert %v3float %377 %372 2 %379 = OpFMul %v3float %378 %335 %380 = OpFSub %v3float %379 %337 %381 = OpExtInst %v3float %1 FClamp %380 %47 %64 %382 = OpCompositeExtract %float %339 0 %383 = OpCompositeExtract %float %312 0 %384 = OpFSub %float %float_1 %383 %385 = OpFMul %float %382 %384 %386 = OpCompositeExtract %float %360 0 %387 = OpFMul %float %386 %384 %388 = OpCompositeExtract %float %381 0 %389 = OpFMul %float %388 %384 %390 = OpCompositeExtract %float %339 1 %391 = OpFAdd %float %385 %390 %392 = OpCompositeExtract %float %360 1 %393 = OpFAdd %float %387 %392 %394 = OpCompositeExtract %float %381 1 %395 = OpFAdd %float %389 %394 %396 = OpCompositeExtract %float %339 2 %397 = OpFMul %float %396 %383 %398 = OpFAdd %float %391 %397 %399 = OpCompositeInsert %v3float %398 %136 0 %400 = OpCompositeExtract %float %360 2 %401 = OpFMul %float %400 %383 %402 = OpFAdd %float %393 %401 %403 = OpCompositeInsert %v3float %402 %399 1 %404 = OpCompositeExtract %float %381 2 %405 = OpFMul %float %404 %383 %406 = OpFAdd %float %395 %405 %407 = OpCompositeInsert %v3float %406 %403 2 %408 = OpCompositeExtract %float %312 1 %409 = OpFSub %float %float_1 %408 %410 = OpCompositeConstruct %v3float %409 %float_1 %408 %411 = OpDot %float %407 %410 %412 = OpFMul %float %float_0_25 %411 %413 = OpExtInst %float %1 FClamp %412 %float_0 %float_1 %414 = OpAccessChain %_ptr_Uniform_float %MobileDirectionalLight %int_3 %int_0 %415 = OpLoad %float %414 %416 = OpFMul %float %224 %415 %417 = OpAccessChain %_ptr_Uniform_float %MobileDirectionalLight %int_3 %int_1 %418 = OpLoad %float %417 %419 = OpFAdd %float %416 %418 %420 = OpExtInst %float %1 FClamp %419 %float_0 %float_1 %421 = OpFMul %float %420 %420 %422 = OpExtInst %float %1 FMix %413 %float_1 %421 OpBranch %306 %306 = OpLabel %423 = OpPhi %float %float_1 %290 %422 %307 %424 = OpLoad %v4float %280 %425 = OpVectorShuffle %v3float %424 %424 0 1 2 %426 = OpDot %float %206 %425 %427 = OpExtInst %float %1 FMax %float_0 %426 %428 = OpFAdd %v3float %181 %425 %429 = OpExtInst %v3float %1 Normalize %428 %430 = OpDot %float %206 %429 %431 = OpExtInst %float %1 FMax %float_0 %430 %432 = OpFMul %float %423 %427 %433 = OpCompositeConstruct %v3float %432 %432 %432 %434 = OpAccessChain %_ptr_Uniform_v4float %MobileDirectionalLight %int_0 %435 = OpLoad %v4float %434 %436 = OpVectorShuffle %v3float %435 %435 0 1 2 %437 = OpFMul %v3float %433 %436 %438 = OpFMul %float %253 %float_0_25 %439 = OpFAdd %float %438 %float_0_25 %440 = OpExtInst %v3float %1 Cross %206 %429 %441 = OpDot %float %440 %440 %442 = OpFMul %float %253 %253 %443 = OpFMul %float %431 %442 %444 = OpFMul %float %443 %443 %445 = OpFAdd %float %441 %444 %446 = OpFDiv %float %442 %445 %447 = OpFMul %float %446 %446 %448 = OpExtInst %float %1 FMin %447 %float_65504 %449 = OpFMul %float %439 %448 %450 = OpFMul %float %276 %449 %451 = OpCompositeConstruct %v3float %450 %450 %450 %452 = OpFAdd %v3float %270 %451 %453 = OpFMul %v3float %437 %452 %454 = OpAccessChain %_ptr_Uniform_float %_Globals %int_3 %int_3 %455 = OpLoad %float %454 %456 = OpFOrdGreaterThan %bool %455 %float_0 %457 = OpSelect %float %456 %float_1 %float_0 %458 = OpFOrdNotEqual %bool %457 %float_0 %459 = OpSelect %float %458 %455 %164 %460 = OpExtInst %float %1 Log2 %253 %461 = OpFMul %float %float_1_20000005 %460 %462 = OpFSub %float %float_1 %461 %463 = OpFSub %float %459 %float_1 %464 = OpFSub %float %463 %462 %465 = OpLoad %type_cube_image %ReflectionCubemap %466 = OpLoad %type_sampler %ReflectionCubemapSampler %467 = OpSampledImage %type_sampled_image %465 %466 %468 = OpImageSampleExplicitLod %v4float %467 %212 Lod %464 OpSelectionMerge %469 None OpBranchConditional %458 %470 %471 %471 = OpLabel %472 = OpVectorShuffle %v3float %468 %468 0 1 2 %473 = OpCompositeExtract %float %468 3 %474 = OpFMul %float %473 %float_16 %475 = OpCompositeConstruct %v3float %474 %474 %474 %476 = OpFMul %v3float %472 %475 %477 = OpFMul %v3float %476 %476 OpBranch %469 %470 = OpLabel %478 = OpVectorShuffle %v3float %468 %468 0 1 2 %479 = OpVectorShuffle %v3float %162 %162 0 1 2 %480 = OpFMul %v3float %478 %479 OpBranch %469 %469 = OpLabel %481 = OpPhi %v3float %477 %471 %480 %470 %482 = OpCompositeConstruct %v3float %277 %277 %277 %483 = OpFMul %v3float %481 %482 %484 = OpCompositeConstruct %v3float %276 %276 %276 %485 = OpFMul %v3float %483 %484 %486 = OpFAdd %v3float %453 %485 OpBranch %487 %487 = OpLabel %488 = OpPhi %v3float %486 %469 %489 %490 %491 = OpPhi %int %int_0 %469 %492 %490 %493 = OpAccessChain %_ptr_Uniform_int %_Globals %int_0 %494 = OpLoad %int %493 %495 = OpSLessThan %bool %491 %494 OpLoopMerge %496 %490 None OpBranchConditional %495 %497 %496 %497 = OpLabel %498 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_1 %491 %499 = OpLoad %v4float %498 %500 = OpVectorShuffle %v3float %499 %499 0 1 2 %501 = OpFSub %v3float %500 %179 %502 = OpDot %float %501 %501 %503 = OpExtInst %float %1 InverseSqrt %502 %504 = OpCompositeConstruct %v3float %503 %503 %503 %505 = OpFMul %v3float %501 %504 %506 = OpFAdd %v3float %181 %505 %507 = OpExtInst %v3float %1 Normalize %506 %508 = OpDot %float %206 %505 %509 = OpExtInst %float %1 FMax %float_0 %508 %510 = OpDot %float %206 %507 %511 = OpExtInst %float %1 FMax %float_0 %510 %512 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_2 %491 %513 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %491 %int_3 %514 = OpLoad %float %513 %515 = OpFOrdEqual %bool %514 %float_0 OpSelectionMerge %490 None OpBranchConditional %515 %516 %517 %517 = OpLabel %518 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %491 %int_3 %519 = OpLoad %float %518 %520 = OpCompositeConstruct %v3float %519 %519 %519 %521 = OpFMul %v3float %501 %520 %522 = OpDot %float %521 %521 %523 = OpExtInst %float %1 FClamp %522 %float_0 %float_1 %524 = OpFSub %float %float_1 %523 %525 = OpExtInst %float %1 Pow %524 %514 OpBranch %490 %516 = OpLabel %526 = OpFAdd %float %502 %float_1 %527 = OpFDiv %float %float_1 %526 %528 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %491 %int_3 %529 = OpLoad %float %528 %530 = OpFMul %float %529 %529 %531 = OpFMul %float %502 %530 %532 = OpFMul %float %531 %531 %533 = OpFSub %float %float_1 %532 %534 = OpExtInst %float %1 FClamp %533 %float_0 %float_1 %535 = OpFMul %float %534 %534 %536 = OpFMul %float %527 %535 OpBranch %490 %490 = OpLabel %537 = OpPhi %float %525 %517 %536 %516 %538 = OpFMul %float %537 %509 %539 = OpCompositeConstruct %v3float %538 %538 %538 %540 = OpLoad %v4float %512 %541 = OpVectorShuffle %v3float %540 %540 0 1 2 %542 = OpFMul %v3float %539 %541 %543 = OpFMul %v3float %542 %57 %544 = OpExtInst %v3float %1 Cross %206 %507 %545 = OpDot %float %544 %544 %546 = OpFMul %float %511 %442 %547 = OpFMul %float %546 %546 %548 = OpFAdd %float %545 %547 %549 = OpFDiv %float %442 %548 %550 = OpFMul %float %549 %549 %551 = OpExtInst %float %1 FMin %550 %float_65504 %552 = OpFMul %float %439 %551 %553 = OpFMul %float %276 %552 %554 = OpCompositeConstruct %v3float %553 %553 %553 %555 = OpFAdd %v3float %270 %554 %556 = OpFMul %v3float %543 %555 %557 = OpExtInst %v3float %1 FMin %55 %556 %489 = OpFAdd %v3float %488 %557 %492 = OpIAdd %int %491 %int_1 OpBranch %487 %496 = OpLabel %558 = OpExtInst %v3float %1 FMax %47 %47 %559 = OpFAdd %v3float %488 %558 %560 = OpFAdd %v3float %270 %484 %561 = OpCompositeConstruct %v3float %160 %160 %160 %562 = OpExtInst %v3float %1 FMix %559 %560 %561 %563 = OpCompositeExtract %float %142 3 %564 = OpCompositeConstruct %v3float %563 %563 %563 %565 = OpFMul %v3float %562 %564 %566 = OpVectorShuffle %v3float %142 %142 0 1 2 %567 = OpFAdd %v3float %565 %566 %568 = OpVectorShuffle %v4float %137 %567 4 5 6 3 %569 = OpCompositeExtract %float %143 3 %570 = OpExtInst %float %1 FMin %569 %float_65500 %571 = OpCompositeInsert %v4float %570 %568 3 OpStore %out_var_SV_Target0 %571 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4-no-opt/asm/frag/array-copy-error.asm.invalid.frag000066400000000000000000001440111400026215700277120ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 353 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPixelShader "main" %gl_FragCoord %in_var_TEXCOORD6 %in_var_TEXCOORD7 %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_TEXCOORD0 %in_var_PRIMITIVE_ID %gl_FrontFacing %gl_FragDepth %out_var_SV_Target0 OpExecutionMode %MainPixelShader OriginUpperLeft OpExecutionMode %MainPixelShader DepthReplacing OpExecutionMode %MainPixelShader DepthLess OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_ClipToWorld" OpMemberName %type_View 3 "View_TranslatedWorldToView" OpMemberName %type_View 4 "View_ViewToTranslatedWorld" OpMemberName %type_View 5 "View_TranslatedWorldToCameraView" OpMemberName %type_View 6 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 7 "View_ViewToClip" OpMemberName %type_View 8 "View_ViewToClipNoAA" OpMemberName %type_View 9 "View_ClipToView" OpMemberName %type_View 10 "View_ClipToTranslatedWorld" OpMemberName %type_View 11 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 12 "View_ScreenToWorld" OpMemberName %type_View 13 "View_ScreenToTranslatedWorld" OpMemberName %type_View 14 "View_ViewForward" OpMemberName %type_View 15 "PrePadding_View_908" OpMemberName %type_View 16 "View_ViewUp" OpMemberName %type_View 17 "PrePadding_View_924" OpMemberName %type_View 18 "View_ViewRight" OpMemberName %type_View 19 "PrePadding_View_940" OpMemberName %type_View 20 "View_HMDViewNoRollUp" OpMemberName %type_View 21 "PrePadding_View_956" OpMemberName %type_View 22 "View_HMDViewNoRollRight" OpMemberName %type_View 23 "PrePadding_View_972" OpMemberName %type_View 24 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 25 "View_ScreenPositionScaleBias" OpMemberName %type_View 26 "View_WorldCameraOrigin" OpMemberName %type_View 27 "PrePadding_View_1020" OpMemberName %type_View 28 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 29 "PrePadding_View_1036" OpMemberName %type_View 30 "View_WorldViewOrigin" OpMemberName %type_View 31 "PrePadding_View_1052" OpMemberName %type_View 32 "View_PreViewTranslation" OpMemberName %type_View 33 "PrePadding_View_1068" OpMemberName %type_View 34 "View_PrevProjection" OpMemberName %type_View 35 "View_PrevViewProj" OpMemberName %type_View 36 "View_PrevViewRotationProj" OpMemberName %type_View 37 "View_PrevViewToClip" OpMemberName %type_View 38 "View_PrevClipToView" OpMemberName %type_View 39 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 40 "View_PrevTranslatedWorldToView" OpMemberName %type_View 41 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 42 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 43 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 44 "View_PrevWorldCameraOrigin" OpMemberName %type_View 45 "PrePadding_View_1724" OpMemberName %type_View 46 "View_PrevWorldViewOrigin" OpMemberName %type_View 47 "PrePadding_View_1740" OpMemberName %type_View 48 "View_PrevPreViewTranslation" OpMemberName %type_View 49 "PrePadding_View_1756" OpMemberName %type_View 50 "View_PrevInvViewProj" OpMemberName %type_View 51 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 52 "View_ClipToPrevClip" OpMemberName %type_View 53 "View_TemporalAAJitter" OpMemberName %type_View 54 "View_GlobalClippingPlane" OpMemberName %type_View 55 "View_FieldOfViewWideAngles" OpMemberName %type_View 56 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 57 "View_ViewRectMin" OpMemberName %type_View 58 "View_ViewSizeAndInvSize" OpMemberName %type_View 59 "View_BufferSizeAndInvSize" OpMemberName %type_View 60 "View_BufferBilinearUVMinMax" OpMemberName %type_View 61 "View_NumSceneColorMSAASamples" OpMemberName %type_View 62 "View_PreExposure" OpMemberName %type_View 63 "View_OneOverPreExposure" OpMemberName %type_View 64 "PrePadding_View_2076" OpMemberName %type_View 65 "View_DiffuseOverrideParameter" OpMemberName %type_View 66 "View_SpecularOverrideParameter" OpMemberName %type_View 67 "View_NormalOverrideParameter" OpMemberName %type_View 68 "View_RoughnessOverrideParameter" OpMemberName %type_View 69 "View_PrevFrameGameTime" OpMemberName %type_View 70 "View_PrevFrameRealTime" OpMemberName %type_View 71 "View_OutOfBoundsMask" OpMemberName %type_View 72 "PrePadding_View_2148" OpMemberName %type_View 73 "PrePadding_View_2152" OpMemberName %type_View 74 "PrePadding_View_2156" OpMemberName %type_View 75 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 76 "View_CullingSign" OpMemberName %type_View 77 "View_NearPlane" OpMemberName %type_View 78 "View_AdaptiveTessellationFactor" OpMemberName %type_View 79 "View_GameTime" OpMemberName %type_View 80 "View_RealTime" OpMemberName %type_View 81 "View_DeltaTime" OpMemberName %type_View 82 "View_MaterialTextureMipBias" OpMemberName %type_View 83 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 84 "View_Random" OpMemberName %type_View 85 "View_FrameNumber" OpMemberName %type_View 86 "View_StateFrameIndexMod8" OpMemberName %type_View 87 "View_StateFrameIndex" OpMemberName %type_View 88 "View_CameraCut" OpMemberName %type_View 89 "View_UnlitViewmodeMask" OpMemberName %type_View 90 "PrePadding_View_2228" OpMemberName %type_View 91 "PrePadding_View_2232" OpMemberName %type_View 92 "PrePadding_View_2236" OpMemberName %type_View 93 "View_DirectionalLightColor" OpMemberName %type_View 94 "View_DirectionalLightDirection" OpMemberName %type_View 95 "PrePadding_View_2268" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 97 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 98 "View_TemporalAAParams" OpMemberName %type_View 99 "View_CircleDOFParams" OpMemberName %type_View 100 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 101 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 102 "View_DepthOfFieldScale" OpMemberName %type_View 103 "View_DepthOfFieldFocalLength" OpMemberName %type_View 104 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 105 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 106 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 107 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 108 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 109 "View_GeneralPurposeTweak" OpMemberName %type_View 110 "View_DemosaicVposOffset" OpMemberName %type_View 111 "PrePadding_View_2412" OpMemberName %type_View 112 "View_IndirectLightingColorScale" OpMemberName %type_View 113 "View_HDR32bppEncodingMode" OpMemberName %type_View 114 "View_AtmosphericFogSunDirection" OpMemberName %type_View 115 "View_AtmosphericFogSunPower" OpMemberName %type_View 116 "View_AtmosphericFogPower" OpMemberName %type_View 117 "View_AtmosphericFogDensityScale" OpMemberName %type_View 118 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 119 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 120 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 121 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 122 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 123 "View_AtmosphericFogStartDistance" OpMemberName %type_View 124 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 125 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 126 "View_AtmosphericFogSunDiscHalfApexAngleRadian" OpMemberName %type_View 127 "PrePadding_View_2492" OpMemberName %type_View 128 "View_AtmosphericFogSunDiscLuminance" OpMemberName %type_View 129 "View_AtmosphericFogRenderMask" OpMemberName %type_View 130 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 131 "PrePadding_View_2520" OpMemberName %type_View 132 "PrePadding_View_2524" OpMemberName %type_View 133 "View_AtmosphericFogSunColor" OpMemberName %type_View 134 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 135 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 136 "View_AmbientCubemapTint" OpMemberName %type_View 137 "View_AmbientCubemapIntensity" OpMemberName %type_View 138 "View_SkyLightParameters" OpMemberName %type_View 139 "PrePadding_View_2584" OpMemberName %type_View 140 "PrePadding_View_2588" OpMemberName %type_View 141 "View_SkyLightColor" OpMemberName %type_View 142 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 143 "View_MobilePreviewMode" OpMemberName %type_View 144 "View_HMDEyePaddingOffset" OpMemberName %type_View 145 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 146 "View_ShowDecalsMask" OpMemberName %type_View 147 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 148 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 149 "PrePadding_View_2744" OpMemberName %type_View 150 "PrePadding_View_2748" OpMemberName %type_View 151 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 152 "View_StereoPassIndex" OpMemberName %type_View 153 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 154 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 155 "View_GlobalVolumeDimension" OpMemberName %type_View 156 "View_GlobalVolumeTexelSize" OpMemberName %type_View 157 "View_MaxGlobalDistance" OpMemberName %type_View 158 "PrePadding_View_2908" OpMemberName %type_View 159 "View_CursorPosition" OpMemberName %type_View 160 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 161 "PrePadding_View_2924" OpMemberName %type_View 162 "View_VolumetricFogInvGridSize" OpMemberName %type_View 163 "PrePadding_View_2940" OpMemberName %type_View 164 "View_VolumetricFogGridZParams" OpMemberName %type_View 165 "PrePadding_View_2956" OpMemberName %type_View 166 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 167 "View_VolumetricFogMaxDistance" OpMemberName %type_View 168 "PrePadding_View_2972" OpMemberName %type_View 169 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 170 "PrePadding_View_2988" OpMemberName %type_View 171 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 172 "PrePadding_View_3004" OpMemberName %type_View 173 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 174 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 175 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 176 "View_StereoIPD" OpMemberName %type_View 177 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 178 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_PrimitiveDither "type.PrimitiveDither" OpMemberName %type_PrimitiveDither 0 "PrimitiveDither_LODFactor" OpName %PrimitiveDither "PrimitiveDither" OpName %type_PrimitiveFade "type.PrimitiveFade" OpMemberName %type_PrimitiveFade 0 "PrimitiveFade_FadeTimeScaleBias" OpName %PrimitiveFade "PrimitiveFade" OpName %type_Material "type.Material" OpMemberName %type_Material 0 "Material_VectorExpressions" OpMemberName %type_Material 1 "Material_ScalarExpressions" OpName %Material "Material" OpName %type_2d_image "type.2d.image" OpName %Material_Texture2D_0 "Material_Texture2D_0" OpName %type_sampler "type.sampler" OpName %Material_Texture2D_0Sampler "Material_Texture2D_0Sampler" OpName %Material_Texture2D_3 "Material_Texture2D_3" OpName %Material_Texture2D_3Sampler "Material_Texture2D_3Sampler" OpName %in_var_TEXCOORD6 "in.var.TEXCOORD6" OpName %in_var_TEXCOORD7 "in.var.TEXCOORD7" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %in_var_PRIMITIVE_ID "in.var.PRIMITIVE_ID" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPixelShader "MainPixelShader" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_Position" OpDecorateString %in_var_TEXCOORD6 UserSemantic "TEXCOORD6" OpDecorateString %in_var_TEXCOORD7 UserSemantic "TEXCOORD7" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %in_var_PRIMITIVE_ID UserSemantic "PRIMITIVE_ID" OpDecorate %in_var_PRIMITIVE_ID Flat OpDecorate %gl_FrontFacing BuiltIn FrontFacing OpDecorateString %gl_FrontFacing UserSemantic "SV_IsFrontFace" OpDecorate %gl_FrontFacing Flat OpDecorate %gl_FragDepth BuiltIn FragDepth OpDecorateString %gl_FragDepth UserSemantic "SV_DepthLessEqual" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD6 Location 0 OpDecorate %in_var_TEXCOORD7 Location 1 OpDecorate %in_var_TEXCOORD10_centroid Location 2 OpDecorate %in_var_TEXCOORD11_centroid Location 3 OpDecorate %in_var_TEXCOORD0 Location 4 OpDecorate %in_var_PRIMITIVE_ID Location 5 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %PrimitiveDither DescriptorSet 0 OpDecorate %PrimitiveDither Binding 1 OpDecorate %PrimitiveFade DescriptorSet 0 OpDecorate %PrimitiveFade Binding 2 OpDecorate %Material DescriptorSet 0 OpDecorate %Material Binding 3 OpDecorate %Material_Texture2D_0 DescriptorSet 0 OpDecorate %Material_Texture2D_0 Binding 0 OpDecorate %Material_Texture2D_0Sampler DescriptorSet 0 OpDecorate %Material_Texture2D_0Sampler Binding 0 OpDecorate %Material_Texture2D_3 DescriptorSet 0 OpDecorate %Material_Texture2D_3 Binding 1 OpDecorate %Material_Texture2D_3Sampler DescriptorSet 0 OpDecorate %Material_Texture2D_3Sampler Binding 1 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 13 MatrixStride 16 OpMemberDecorate %type_View 13 ColMajor OpMemberDecorate %type_View 14 Offset 896 OpMemberDecorate %type_View 15 Offset 908 OpMemberDecorate %type_View 16 Offset 912 OpMemberDecorate %type_View 17 Offset 924 OpMemberDecorate %type_View 18 Offset 928 OpMemberDecorate %type_View 19 Offset 940 OpMemberDecorate %type_View 20 Offset 944 OpMemberDecorate %type_View 21 Offset 956 OpMemberDecorate %type_View 22 Offset 960 OpMemberDecorate %type_View 23 Offset 972 OpMemberDecorate %type_View 24 Offset 976 OpMemberDecorate %type_View 25 Offset 992 OpMemberDecorate %type_View 26 Offset 1008 OpMemberDecorate %type_View 27 Offset 1020 OpMemberDecorate %type_View 28 Offset 1024 OpMemberDecorate %type_View 29 Offset 1036 OpMemberDecorate %type_View 30 Offset 1040 OpMemberDecorate %type_View 31 Offset 1052 OpMemberDecorate %type_View 32 Offset 1056 OpMemberDecorate %type_View 33 Offset 1068 OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 43 MatrixStride 16 OpMemberDecorate %type_View 43 ColMajor OpMemberDecorate %type_View 44 Offset 1712 OpMemberDecorate %type_View 45 Offset 1724 OpMemberDecorate %type_View 46 Offset 1728 OpMemberDecorate %type_View 47 Offset 1740 OpMemberDecorate %type_View 48 Offset 1744 OpMemberDecorate %type_View 49 Offset 1756 OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 52 MatrixStride 16 OpMemberDecorate %type_View 52 ColMajor OpMemberDecorate %type_View 53 Offset 1952 OpMemberDecorate %type_View 54 Offset 1968 OpMemberDecorate %type_View 55 Offset 1984 OpMemberDecorate %type_View 56 Offset 1992 OpMemberDecorate %type_View 57 Offset 2000 OpMemberDecorate %type_View 58 Offset 2016 OpMemberDecorate %type_View 59 Offset 2032 OpMemberDecorate %type_View 60 Offset 2048 OpMemberDecorate %type_View 61 Offset 2064 OpMemberDecorate %type_View 62 Offset 2068 OpMemberDecorate %type_View 63 Offset 2072 OpMemberDecorate %type_View 64 Offset 2076 OpMemberDecorate %type_View 65 Offset 2080 OpMemberDecorate %type_View 66 Offset 2096 OpMemberDecorate %type_View 67 Offset 2112 OpMemberDecorate %type_View 68 Offset 2128 OpMemberDecorate %type_View 69 Offset 2136 OpMemberDecorate %type_View 70 Offset 2140 OpMemberDecorate %type_View 71 Offset 2144 OpMemberDecorate %type_View 72 Offset 2148 OpMemberDecorate %type_View 73 Offset 2152 OpMemberDecorate %type_View 74 Offset 2156 OpMemberDecorate %type_View 75 Offset 2160 OpMemberDecorate %type_View 76 Offset 2172 OpMemberDecorate %type_View 77 Offset 2176 OpMemberDecorate %type_View 78 Offset 2180 OpMemberDecorate %type_View 79 Offset 2184 OpMemberDecorate %type_View 80 Offset 2188 OpMemberDecorate %type_View 81 Offset 2192 OpMemberDecorate %type_View 82 Offset 2196 OpMemberDecorate %type_View 83 Offset 2200 OpMemberDecorate %type_View 84 Offset 2204 OpMemberDecorate %type_View 85 Offset 2208 OpMemberDecorate %type_View 86 Offset 2212 OpMemberDecorate %type_View 87 Offset 2216 OpMemberDecorate %type_View 88 Offset 2220 OpMemberDecorate %type_View 89 Offset 2224 OpMemberDecorate %type_View 90 Offset 2228 OpMemberDecorate %type_View 91 Offset 2232 OpMemberDecorate %type_View 92 Offset 2236 OpMemberDecorate %type_View 93 Offset 2240 OpMemberDecorate %type_View 94 Offset 2256 OpMemberDecorate %type_View 95 Offset 2268 OpMemberDecorate %type_View 96 Offset 2272 OpMemberDecorate %type_View 97 Offset 2304 OpMemberDecorate %type_View 98 Offset 2336 OpMemberDecorate %type_View 99 Offset 2352 OpMemberDecorate %type_View 100 Offset 2368 OpMemberDecorate %type_View 101 Offset 2372 OpMemberDecorate %type_View 102 Offset 2376 OpMemberDecorate %type_View 103 Offset 2380 OpMemberDecorate %type_View 104 Offset 2384 OpMemberDecorate %type_View 105 Offset 2388 OpMemberDecorate %type_View 106 Offset 2392 OpMemberDecorate %type_View 107 Offset 2396 OpMemberDecorate %type_View 108 Offset 2400 OpMemberDecorate %type_View 109 Offset 2404 OpMemberDecorate %type_View 110 Offset 2408 OpMemberDecorate %type_View 111 Offset 2412 OpMemberDecorate %type_View 112 Offset 2416 OpMemberDecorate %type_View 113 Offset 2428 OpMemberDecorate %type_View 114 Offset 2432 OpMemberDecorate %type_View 115 Offset 2444 OpMemberDecorate %type_View 116 Offset 2448 OpMemberDecorate %type_View 117 Offset 2452 OpMemberDecorate %type_View 118 Offset 2456 OpMemberDecorate %type_View 119 Offset 2460 OpMemberDecorate %type_View 120 Offset 2464 OpMemberDecorate %type_View 121 Offset 2468 OpMemberDecorate %type_View 122 Offset 2472 OpMemberDecorate %type_View 123 Offset 2476 OpMemberDecorate %type_View 124 Offset 2480 OpMemberDecorate %type_View 125 Offset 2484 OpMemberDecorate %type_View 126 Offset 2488 OpMemberDecorate %type_View 127 Offset 2492 OpMemberDecorate %type_View 128 Offset 2496 OpMemberDecorate %type_View 129 Offset 2512 OpMemberDecorate %type_View 130 Offset 2516 OpMemberDecorate %type_View 131 Offset 2520 OpMemberDecorate %type_View 132 Offset 2524 OpMemberDecorate %type_View 133 Offset 2528 OpMemberDecorate %type_View 134 Offset 2544 OpMemberDecorate %type_View 135 Offset 2556 OpMemberDecorate %type_View 136 Offset 2560 OpMemberDecorate %type_View 137 Offset 2576 OpMemberDecorate %type_View 138 Offset 2580 OpMemberDecorate %type_View 139 Offset 2584 OpMemberDecorate %type_View 140 Offset 2588 OpMemberDecorate %type_View 141 Offset 2592 OpMemberDecorate %type_View 142 Offset 2608 OpMemberDecorate %type_View 143 Offset 2720 OpMemberDecorate %type_View 144 Offset 2724 OpMemberDecorate %type_View 145 Offset 2728 OpMemberDecorate %type_View 146 Offset 2732 OpMemberDecorate %type_View 147 Offset 2736 OpMemberDecorate %type_View 148 Offset 2740 OpMemberDecorate %type_View 149 Offset 2744 OpMemberDecorate %type_View 150 Offset 2748 OpMemberDecorate %type_View 151 Offset 2752 OpMemberDecorate %type_View 152 Offset 2764 OpMemberDecorate %type_View 153 Offset 2768 OpMemberDecorate %type_View 154 Offset 2832 OpMemberDecorate %type_View 155 Offset 2896 OpMemberDecorate %type_View 156 Offset 2900 OpMemberDecorate %type_View 157 Offset 2904 OpMemberDecorate %type_View 158 Offset 2908 OpMemberDecorate %type_View 159 Offset 2912 OpMemberDecorate %type_View 160 Offset 2920 OpMemberDecorate %type_View 161 Offset 2924 OpMemberDecorate %type_View 162 Offset 2928 OpMemberDecorate %type_View 163 Offset 2940 OpMemberDecorate %type_View 164 Offset 2944 OpMemberDecorate %type_View 165 Offset 2956 OpMemberDecorate %type_View 166 Offset 2960 OpMemberDecorate %type_View 167 Offset 2968 OpMemberDecorate %type_View 168 Offset 2972 OpMemberDecorate %type_View 169 Offset 2976 OpMemberDecorate %type_View 170 Offset 2988 OpMemberDecorate %type_View 171 Offset 2992 OpMemberDecorate %type_View 172 Offset 3004 OpMemberDecorate %type_View 173 Offset 3008 OpMemberDecorate %type_View 174 Offset 3020 OpMemberDecorate %type_View 175 Offset 3024 OpMemberDecorate %type_View 176 Offset 3036 OpMemberDecorate %type_View 177 Offset 3040 OpMemberDecorate %type_View 178 Offset 3044 OpDecorate %type_View Block OpMemberDecorate %type_PrimitiveDither 0 Offset 0 OpDecorate %type_PrimitiveDither Block OpMemberDecorate %type_PrimitiveFade 0 Offset 0 OpDecorate %type_PrimitiveFade Block OpDecorate %_arr_v4float_uint_9 ArrayStride 16 OpDecorate %_arr_v4float_uint_3 ArrayStride 16 OpMemberDecorate %type_Material 0 Offset 0 OpMemberDecorate %type_Material 1 Offset 144 OpDecorate %type_Material Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %v2int = OpTypeVector %int 2 %float_0_00100000005 = OpConstant %float 0.00100000005 %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %49 = OpConstantComposite %v2float %float_0 %float_0 %float_1 = OpConstant %float 1 %int_4 = OpConstant %int 4 %int_11 = OpConstant %int 11 %float_0_249500006 = OpConstant %float 0.249500006 %54 = OpConstantComposite %v2float %float_0_249500006 %float_0_249500006 %float_0_499992371 = OpConstant %float 0.499992371 %56 = OpConstantComposite %v2float %float_0_499992371 %float_0_499992371 %int_32 = OpConstant %int 32 %int_53 = OpConstant %int 53 %int_57 = OpConstant %int 57 %int_80 = OpConstant %int 80 %int_82 = OpConstant %int 82 %int_98 = OpConstant %int 98 %uint_1 = OpConstant %uint 1 %mat3v3float = OpTypeMatrix %v3float 3 %float_2 = OpConstant %float 2 %float_n1 = OpConstant %float -1 %67 = OpConstantComposite %v2float %float_n1 %float_n1 %bool = OpTypeBool %float_n0_5 = OpConstant %float -0.5 %70 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %float_0_333299994 = OpConstant %float 0.333299994 %uint_5 = OpConstant %uint 5 %float_347_834503 = OpConstant %float 347.834503 %float_3343_28369 = OpConstant %float 3343.28369 %75 = OpConstantComposite %v2float %float_347_834503 %float_3343_28369 %float_1000 = OpConstant %float 1000 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %uint %uint %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v2int %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_PrimitiveDither = OpTypeStruct %float %_ptr_Uniform_type_PrimitiveDither = OpTypePointer Uniform %type_PrimitiveDither %type_PrimitiveFade = OpTypeStruct %v2float %_ptr_Uniform_type_PrimitiveFade = OpTypePointer Uniform %type_PrimitiveFade %uint_9 = OpConstant %uint 9 %_arr_v4float_uint_9 = OpTypeArray %v4float %uint_9 %uint_3 = OpConstant %uint 3 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %type_Material = OpTypeStruct %_arr_v4float_uint_9 %_arr_v4float_uint_3 %_ptr_Uniform_type_Material = OpTypePointer Uniform %type_Material %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %_ptr_Input_v4float = OpTypePointer Input %v4float %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %_ptr_Input__arr_v4float_uint_1 = OpTypePointer Input %_arr_v4float_uint_1 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Input_bool = OpTypePointer Input %bool %_ptr_Output_float = OpTypePointer Output %float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %93 = OpTypeFunction %void %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %type_sampled_image = OpTypeSampledImage %type_2d_image %View = OpVariable %_ptr_Uniform_type_View Uniform %PrimitiveDither = OpVariable %_ptr_Uniform_type_PrimitiveDither Uniform %PrimitiveFade = OpVariable %_ptr_Uniform_type_PrimitiveFade Uniform %Material = OpVariable %_ptr_Uniform_type_Material Uniform %Material_Texture2D_0 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %Material_Texture2D_0Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %Material_Texture2D_3 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %Material_Texture2D_3Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD6 = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD7 = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD0 = OpVariable %_ptr_Input__arr_v4float_uint_1 Input %in_var_PRIMITIVE_ID = OpVariable %_ptr_Input_uint Input %gl_FrontFacing = OpVariable %_ptr_Input_bool Input %gl_FragDepth = OpVariable %_ptr_Output_float Output %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %98 = OpUndef %float %99 = OpConstantNull %v2float %float_0_015625 = OpConstant %float 0.015625 %101 = OpConstantComposite %v2float %float_0_015625 %float_0_015625 %float_0_166666672 = OpConstant %float 0.166666672 %103 = OpUndef %float %104 = OpConstantNull %v3float %MainPixelShader = OpFunction %void None %93 %105 = OpLabel %106 = OpLoad %v4float %gl_FragCoord %107 = OpLoad %v4float %in_var_TEXCOORD6 %108 = OpLoad %v4float %in_var_TEXCOORD7 %109 = OpLoad %v4float %in_var_TEXCOORD10_centroid %110 = OpLoad %v4float %in_var_TEXCOORD11_centroid %111 = OpLoad %_arr_v4float_uint_1 %in_var_TEXCOORD0 %112 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_4 %113 = OpLoad %mat4v4float %112 %114 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_11 %115 = OpLoad %mat4v4float %114 %116 = OpAccessChain %_ptr_Uniform_v3float %View %int_32 %117 = OpLoad %v3float %116 %118 = OpAccessChain %_ptr_Uniform_v4float %View %int_53 %119 = OpLoad %v4float %118 %120 = OpAccessChain %_ptr_Uniform_v4float %View %int_57 %121 = OpLoad %v4float %120 %122 = OpAccessChain %_ptr_Uniform_float %View %int_80 %123 = OpLoad %float %122 %124 = OpCompositeExtract %v4float %111 0 %125 = OpVectorShuffle %v2float %99 %124 2 3 %126 = OpVectorShuffle %v3float %109 %109 0 1 2 %127 = OpVectorShuffle %v3float %110 %110 0 1 2 %128 = OpExtInst %v3float %1 Cross %127 %126 %129 = OpCompositeExtract %float %110 3 %130 = OpCompositeConstruct %v3float %129 %129 %129 %131 = OpFMul %v3float %128 %130 %132 = OpCompositeConstruct %mat3v3float %126 %131 %127 %133 = OpVectorShuffle %v2float %106 %106 0 1 %134 = OpVectorShuffle %v2float %121 %121 0 1 %135 = OpFSub %v2float %133 %134 %136 = OpCompositeExtract %float %106 2 %137 = OpCompositeConstruct %v4float %103 %103 %136 %float_1 %138 = OpCompositeExtract %float %106 3 %139 = OpCompositeConstruct %v4float %138 %138 %138 %138 %140 = OpFMul %v4float %137 %139 %141 = OpCompositeExtract %float %106 0 %142 = OpCompositeExtract %float %106 1 %143 = OpCompositeConstruct %v4float %141 %142 %136 %float_1 %144 = OpMatrixTimesVector %v4float %115 %143 %145 = OpVectorShuffle %v3float %144 %144 0 1 2 %146 = OpCompositeExtract %float %144 3 %147 = OpCompositeConstruct %v3float %146 %146 %146 %148 = OpFDiv %v3float %145 %147 %149 = OpFSub %v3float %148 %117 %150 = OpFNegate %v3float %148 %151 = OpExtInst %v3float %1 Normalize %150 %152 = OpVectorTimesMatrix %v3float %151 %132 %153 = OpVectorShuffle %v2float %152 %152 0 1 %154 = OpFMul %v2float %153 %67 %155 = OpCompositeExtract %float %152 2 %156 = OpCompositeConstruct %v2float %155 %155 %157 = OpFDiv %v2float %154 %156 %158 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_0 %int_0 %159 = OpLoad %float %158 %160 = OpCompositeConstruct %v2float %159 %159 %161 = OpFMul %v2float %160 %157 %162 = OpDot %float %151 %127 %163 = OpExtInst %float %1 FAbs %162 %164 = OpExtInst %float %1 FMax %163 %float_0 %165 = OpExtInst %float %1 FMin %164 %float_1 %166 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_0 %int_1 %167 = OpLoad %float %166 %168 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_0 %int_2 %169 = OpLoad %float %168 %170 = OpExtInst %float %1 FMix %167 %169 %165 %171 = OpExtInst %float %1 Floor %170 %172 = OpFDiv %float %float_1 %170 %173 = OpCompositeConstruct %v2float %172 %172 %174 = OpFMul %v2float %161 %173 %175 = OpDPdx %v2float %125 %176 = OpDPdy %v2float %125 %177 = OpLoad %type_2d_image %Material_Texture2D_0 %178 = OpLoad %type_sampler %Material_Texture2D_0Sampler OpBranch %179 %179 = OpLabel %180 = OpPhi %float %float_1 %105 %181 %182 %183 = OpPhi %v2float %49 %105 %184 %182 %185 = OpPhi %int %int_0 %105 %186 %182 %187 = OpPhi %float %float_1 %105 %188 %182 %189 = OpPhi %float %float_1 %105 %180 %182 %190 = OpConvertSToF %float %185 %191 = OpFAdd %float %171 %float_2 %192 = OpFOrdLessThan %bool %190 %191 OpLoopMerge %193 %182 None OpBranchConditional %192 %194 %193 %194 = OpLabel %195 = OpFAdd %v2float %125 %183 %196 = OpSampledImage %type_sampled_image %177 %178 %197 = OpImageSampleExplicitLod %v4float %196 %195 Grad %175 %176 %188 = OpCompositeExtract %float %197 1 %198 = OpFOrdLessThan %bool %180 %188 OpSelectionMerge %182 None OpBranchConditional %198 %199 %182 %199 = OpLabel %200 = OpFSub %float %189 %187 %201 = OpFSub %float %188 %180 %202 = OpFAdd %float %200 %201 %203 = OpFDiv %float %201 %202 %204 = OpFMul %float %189 %203 %205 = OpFSub %float %float_1 %203 %206 = OpFMul %float %180 %205 %207 = OpFAdd %float %204 %206 %208 = OpCompositeConstruct %v2float %203 %203 %209 = OpFMul %v2float %208 %174 %210 = OpFSub %v2float %183 %209 OpBranch %193 %182 = OpLabel %181 = OpFSub %float %180 %172 %184 = OpFAdd %v2float %183 %174 %186 = OpIAdd %int %185 %int_1 OpBranch %179 %193 = OpLabel %211 = OpPhi %float %98 %179 %207 %199 %212 = OpPhi %v2float %183 %179 %210 %199 %213 = OpVectorShuffle %v2float %212 %104 0 1 %214 = OpFAdd %v2float %125 %213 %215 = OpAccessChain %_ptr_Uniform_float %View %int_82 %216 = OpLoad %float %215 %217 = OpSampledImage %type_sampled_image %177 %178 %218 = OpImageSampleImplicitLod %v4float %217 %214 Bias %216 %219 = OpCompositeExtract %float %218 0 %220 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_2 %int_1 %221 = OpLoad %float %220 %222 = OpFMul %float %219 %221 %223 = OpFSub %float %float_1 %222 %224 = OpExtInst %float %1 FMax %223 %float_0 %225 = OpExtInst %float %1 FMin %224 %float_1 %226 = OpAccessChain %_ptr_Uniform_float %View %int_98 %int_0 %227 = OpLoad %float %226 %228 = OpCompositeConstruct %v2float %227 %227 %229 = OpFAdd %v2float %135 %228 %230 = OpCompositeExtract %float %229 0 %231 = OpConvertFToU %uint %230 %232 = OpCompositeExtract %float %229 1 %233 = OpConvertFToU %uint %232 %234 = OpIMul %uint %uint_2 %233 %235 = OpIAdd %uint %231 %234 %236 = OpUMod %uint %235 %uint_5 %237 = OpConvertUToF %float %236 %238 = OpFMul %v2float %135 %101 %239 = OpLoad %type_2d_image %Material_Texture2D_3 %240 = OpLoad %type_sampler %Material_Texture2D_3Sampler %241 = OpSampledImage %type_sampled_image %239 %240 %242 = OpImageSampleImplicitLod %v4float %241 %238 Bias %216 %243 = OpCompositeExtract %float %242 0 %244 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_2 %int_2 %245 = OpLoad %float %244 %246 = OpFMul %float %243 %245 %247 = OpFAdd %float %237 %246 %248 = OpFMul %float %247 %float_0_166666672 %249 = OpFAdd %float %225 %248 %250 = OpFAdd %float %249 %float_n0_5 %251 = OpCompositeExtract %float %218 2 %252 = OpFAdd %float %251 %250 %253 = OpSampledImage %type_sampled_image %239 %240 %254 = OpImageSampleImplicitLod %v4float %253 %238 Bias %216 %255 = OpCompositeExtract %float %254 0 %256 = OpFAdd %float %237 %255 %257 = OpFMul %float %256 %float_0_166666672 %258 = OpAccessChain %_ptr_Uniform_float %PrimitiveFade %int_0 %int_0 %259 = OpLoad %float %258 %260 = OpFMul %float %123 %259 %261 = OpAccessChain %_ptr_Uniform_float %PrimitiveFade %int_0 %int_1 %262 = OpLoad %float %261 %263 = OpFAdd %float %260 %262 %264 = OpExtInst %float %1 FClamp %263 %float_0 %float_1 %265 = OpFAdd %float %264 %257 %266 = OpFAdd %float %265 %float_n0_5 %267 = OpFMul %float %252 %266 %268 = OpFSub %float %float_1 %211 %269 = OpFMul %float %268 %159 %270 = OpCompositeExtract %float %212 0 %271 = OpCompositeExtract %float %212 1 %272 = OpCompositeConstruct %v3float %270 %271 %269 %273 = OpDot %float %272 %272 %274 = OpExtInst %float %1 Sqrt %273 %275 = OpDPdx %v2float %125 %276 = OpExtInst %v2float %1 FAbs %275 %277 = OpDot %float %276 %276 %278 = OpExtInst %float %1 Sqrt %277 %279 = OpDPdx %v3float %149 %280 = OpDot %float %279 %279 %281 = OpExtInst %float %1 Sqrt %280 %282 = OpFDiv %float %278 %281 %283 = OpDPdy %v2float %125 %284 = OpExtInst %v2float %1 FAbs %283 %285 = OpDot %float %284 %284 %286 = OpExtInst %float %1 Sqrt %285 %287 = OpDPdy %v3float %149 %288 = OpDot %float %287 %287 %289 = OpExtInst %float %1 Sqrt %288 %290 = OpFDiv %float %286 %289 %291 = OpExtInst %float %1 FMax %282 %290 %292 = OpCompositeExtract %v4float %113 0 %293 = OpVectorShuffle %v3float %292 %292 0 1 2 %294 = OpCompositeExtract %v4float %113 1 %295 = OpVectorShuffle %v3float %294 %294 0 1 2 %296 = OpCompositeExtract %v4float %113 2 %297 = OpVectorShuffle %v3float %296 %296 0 1 2 %298 = OpCompositeConstruct %mat3v3float %293 %295 %297 %299 = OpMatrixTimesVector %v3float %298 %70 %300 = OpDot %float %299 %151 %301 = OpExtInst %float %1 FAbs %300 %302 = OpFDiv %float %291 %301 %303 = OpFDiv %float %274 %302 %304 = OpAccessChain %_ptr_Uniform_float %PrimitiveDither %int_0 %305 = OpLoad %float %304 %306 = OpFOrdNotEqual %bool %305 %float_0 OpSelectionMerge %307 None OpBranchConditional %306 %308 %307 %308 = OpLabel %309 = OpExtInst %float %1 FAbs %305 %310 = OpFOrdGreaterThan %bool %309 %float_0_00100000005 OpSelectionMerge %311 None OpBranchConditional %310 %312 %311 %312 = OpLabel %313 = OpExtInst %v2float %1 Floor %133 %314 = OpDot %float %313 %75 %315 = OpExtInst %float %1 Cos %314 %316 = OpFMul %float %315 %float_1000 %317 = OpExtInst %float %1 Fract %316 %318 = OpFOrdLessThan %bool %305 %float_0 %319 = OpFAdd %float %305 %float_1 %320 = OpFOrdGreaterThan %bool %319 %317 %321 = OpFOrdLessThan %bool %305 %317 %322 = OpSelect %bool %318 %320 %321 %323 = OpSelect %float %322 %float_1 %float_0 %324 = OpFSub %float %323 %float_0_00100000005 %325 = OpFOrdLessThan %bool %324 %float_0 OpSelectionMerge %326 None OpBranchConditional %325 %327 %326 %327 = OpLabel OpKill %326 = OpLabel OpBranch %311 %311 = OpLabel OpBranch %307 %307 = OpLabel %328 = OpFSub %float %267 %float_0_333299994 %329 = OpFOrdLessThan %bool %328 %float_0 OpSelectionMerge %330 None OpBranchConditional %329 %331 %330 %331 = OpLabel OpKill %330 = OpLabel %332 = OpCompositeExtract %float %140 2 %333 = OpCompositeExtract %float %140 3 %334 = OpFAdd %float %333 %303 %335 = OpFDiv %float %332 %334 %336 = OpExtInst %float %1 FMin %335 %136 %337 = OpVectorShuffle %v2float %107 %107 0 1 %338 = OpCompositeExtract %float %107 3 %339 = OpCompositeConstruct %v2float %338 %338 %340 = OpFDiv %v2float %337 %339 %341 = OpVectorShuffle %v2float %119 %119 0 1 %342 = OpFSub %v2float %340 %341 %343 = OpVectorShuffle %v2float %108 %108 0 1 %344 = OpCompositeExtract %float %108 3 %345 = OpCompositeConstruct %v2float %344 %344 %346 = OpFDiv %v2float %343 %345 %347 = OpVectorShuffle %v2float %119 %119 2 3 %348 = OpFSub %v2float %346 %347 %349 = OpFSub %v2float %342 %348 %350 = OpFMul %v2float %349 %54 %351 = OpFAdd %v2float %350 %56 %352 = OpVectorShuffle %v4float %351 %49 0 1 2 3 OpStore %gl_FragDepth %336 OpStore %out_var_SV_Target0 %352 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4-no-opt/asm/frag/phi-variable-declaration.asm.invalid.frag000066400000000000000000001440111400026215700313230ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 353 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPixelShader "main" %gl_FragCoord %in_var_TEXCOORD6 %in_var_TEXCOORD7 %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_TEXCOORD0 %in_var_PRIMITIVE_ID %gl_FrontFacing %gl_FragDepth %out_var_SV_Target0 OpExecutionMode %MainPixelShader OriginUpperLeft OpExecutionMode %MainPixelShader DepthReplacing OpExecutionMode %MainPixelShader DepthLess OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_ClipToWorld" OpMemberName %type_View 3 "View_TranslatedWorldToView" OpMemberName %type_View 4 "View_ViewToTranslatedWorld" OpMemberName %type_View 5 "View_TranslatedWorldToCameraView" OpMemberName %type_View 6 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 7 "View_ViewToClip" OpMemberName %type_View 8 "View_ViewToClipNoAA" OpMemberName %type_View 9 "View_ClipToView" OpMemberName %type_View 10 "View_ClipToTranslatedWorld" OpMemberName %type_View 11 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 12 "View_ScreenToWorld" OpMemberName %type_View 13 "View_ScreenToTranslatedWorld" OpMemberName %type_View 14 "View_ViewForward" OpMemberName %type_View 15 "PrePadding_View_908" OpMemberName %type_View 16 "View_ViewUp" OpMemberName %type_View 17 "PrePadding_View_924" OpMemberName %type_View 18 "View_ViewRight" OpMemberName %type_View 19 "PrePadding_View_940" OpMemberName %type_View 20 "View_HMDViewNoRollUp" OpMemberName %type_View 21 "PrePadding_View_956" OpMemberName %type_View 22 "View_HMDViewNoRollRight" OpMemberName %type_View 23 "PrePadding_View_972" OpMemberName %type_View 24 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 25 "View_ScreenPositionScaleBias" OpMemberName %type_View 26 "View_WorldCameraOrigin" OpMemberName %type_View 27 "PrePadding_View_1020" OpMemberName %type_View 28 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 29 "PrePadding_View_1036" OpMemberName %type_View 30 "View_WorldViewOrigin" OpMemberName %type_View 31 "PrePadding_View_1052" OpMemberName %type_View 32 "View_PreViewTranslation" OpMemberName %type_View 33 "PrePadding_View_1068" OpMemberName %type_View 34 "View_PrevProjection" OpMemberName %type_View 35 "View_PrevViewProj" OpMemberName %type_View 36 "View_PrevViewRotationProj" OpMemberName %type_View 37 "View_PrevViewToClip" OpMemberName %type_View 38 "View_PrevClipToView" OpMemberName %type_View 39 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 40 "View_PrevTranslatedWorldToView" OpMemberName %type_View 41 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 42 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 43 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 44 "View_PrevWorldCameraOrigin" OpMemberName %type_View 45 "PrePadding_View_1724" OpMemberName %type_View 46 "View_PrevWorldViewOrigin" OpMemberName %type_View 47 "PrePadding_View_1740" OpMemberName %type_View 48 "View_PrevPreViewTranslation" OpMemberName %type_View 49 "PrePadding_View_1756" OpMemberName %type_View 50 "View_PrevInvViewProj" OpMemberName %type_View 51 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 52 "View_ClipToPrevClip" OpMemberName %type_View 53 "View_TemporalAAJitter" OpMemberName %type_View 54 "View_GlobalClippingPlane" OpMemberName %type_View 55 "View_FieldOfViewWideAngles" OpMemberName %type_View 56 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 57 "View_ViewRectMin" OpMemberName %type_View 58 "View_ViewSizeAndInvSize" OpMemberName %type_View 59 "View_BufferSizeAndInvSize" OpMemberName %type_View 60 "View_BufferBilinearUVMinMax" OpMemberName %type_View 61 "View_NumSceneColorMSAASamples" OpMemberName %type_View 62 "View_PreExposure" OpMemberName %type_View 63 "View_OneOverPreExposure" OpMemberName %type_View 64 "PrePadding_View_2076" OpMemberName %type_View 65 "View_DiffuseOverrideParameter" OpMemberName %type_View 66 "View_SpecularOverrideParameter" OpMemberName %type_View 67 "View_NormalOverrideParameter" OpMemberName %type_View 68 "View_RoughnessOverrideParameter" OpMemberName %type_View 69 "View_PrevFrameGameTime" OpMemberName %type_View 70 "View_PrevFrameRealTime" OpMemberName %type_View 71 "View_OutOfBoundsMask" OpMemberName %type_View 72 "PrePadding_View_2148" OpMemberName %type_View 73 "PrePadding_View_2152" OpMemberName %type_View 74 "PrePadding_View_2156" OpMemberName %type_View 75 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 76 "View_CullingSign" OpMemberName %type_View 77 "View_NearPlane" OpMemberName %type_View 78 "View_AdaptiveTessellationFactor" OpMemberName %type_View 79 "View_GameTime" OpMemberName %type_View 80 "View_RealTime" OpMemberName %type_View 81 "View_DeltaTime" OpMemberName %type_View 82 "View_MaterialTextureMipBias" OpMemberName %type_View 83 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 84 "View_Random" OpMemberName %type_View 85 "View_FrameNumber" OpMemberName %type_View 86 "View_StateFrameIndexMod8" OpMemberName %type_View 87 "View_StateFrameIndex" OpMemberName %type_View 88 "View_CameraCut" OpMemberName %type_View 89 "View_UnlitViewmodeMask" OpMemberName %type_View 90 "PrePadding_View_2228" OpMemberName %type_View 91 "PrePadding_View_2232" OpMemberName %type_View 92 "PrePadding_View_2236" OpMemberName %type_View 93 "View_DirectionalLightColor" OpMemberName %type_View 94 "View_DirectionalLightDirection" OpMemberName %type_View 95 "PrePadding_View_2268" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 97 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 98 "View_TemporalAAParams" OpMemberName %type_View 99 "View_CircleDOFParams" OpMemberName %type_View 100 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 101 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 102 "View_DepthOfFieldScale" OpMemberName %type_View 103 "View_DepthOfFieldFocalLength" OpMemberName %type_View 104 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 105 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 106 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 107 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 108 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 109 "View_GeneralPurposeTweak" OpMemberName %type_View 110 "View_DemosaicVposOffset" OpMemberName %type_View 111 "PrePadding_View_2412" OpMemberName %type_View 112 "View_IndirectLightingColorScale" OpMemberName %type_View 113 "View_HDR32bppEncodingMode" OpMemberName %type_View 114 "View_AtmosphericFogSunDirection" OpMemberName %type_View 115 "View_AtmosphericFogSunPower" OpMemberName %type_View 116 "View_AtmosphericFogPower" OpMemberName %type_View 117 "View_AtmosphericFogDensityScale" OpMemberName %type_View 118 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 119 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 120 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 121 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 122 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 123 "View_AtmosphericFogStartDistance" OpMemberName %type_View 124 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 125 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 126 "View_AtmosphericFogSunDiscHalfApexAngleRadian" OpMemberName %type_View 127 "PrePadding_View_2492" OpMemberName %type_View 128 "View_AtmosphericFogSunDiscLuminance" OpMemberName %type_View 129 "View_AtmosphericFogRenderMask" OpMemberName %type_View 130 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 131 "PrePadding_View_2520" OpMemberName %type_View 132 "PrePadding_View_2524" OpMemberName %type_View 133 "View_AtmosphericFogSunColor" OpMemberName %type_View 134 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 135 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 136 "View_AmbientCubemapTint" OpMemberName %type_View 137 "View_AmbientCubemapIntensity" OpMemberName %type_View 138 "View_SkyLightParameters" OpMemberName %type_View 139 "PrePadding_View_2584" OpMemberName %type_View 140 "PrePadding_View_2588" OpMemberName %type_View 141 "View_SkyLightColor" OpMemberName %type_View 142 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 143 "View_MobilePreviewMode" OpMemberName %type_View 144 "View_HMDEyePaddingOffset" OpMemberName %type_View 145 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 146 "View_ShowDecalsMask" OpMemberName %type_View 147 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 148 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 149 "PrePadding_View_2744" OpMemberName %type_View 150 "PrePadding_View_2748" OpMemberName %type_View 151 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 152 "View_StereoPassIndex" OpMemberName %type_View 153 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 154 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 155 "View_GlobalVolumeDimension" OpMemberName %type_View 156 "View_GlobalVolumeTexelSize" OpMemberName %type_View 157 "View_MaxGlobalDistance" OpMemberName %type_View 158 "PrePadding_View_2908" OpMemberName %type_View 159 "View_CursorPosition" OpMemberName %type_View 160 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 161 "PrePadding_View_2924" OpMemberName %type_View 162 "View_VolumetricFogInvGridSize" OpMemberName %type_View 163 "PrePadding_View_2940" OpMemberName %type_View 164 "View_VolumetricFogGridZParams" OpMemberName %type_View 165 "PrePadding_View_2956" OpMemberName %type_View 166 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 167 "View_VolumetricFogMaxDistance" OpMemberName %type_View 168 "PrePadding_View_2972" OpMemberName %type_View 169 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 170 "PrePadding_View_2988" OpMemberName %type_View 171 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 172 "PrePadding_View_3004" OpMemberName %type_View 173 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 174 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 175 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 176 "View_StereoIPD" OpMemberName %type_View 177 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 178 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_PrimitiveDither "type.PrimitiveDither" OpMemberName %type_PrimitiveDither 0 "PrimitiveDither_LODFactor" OpName %PrimitiveDither "PrimitiveDither" OpName %type_PrimitiveFade "type.PrimitiveFade" OpMemberName %type_PrimitiveFade 0 "PrimitiveFade_FadeTimeScaleBias" OpName %PrimitiveFade "PrimitiveFade" OpName %type_Material "type.Material" OpMemberName %type_Material 0 "Material_VectorExpressions" OpMemberName %type_Material 1 "Material_ScalarExpressions" OpName %Material "Material" OpName %type_2d_image "type.2d.image" OpName %Material_Texture2D_0 "Material_Texture2D_0" OpName %type_sampler "type.sampler" OpName %Material_Texture2D_0Sampler "Material_Texture2D_0Sampler" OpName %Material_Texture2D_3 "Material_Texture2D_3" OpName %Material_Texture2D_3Sampler "Material_Texture2D_3Sampler" OpName %in_var_TEXCOORD6 "in.var.TEXCOORD6" OpName %in_var_TEXCOORD7 "in.var.TEXCOORD7" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %in_var_PRIMITIVE_ID "in.var.PRIMITIVE_ID" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPixelShader "MainPixelShader" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_Position" OpDecorateString %in_var_TEXCOORD6 UserSemantic "TEXCOORD6" OpDecorateString %in_var_TEXCOORD7 UserSemantic "TEXCOORD7" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %in_var_PRIMITIVE_ID UserSemantic "PRIMITIVE_ID" OpDecorate %in_var_PRIMITIVE_ID Flat OpDecorate %gl_FrontFacing BuiltIn FrontFacing OpDecorateString %gl_FrontFacing UserSemantic "SV_IsFrontFace" OpDecorate %gl_FrontFacing Flat OpDecorate %gl_FragDepth BuiltIn FragDepth OpDecorateString %gl_FragDepth UserSemantic "SV_DepthLessEqual" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD6 Location 0 OpDecorate %in_var_TEXCOORD7 Location 1 OpDecorate %in_var_TEXCOORD10_centroid Location 2 OpDecorate %in_var_TEXCOORD11_centroid Location 3 OpDecorate %in_var_TEXCOORD0 Location 4 OpDecorate %in_var_PRIMITIVE_ID Location 5 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %PrimitiveDither DescriptorSet 0 OpDecorate %PrimitiveDither Binding 1 OpDecorate %PrimitiveFade DescriptorSet 0 OpDecorate %PrimitiveFade Binding 2 OpDecorate %Material DescriptorSet 0 OpDecorate %Material Binding 3 OpDecorate %Material_Texture2D_0 DescriptorSet 0 OpDecorate %Material_Texture2D_0 Binding 0 OpDecorate %Material_Texture2D_0Sampler DescriptorSet 0 OpDecorate %Material_Texture2D_0Sampler Binding 0 OpDecorate %Material_Texture2D_3 DescriptorSet 0 OpDecorate %Material_Texture2D_3 Binding 1 OpDecorate %Material_Texture2D_3Sampler DescriptorSet 0 OpDecorate %Material_Texture2D_3Sampler Binding 1 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 13 MatrixStride 16 OpMemberDecorate %type_View 13 ColMajor OpMemberDecorate %type_View 14 Offset 896 OpMemberDecorate %type_View 15 Offset 908 OpMemberDecorate %type_View 16 Offset 912 OpMemberDecorate %type_View 17 Offset 924 OpMemberDecorate %type_View 18 Offset 928 OpMemberDecorate %type_View 19 Offset 940 OpMemberDecorate %type_View 20 Offset 944 OpMemberDecorate %type_View 21 Offset 956 OpMemberDecorate %type_View 22 Offset 960 OpMemberDecorate %type_View 23 Offset 972 OpMemberDecorate %type_View 24 Offset 976 OpMemberDecorate %type_View 25 Offset 992 OpMemberDecorate %type_View 26 Offset 1008 OpMemberDecorate %type_View 27 Offset 1020 OpMemberDecorate %type_View 28 Offset 1024 OpMemberDecorate %type_View 29 Offset 1036 OpMemberDecorate %type_View 30 Offset 1040 OpMemberDecorate %type_View 31 Offset 1052 OpMemberDecorate %type_View 32 Offset 1056 OpMemberDecorate %type_View 33 Offset 1068 OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 43 MatrixStride 16 OpMemberDecorate %type_View 43 ColMajor OpMemberDecorate %type_View 44 Offset 1712 OpMemberDecorate %type_View 45 Offset 1724 OpMemberDecorate %type_View 46 Offset 1728 OpMemberDecorate %type_View 47 Offset 1740 OpMemberDecorate %type_View 48 Offset 1744 OpMemberDecorate %type_View 49 Offset 1756 OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 52 MatrixStride 16 OpMemberDecorate %type_View 52 ColMajor OpMemberDecorate %type_View 53 Offset 1952 OpMemberDecorate %type_View 54 Offset 1968 OpMemberDecorate %type_View 55 Offset 1984 OpMemberDecorate %type_View 56 Offset 1992 OpMemberDecorate %type_View 57 Offset 2000 OpMemberDecorate %type_View 58 Offset 2016 OpMemberDecorate %type_View 59 Offset 2032 OpMemberDecorate %type_View 60 Offset 2048 OpMemberDecorate %type_View 61 Offset 2064 OpMemberDecorate %type_View 62 Offset 2068 OpMemberDecorate %type_View 63 Offset 2072 OpMemberDecorate %type_View 64 Offset 2076 OpMemberDecorate %type_View 65 Offset 2080 OpMemberDecorate %type_View 66 Offset 2096 OpMemberDecorate %type_View 67 Offset 2112 OpMemberDecorate %type_View 68 Offset 2128 OpMemberDecorate %type_View 69 Offset 2136 OpMemberDecorate %type_View 70 Offset 2140 OpMemberDecorate %type_View 71 Offset 2144 OpMemberDecorate %type_View 72 Offset 2148 OpMemberDecorate %type_View 73 Offset 2152 OpMemberDecorate %type_View 74 Offset 2156 OpMemberDecorate %type_View 75 Offset 2160 OpMemberDecorate %type_View 76 Offset 2172 OpMemberDecorate %type_View 77 Offset 2176 OpMemberDecorate %type_View 78 Offset 2180 OpMemberDecorate %type_View 79 Offset 2184 OpMemberDecorate %type_View 80 Offset 2188 OpMemberDecorate %type_View 81 Offset 2192 OpMemberDecorate %type_View 82 Offset 2196 OpMemberDecorate %type_View 83 Offset 2200 OpMemberDecorate %type_View 84 Offset 2204 OpMemberDecorate %type_View 85 Offset 2208 OpMemberDecorate %type_View 86 Offset 2212 OpMemberDecorate %type_View 87 Offset 2216 OpMemberDecorate %type_View 88 Offset 2220 OpMemberDecorate %type_View 89 Offset 2224 OpMemberDecorate %type_View 90 Offset 2228 OpMemberDecorate %type_View 91 Offset 2232 OpMemberDecorate %type_View 92 Offset 2236 OpMemberDecorate %type_View 93 Offset 2240 OpMemberDecorate %type_View 94 Offset 2256 OpMemberDecorate %type_View 95 Offset 2268 OpMemberDecorate %type_View 96 Offset 2272 OpMemberDecorate %type_View 97 Offset 2304 OpMemberDecorate %type_View 98 Offset 2336 OpMemberDecorate %type_View 99 Offset 2352 OpMemberDecorate %type_View 100 Offset 2368 OpMemberDecorate %type_View 101 Offset 2372 OpMemberDecorate %type_View 102 Offset 2376 OpMemberDecorate %type_View 103 Offset 2380 OpMemberDecorate %type_View 104 Offset 2384 OpMemberDecorate %type_View 105 Offset 2388 OpMemberDecorate %type_View 106 Offset 2392 OpMemberDecorate %type_View 107 Offset 2396 OpMemberDecorate %type_View 108 Offset 2400 OpMemberDecorate %type_View 109 Offset 2404 OpMemberDecorate %type_View 110 Offset 2408 OpMemberDecorate %type_View 111 Offset 2412 OpMemberDecorate %type_View 112 Offset 2416 OpMemberDecorate %type_View 113 Offset 2428 OpMemberDecorate %type_View 114 Offset 2432 OpMemberDecorate %type_View 115 Offset 2444 OpMemberDecorate %type_View 116 Offset 2448 OpMemberDecorate %type_View 117 Offset 2452 OpMemberDecorate %type_View 118 Offset 2456 OpMemberDecorate %type_View 119 Offset 2460 OpMemberDecorate %type_View 120 Offset 2464 OpMemberDecorate %type_View 121 Offset 2468 OpMemberDecorate %type_View 122 Offset 2472 OpMemberDecorate %type_View 123 Offset 2476 OpMemberDecorate %type_View 124 Offset 2480 OpMemberDecorate %type_View 125 Offset 2484 OpMemberDecorate %type_View 126 Offset 2488 OpMemberDecorate %type_View 127 Offset 2492 OpMemberDecorate %type_View 128 Offset 2496 OpMemberDecorate %type_View 129 Offset 2512 OpMemberDecorate %type_View 130 Offset 2516 OpMemberDecorate %type_View 131 Offset 2520 OpMemberDecorate %type_View 132 Offset 2524 OpMemberDecorate %type_View 133 Offset 2528 OpMemberDecorate %type_View 134 Offset 2544 OpMemberDecorate %type_View 135 Offset 2556 OpMemberDecorate %type_View 136 Offset 2560 OpMemberDecorate %type_View 137 Offset 2576 OpMemberDecorate %type_View 138 Offset 2580 OpMemberDecorate %type_View 139 Offset 2584 OpMemberDecorate %type_View 140 Offset 2588 OpMemberDecorate %type_View 141 Offset 2592 OpMemberDecorate %type_View 142 Offset 2608 OpMemberDecorate %type_View 143 Offset 2720 OpMemberDecorate %type_View 144 Offset 2724 OpMemberDecorate %type_View 145 Offset 2728 OpMemberDecorate %type_View 146 Offset 2732 OpMemberDecorate %type_View 147 Offset 2736 OpMemberDecorate %type_View 148 Offset 2740 OpMemberDecorate %type_View 149 Offset 2744 OpMemberDecorate %type_View 150 Offset 2748 OpMemberDecorate %type_View 151 Offset 2752 OpMemberDecorate %type_View 152 Offset 2764 OpMemberDecorate %type_View 153 Offset 2768 OpMemberDecorate %type_View 154 Offset 2832 OpMemberDecorate %type_View 155 Offset 2896 OpMemberDecorate %type_View 156 Offset 2900 OpMemberDecorate %type_View 157 Offset 2904 OpMemberDecorate %type_View 158 Offset 2908 OpMemberDecorate %type_View 159 Offset 2912 OpMemberDecorate %type_View 160 Offset 2920 OpMemberDecorate %type_View 161 Offset 2924 OpMemberDecorate %type_View 162 Offset 2928 OpMemberDecorate %type_View 163 Offset 2940 OpMemberDecorate %type_View 164 Offset 2944 OpMemberDecorate %type_View 165 Offset 2956 OpMemberDecorate %type_View 166 Offset 2960 OpMemberDecorate %type_View 167 Offset 2968 OpMemberDecorate %type_View 168 Offset 2972 OpMemberDecorate %type_View 169 Offset 2976 OpMemberDecorate %type_View 170 Offset 2988 OpMemberDecorate %type_View 171 Offset 2992 OpMemberDecorate %type_View 172 Offset 3004 OpMemberDecorate %type_View 173 Offset 3008 OpMemberDecorate %type_View 174 Offset 3020 OpMemberDecorate %type_View 175 Offset 3024 OpMemberDecorate %type_View 176 Offset 3036 OpMemberDecorate %type_View 177 Offset 3040 OpMemberDecorate %type_View 178 Offset 3044 OpDecorate %type_View Block OpMemberDecorate %type_PrimitiveDither 0 Offset 0 OpDecorate %type_PrimitiveDither Block OpMemberDecorate %type_PrimitiveFade 0 Offset 0 OpDecorate %type_PrimitiveFade Block OpDecorate %_arr_v4float_uint_9 ArrayStride 16 OpDecorate %_arr_v4float_uint_3 ArrayStride 16 OpMemberDecorate %type_Material 0 Offset 0 OpMemberDecorate %type_Material 1 Offset 144 OpDecorate %type_Material Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %v2int = OpTypeVector %int 2 %float_0_00100000005 = OpConstant %float 0.00100000005 %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %49 = OpConstantComposite %v2float %float_0 %float_0 %float_1 = OpConstant %float 1 %int_4 = OpConstant %int 4 %int_11 = OpConstant %int 11 %float_0_249500006 = OpConstant %float 0.249500006 %54 = OpConstantComposite %v2float %float_0_249500006 %float_0_249500006 %float_0_499992371 = OpConstant %float 0.499992371 %56 = OpConstantComposite %v2float %float_0_499992371 %float_0_499992371 %int_32 = OpConstant %int 32 %int_53 = OpConstant %int 53 %int_57 = OpConstant %int 57 %int_80 = OpConstant %int 80 %int_82 = OpConstant %int 82 %int_98 = OpConstant %int 98 %uint_1 = OpConstant %uint 1 %mat3v3float = OpTypeMatrix %v3float 3 %float_2 = OpConstant %float 2 %float_n1 = OpConstant %float -1 %67 = OpConstantComposite %v2float %float_n1 %float_n1 %bool = OpTypeBool %float_n0_5 = OpConstant %float -0.5 %70 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %float_0_333299994 = OpConstant %float 0.333299994 %uint_5 = OpConstant %uint 5 %float_347_834503 = OpConstant %float 347.834503 %float_3343_28369 = OpConstant %float 3343.28369 %75 = OpConstantComposite %v2float %float_347_834503 %float_3343_28369 %float_1000 = OpConstant %float 1000 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %uint %uint %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v2int %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_PrimitiveDither = OpTypeStruct %float %_ptr_Uniform_type_PrimitiveDither = OpTypePointer Uniform %type_PrimitiveDither %type_PrimitiveFade = OpTypeStruct %v2float %_ptr_Uniform_type_PrimitiveFade = OpTypePointer Uniform %type_PrimitiveFade %uint_9 = OpConstant %uint 9 %_arr_v4float_uint_9 = OpTypeArray %v4float %uint_9 %uint_3 = OpConstant %uint 3 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %type_Material = OpTypeStruct %_arr_v4float_uint_9 %_arr_v4float_uint_3 %_ptr_Uniform_type_Material = OpTypePointer Uniform %type_Material %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %_ptr_Input_v4float = OpTypePointer Input %v4float %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %_ptr_Input__arr_v4float_uint_1 = OpTypePointer Input %_arr_v4float_uint_1 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Input_bool = OpTypePointer Input %bool %_ptr_Output_float = OpTypePointer Output %float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %93 = OpTypeFunction %void %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %type_sampled_image = OpTypeSampledImage %type_2d_image %View = OpVariable %_ptr_Uniform_type_View Uniform %PrimitiveDither = OpVariable %_ptr_Uniform_type_PrimitiveDither Uniform %PrimitiveFade = OpVariable %_ptr_Uniform_type_PrimitiveFade Uniform %Material = OpVariable %_ptr_Uniform_type_Material Uniform %Material_Texture2D_0 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %Material_Texture2D_0Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %Material_Texture2D_3 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %Material_Texture2D_3Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD6 = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD7 = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD0 = OpVariable %_ptr_Input__arr_v4float_uint_1 Input %in_var_PRIMITIVE_ID = OpVariable %_ptr_Input_uint Input %gl_FrontFacing = OpVariable %_ptr_Input_bool Input %gl_FragDepth = OpVariable %_ptr_Output_float Output %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %98 = OpUndef %float %99 = OpConstantNull %v2float %float_0_015625 = OpConstant %float 0.015625 %101 = OpConstantComposite %v2float %float_0_015625 %float_0_015625 %float_0_166666672 = OpConstant %float 0.166666672 %103 = OpUndef %float %104 = OpConstantNull %v3float %MainPixelShader = OpFunction %void None %93 %105 = OpLabel %106 = OpLoad %v4float %gl_FragCoord %107 = OpLoad %v4float %in_var_TEXCOORD6 %108 = OpLoad %v4float %in_var_TEXCOORD7 %109 = OpLoad %v4float %in_var_TEXCOORD10_centroid %110 = OpLoad %v4float %in_var_TEXCOORD11_centroid %111 = OpLoad %_arr_v4float_uint_1 %in_var_TEXCOORD0 %112 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_4 %113 = OpLoad %mat4v4float %112 %114 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_11 %115 = OpLoad %mat4v4float %114 %116 = OpAccessChain %_ptr_Uniform_v3float %View %int_32 %117 = OpLoad %v3float %116 %118 = OpAccessChain %_ptr_Uniform_v4float %View %int_53 %119 = OpLoad %v4float %118 %120 = OpAccessChain %_ptr_Uniform_v4float %View %int_57 %121 = OpLoad %v4float %120 %122 = OpAccessChain %_ptr_Uniform_float %View %int_80 %123 = OpLoad %float %122 %124 = OpCompositeExtract %v4float %111 0 %125 = OpVectorShuffle %v2float %99 %124 2 3 %126 = OpVectorShuffle %v3float %109 %109 0 1 2 %127 = OpVectorShuffle %v3float %110 %110 0 1 2 %128 = OpExtInst %v3float %1 Cross %127 %126 %129 = OpCompositeExtract %float %110 3 %130 = OpCompositeConstruct %v3float %129 %129 %129 %131 = OpFMul %v3float %128 %130 %132 = OpCompositeConstruct %mat3v3float %126 %131 %127 %133 = OpVectorShuffle %v2float %106 %106 0 1 %134 = OpVectorShuffle %v2float %121 %121 0 1 %135 = OpFSub %v2float %133 %134 %136 = OpCompositeExtract %float %106 2 %137 = OpCompositeConstruct %v4float %103 %103 %136 %float_1 %138 = OpCompositeExtract %float %106 3 %139 = OpCompositeConstruct %v4float %138 %138 %138 %138 %140 = OpFMul %v4float %137 %139 %141 = OpCompositeExtract %float %106 0 %142 = OpCompositeExtract %float %106 1 %143 = OpCompositeConstruct %v4float %141 %142 %136 %float_1 %144 = OpMatrixTimesVector %v4float %115 %143 %145 = OpVectorShuffle %v3float %144 %144 0 1 2 %146 = OpCompositeExtract %float %144 3 %147 = OpCompositeConstruct %v3float %146 %146 %146 %148 = OpFDiv %v3float %145 %147 %149 = OpFSub %v3float %148 %117 %150 = OpFNegate %v3float %148 %151 = OpExtInst %v3float %1 Normalize %150 %152 = OpVectorTimesMatrix %v3float %151 %132 %153 = OpVectorShuffle %v2float %152 %152 0 1 %154 = OpFMul %v2float %153 %67 %155 = OpCompositeExtract %float %152 2 %156 = OpCompositeConstruct %v2float %155 %155 %157 = OpFDiv %v2float %154 %156 %158 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_0 %int_0 %159 = OpLoad %float %158 %160 = OpCompositeConstruct %v2float %159 %159 %161 = OpFMul %v2float %160 %157 %162 = OpDot %float %151 %127 %163 = OpExtInst %float %1 FAbs %162 %164 = OpExtInst %float %1 FMax %163 %float_0 %165 = OpExtInst %float %1 FMin %164 %float_1 %166 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_0 %int_1 %167 = OpLoad %float %166 %168 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_0 %int_2 %169 = OpLoad %float %168 %170 = OpExtInst %float %1 FMix %167 %169 %165 %171 = OpExtInst %float %1 Floor %170 %172 = OpFDiv %float %float_1 %170 %173 = OpCompositeConstruct %v2float %172 %172 %174 = OpFMul %v2float %161 %173 %175 = OpDPdx %v2float %125 %176 = OpDPdy %v2float %125 %177 = OpLoad %type_2d_image %Material_Texture2D_0 %178 = OpLoad %type_sampler %Material_Texture2D_0Sampler OpBranch %179 %179 = OpLabel %180 = OpPhi %float %float_1 %105 %181 %182 %183 = OpPhi %v2float %49 %105 %184 %182 %185 = OpPhi %int %int_0 %105 %186 %182 %187 = OpPhi %float %float_1 %105 %188 %182 %189 = OpPhi %float %float_1 %105 %180 %182 %190 = OpConvertSToF %float %185 %191 = OpFAdd %float %171 %float_2 %192 = OpFOrdLessThan %bool %190 %191 OpLoopMerge %193 %182 None OpBranchConditional %192 %194 %193 %194 = OpLabel %195 = OpFAdd %v2float %125 %183 %196 = OpSampledImage %type_sampled_image %177 %178 %197 = OpImageSampleExplicitLod %v4float %196 %195 Grad %175 %176 %188 = OpCompositeExtract %float %197 1 %198 = OpFOrdLessThan %bool %180 %188 OpSelectionMerge %182 None OpBranchConditional %198 %199 %182 %199 = OpLabel %200 = OpFSub %float %189 %187 %201 = OpFSub %float %188 %180 %202 = OpFAdd %float %200 %201 %203 = OpFDiv %float %201 %202 %204 = OpFMul %float %189 %203 %205 = OpFSub %float %float_1 %203 %206 = OpFMul %float %180 %205 %207 = OpFAdd %float %204 %206 %208 = OpCompositeConstruct %v2float %203 %203 %209 = OpFMul %v2float %208 %174 %210 = OpFSub %v2float %183 %209 OpBranch %193 %182 = OpLabel %181 = OpFSub %float %180 %172 %184 = OpFAdd %v2float %183 %174 %186 = OpIAdd %int %185 %int_1 OpBranch %179 %193 = OpLabel %211 = OpPhi %float %98 %179 %207 %199 %212 = OpPhi %v2float %183 %179 %210 %199 %213 = OpVectorShuffle %v2float %212 %104 0 1 %214 = OpFAdd %v2float %125 %213 %215 = OpAccessChain %_ptr_Uniform_float %View %int_82 %216 = OpLoad %float %215 %217 = OpSampledImage %type_sampled_image %177 %178 %218 = OpImageSampleImplicitLod %v4float %217 %214 Bias %216 %219 = OpCompositeExtract %float %218 0 %220 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_2 %int_1 %221 = OpLoad %float %220 %222 = OpFMul %float %219 %221 %223 = OpFSub %float %float_1 %222 %224 = OpExtInst %float %1 FMax %223 %float_0 %225 = OpExtInst %float %1 FMin %224 %float_1 %226 = OpAccessChain %_ptr_Uniform_float %View %int_98 %int_0 %227 = OpLoad %float %226 %228 = OpCompositeConstruct %v2float %227 %227 %229 = OpFAdd %v2float %135 %228 %230 = OpCompositeExtract %float %229 0 %231 = OpConvertFToU %uint %230 %232 = OpCompositeExtract %float %229 1 %233 = OpConvertFToU %uint %232 %234 = OpIMul %uint %uint_2 %233 %235 = OpIAdd %uint %231 %234 %236 = OpUMod %uint %235 %uint_5 %237 = OpConvertUToF %float %236 %238 = OpFMul %v2float %135 %101 %239 = OpLoad %type_2d_image %Material_Texture2D_3 %240 = OpLoad %type_sampler %Material_Texture2D_3Sampler %241 = OpSampledImage %type_sampled_image %239 %240 %242 = OpImageSampleImplicitLod %v4float %241 %238 Bias %216 %243 = OpCompositeExtract %float %242 0 %244 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_2 %int_2 %245 = OpLoad %float %244 %246 = OpFMul %float %243 %245 %247 = OpFAdd %float %237 %246 %248 = OpFMul %float %247 %float_0_166666672 %249 = OpFAdd %float %225 %248 %250 = OpFAdd %float %249 %float_n0_5 %251 = OpCompositeExtract %float %218 2 %252 = OpFAdd %float %251 %250 %253 = OpSampledImage %type_sampled_image %239 %240 %254 = OpImageSampleImplicitLod %v4float %253 %238 Bias %216 %255 = OpCompositeExtract %float %254 0 %256 = OpFAdd %float %237 %255 %257 = OpFMul %float %256 %float_0_166666672 %258 = OpAccessChain %_ptr_Uniform_float %PrimitiveFade %int_0 %int_0 %259 = OpLoad %float %258 %260 = OpFMul %float %123 %259 %261 = OpAccessChain %_ptr_Uniform_float %PrimitiveFade %int_0 %int_1 %262 = OpLoad %float %261 %263 = OpFAdd %float %260 %262 %264 = OpExtInst %float %1 FClamp %263 %float_0 %float_1 %265 = OpFAdd %float %264 %257 %266 = OpFAdd %float %265 %float_n0_5 %267 = OpFMul %float %252 %266 %268 = OpFSub %float %float_1 %211 %269 = OpFMul %float %268 %159 %270 = OpCompositeExtract %float %212 0 %271 = OpCompositeExtract %float %212 1 %272 = OpCompositeConstruct %v3float %270 %271 %269 %273 = OpDot %float %272 %272 %274 = OpExtInst %float %1 Sqrt %273 %275 = OpDPdx %v2float %125 %276 = OpExtInst %v2float %1 FAbs %275 %277 = OpDot %float %276 %276 %278 = OpExtInst %float %1 Sqrt %277 %279 = OpDPdx %v3float %149 %280 = OpDot %float %279 %279 %281 = OpExtInst %float %1 Sqrt %280 %282 = OpFDiv %float %278 %281 %283 = OpDPdy %v2float %125 %284 = OpExtInst %v2float %1 FAbs %283 %285 = OpDot %float %284 %284 %286 = OpExtInst %float %1 Sqrt %285 %287 = OpDPdy %v3float %149 %288 = OpDot %float %287 %287 %289 = OpExtInst %float %1 Sqrt %288 %290 = OpFDiv %float %286 %289 %291 = OpExtInst %float %1 FMax %282 %290 %292 = OpCompositeExtract %v4float %113 0 %293 = OpVectorShuffle %v3float %292 %292 0 1 2 %294 = OpCompositeExtract %v4float %113 1 %295 = OpVectorShuffle %v3float %294 %294 0 1 2 %296 = OpCompositeExtract %v4float %113 2 %297 = OpVectorShuffle %v3float %296 %296 0 1 2 %298 = OpCompositeConstruct %mat3v3float %293 %295 %297 %299 = OpMatrixTimesVector %v3float %298 %70 %300 = OpDot %float %299 %151 %301 = OpExtInst %float %1 FAbs %300 %302 = OpFDiv %float %291 %301 %303 = OpFDiv %float %274 %302 %304 = OpAccessChain %_ptr_Uniform_float %PrimitiveDither %int_0 %305 = OpLoad %float %304 %306 = OpFOrdNotEqual %bool %305 %float_0 OpSelectionMerge %307 None OpBranchConditional %306 %308 %307 %308 = OpLabel %309 = OpExtInst %float %1 FAbs %305 %310 = OpFOrdGreaterThan %bool %309 %float_0_00100000005 OpSelectionMerge %311 None OpBranchConditional %310 %312 %311 %312 = OpLabel %313 = OpExtInst %v2float %1 Floor %133 %314 = OpDot %float %313 %75 %315 = OpExtInst %float %1 Cos %314 %316 = OpFMul %float %315 %float_1000 %317 = OpExtInst %float %1 Fract %316 %318 = OpFOrdLessThan %bool %305 %float_0 %319 = OpFAdd %float %305 %float_1 %320 = OpFOrdGreaterThan %bool %319 %317 %321 = OpFOrdLessThan %bool %305 %317 %322 = OpSelect %bool %318 %320 %321 %323 = OpSelect %float %322 %float_1 %float_0 %324 = OpFSub %float %323 %float_0_00100000005 %325 = OpFOrdLessThan %bool %324 %float_0 OpSelectionMerge %326 None OpBranchConditional %325 %327 %326 %327 = OpLabel OpKill %326 = OpLabel OpBranch %311 %311 = OpLabel OpBranch %307 %307 = OpLabel %328 = OpFSub %float %267 %float_0_333299994 %329 = OpFOrdLessThan %bool %328 %float_0 OpSelectionMerge %330 None OpBranchConditional %329 %331 %330 %331 = OpLabel OpKill %330 = OpLabel %332 = OpCompositeExtract %float %140 2 %333 = OpCompositeExtract %float %140 3 %334 = OpFAdd %float %333 %303 %335 = OpFDiv %float %332 %334 %336 = OpExtInst %float %1 FMin %335 %136 %337 = OpVectorShuffle %v2float %107 %107 0 1 %338 = OpCompositeExtract %float %107 3 %339 = OpCompositeConstruct %v2float %338 %338 %340 = OpFDiv %v2float %337 %339 %341 = OpVectorShuffle %v2float %119 %119 0 1 %342 = OpFSub %v2float %340 %341 %343 = OpVectorShuffle %v2float %108 %108 0 1 %344 = OpCompositeExtract %float %108 3 %345 = OpCompositeConstruct %v2float %344 %344 %346 = OpFDiv %v2float %343 %345 %347 = OpVectorShuffle %v2float %119 %119 2 3 %348 = OpFSub %v2float %346 %347 %349 = OpFSub %v2float %342 %348 %350 = OpFMul %v2float %349 %54 %351 = OpFAdd %v2float %350 %56 %352 = OpVectorShuffle %v4float %351 %49 0 1 2 3 OpStore %gl_FragDepth %336 OpStore %out_var_SV_Target0 %352 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4-no-opt/asm/vert/000077500000000000000000000000001400026215700214705ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4-no-opt/asm/vert/loop-accesschain-writethrough.asm.invalid.vert000066400000000000000000000311621400026215700325450ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 181 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %ScatterMainVS "main" %gl_VertexIndex %gl_InstanceIndex %out_var_TEXCOORD0 %out_var_TEXCOORD1 %out_var_TEXCOORD2 %out_var_TEXCOORD3 %out_var_TEXCOORD4 %out_var_TEXCOORD5 %out_var_TEXCOORD6 %gl_Position OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "ViewportSize" OpMemberName %type__Globals 1 "ScatteringScaling" OpMemberName %type__Globals 2 "CocRadiusToCircumscribedRadius" OpName %_Globals "$Globals" OpName %type_StructuredBuffer_v4float "type.StructuredBuffer.v4float" OpName %ScatterDrawList "ScatterDrawList" OpName %out_var_TEXCOORD0 "out.var.TEXCOORD0" OpName %out_var_TEXCOORD1 "out.var.TEXCOORD1" OpName %out_var_TEXCOORD2 "out.var.TEXCOORD2" OpName %out_var_TEXCOORD3 "out.var.TEXCOORD3" OpName %out_var_TEXCOORD4 "out.var.TEXCOORD4" OpName %out_var_TEXCOORD5 "out.var.TEXCOORD5" OpName %out_var_TEXCOORD6 "out.var.TEXCOORD6" OpName %ScatterMainVS "ScatterMainVS" OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpDecorateString %gl_VertexIndex UserSemantic "SV_VertexID" OpDecorate %gl_InstanceIndex BuiltIn InstanceIndex OpDecorateString %gl_InstanceIndex UserSemantic "SV_InstanceID" OpDecorateString %out_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %out_var_TEXCOORD1 UserSemantic "TEXCOORD1" OpDecorateString %out_var_TEXCOORD2 UserSemantic "TEXCOORD2" OpDecorateString %out_var_TEXCOORD3 UserSemantic "TEXCOORD3" OpDecorateString %out_var_TEXCOORD4 UserSemantic "TEXCOORD4" OpDecorateString %out_var_TEXCOORD5 UserSemantic "TEXCOORD5" OpDecorateString %out_var_TEXCOORD6 UserSemantic "TEXCOORD6" OpDecorate %gl_Position BuiltIn Position OpDecorateString %gl_Position UserSemantic "SV_POSITION" OpDecorate %out_var_TEXCOORD0 Location 0 OpDecorate %out_var_TEXCOORD1 Location 1 OpDecorate %out_var_TEXCOORD2 Location 2 OpDecorate %out_var_TEXCOORD3 Location 3 OpDecorate %out_var_TEXCOORD4 Location 4 OpDecorate %out_var_TEXCOORD5 Location 5 OpDecorate %out_var_TEXCOORD6 Location 6 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 1 OpDecorate %ScatterDrawList DescriptorSet 0 OpDecorate %ScatterDrawList Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 20 OpDecorate %type__Globals Block OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %type_StructuredBuffer_v4float 0 Offset 0 OpMemberDecorate %type_StructuredBuffer_v4float 0 NonWritable OpDecorate %type_StructuredBuffer_v4float BufferBlock %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_4 = OpConstant %uint 4 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %float_0_5 = OpConstant %float 0.5 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %uint_16 = OpConstant %uint 16 %float_0 = OpConstant %float 0 %uint_0 = OpConstant %uint 0 %uint_5 = OpConstant %uint 5 %uint_1 = OpConstant %uint 1 %int_3 = OpConstant %int 3 %float_n0_5 = OpConstant %float -0.5 %int_2 = OpConstant %int 2 %float_2 = OpConstant %float 2 %39 = OpConstantComposite %v2float %float_2 %float_2 %40 = OpConstantComposite %v2float %float_1 %float_1 %41 = OpConstantComposite %v2float %float_0_5 %float_0_5 %type__Globals = OpTypeStruct %v4float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %_runtimearr_v4float = OpTypeRuntimeArray %v4float %type_StructuredBuffer_v4float = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_type_StructuredBuffer_v4float = OpTypePointer Uniform %type_StructuredBuffer_v4float %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output_v2float = OpTypePointer Output %v2float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %48 = OpTypeFunction %void %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function__arr_v4float_uint_4 = OpTypePointer Function %_arr_v4float_uint_4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Function__arr_float_uint_4 = OpTypePointer Function %_arr_float_uint_4 %_arr_v2float_uint_4 = OpTypeArray %v2float %uint_4 %_ptr_Function__arr_v2float_uint_4 = OpTypePointer Function %_arr_v2float_uint_4 %_ptr_Function_float = OpTypePointer Function %float %bool = OpTypeBool %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %ScatterDrawList = OpVariable %_ptr_Uniform_type_StructuredBuffer_v4float Uniform %gl_VertexIndex = OpVariable %_ptr_Input_uint Input %gl_InstanceIndex = OpVariable %_ptr_Input_uint Input %out_var_TEXCOORD0 = OpVariable %_ptr_Output_v2float Output %out_var_TEXCOORD1 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD2 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD3 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD4 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD5 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD6 = OpVariable %_ptr_Output_v4float Output %gl_Position = OpVariable %_ptr_Output_v4float Output %ScatterMainVS = OpFunction %void None %48 %60 = OpLabel %61 = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %62 = OpVariable %_ptr_Function__arr_float_uint_4 Function %63 = OpVariable %_ptr_Function__arr_v2float_uint_4 Function %64 = OpLoad %uint %gl_VertexIndex %65 = OpLoad %uint %gl_InstanceIndex %66 = OpUDiv %uint %64 %uint_4 %67 = OpIMul %uint %66 %uint_4 %68 = OpISub %uint %64 %67 %69 = OpIMul %uint %uint_16 %65 %70 = OpIAdd %uint %69 %66 OpBranch %71 %71 = OpLabel %72 = OpPhi %float %float_0 %60 %73 %74 %75 = OpPhi %uint %uint_0 %60 %76 %74 %77 = OpULessThan %bool %75 %uint_4 OpLoopMerge %78 %74 Unroll OpBranchConditional %77 %79 %78 %79 = OpLabel %80 = OpIMul %uint %uint_5 %70 %81 = OpIAdd %uint %80 %75 %82 = OpIAdd %uint %81 %uint_1 %83 = OpAccessChain %_ptr_Uniform_v4float %ScatterDrawList %int_0 %82 %84 = OpLoad %v4float %83 %85 = OpCompositeExtract %float %84 0 %86 = OpCompositeExtract %float %84 1 %87 = OpCompositeExtract %float %84 2 %88 = OpCompositeConstruct %v4float %85 %86 %87 %float_0 %89 = OpAccessChain %_ptr_Function_v4float %61 %75 OpStore %89 %88 %90 = OpCompositeExtract %float %84 3 %91 = OpAccessChain %_ptr_Function_float %62 %75 OpStore %91 %90 %92 = OpIEqual %bool %75 %uint_0 OpSelectionMerge %74 None OpBranchConditional %92 %93 %94 %93 = OpLabel %95 = OpLoad %float %91 OpBranch %74 %94 = OpLabel %96 = OpLoad %float %91 %97 = OpExtInst %float %1 FMax %72 %96 OpBranch %74 %74 = OpLabel %73 = OpPhi %float %95 %93 %97 %94 %98 = OpLoad %float %91 %99 = OpFDiv %float %float_n0_5 %98 %100 = OpAccessChain %_ptr_Function_float %63 %75 %int_0 OpStore %100 %99 %101 = OpLoad %float %91 %102 = OpFMul %float %float_0_5 %101 %103 = OpFAdd %float %102 %float_0_5 %104 = OpAccessChain %_ptr_Function_float %63 %75 %int_1 OpStore %104 %103 %76 = OpIAdd %uint %75 %uint_1 OpBranch %71 %78 = OpLabel %105 = OpAccessChain %_ptr_Function_v4float %61 %int_0 %106 = OpLoad %v4float %105 %107 = OpCompositeExtract %float %106 0 %108 = OpCompositeExtract %float %106 1 %109 = OpCompositeExtract %float %106 2 %110 = OpAccessChain %_ptr_Function_float %62 %int_0 %111 = OpLoad %float %110 %112 = OpCompositeConstruct %v4float %107 %108 %109 %111 %113 = OpAccessChain %_ptr_Function_v4float %61 %int_1 %114 = OpLoad %v4float %113 %115 = OpCompositeExtract %float %114 0 %116 = OpCompositeExtract %float %114 1 %117 = OpCompositeExtract %float %114 2 %118 = OpAccessChain %_ptr_Function_float %62 %int_1 %119 = OpLoad %float %118 %120 = OpCompositeConstruct %v4float %115 %116 %117 %119 %121 = OpAccessChain %_ptr_Function_v4float %61 %int_2 %122 = OpLoad %v4float %121 %123 = OpCompositeExtract %float %122 0 %124 = OpCompositeExtract %float %122 1 %125 = OpCompositeExtract %float %122 2 %126 = OpAccessChain %_ptr_Function_float %62 %int_2 %127 = OpLoad %float %126 %128 = OpCompositeConstruct %v4float %123 %124 %125 %127 %129 = OpAccessChain %_ptr_Function_v4float %61 %int_3 %130 = OpLoad %v4float %129 %131 = OpCompositeExtract %float %130 0 %132 = OpCompositeExtract %float %130 1 %133 = OpCompositeExtract %float %130 2 %134 = OpAccessChain %_ptr_Function_float %62 %int_3 %135 = OpLoad %float %134 %136 = OpCompositeConstruct %v4float %131 %132 %133 %135 %137 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %138 = OpLoad %float %137 %139 = OpCompositeConstruct %v2float %138 %138 %140 = OpIMul %uint %uint_5 %70 %141 = OpAccessChain %_ptr_Uniform_v4float %ScatterDrawList %int_0 %140 %142 = OpLoad %v4float %141 %143 = OpVectorShuffle %v2float %142 %142 0 1 %144 = OpFMul %v2float %139 %143 %145 = OpAccessChain %_ptr_Function_v2float %63 %int_0 %146 = OpLoad %v2float %145 %147 = OpAccessChain %_ptr_Function_v2float %63 %int_1 %148 = OpLoad %v2float %147 %149 = OpVectorShuffle %v4float %146 %148 0 1 2 3 %150 = OpAccessChain %_ptr_Function_v2float %63 %int_2 %151 = OpLoad %v2float %150 %152 = OpAccessChain %_ptr_Function_v2float %63 %int_3 %153 = OpLoad %v2float %152 %154 = OpVectorShuffle %v4float %151 %153 0 1 2 3 %155 = OpUMod %uint %68 %uint_2 %156 = OpConvertUToF %float %155 %157 = OpUDiv %uint %68 %uint_2 %158 = OpConvertUToF %float %157 %159 = OpCompositeConstruct %v2float %156 %158 %160 = OpFMul %v2float %159 %39 %161 = OpFSub %v2float %160 %40 %162 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %163 = OpLoad %float %162 %164 = OpFMul %float %72 %163 %165 = OpFAdd %float %164 %float_1 %166 = OpCompositeConstruct %v2float %165 %165 %167 = OpFMul %v2float %166 %161 %168 = OpFAdd %v2float %167 %144 %169 = OpFAdd %v2float %168 %41 %170 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_0 %171 = OpLoad %v4float %170 %172 = OpVectorShuffle %v2float %171 %171 2 3 %173 = OpFMul %v2float %169 %172 %174 = OpCompositeExtract %float %173 0 %175 = OpFMul %float %174 %float_2 %176 = OpFSub %float %175 %float_1 %177 = OpCompositeExtract %float %173 1 %178 = OpFMul %float %177 %float_2 %179 = OpFSub %float %float_1 %178 %180 = OpCompositeConstruct %v4float %176 %179 %float_0 %float_1 OpStore %out_var_TEXCOORD0 %144 OpStore %out_var_TEXCOORD1 %112 OpStore %out_var_TEXCOORD2 %120 OpStore %out_var_TEXCOORD3 %128 OpStore %out_var_TEXCOORD4 %136 OpStore %out_var_TEXCOORD5 %149 OpStore %out_var_TEXCOORD6 %154 OpStore %gl_Position %180 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/000077500000000000000000000000001400026215700165165ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4/asm/000077500000000000000000000000001400026215700172765ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4/asm/frag/000077500000000000000000000000001400026215700202155ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4/asm/frag/depth-compare.asm.frag000066400000000000000000001551131400026215700243730ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 452 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainOnePassPointLightPS "main" %gl_FragCoord %out_var_SV_Target0 OpExecutionMode %MainOnePassPointLightPS OriginUpperLeft OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_TranslatedWorldToView" OpMemberName %type_View 3 "View_ViewToTranslatedWorld" OpMemberName %type_View 4 "View_TranslatedWorldToCameraView" OpMemberName %type_View 5 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 6 "View_ViewToClip" OpMemberName %type_View 7 "View_ViewToClipNoAA" OpMemberName %type_View 8 "View_ClipToView" OpMemberName %type_View 9 "View_ClipToTranslatedWorld" OpMemberName %type_View 10 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 11 "View_ScreenToWorld" OpMemberName %type_View 12 "View_ScreenToTranslatedWorld" OpMemberName %type_View 13 "View_ViewForward" OpMemberName %type_View 14 "PrePadding_View_844" OpMemberName %type_View 15 "View_ViewUp" OpMemberName %type_View 16 "PrePadding_View_860" OpMemberName %type_View 17 "View_ViewRight" OpMemberName %type_View 18 "PrePadding_View_876" OpMemberName %type_View 19 "View_HMDViewNoRollUp" OpMemberName %type_View 20 "PrePadding_View_892" OpMemberName %type_View 21 "View_HMDViewNoRollRight" OpMemberName %type_View 22 "PrePadding_View_908" OpMemberName %type_View 23 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 24 "View_ScreenPositionScaleBias" OpMemberName %type_View 25 "View_WorldCameraOrigin" OpMemberName %type_View 26 "PrePadding_View_956" OpMemberName %type_View 27 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 28 "PrePadding_View_972" OpMemberName %type_View 29 "View_WorldViewOrigin" OpMemberName %type_View 30 "PrePadding_View_988" OpMemberName %type_View 31 "View_PreViewTranslation" OpMemberName %type_View 32 "PrePadding_View_1004" OpMemberName %type_View 33 "View_PrevProjection" OpMemberName %type_View 34 "View_PrevViewProj" OpMemberName %type_View 35 "View_PrevViewRotationProj" OpMemberName %type_View 36 "View_PrevViewToClip" OpMemberName %type_View 37 "View_PrevClipToView" OpMemberName %type_View 38 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 39 "View_PrevTranslatedWorldToView" OpMemberName %type_View 40 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 41 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 42 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 43 "View_PrevWorldCameraOrigin" OpMemberName %type_View 44 "PrePadding_View_1660" OpMemberName %type_View 45 "View_PrevWorldViewOrigin" OpMemberName %type_View 46 "PrePadding_View_1676" OpMemberName %type_View 47 "View_PrevPreViewTranslation" OpMemberName %type_View 48 "PrePadding_View_1692" OpMemberName %type_View 49 "View_PrevInvViewProj" OpMemberName %type_View 50 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 51 "View_ClipToPrevClip" OpMemberName %type_View 52 "View_TemporalAAJitter" OpMemberName %type_View 53 "View_GlobalClippingPlane" OpMemberName %type_View 54 "View_FieldOfViewWideAngles" OpMemberName %type_View 55 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 56 "View_ViewRectMin" OpMemberName %type_View 57 "View_ViewSizeAndInvSize" OpMemberName %type_View 58 "View_BufferSizeAndInvSize" OpMemberName %type_View 59 "View_BufferBilinearUVMinMax" OpMemberName %type_View 60 "View_NumSceneColorMSAASamples" OpMemberName %type_View 61 "View_PreExposure" OpMemberName %type_View 62 "View_OneOverPreExposure" OpMemberName %type_View 63 "PrePadding_View_2012" OpMemberName %type_View 64 "View_DiffuseOverrideParameter" OpMemberName %type_View 65 "View_SpecularOverrideParameter" OpMemberName %type_View 66 "View_NormalOverrideParameter" OpMemberName %type_View 67 "View_RoughnessOverrideParameter" OpMemberName %type_View 68 "View_PrevFrameGameTime" OpMemberName %type_View 69 "View_PrevFrameRealTime" OpMemberName %type_View 70 "View_OutOfBoundsMask" OpMemberName %type_View 71 "PrePadding_View_2084" OpMemberName %type_View 72 "PrePadding_View_2088" OpMemberName %type_View 73 "PrePadding_View_2092" OpMemberName %type_View 74 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 75 "View_CullingSign" OpMemberName %type_View 76 "View_NearPlane" OpMemberName %type_View 77 "View_AdaptiveTessellationFactor" OpMemberName %type_View 78 "View_GameTime" OpMemberName %type_View 79 "View_RealTime" OpMemberName %type_View 80 "View_DeltaTime" OpMemberName %type_View 81 "View_MaterialTextureMipBias" OpMemberName %type_View 82 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 83 "View_Random" OpMemberName %type_View 84 "View_FrameNumber" OpMemberName %type_View 85 "View_StateFrameIndexMod8" OpMemberName %type_View 86 "View_StateFrameIndex" OpMemberName %type_View 87 "View_CameraCut" OpMemberName %type_View 88 "View_UnlitViewmodeMask" OpMemberName %type_View 89 "PrePadding_View_2164" OpMemberName %type_View 90 "PrePadding_View_2168" OpMemberName %type_View 91 "PrePadding_View_2172" OpMemberName %type_View 92 "View_DirectionalLightColor" OpMemberName %type_View 93 "View_DirectionalLightDirection" OpMemberName %type_View 94 "PrePadding_View_2204" OpMemberName %type_View 95 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 97 "View_TemporalAAParams" OpMemberName %type_View 98 "View_CircleDOFParams" OpMemberName %type_View 99 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 100 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 101 "View_DepthOfFieldScale" OpMemberName %type_View 102 "View_DepthOfFieldFocalLength" OpMemberName %type_View 103 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 104 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 105 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 106 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 107 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 108 "View_GeneralPurposeTweak" OpMemberName %type_View 109 "View_DemosaicVposOffset" OpMemberName %type_View 110 "PrePadding_View_2348" OpMemberName %type_View 111 "View_IndirectLightingColorScale" OpMemberName %type_View 112 "View_HDR32bppEncodingMode" OpMemberName %type_View 113 "View_AtmosphericFogSunDirection" OpMemberName %type_View 114 "View_AtmosphericFogSunPower" OpMemberName %type_View 115 "View_AtmosphericFogPower" OpMemberName %type_View 116 "View_AtmosphericFogDensityScale" OpMemberName %type_View 117 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 118 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 119 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 120 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 121 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 122 "View_AtmosphericFogStartDistance" OpMemberName %type_View 123 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 124 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 125 "View_AtmosphericFogRenderMask" OpMemberName %type_View 126 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 127 "View_AtmosphericFogSunColor" OpMemberName %type_View 128 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 129 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 130 "View_AmbientCubemapTint" OpMemberName %type_View 131 "View_AmbientCubemapIntensity" OpMemberName %type_View 132 "View_SkyLightParameters" OpMemberName %type_View 133 "PrePadding_View_2488" OpMemberName %type_View 134 "PrePadding_View_2492" OpMemberName %type_View 135 "View_SkyLightColor" OpMemberName %type_View 136 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 137 "View_MobilePreviewMode" OpMemberName %type_View 138 "View_HMDEyePaddingOffset" OpMemberName %type_View 139 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 140 "View_ShowDecalsMask" OpMemberName %type_View 141 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 142 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 143 "PrePadding_View_2648" OpMemberName %type_View 144 "PrePadding_View_2652" OpMemberName %type_View 145 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 146 "View_StereoPassIndex" OpMemberName %type_View 147 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 148 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 149 "View_GlobalVolumeDimension" OpMemberName %type_View 150 "View_GlobalVolumeTexelSize" OpMemberName %type_View 151 "View_MaxGlobalDistance" OpMemberName %type_View 152 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 153 "View_VolumetricFogInvGridSize" OpMemberName %type_View 154 "PrePadding_View_2828" OpMemberName %type_View 155 "View_VolumetricFogGridZParams" OpMemberName %type_View 156 "PrePadding_View_2844" OpMemberName %type_View 157 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 158 "View_VolumetricFogMaxDistance" OpMemberName %type_View 159 "PrePadding_View_2860" OpMemberName %type_View 160 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 161 "PrePadding_View_2876" OpMemberName %type_View 162 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 163 "PrePadding_View_2892" OpMemberName %type_View 164 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 165 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 166 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 167 "View_StereoIPD" OpMemberName %type_View 168 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 169 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_2d_image "type.2d.image" OpName %SceneTexturesStruct_SceneDepthTexture "SceneTexturesStruct_SceneDepthTexture" OpName %type_sampler "type.sampler" OpName %SceneTexturesStruct_SceneDepthTextureSampler "SceneTexturesStruct_SceneDepthTextureSampler" OpName %SceneTexturesStruct_GBufferATexture "SceneTexturesStruct_GBufferATexture" OpName %SceneTexturesStruct_GBufferBTexture "SceneTexturesStruct_GBufferBTexture" OpName %SceneTexturesStruct_GBufferDTexture "SceneTexturesStruct_GBufferDTexture" OpName %SceneTexturesStruct_GBufferATextureSampler "SceneTexturesStruct_GBufferATextureSampler" OpName %SceneTexturesStruct_GBufferBTextureSampler "SceneTexturesStruct_GBufferBTextureSampler" OpName %SceneTexturesStruct_GBufferDTextureSampler "SceneTexturesStruct_GBufferDTextureSampler" OpName %ShadowDepthTextureSampler "ShadowDepthTextureSampler" OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "SoftTransitionScale" OpMemberName %type__Globals 1 "ShadowViewProjectionMatrices" OpMemberName %type__Globals 2 "InvShadowmapResolution" OpMemberName %type__Globals 3 "ShadowFadeFraction" OpMemberName %type__Globals 4 "ShadowSharpen" OpMemberName %type__Globals 5 "LightPositionAndInvRadius" OpMemberName %type__Globals 6 "ProjectionDepthBiasParameters" OpMemberName %type__Globals 7 "PointLightDepthBiasAndProjParameters" OpName %_Globals "$Globals" OpName %type_cube_image "type.cube.image" OpName %ShadowDepthCubeTexture "ShadowDepthCubeTexture" OpName %ShadowDepthCubeTextureSampler "ShadowDepthCubeTextureSampler" OpName %SSProfilesTexture "SSProfilesTexture" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainOnePassPointLightPS "MainOnePassPointLightPS" OpName %type_sampled_image "type.sampled.image" OpName %type_sampled_image_0 "type.sampled.image" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_POSITION" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %SceneTexturesStruct_SceneDepthTexture DescriptorSet 0 OpDecorate %SceneTexturesStruct_SceneDepthTexture Binding 0 OpDecorate %SceneTexturesStruct_SceneDepthTextureSampler DescriptorSet 0 OpDecorate %SceneTexturesStruct_SceneDepthTextureSampler Binding 0 OpDecorate %SceneTexturesStruct_GBufferATexture DescriptorSet 0 OpDecorate %SceneTexturesStruct_GBufferATexture Binding 1 OpDecorate %SceneTexturesStruct_GBufferBTexture DescriptorSet 0 OpDecorate %SceneTexturesStruct_GBufferBTexture Binding 2 OpDecorate %SceneTexturesStruct_GBufferDTexture DescriptorSet 0 OpDecorate %SceneTexturesStruct_GBufferDTexture Binding 3 OpDecorate %SceneTexturesStruct_GBufferATextureSampler DescriptorSet 0 OpDecorate %SceneTexturesStruct_GBufferATextureSampler Binding 1 OpDecorate %SceneTexturesStruct_GBufferBTextureSampler DescriptorSet 0 OpDecorate %SceneTexturesStruct_GBufferBTextureSampler Binding 2 OpDecorate %SceneTexturesStruct_GBufferDTextureSampler DescriptorSet 0 OpDecorate %SceneTexturesStruct_GBufferDTextureSampler Binding 3 OpDecorate %ShadowDepthTextureSampler DescriptorSet 0 OpDecorate %ShadowDepthTextureSampler Binding 4 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 1 OpDecorate %ShadowDepthCubeTexture DescriptorSet 0 OpDecorate %ShadowDepthCubeTexture Binding 4 OpDecorate %ShadowDepthCubeTextureSampler DescriptorSet 0 OpDecorate %ShadowDepthCubeTextureSampler Binding 5 OpDecorate %SSProfilesTexture DescriptorSet 0 OpDecorate %SSProfilesTexture Binding 5 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 14 Offset 844 OpMemberDecorate %type_View 15 Offset 848 OpMemberDecorate %type_View 16 Offset 860 OpMemberDecorate %type_View 17 Offset 864 OpMemberDecorate %type_View 18 Offset 876 OpMemberDecorate %type_View 19 Offset 880 OpMemberDecorate %type_View 20 Offset 892 OpMemberDecorate %type_View 21 Offset 896 OpMemberDecorate %type_View 22 Offset 908 OpMemberDecorate %type_View 23 Offset 912 OpMemberDecorate %type_View 24 Offset 928 OpMemberDecorate %type_View 25 Offset 944 OpMemberDecorate %type_View 26 Offset 956 OpMemberDecorate %type_View 27 Offset 960 OpMemberDecorate %type_View 28 Offset 972 OpMemberDecorate %type_View 29 Offset 976 OpMemberDecorate %type_View 30 Offset 988 OpMemberDecorate %type_View 31 Offset 992 OpMemberDecorate %type_View 32 Offset 1004 OpMemberDecorate %type_View 33 Offset 1008 OpMemberDecorate %type_View 33 MatrixStride 16 OpMemberDecorate %type_View 33 ColMajor OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 44 Offset 1660 OpMemberDecorate %type_View 45 Offset 1664 OpMemberDecorate %type_View 46 Offset 1676 OpMemberDecorate %type_View 47 Offset 1680 OpMemberDecorate %type_View 48 Offset 1692 OpMemberDecorate %type_View 49 Offset 1696 OpMemberDecorate %type_View 49 MatrixStride 16 OpMemberDecorate %type_View 49 ColMajor OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 53 Offset 1904 OpMemberDecorate %type_View 54 Offset 1920 OpMemberDecorate %type_View 55 Offset 1928 OpMemberDecorate %type_View 56 Offset 1936 OpMemberDecorate %type_View 57 Offset 1952 OpMemberDecorate %type_View 58 Offset 1968 OpMemberDecorate %type_View 59 Offset 1984 OpMemberDecorate %type_View 60 Offset 2000 OpMemberDecorate %type_View 61 Offset 2004 OpMemberDecorate %type_View 62 Offset 2008 OpMemberDecorate %type_View 63 Offset 2012 OpMemberDecorate %type_View 64 Offset 2016 OpMemberDecorate %type_View 65 Offset 2032 OpMemberDecorate %type_View 66 Offset 2048 OpMemberDecorate %type_View 67 Offset 2064 OpMemberDecorate %type_View 68 Offset 2072 OpMemberDecorate %type_View 69 Offset 2076 OpMemberDecorate %type_View 70 Offset 2080 OpMemberDecorate %type_View 71 Offset 2084 OpMemberDecorate %type_View 72 Offset 2088 OpMemberDecorate %type_View 73 Offset 2092 OpMemberDecorate %type_View 74 Offset 2096 OpMemberDecorate %type_View 75 Offset 2108 OpMemberDecorate %type_View 76 Offset 2112 OpMemberDecorate %type_View 77 Offset 2116 OpMemberDecorate %type_View 78 Offset 2120 OpMemberDecorate %type_View 79 Offset 2124 OpMemberDecorate %type_View 80 Offset 2128 OpMemberDecorate %type_View 81 Offset 2132 OpMemberDecorate %type_View 82 Offset 2136 OpMemberDecorate %type_View 83 Offset 2140 OpMemberDecorate %type_View 84 Offset 2144 OpMemberDecorate %type_View 85 Offset 2148 OpMemberDecorate %type_View 86 Offset 2152 OpMemberDecorate %type_View 87 Offset 2156 OpMemberDecorate %type_View 88 Offset 2160 OpMemberDecorate %type_View 89 Offset 2164 OpMemberDecorate %type_View 90 Offset 2168 OpMemberDecorate %type_View 91 Offset 2172 OpMemberDecorate %type_View 92 Offset 2176 OpMemberDecorate %type_View 93 Offset 2192 OpMemberDecorate %type_View 94 Offset 2204 OpMemberDecorate %type_View 95 Offset 2208 OpMemberDecorate %type_View 96 Offset 2240 OpMemberDecorate %type_View 97 Offset 2272 OpMemberDecorate %type_View 98 Offset 2288 OpMemberDecorate %type_View 99 Offset 2304 OpMemberDecorate %type_View 100 Offset 2308 OpMemberDecorate %type_View 101 Offset 2312 OpMemberDecorate %type_View 102 Offset 2316 OpMemberDecorate %type_View 103 Offset 2320 OpMemberDecorate %type_View 104 Offset 2324 OpMemberDecorate %type_View 105 Offset 2328 OpMemberDecorate %type_View 106 Offset 2332 OpMemberDecorate %type_View 107 Offset 2336 OpMemberDecorate %type_View 108 Offset 2340 OpMemberDecorate %type_View 109 Offset 2344 OpMemberDecorate %type_View 110 Offset 2348 OpMemberDecorate %type_View 111 Offset 2352 OpMemberDecorate %type_View 112 Offset 2364 OpMemberDecorate %type_View 113 Offset 2368 OpMemberDecorate %type_View 114 Offset 2380 OpMemberDecorate %type_View 115 Offset 2384 OpMemberDecorate %type_View 116 Offset 2388 OpMemberDecorate %type_View 117 Offset 2392 OpMemberDecorate %type_View 118 Offset 2396 OpMemberDecorate %type_View 119 Offset 2400 OpMemberDecorate %type_View 120 Offset 2404 OpMemberDecorate %type_View 121 Offset 2408 OpMemberDecorate %type_View 122 Offset 2412 OpMemberDecorate %type_View 123 Offset 2416 OpMemberDecorate %type_View 124 Offset 2420 OpMemberDecorate %type_View 125 Offset 2424 OpMemberDecorate %type_View 126 Offset 2428 OpMemberDecorate %type_View 127 Offset 2432 OpMemberDecorate %type_View 128 Offset 2448 OpMemberDecorate %type_View 129 Offset 2460 OpMemberDecorate %type_View 130 Offset 2464 OpMemberDecorate %type_View 131 Offset 2480 OpMemberDecorate %type_View 132 Offset 2484 OpMemberDecorate %type_View 133 Offset 2488 OpMemberDecorate %type_View 134 Offset 2492 OpMemberDecorate %type_View 135 Offset 2496 OpMemberDecorate %type_View 136 Offset 2512 OpMemberDecorate %type_View 137 Offset 2624 OpMemberDecorate %type_View 138 Offset 2628 OpMemberDecorate %type_View 139 Offset 2632 OpMemberDecorate %type_View 140 Offset 2636 OpMemberDecorate %type_View 141 Offset 2640 OpMemberDecorate %type_View 142 Offset 2644 OpMemberDecorate %type_View 143 Offset 2648 OpMemberDecorate %type_View 144 Offset 2652 OpMemberDecorate %type_View 145 Offset 2656 OpMemberDecorate %type_View 146 Offset 2668 OpMemberDecorate %type_View 147 Offset 2672 OpMemberDecorate %type_View 148 Offset 2736 OpMemberDecorate %type_View 149 Offset 2800 OpMemberDecorate %type_View 150 Offset 2804 OpMemberDecorate %type_View 151 Offset 2808 OpMemberDecorate %type_View 152 Offset 2812 OpMemberDecorate %type_View 153 Offset 2816 OpMemberDecorate %type_View 154 Offset 2828 OpMemberDecorate %type_View 155 Offset 2832 OpMemberDecorate %type_View 156 Offset 2844 OpMemberDecorate %type_View 157 Offset 2848 OpMemberDecorate %type_View 158 Offset 2856 OpMemberDecorate %type_View 159 Offset 2860 OpMemberDecorate %type_View 160 Offset 2864 OpMemberDecorate %type_View 161 Offset 2876 OpMemberDecorate %type_View 162 Offset 2880 OpMemberDecorate %type_View 163 Offset 2892 OpMemberDecorate %type_View 164 Offset 2896 OpMemberDecorate %type_View 165 Offset 2908 OpMemberDecorate %type_View 166 Offset 2912 OpMemberDecorate %type_View 167 Offset 2924 OpMemberDecorate %type_View 168 Offset 2928 OpMemberDecorate %type_View 169 Offset 2932 OpDecorate %type_View Block OpDecorate %_arr_mat4v4float_uint_6 ArrayStride 64 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 1 MatrixStride 16 OpMemberDecorate %type__Globals 1 ColMajor OpMemberDecorate %type__Globals 2 Offset 400 OpMemberDecorate %type__Globals 3 Offset 404 OpMemberDecorate %type__Globals 4 Offset 408 OpMemberDecorate %type__Globals 5 Offset 416 OpMemberDecorate %type__Globals 6 Offset 432 OpMemberDecorate %type__Globals 7 Offset 448 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %float_0 = OpConstant %float 0 %float_2_5 = OpConstant %float 2.5 %float_2_37764096 = OpConstant %float 2.37764096 %float_0_772542 = OpConstant %float 0.772542 %float_1_46946299 = OpConstant %float 1.46946299 %float_n2_02254295 = OpConstant %float -2.02254295 %float_n1_46946299 = OpConstant %float -1.46946299 %float_n2_022542 = OpConstant %float -2.022542 %float_n2_37764096 = OpConstant %float -2.37764096 %float_0_772543013 = OpConstant %float 0.772543013 %float_1 = OpConstant %float 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %int_7 = OpConstant %int 7 %int_58 = OpConstant %int 58 %int_24 = OpConstant %int 24 %int_11 = OpConstant %int 11 %int_5 = OpConstant %int 5 %float_0_5 = OpConstant %float 0.5 %int_4 = OpConstant %int 4 %int_2 = OpConstant %int 2 %62 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %bool = OpTypeBool %uint_5 = OpConstant %uint 5 %65 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %66 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_10 = OpConstant %float 10 %float_5 = OpConstant %float 5 %uint_0 = OpConstant %uint 0 %int_23 = OpConstant %int 23 %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 %uint_16 = OpConstant %uint 16 %float_0_150000006 = OpConstant %float 0.150000006 %float_0_25 = OpConstant %float 0.25 %float_2 = OpConstant %float 2 %77 = OpConstantComposite %v3float %float_2 %float_2 %float_2 %float_255 = OpConstant %float 255 %uint_15 = OpConstant %uint 15 %uint_4294967280 = OpConstant %uint 4294967280 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %uint_6 = OpConstant %uint 6 %_arr_mat4v4float_uint_6 = OpTypeArray %mat4v4float %uint_6 %type__Globals = OpTypeStruct %v3float %_arr_mat4v4float_uint_6 %float %float %float %v4float %v2float %v4float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %type_cube_image = OpTypeImage %float Cube 2 0 0 1 Unknown %_ptr_UniformConstant_type_cube_image = OpTypePointer UniformConstant %type_cube_image %v2int = OpTypeVector %int 2 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %91 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %type_sampled_image = OpTypeSampledImage %type_cube_image %v3int = OpTypeVector %int 3 %type_sampled_image_0 = OpTypeSampledImage %type_2d_image %v4bool = OpTypeVector %bool 4 %View = OpVariable %_ptr_Uniform_type_View Uniform %SceneTexturesStruct_SceneDepthTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %SceneTexturesStruct_SceneDepthTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %SceneTexturesStruct_GBufferATexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %SceneTexturesStruct_GBufferBTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %SceneTexturesStruct_GBufferDTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %SceneTexturesStruct_GBufferATextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %SceneTexturesStruct_GBufferBTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %SceneTexturesStruct_GBufferDTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %ShadowDepthTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %ShadowDepthCubeTexture = OpVariable %_ptr_UniformConstant_type_cube_image UniformConstant %ShadowDepthCubeTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %SSProfilesTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %float_0_200000003 = OpConstant %float 0.200000003 %98 = OpConstantComposite %v3float %float_2_5 %float_2_5 %float_2_5 %99 = OpConstantComposite %v3float %float_2_37764096 %float_2_37764096 %float_2_37764096 %100 = OpConstantComposite %v3float %float_0_772542 %float_0_772542 %float_0_772542 %101 = OpConstantComposite %v3float %float_1_46946299 %float_1_46946299 %float_1_46946299 %102 = OpConstantComposite %v3float %float_n2_02254295 %float_n2_02254295 %float_n2_02254295 %103 = OpConstantComposite %v3float %float_n1_46946299 %float_n1_46946299 %float_n1_46946299 %104 = OpConstantComposite %v3float %float_n2_022542 %float_n2_022542 %float_n2_022542 %105 = OpConstantComposite %v3float %float_n2_37764096 %float_n2_37764096 %float_n2_37764096 %106 = OpConstantComposite %v3float %float_0_772543013 %float_0_772543013 %float_0_772543013 %107 = OpUndef %v4float %MainOnePassPointLightPS = OpFunction %void None %91 %108 = OpLabel %109 = OpLoad %v4float %gl_FragCoord %110 = OpVectorShuffle %v2float %109 %109 0 1 %111 = OpAccessChain %_ptr_Uniform_v4float %View %int_58 %112 = OpLoad %v4float %111 %113 = OpVectorShuffle %v2float %112 %112 2 3 %114 = OpFMul %v2float %110 %113 %115 = OpLoad %type_2d_image %SceneTexturesStruct_SceneDepthTexture %116 = OpLoad %type_sampler %SceneTexturesStruct_SceneDepthTextureSampler %117 = OpSampledImage %type_sampled_image_0 %115 %116 %118 = OpImageSampleExplicitLod %v4float %117 %114 Lod %float_0 %119 = OpCompositeExtract %float %118 0 %120 = OpAccessChain %_ptr_Uniform_float %View %int_23 %uint_0 %121 = OpLoad %float %120 %122 = OpFMul %float %119 %121 %123 = OpAccessChain %_ptr_Uniform_float %View %int_23 %uint_1 %124 = OpLoad %float %123 %125 = OpFAdd %float %122 %124 %126 = OpAccessChain %_ptr_Uniform_float %View %int_23 %uint_2 %127 = OpLoad %float %126 %128 = OpFMul %float %119 %127 %129 = OpAccessChain %_ptr_Uniform_float %View %int_23 %uint_3 %130 = OpLoad %float %129 %131 = OpFSub %float %128 %130 %132 = OpFDiv %float %float_1 %131 %133 = OpFAdd %float %125 %132 %134 = OpAccessChain %_ptr_Uniform_v4float %View %int_24 %135 = OpLoad %v4float %134 %136 = OpVectorShuffle %v2float %135 %135 3 2 %137 = OpFSub %v2float %114 %136 %138 = OpVectorShuffle %v2float %135 %135 0 1 %139 = OpFDiv %v2float %137 %138 %140 = OpCompositeConstruct %v2float %133 %133 %141 = OpFMul %v2float %139 %140 %142 = OpCompositeExtract %float %141 0 %143 = OpCompositeExtract %float %141 1 %144 = OpCompositeConstruct %v4float %142 %143 %133 %float_1 %145 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_11 %146 = OpLoad %mat4v4float %145 %147 = OpMatrixTimesVector %v4float %146 %144 %148 = OpVectorShuffle %v3float %147 %147 0 1 2 %149 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_5 %150 = OpLoad %v4float %149 %151 = OpVectorShuffle %v3float %150 %150 0 1 2 %152 = OpFSub %v3float %151 %148 %153 = OpAccessChain %_ptr_Uniform_float %_Globals %int_5 %int_3 %154 = OpLoad %float %153 %155 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_7 %156 = OpAccessChain %_ptr_Uniform_float %_Globals %int_7 %int_0 %157 = OpLoad %float %156 %158 = OpExtInst %float %1 Length %152 %159 = OpFMul %float %158 %154 %160 = OpFOrdLessThan %bool %159 %float_1 OpSelectionMerge %161 DontFlatten OpBranchConditional %160 %162 %161 %162 = OpLabel %163 = OpCompositeConstruct %v3float %158 %158 %158 %164 = OpFDiv %v3float %152 %163 %165 = OpExtInst %v3float %1 FAbs %152 %166 = OpCompositeExtract %float %165 0 %167 = OpCompositeExtract %float %165 1 %168 = OpCompositeExtract %float %165 2 %169 = OpExtInst %float %1 FMax %167 %168 %170 = OpExtInst %float %1 FMax %166 %169 %171 = OpFOrdEqual %bool %170 %166 OpSelectionMerge %172 None OpBranchConditional %171 %173 %174 %174 = OpLabel %175 = OpFOrdEqual %bool %170 %167 OpSelectionMerge %176 None OpBranchConditional %175 %177 %178 %178 = OpLabel %179 = OpCompositeExtract %float %152 2 %180 = OpFOrdEqual %bool %168 %179 %181 = OpSelect %int %180 %int_4 %int_5 OpBranch %176 %177 = OpLabel %182 = OpCompositeExtract %float %152 1 %183 = OpFOrdEqual %bool %167 %182 %184 = OpSelect %int %183 %int_2 %int_3 OpBranch %176 %176 = OpLabel %185 = OpPhi %int %184 %177 %181 %178 OpBranch %172 %173 = OpLabel %186 = OpCompositeExtract %float %152 0 %187 = OpFOrdEqual %bool %166 %186 %188 = OpSelect %int %187 %int_0 %int_1 OpBranch %172 %172 = OpLabel %189 = OpPhi %int %188 %173 %185 %176 %190 = OpCompositeExtract %float %147 0 %191 = OpCompositeExtract %float %147 1 %192 = OpCompositeExtract %float %147 2 %193 = OpCompositeConstruct %v4float %190 %191 %192 %float_1 %194 = OpAccessChain %_ptr_Uniform_mat4v4float %_Globals %int_1 %189 %195 = OpLoad %mat4v4float %194 %196 = OpMatrixTimesVector %v4float %195 %193 %197 = OpCompositeExtract %float %196 2 %198 = OpCompositeExtract %float %196 3 %199 = OpFDiv %float %197 %198 %200 = OpFNegate %float %157 %201 = OpFDiv %float %200 %198 %202 = OpLoad %type_cube_image %ShadowDepthCubeTexture %203 = OpLoad %type_sampler %ShadowDepthCubeTextureSampler %204 = OpFAdd %float %199 %201 %205 = OpSampledImage %type_sampled_image %202 %203 %206 = OpImageSampleDrefExplicitLod %float %205 %164 %204 Lod %float_0 OpBranch %161 %161 = OpLabel %207 = OpPhi %float %float_1 %108 %206 %172 %208 = OpFSub %float %207 %float_0_5 %209 = OpAccessChain %_ptr_Uniform_float %_Globals %int_4 %210 = OpLoad %float %209 %211 = OpFMul %float %208 %210 %212 = OpFAdd %float %211 %float_0_5 %213 = OpExtInst %float %1 FClamp %212 %float_0 %float_1 %214 = OpFMul %float %213 %213 %215 = OpAccessChain %_ptr_Uniform_float %_Globals %int_3 %216 = OpLoad %float %215 %217 = OpExtInst %float %1 FMix %float_1 %214 %216 %218 = OpExtInst %float %1 Sqrt %217 %219 = OpCompositeInsert %v4float %218 %107 2 %220 = OpVectorShuffle %v4float %219 %62 4 5 2 6 %221 = OpLoad %type_2d_image %SceneTexturesStruct_GBufferATexture %222 = OpLoad %type_sampler %SceneTexturesStruct_GBufferATextureSampler %223 = OpSampledImage %type_sampled_image_0 %221 %222 %224 = OpImageSampleExplicitLod %v4float %223 %114 Lod %float_0 %225 = OpLoad %type_2d_image %SceneTexturesStruct_GBufferBTexture %226 = OpLoad %type_sampler %SceneTexturesStruct_GBufferBTextureSampler %227 = OpSampledImage %type_sampled_image_0 %225 %226 %228 = OpImageSampleExplicitLod %v4float %227 %114 Lod %float_0 %229 = OpLoad %type_2d_image %SceneTexturesStruct_GBufferDTexture %230 = OpLoad %type_sampler %SceneTexturesStruct_GBufferDTextureSampler %231 = OpSampledImage %type_sampled_image_0 %229 %230 %232 = OpImageSampleExplicitLod %v4float %231 %114 Lod %float_0 %233 = OpVectorShuffle %v3float %224 %224 0 1 2 %234 = OpFMul %v3float %233 %77 %235 = OpFSub %v3float %234 %62 %236 = OpExtInst %v3float %1 Normalize %235 %237 = OpCompositeExtract %float %228 3 %238 = OpFMul %float %237 %float_255 %239 = OpExtInst %float %1 Round %238 %240 = OpConvertFToU %uint %239 %241 = OpBitwiseAnd %uint %240 %uint_15 %242 = OpBitwiseAnd %uint %240 %uint_4294967280 %243 = OpBitwiseAnd %uint %242 %uint_16 %244 = OpINotEqual %bool %243 %uint_0 %245 = OpLogicalNot %bool %244 %246 = OpCompositeConstruct %v4bool %245 %245 %245 %245 %247 = OpSelect %v4float %246 %232 %66 %248 = OpIEqual %bool %241 %uint_5 OpSelectionMerge %249 None OpBranchConditional %248 %250 %249 %250 = OpLabel %251 = OpLoad %v4float %155 %252 = OpCompositeExtract %float %247 0 %253 = OpFMul %float %252 %float_255 %254 = OpFAdd %float %253 %float_0_5 %255 = OpConvertFToU %uint %254 %256 = OpBitcast %int %255 %257 = OpCompositeConstruct %v3int %int_1 %256 %int_0 %258 = OpVectorShuffle %v2int %257 %257 0 1 %259 = OpLoad %type_2d_image %SSProfilesTexture %260 = OpImageFetch %v4float %259 %258 Lod %int_0 %261 = OpCompositeExtract %float %260 0 %262 = OpCompositeExtract %float %260 1 %263 = OpFMul %float %262 %float_0_5 %264 = OpCompositeConstruct %v3float %263 %263 %263 %265 = OpFMul %v3float %236 %264 %266 = OpFSub %v3float %148 %265 %267 = OpDot %float %152 %152 %268 = OpExtInst %float %1 InverseSqrt %267 %269 = OpCompositeConstruct %v3float %268 %268 %268 %270 = OpFMul %v3float %152 %269 %271 = OpFNegate %v3float %270 %272 = OpDot %float %271 %236 %273 = OpExtInst %float %1 FClamp %272 %float_0 %float_1 %274 = OpExtInst %float %1 Pow %273 %float_1 OpSelectionMerge %275 DontFlatten OpBranchConditional %160 %276 %275 %276 = OpLabel %277 = OpCompositeConstruct %v3float %158 %158 %158 %278 = OpFDiv %v3float %152 %277 %279 = OpExtInst %v3float %1 Cross %278 %65 %280 = OpExtInst %v3float %1 Normalize %279 %281 = OpExtInst %v3float %1 Cross %280 %278 %282 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %283 = OpLoad %float %282 %284 = OpCompositeConstruct %v3float %283 %283 %283 %285 = OpFMul %v3float %280 %284 %286 = OpFMul %v3float %281 %284 %287 = OpExtInst %v3float %1 FAbs %278 %288 = OpCompositeExtract %float %287 0 %289 = OpCompositeExtract %float %287 1 %290 = OpCompositeExtract %float %287 2 %291 = OpExtInst %float %1 FMax %289 %290 %292 = OpExtInst %float %1 FMax %288 %291 %293 = OpFOrdEqual %bool %292 %288 OpSelectionMerge %294 None OpBranchConditional %293 %295 %296 %296 = OpLabel %297 = OpFOrdEqual %bool %292 %289 OpSelectionMerge %298 None OpBranchConditional %297 %299 %300 %300 = OpLabel %301 = OpCompositeExtract %float %278 2 %302 = OpFOrdEqual %bool %290 %301 %303 = OpSelect %int %302 %int_4 %int_5 OpBranch %298 %299 = OpLabel %304 = OpCompositeExtract %float %278 1 %305 = OpFOrdEqual %bool %289 %304 %306 = OpSelect %int %305 %int_2 %int_3 OpBranch %298 %298 = OpLabel %307 = OpPhi %int %306 %299 %303 %300 OpBranch %294 %295 = OpLabel %308 = OpCompositeExtract %float %278 0 %309 = OpFOrdEqual %bool %288 %308 %310 = OpSelect %int %309 %int_0 %int_1 OpBranch %294 %294 = OpLabel %311 = OpPhi %int %310 %295 %307 %298 %312 = OpCompositeExtract %float %266 0 %313 = OpCompositeExtract %float %266 1 %314 = OpCompositeExtract %float %266 2 %315 = OpCompositeConstruct %v4float %312 %313 %314 %float_1 %316 = OpAccessChain %_ptr_Uniform_mat4v4float %_Globals %int_1 %311 %317 = OpLoad %mat4v4float %316 %318 = OpMatrixTimesVector %v4float %317 %315 %319 = OpCompositeExtract %float %318 2 %320 = OpCompositeExtract %float %318 3 %321 = OpFDiv %float %319 %320 %322 = OpFDiv %float %float_10 %154 %323 = OpFMul %float %261 %322 %324 = OpCompositeExtract %float %251 2 %325 = OpFMul %float %321 %324 %326 = OpCompositeExtract %float %251 3 %327 = OpFSub %float %325 %326 %328 = OpFDiv %float %float_1 %327 %329 = OpFMul %float %328 %154 %330 = OpFMul %v3float %286 %98 %331 = OpFAdd %v3float %278 %330 %332 = OpLoad %type_cube_image %ShadowDepthCubeTexture %333 = OpLoad %type_sampler %ShadowDepthTextureSampler %334 = OpSampledImage %type_sampled_image %332 %333 %335 = OpImageSampleExplicitLod %v4float %334 %331 Lod %float_0 %336 = OpCompositeExtract %float %335 0 %337 = OpFMul %float %336 %324 %338 = OpFSub %float %337 %326 %339 = OpFDiv %float %float_1 %338 %340 = OpFMul %float %339 %154 %341 = OpFSub %float %329 %340 %342 = OpFMul %float %341 %323 %343 = OpFOrdGreaterThan %bool %342 %float_0 %344 = OpFAdd %float %342 %263 %345 = OpFMul %float %342 %274 %346 = OpFAdd %float %345 %263 %347 = OpExtInst %float %1 FMax %float_0 %346 %348 = OpSelect %float %343 %344 %347 %349 = OpExtInst %float %1 FAbs %348 %350 = OpExtInst %float %1 FClamp %349 %float_0_150000006 %float_5 %351 = OpFAdd %float %350 %float_0_25 %352 = OpFMul %v3float %285 %99 %353 = OpFAdd %v3float %278 %352 %354 = OpFMul %v3float %286 %100 %355 = OpFAdd %v3float %353 %354 %356 = OpSampledImage %type_sampled_image %332 %333 %357 = OpImageSampleExplicitLod %v4float %356 %355 Lod %float_0 %358 = OpCompositeExtract %float %357 0 %359 = OpFMul %float %358 %324 %360 = OpFSub %float %359 %326 %361 = OpFDiv %float %float_1 %360 %362 = OpFMul %float %361 %154 %363 = OpFSub %float %329 %362 %364 = OpFMul %float %363 %323 %365 = OpFOrdGreaterThan %bool %364 %float_0 %366 = OpFAdd %float %364 %263 %367 = OpFMul %float %364 %274 %368 = OpFAdd %float %367 %263 %369 = OpExtInst %float %1 FMax %float_0 %368 %370 = OpSelect %float %365 %366 %369 %371 = OpExtInst %float %1 FAbs %370 %372 = OpExtInst %float %1 FClamp %371 %float_0_150000006 %float_5 %373 = OpFAdd %float %372 %float_0_25 %374 = OpFAdd %float %351 %373 %375 = OpFMul %v3float %285 %101 %376 = OpFAdd %v3float %278 %375 %377 = OpFMul %v3float %286 %102 %378 = OpFAdd %v3float %376 %377 %379 = OpSampledImage %type_sampled_image %332 %333 %380 = OpImageSampleExplicitLod %v4float %379 %378 Lod %float_0 %381 = OpCompositeExtract %float %380 0 %382 = OpFMul %float %381 %324 %383 = OpFSub %float %382 %326 %384 = OpFDiv %float %float_1 %383 %385 = OpFMul %float %384 %154 %386 = OpFSub %float %329 %385 %387 = OpFMul %float %386 %323 %388 = OpFOrdGreaterThan %bool %387 %float_0 %389 = OpFAdd %float %387 %263 %390 = OpFMul %float %387 %274 %391 = OpFAdd %float %390 %263 %392 = OpExtInst %float %1 FMax %float_0 %391 %393 = OpSelect %float %388 %389 %392 %394 = OpExtInst %float %1 FAbs %393 %395 = OpExtInst %float %1 FClamp %394 %float_0_150000006 %float_5 %396 = OpFAdd %float %395 %float_0_25 %397 = OpFAdd %float %374 %396 %398 = OpFMul %v3float %285 %103 %399 = OpFAdd %v3float %278 %398 %400 = OpFMul %v3float %286 %104 %401 = OpFAdd %v3float %399 %400 %402 = OpSampledImage %type_sampled_image %332 %333 %403 = OpImageSampleExplicitLod %v4float %402 %401 Lod %float_0 %404 = OpCompositeExtract %float %403 0 %405 = OpFMul %float %404 %324 %406 = OpFSub %float %405 %326 %407 = OpFDiv %float %float_1 %406 %408 = OpFMul %float %407 %154 %409 = OpFSub %float %329 %408 %410 = OpFMul %float %409 %323 %411 = OpFOrdGreaterThan %bool %410 %float_0 %412 = OpFAdd %float %410 %263 %413 = OpFMul %float %410 %274 %414 = OpFAdd %float %413 %263 %415 = OpExtInst %float %1 FMax %float_0 %414 %416 = OpSelect %float %411 %412 %415 %417 = OpExtInst %float %1 FAbs %416 %418 = OpExtInst %float %1 FClamp %417 %float_0_150000006 %float_5 %419 = OpFAdd %float %418 %float_0_25 %420 = OpFAdd %float %397 %419 %421 = OpFMul %v3float %285 %105 %422 = OpFAdd %v3float %278 %421 %423 = OpFMul %v3float %286 %106 %424 = OpFAdd %v3float %422 %423 %425 = OpSampledImage %type_sampled_image %332 %333 %426 = OpImageSampleExplicitLod %v4float %425 %424 Lod %float_0 %427 = OpCompositeExtract %float %426 0 %428 = OpFMul %float %427 %324 %429 = OpFSub %float %428 %326 %430 = OpFDiv %float %float_1 %429 %431 = OpFMul %float %430 %154 %432 = OpFSub %float %329 %431 %433 = OpFMul %float %432 %323 %434 = OpFOrdGreaterThan %bool %433 %float_0 %435 = OpFAdd %float %433 %263 %436 = OpFMul %float %433 %274 %437 = OpFAdd %float %436 %263 %438 = OpExtInst %float %1 FMax %float_0 %437 %439 = OpSelect %float %434 %435 %438 %440 = OpExtInst %float %1 FAbs %439 %441 = OpExtInst %float %1 FClamp %440 %float_0_150000006 %float_5 %442 = OpFAdd %float %441 %float_0_25 %443 = OpFAdd %float %420 %442 %444 = OpFMul %float %443 %float_0_200000003 OpBranch %275 %275 = OpLabel %445 = OpPhi %float %float_1 %250 %444 %294 %446 = OpFMul %float %445 %float_0_200000003 %447 = OpFSub %float %float_1 %446 OpBranch %249 %249 = OpLabel %448 = OpPhi %float %float_1 %161 %447 %275 %449 = OpExtInst %float %1 Sqrt %448 %450 = OpSelect %float %248 %449 %218 %451 = OpCompositeInsert %v4float %450 %220 3 OpStore %out_var_SV_Target0 %451 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/frag/global-constant-arrays.asm.frag000066400000000000000000005073411400026215700262350ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 3005 ; Schema: 0 OpCapability Shader OpCapability Geometry OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPS "main" %in_var_TEXCOORD0 %gl_FragCoord %gl_Layer %out_var_SV_Target0 OpExecutionMode %MainPS OriginUpperLeft OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "MappingPolynomial" OpMemberName %type__Globals 1 "InverseGamma" OpMemberName %type__Globals 2 "ColorMatrixR_ColorCurveCd1" OpMemberName %type__Globals 3 "ColorMatrixG_ColorCurveCd3Cm3" OpMemberName %type__Globals 4 "ColorMatrixB_ColorCurveCm2" OpMemberName %type__Globals 5 "ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3" OpMemberName %type__Globals 6 "ColorCurve_Ch1_Ch2" OpMemberName %type__Globals 7 "ColorShadow_Luma" OpMemberName %type__Globals 8 "ColorShadow_Tint1" OpMemberName %type__Globals 9 "ColorShadow_Tint2" OpMemberName %type__Globals 10 "FilmSlope" OpMemberName %type__Globals 11 "FilmToe" OpMemberName %type__Globals 12 "FilmShoulder" OpMemberName %type__Globals 13 "FilmBlackClip" OpMemberName %type__Globals 14 "FilmWhiteClip" OpMemberName %type__Globals 15 "ColorScale" OpMemberName %type__Globals 16 "OverlayColor" OpMemberName %type__Globals 17 "WhiteTemp" OpMemberName %type__Globals 18 "WhiteTint" OpMemberName %type__Globals 19 "ColorSaturation" OpMemberName %type__Globals 20 "ColorContrast" OpMemberName %type__Globals 21 "ColorGamma" OpMemberName %type__Globals 22 "ColorGain" OpMemberName %type__Globals 23 "ColorOffset" OpMemberName %type__Globals 24 "ColorSaturationShadows" OpMemberName %type__Globals 25 "ColorContrastShadows" OpMemberName %type__Globals 26 "ColorGammaShadows" OpMemberName %type__Globals 27 "ColorGainShadows" OpMemberName %type__Globals 28 "ColorOffsetShadows" OpMemberName %type__Globals 29 "ColorSaturationMidtones" OpMemberName %type__Globals 30 "ColorContrastMidtones" OpMemberName %type__Globals 31 "ColorGammaMidtones" OpMemberName %type__Globals 32 "ColorGainMidtones" OpMemberName %type__Globals 33 "ColorOffsetMidtones" OpMemberName %type__Globals 34 "ColorSaturationHighlights" OpMemberName %type__Globals 35 "ColorContrastHighlights" OpMemberName %type__Globals 36 "ColorGammaHighlights" OpMemberName %type__Globals 37 "ColorGainHighlights" OpMemberName %type__Globals 38 "ColorOffsetHighlights" OpMemberName %type__Globals 39 "ColorCorrectionShadowsMax" OpMemberName %type__Globals 40 "ColorCorrectionHighlightsMin" OpMemberName %type__Globals 41 "OutputDevice" OpMemberName %type__Globals 42 "OutputGamut" OpMemberName %type__Globals 43 "BlueCorrection" OpMemberName %type__Globals 44 "ExpandGamut" OpName %_Globals "$Globals" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPS "MainPS" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorate %in_var_TEXCOORD0 NoPerspective OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_POSITION" OpDecorate %gl_Layer BuiltIn Layer OpDecorateString %gl_Layer UserSemantic "SV_RenderTargetArrayIndex" OpDecorate %gl_Layer Flat OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 32 OpMemberDecorate %type__Globals 3 Offset 48 OpMemberDecorate %type__Globals 4 Offset 64 OpMemberDecorate %type__Globals 5 Offset 80 OpMemberDecorate %type__Globals 6 Offset 96 OpMemberDecorate %type__Globals 7 Offset 112 OpMemberDecorate %type__Globals 8 Offset 128 OpMemberDecorate %type__Globals 9 Offset 144 OpMemberDecorate %type__Globals 10 Offset 160 OpMemberDecorate %type__Globals 11 Offset 164 OpMemberDecorate %type__Globals 12 Offset 168 OpMemberDecorate %type__Globals 13 Offset 172 OpMemberDecorate %type__Globals 14 Offset 176 OpMemberDecorate %type__Globals 15 Offset 180 OpMemberDecorate %type__Globals 16 Offset 192 OpMemberDecorate %type__Globals 17 Offset 208 OpMemberDecorate %type__Globals 18 Offset 212 OpMemberDecorate %type__Globals 19 Offset 224 OpMemberDecorate %type__Globals 20 Offset 240 OpMemberDecorate %type__Globals 21 Offset 256 OpMemberDecorate %type__Globals 22 Offset 272 OpMemberDecorate %type__Globals 23 Offset 288 OpMemberDecorate %type__Globals 24 Offset 304 OpMemberDecorate %type__Globals 25 Offset 320 OpMemberDecorate %type__Globals 26 Offset 336 OpMemberDecorate %type__Globals 27 Offset 352 OpMemberDecorate %type__Globals 28 Offset 368 OpMemberDecorate %type__Globals 29 Offset 384 OpMemberDecorate %type__Globals 30 Offset 400 OpMemberDecorate %type__Globals 31 Offset 416 OpMemberDecorate %type__Globals 32 Offset 432 OpMemberDecorate %type__Globals 33 Offset 448 OpMemberDecorate %type__Globals 34 Offset 464 OpMemberDecorate %type__Globals 35 Offset 480 OpMemberDecorate %type__Globals 36 Offset 496 OpMemberDecorate %type__Globals 37 Offset 512 OpMemberDecorate %type__Globals 38 Offset 528 OpMemberDecorate %type__Globals 39 Offset 544 OpMemberDecorate %type__Globals 40 Offset 548 OpMemberDecorate %type__Globals 41 Offset 552 OpMemberDecorate %type__Globals 42 Offset 556 OpMemberDecorate %type__Globals 43 Offset 560 OpMemberDecorate %type__Globals 44 Offset 564 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %float_0_952552378 = OpConstant %float 0.952552378 %float_0 = OpConstant %float 0 ; HACK: Needed to hack this constant since MSVC and GNU libc are off by 1 ULP when converting to string (it probably still works fine though in a roundtrip ...) %float_9_36786018en05 = OpConstant %float 9.25 %float_0_343966454 = OpConstant %float 0.343966454 %float_0_728166103 = OpConstant %float 0.728166103 %float_n0_0721325427 = OpConstant %float -0.0721325427 %float_1_00882518 = OpConstant %float 1.00882518 %float_1_04981101 = OpConstant %float 1.04981101 %float_n9_74845025en05 = OpConstant %float -9.74845025e-05 %float_n0_495903015 = OpConstant %float -0.495903015 %float_1_37331307 = OpConstant %float 1.37331307 %float_0_0982400328 = OpConstant %float 0.0982400328 %float_0_991252005 = OpConstant %float 0.991252005 %float_0_662454188 = OpConstant %float 0.662454188 %float_0_134004205 = OpConstant %float 0.134004205 %float_0_156187683 = OpConstant %float 0.156187683 %float_0_272228718 = OpConstant %float 0.272228718 %float_0_674081743 = OpConstant %float 0.674081743 %float_0_0536895171 = OpConstant %float 0.0536895171 %float_n0_00557464967 = OpConstant %float -0.00557464967 %float_0_0040607336 = OpConstant %float 0.0040607336 %float_1_01033914 = OpConstant %float 1.01033914 %float_1_6410234 = OpConstant %float 1.6410234 %float_n0_324803293 = OpConstant %float -0.324803293 %float_n0_236424699 = OpConstant %float -0.236424699 %float_n0_663662851 = OpConstant %float -0.663662851 %float_1_61533165 = OpConstant %float 1.61533165 %float_0_0167563483 = OpConstant %float 0.0167563483 %float_0_0117218941 = OpConstant %float 0.0117218941 %float_n0_00828444213 = OpConstant %float -0.00828444213 %float_0_988394856 = OpConstant %float 0.988394856 %float_1_45143926 = OpConstant %float 1.45143926 %float_n0_236510754 = OpConstant %float -0.236510754 %float_n0_214928567 = OpConstant %float -0.214928567 %float_n0_0765537769 = OpConstant %float -0.0765537769 %float_1_17622972 = OpConstant %float 1.17622972 %float_n0_0996759236 = OpConstant %float -0.0996759236 %float_0_00831614807 = OpConstant %float 0.00831614807 %float_n0_00603244966 = OpConstant %float -0.00603244966 %float_0_997716308 = OpConstant %float 0.997716308 %float_0_695452213 = OpConstant %float 0.695452213 %float_0_140678704 = OpConstant %float 0.140678704 %float_0_163869068 = OpConstant %float 0.163869068 %float_0_0447945632 = OpConstant %float 0.0447945632 %float_0_859671116 = OpConstant %float 0.859671116 %float_0_0955343172 = OpConstant %float 0.0955343172 %float_n0_00552588282 = OpConstant %float -0.00552588282 %float_0_00402521016 = OpConstant %float 0.00402521016 %float_1_00150073 = OpConstant %float 1.00150073 %67 = OpConstantComposite %v3float %float_0_272228718 %float_0_674081743 %float_0_0536895171 %float_3_2409699 = OpConstant %float 3.2409699 %float_n1_5373832 = OpConstant %float -1.5373832 %float_n0_498610765 = OpConstant %float -0.498610765 %float_n0_969243646 = OpConstant %float -0.969243646 %float_1_8759675 = OpConstant %float 1.8759675 %float_0_0415550582 = OpConstant %float 0.0415550582 %float_0_0556300804 = OpConstant %float 0.0556300804 %float_n0_203976959 = OpConstant %float -0.203976959 %float_1_05697155 = OpConstant %float 1.05697155 %float_0_412456393 = OpConstant %float 0.412456393 %float_0_357576102 = OpConstant %float 0.357576102 %float_0_180437505 = OpConstant %float 0.180437505 %float_0_212672904 = OpConstant %float 0.212672904 %float_0_715152204 = OpConstant %float 0.715152204 %float_0_0721750036 = OpConstant %float 0.0721750036 %float_0_0193339009 = OpConstant %float 0.0193339009 %float_0_119191997 = OpConstant %float 0.119191997 %float_0_950304091 = OpConstant %float 0.950304091 %float_1_71660841 = OpConstant %float 1.71660841 %float_n0_355662107 = OpConstant %float -0.355662107 %float_n0_253360093 = OpConstant %float -0.253360093 %float_n0_666682899 = OpConstant %float -0.666682899 %float_1_61647761 = OpConstant %float 1.61647761 %float_0_0157685 = OpConstant %float 0.0157685 %float_0_0176422 = OpConstant %float 0.0176422 %float_n0_0427763015 = OpConstant %float -0.0427763015 %float_0_942228675 = OpConstant %float 0.942228675 %float_2_49339628 = OpConstant %float 2.49339628 %float_n0_93134588 = OpConstant %float -0.93134588 %float_n0_402694494 = OpConstant %float -0.402694494 %float_n0_829486787 = OpConstant %float -0.829486787 %float_1_76265967 = OpConstant %float 1.76265967 %float_0_0236246008 = OpConstant %float 0.0236246008 %float_0_0358507 = OpConstant %float 0.0358507 %float_n0_0761827007 = OpConstant %float -0.0761827007 %float_0_957014024 = OpConstant %float 0.957014024 %float_1_01303005 = OpConstant %float 1.01303005 %float_0_00610530982 = OpConstant %float 0.00610530982 %float_n0_0149710001 = OpConstant %float -0.0149710001 %float_0_00769822998 = OpConstant %float 0.00769822998 %float_0_998165011 = OpConstant %float 0.998165011 %float_n0_00503202993 = OpConstant %float -0.00503202993 %float_n0_00284131011 = OpConstant %float -0.00284131011 %float_0_00468515977 = OpConstant %float 0.00468515977 %float_0_924507022 = OpConstant %float 0.924507022 %float_0_987223983 = OpConstant %float 0.987223983 %float_n0_00611326983 = OpConstant %float -0.00611326983 %float_0_0159533005 = OpConstant %float 0.0159533005 %float_n0_00759836007 = OpConstant %float -0.00759836007 %float_1_00186002 = OpConstant %float 1.00186002 %float_0_0053300201 = OpConstant %float 0.0053300201 %float_0_00307257008 = OpConstant %float 0.00307257008 %float_n0_00509594986 = OpConstant %float -0.00509594986 %float_1_08168006 = OpConstant %float 1.08168006 %float_0_5 = OpConstant %float 0.5 %float_n1 = OpConstant %float -1 %float_1 = OpConstant %float 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_0_015625 = OpConstant %float 0.015625 %128 = OpConstantComposite %v2float %float_0_015625 %float_0_015625 %129 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int_42 = OpConstant %int 42 %uint_3 = OpConstant %uint 3 %132 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %int_9 = OpConstant %int 9 %int_3 = OpConstant %int 3 %135 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_n4 = OpConstant %float -4 %int_44 = OpConstant %int 44 %float_0_544169128 = OpConstant %float 0.544169128 %float_0_239592597 = OpConstant %float 0.239592597 %float_0_166694298 = OpConstant %float 0.166694298 %float_0_239465594 = OpConstant %float 0.239465594 %float_0_702153027 = OpConstant %float 0.702153027 %float_0_058381401 = OpConstant %float 0.058381401 %float_n0_00234390004 = OpConstant %float -0.00234390004 %float_0_0361833982 = OpConstant %float 0.0361833982 %float_1_05521834 = OpConstant %float 1.05521834 %float_0_940437257 = OpConstant %float 0.940437257 %float_n0_0183068793 = OpConstant %float -0.0183068793 %float_0_077869609 = OpConstant %float 0.077869609 %float_0_00837869663 = OpConstant %float 0.00837869663 %float_0_828660011 = OpConstant %float 0.828660011 %float_0_162961304 = OpConstant %float 0.162961304 %float_0_00054712611 = OpConstant %float 0.00054712611 %float_n0_000883374596 = OpConstant %float -0.000883374596 %float_1_00033629 = OpConstant %float 1.00033629 %float_1_06317997 = OpConstant %float 1.06317997 %float_0_0233955998 = OpConstant %float 0.0233955998 %float_n0_0865726024 = OpConstant %float -0.0865726024 %float_n0_0106336996 = OpConstant %float -0.0106336996 %float_1_20632005 = OpConstant %float 1.20632005 %float_n0_195690006 = OpConstant %float -0.195690006 %float_n0_000590886979 = OpConstant %float -0.000590886979 %float_0_00105247996 = OpConstant %float 0.00105247996 %float_0_999538004 = OpConstant %float 0.999538004 %int_43 = OpConstant %int 43 %int_15 = OpConstant %int 15 %int_16 = OpConstant %int 16 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_5 = OpConstant %uint 5 %uint_6 = OpConstant %uint 6 %int_2 = OpConstant %int 2 %mat3v3float = OpTypeMatrix %v3float 3 %int_41 = OpConstant %int 41 %float_0_159301758 = OpConstant %float 0.159301758 %float_78_84375 = OpConstant %float 78.84375 %float_0_8359375 = OpConstant %float 0.8359375 %float_18_8515625 = OpConstant %float 18.8515625 %float_18_6875 = OpConstant %float 18.6875 %float_10000 = OpConstant %float 10000 %float_0_0126833133 = OpConstant %float 0.0126833133 %182 = OpConstantComposite %v3float %float_0_0126833133 %float_0_0126833133 %float_0_0126833133 %183 = OpConstantComposite %v3float %float_0_8359375 %float_0_8359375 %float_0_8359375 %184 = OpConstantComposite %v3float %float_18_8515625 %float_18_8515625 %float_18_8515625 %185 = OpConstantComposite %v3float %float_18_6875 %float_18_6875 %float_18_6875 %float_6_27739477 = OpConstant %float 6.27739477 %187 = OpConstantComposite %v3float %float_6_27739477 %float_6_27739477 %float_6_27739477 %188 = OpConstantComposite %v3float %float_10000 %float_10000 %float_10000 %float_14 = OpConstant %float 14 %float_0_180000007 = OpConstant %float 0.180000007 %float_0_434017599 = OpConstant %float 0.434017599 %192 = OpConstantComposite %v3float %float_0_434017599 %float_0_434017599 %float_0_434017599 %193 = OpConstantComposite %v3float %float_14 %float_14 %float_14 %194 = OpConstantComposite %v3float %float_0_180000007 %float_0_180000007 %float_0_180000007 %int_17 = OpConstant %int 17 %float_4000 = OpConstant %float 4000 %float_0_312700003 = OpConstant %float 0.312700003 %float_0_328999996 = OpConstant %float 0.328999996 %int_18 = OpConstant %int 18 %int_24 = OpConstant %int 24 %int_19 = OpConstant %int 19 %int_25 = OpConstant %int 25 %int_20 = OpConstant %int 20 %int_26 = OpConstant %int 26 %int_21 = OpConstant %int 21 %int_27 = OpConstant %int 27 %int_22 = OpConstant %int 22 %int_28 = OpConstant %int 28 %int_23 = OpConstant %int 23 %int_39 = OpConstant %int 39 %int_34 = OpConstant %int 34 %int_35 = OpConstant %int 35 %int_36 = OpConstant %int 36 %int_37 = OpConstant %int 37 %int_38 = OpConstant %int 38 %int_40 = OpConstant %int 40 %int_29 = OpConstant %int 29 %int_30 = OpConstant %int 30 %int_31 = OpConstant %int 31 %int_32 = OpConstant %int 32 %int_33 = OpConstant %int 33 %float_0_0500000007 = OpConstant %float 0.0500000007 %float_1_75 = OpConstant %float 1.75 %float_0_400000006 = OpConstant %float 0.400000006 %float_0_0299999993 = OpConstant %float 0.0299999993 %float_2 = OpConstant %float 2 %float_0_959999979 = OpConstant %float 0.959999979 %228 = OpConstantComposite %v3float %float_0_959999979 %float_0_959999979 %float_0_959999979 %int_13 = OpConstant %int 13 %int_11 = OpConstant %int 11 %int_14 = OpConstant %int 14 %int_12 = OpConstant %int 12 %float_0_800000012 = OpConstant %float 0.800000012 %int_10 = OpConstant %int 10 %float_10 = OpConstant %float 10 %float_n2 = OpConstant %float -2 %float_3 = OpConstant %float 3 %238 = OpConstantComposite %v3float %float_3 %float_3 %float_3 %239 = OpConstantComposite %v3float %float_2 %float_2 %float_2 %float_0_930000007 = OpConstant %float 0.930000007 %241 = OpConstantComposite %v3float %float_0_930000007 %float_0_930000007 %float_0_930000007 %int_4 = OpConstant %int 4 %int_8 = OpConstant %int 8 %int_7 = OpConstant %int 7 %int_5 = OpConstant %int 5 %int_6 = OpConstant %int 6 %float_0_00200000009 = OpConstant %float 0.00200000009 %248 = OpConstantComposite %v3float %float_0_00200000009 %float_0_00200000009 %float_0_00200000009 %float_6_10351999en05 = OpConstant %float 6.10351999e-05 %250 = OpConstantComposite %v3float %float_6_10351999en05 %float_6_10351999en05 %float_6_10351999en05 %float_4_5 = OpConstant %float 4.5 %252 = OpConstantComposite %v3float %float_4_5 %float_4_5 %float_4_5 %float_0_0179999992 = OpConstant %float 0.0179999992 %254 = OpConstantComposite %v3float %float_0_0179999992 %float_0_0179999992 %float_0_0179999992 %float_0_449999988 = OpConstant %float 0.449999988 %256 = OpConstantComposite %v3float %float_0_449999988 %float_0_449999988 %float_0_449999988 %float_1_09899998 = OpConstant %float 1.09899998 %258 = OpConstantComposite %v3float %float_1_09899998 %float_1_09899998 %float_1_09899998 %float_0_0989999995 = OpConstant %float 0.0989999995 %260 = OpConstantComposite %v3float %float_0_0989999995 %float_0_0989999995 %float_0_0989999995 %float_1_5 = OpConstant %float 1.5 %262 = OpConstantComposite %v3float %float_1_5 %float_1_5 %float_1_5 %263 = OpConstantComposite %v3float %float_0_159301758 %float_0_159301758 %float_0_159301758 %264 = OpConstantComposite %v3float %float_78_84375 %float_78_84375 %float_78_84375 %float_1_00055635 = OpConstant %float 1.00055635 %float_7000 = OpConstant %float 7000 %float_0_244063005 = OpConstant %float 0.244063005 %float_99_1100006 = OpConstant %float 99.1100006 %float_2967800 = OpConstant %float 2967800 %float_0_237039998 = OpConstant %float 0.237039998 %float_247_479996 = OpConstant %float 247.479996 %float_1901800 = OpConstant %float 1901800 %float_n3 = OpConstant %float -3 %float_2_86999989 = OpConstant %float 2.86999989 %float_0_275000006 = OpConstant %float 0.275000006 %float_0_860117733 = OpConstant %float 0.860117733 %float_0_000154118257 = OpConstant %float 0.000154118257 %float_1_28641219en07 = OpConstant %float 1.28641219e-07 %float_0_00084242021 = OpConstant %float 0.00084242021 %float_7_08145137en07 = OpConstant %float 7.08145137e-07 %float_0_317398727 = OpConstant %float 0.317398727 ; HACK: Needed to hack this constant since MSVC and GNU libc are off by 1 ULP when converting to string (it probably still works fine though in a roundtrip ...) %float_4_22806261en05 = OpConstant %float 4.25 %float_4_20481676en08 = OpConstant %float 4.20481676e-08 %float_2_8974182en05 = OpConstant %float 2.8974182e-05 %float_1_61456057en07 = OpConstant %float 1.61456057e-07 %float_8 = OpConstant %float 8 %float_4 = OpConstant %float 4 %float_0_895099998 = OpConstant %float 0.895099998 %float_0_266400009 = OpConstant %float 0.266400009 %float_n0_161400005 = OpConstant %float -0.161400005 %float_n0_750199974 = OpConstant %float -0.750199974 %float_1_71350002 = OpConstant %float 1.71350002 %float_0_0366999991 = OpConstant %float 0.0366999991 %float_0_0388999991 = OpConstant %float 0.0388999991 %float_n0_0684999973 = OpConstant %float -0.0684999973 %float_1_02960002 = OpConstant %float 1.02960002 %float_0_986992896 = OpConstant %float 0.986992896 %float_n0_1470543 = OpConstant %float -0.1470543 %float_0_159962699 = OpConstant %float 0.159962699 %float_0_432305306 = OpConstant %float 0.432305306 %float_0_518360317 = OpConstant %float 0.518360317 %float_0_0492912009 = OpConstant %float 0.0492912009 %float_n0_0085287001 = OpConstant %float -0.0085287001 %float_0_040042799 = OpConstant %float 0.040042799 %float_0_968486726 = OpConstant %float 0.968486726 %float_5_55555534 = OpConstant %float 5.55555534 %307 = OpConstantComposite %v3float %float_5_55555534 %float_5_55555534 %float_5_55555534 %float_1_00000001en10 = OpConstant %float 1.00000001e-10 %float_0_00999999978 = OpConstant %float 0.00999999978 %float_0_666666687 = OpConstant %float 0.666666687 %float_180 = OpConstant %float 180 %float_360 = OpConstant %float 360 %float_65535 = OpConstant %float 65535 %314 = OpConstantComposite %v3float %float_65535 %float_65535 %float_65535 %float_n4_97062206 = OpConstant %float -4.97062206 %float_n3_02937818 = OpConstant %float -3.02937818 %float_n2_12619996 = OpConstant %float -2.12619996 %float_n1_51049995 = OpConstant %float -1.51049995 %float_n1_05780005 = OpConstant %float -1.05780005 %float_n0_466800004 = OpConstant %float -0.466800004 %float_0_119379997 = OpConstant %float 0.119379997 %float_0_708813429 = OpConstant %float 0.708813429 %float_1_29118657 = OpConstant %float 1.29118657 %float_0_808913231 = OpConstant %float 0.808913231 %float_1_19108677 = OpConstant %float 1.19108677 %float_1_56830001 = OpConstant %float 1.56830001 %float_1_9483 = OpConstant %float 1.9483 %float_2_30830002 = OpConstant %float 2.30830002 %float_2_63840008 = OpConstant %float 2.63840008 %float_2_85949993 = OpConstant %float 2.85949993 %float_2_98726082 = OpConstant %float 2.98726082 %float_3_01273918 = OpConstant %float 3.01273918 %float_0_179999992 = OpConstant %float 0.179999992 %float_9_99999975en05 = OpConstant %float 9.99999975e-05 %float_1000 = OpConstant %float 1000 %float_0_0599999987 = OpConstant %float 0.0599999987 %float_3_50738446en05 = OpConstant %float 3.50738446e-05 %338 = OpConstantComposite %v3float %float_3_50738446en05 %float_3_50738446en05 %float_3_50738446en05 %float_n2_30102992 = OpConstant %float -2.30102992 %float_n1_93120003 = OpConstant %float -1.93120003 %float_n1_52049994 = OpConstant %float -1.52049994 %float_0_801995218 = OpConstant %float 0.801995218 %float_1_19800484 = OpConstant %float 1.19800484 %float_1_59430003 = OpConstant %float 1.59430003 %float_1_99730003 = OpConstant %float 1.99730003 %float_2_37829995 = OpConstant %float 2.37829995 %float_2_76839995 = OpConstant %float 2.76839995 %float_3_05150008 = OpConstant %float 3.05150008 %float_3_27462935 = OpConstant %float 3.27462935 %float_3_32743073 = OpConstant %float 3.32743073 %float_0_00499999989 = OpConstant %float 0.00499999989 %float_11 = OpConstant %float 11 %float_2000 = OpConstant %float 2000 %float_0_119999997 = OpConstant %float 0.119999997 %float_0_00313066994 = OpConstant %float 0.00313066994 %float_12_9200001 = OpConstant %float 12.9200001 %float_0_416666657 = OpConstant %float 0.416666657 %float_1_05499995 = OpConstant %float 1.05499995 %float_0_0549999997 = OpConstant %float 0.0549999997 %float_n0_166666672 = OpConstant %float -0.166666672 %float_n0_5 = OpConstant %float -0.5 %float_0_166666672 = OpConstant %float 0.166666672 %float_n3_15737653 = OpConstant %float -3.15737653 %float_n0_485249996 = OpConstant %float -0.485249996 %float_1_84773242 = OpConstant %float 1.84773242 %float_n0_718548238 = OpConstant %float -0.718548238 %float_2_08103061 = OpConstant %float 2.08103061 %float_3_6681242 = OpConstant %float 3.6681242 %float_18 = OpConstant %float 18 %float_7 = OpConstant %float 7 %type__Globals = OpTypeStruct %v4float %v3float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %float %float %float %float %float %v3float %v4float %float %float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %float %float %uint %uint %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %377 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %v2bool = OpTypeVector %bool 2 %v3bool = OpTypeVector %bool 3 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %_arr_float_uint_6 = OpTypeArray %float %uint_6 %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %gl_Layer = OpVariable %_ptr_Input_uint Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %_ptr_Function__arr_float_uint_6 = OpTypePointer Function %_arr_float_uint_6 %_ptr_Function__arr_float_uint_10 = OpTypePointer Function %_arr_float_uint_10 %391 = OpUndef %v3float %392 = OpConstantComposite %v3float %float_0_952552378 %float_0 %float_9_36786018en05 %393 = OpConstantComposite %v3float %float_0_343966454 %float_0_728166103 %float_n0_0721325427 %394 = OpConstantComposite %v3float %float_0 %float_0 %float_1_00882518 %395 = OpConstantComposite %mat3v3float %392 %393 %394 %396 = OpConstantComposite %v3float %float_1_04981101 %float_0 %float_n9_74845025en05 %397 = OpConstantComposite %v3float %float_n0_495903015 %float_1_37331307 %float_0_0982400328 %398 = OpConstantComposite %v3float %float_0 %float_0 %float_0_991252005 %399 = OpConstantComposite %mat3v3float %396 %397 %398 %400 = OpConstantComposite %v3float %float_0_662454188 %float_0_134004205 %float_0_156187683 %401 = OpConstantComposite %v3float %float_n0_00557464967 %float_0_0040607336 %float_1_01033914 %402 = OpConstantComposite %mat3v3float %400 %67 %401 %403 = OpConstantComposite %v3float %float_1_6410234 %float_n0_324803293 %float_n0_236424699 %404 = OpConstantComposite %v3float %float_n0_663662851 %float_1_61533165 %float_0_0167563483 %405 = OpConstantComposite %v3float %float_0_0117218941 %float_n0_00828444213 %float_0_988394856 %406 = OpConstantComposite %mat3v3float %403 %404 %405 %407 = OpConstantComposite %v3float %float_1_45143926 %float_n0_236510754 %float_n0_214928567 %408 = OpConstantComposite %v3float %float_n0_0765537769 %float_1_17622972 %float_n0_0996759236 %409 = OpConstantComposite %v3float %float_0_00831614807 %float_n0_00603244966 %float_0_997716308 %410 = OpConstantComposite %mat3v3float %407 %408 %409 %411 = OpConstantComposite %v3float %float_0_695452213 %float_0_140678704 %float_0_163869068 %412 = OpConstantComposite %v3float %float_0_0447945632 %float_0_859671116 %float_0_0955343172 %413 = OpConstantComposite %v3float %float_n0_00552588282 %float_0_00402521016 %float_1_00150073 %414 = OpConstantComposite %mat3v3float %411 %412 %413 %415 = OpConstantComposite %v3float %float_3_2409699 %float_n1_5373832 %float_n0_498610765 %416 = OpConstantComposite %v3float %float_n0_969243646 %float_1_8759675 %float_0_0415550582 %417 = OpConstantComposite %v3float %float_0_0556300804 %float_n0_203976959 %float_1_05697155 %418 = OpConstantComposite %mat3v3float %415 %416 %417 %419 = OpConstantComposite %v3float %float_0_412456393 %float_0_357576102 %float_0_180437505 %420 = OpConstantComposite %v3float %float_0_212672904 %float_0_715152204 %float_0_0721750036 %421 = OpConstantComposite %v3float %float_0_0193339009 %float_0_119191997 %float_0_950304091 %422 = OpConstantComposite %mat3v3float %419 %420 %421 %423 = OpConstantComposite %v3float %float_1_71660841 %float_n0_355662107 %float_n0_253360093 %424 = OpConstantComposite %v3float %float_n0_666682899 %float_1_61647761 %float_0_0157685 %425 = OpConstantComposite %v3float %float_0_0176422 %float_n0_0427763015 %float_0_942228675 %426 = OpConstantComposite %mat3v3float %423 %424 %425 %427 = OpConstantComposite %v3float %float_2_49339628 %float_n0_93134588 %float_n0_402694494 %428 = OpConstantComposite %v3float %float_n0_829486787 %float_1_76265967 %float_0_0236246008 %429 = OpConstantComposite %v3float %float_0_0358507 %float_n0_0761827007 %float_0_957014024 %430 = OpConstantComposite %mat3v3float %427 %428 %429 %431 = OpConstantComposite %v3float %float_1_01303005 %float_0_00610530982 %float_n0_0149710001 %432 = OpConstantComposite %v3float %float_0_00769822998 %float_0_998165011 %float_n0_00503202993 %433 = OpConstantComposite %v3float %float_n0_00284131011 %float_0_00468515977 %float_0_924507022 %434 = OpConstantComposite %mat3v3float %431 %432 %433 %435 = OpConstantComposite %v3float %float_0_987223983 %float_n0_00611326983 %float_0_0159533005 %436 = OpConstantComposite %v3float %float_n0_00759836007 %float_1_00186002 %float_0_0053300201 %437 = OpConstantComposite %v3float %float_0_00307257008 %float_n0_00509594986 %float_1_08168006 %438 = OpConstantComposite %mat3v3float %435 %436 %437 %439 = OpConstantComposite %v3float %float_0_5 %float_n1 %float_0_5 %440 = OpConstantComposite %v3float %float_n1 %float_1 %float_0_5 %441 = OpConstantComposite %v3float %float_0_5 %float_0 %float_0 %442 = OpConstantComposite %mat3v3float %439 %440 %441 %443 = OpConstantComposite %v3float %float_1 %float_0 %float_0 %444 = OpConstantComposite %v3float %float_0 %float_1 %float_0 %445 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %446 = OpConstantComposite %mat3v3float %443 %444 %445 %float_n6_07624626 = OpConstant %float -6.07624626 %448 = OpConstantComposite %v3float %float_n6_07624626 %float_n6_07624626 %float_n6_07624626 %449 = OpConstantComposite %v3float %float_0_895099998 %float_0_266400009 %float_n0_161400005 %450 = OpConstantComposite %v3float %float_n0_750199974 %float_1_71350002 %float_0_0366999991 %451 = OpConstantComposite %v3float %float_0_0388999991 %float_n0_0684999973 %float_1_02960002 %452 = OpConstantComposite %mat3v3float %449 %450 %451 %453 = OpConstantComposite %v3float %float_0_986992896 %float_n0_1470543 %float_0_159962699 %454 = OpConstantComposite %v3float %float_0_432305306 %float_0_518360317 %float_0_0492912009 %455 = OpConstantComposite %v3float %float_n0_0085287001 %float_0_040042799 %float_0_968486726 %456 = OpConstantComposite %mat3v3float %453 %454 %455 %float_0_358299971 = OpConstant %float 0.358299971 %458 = OpConstantComposite %v3float %float_0_544169128 %float_0_239592597 %float_0_166694298 %459 = OpConstantComposite %v3float %float_0_239465594 %float_0_702153027 %float_0_058381401 %460 = OpConstantComposite %v3float %float_n0_00234390004 %float_0_0361833982 %float_1_05521834 %461 = OpConstantComposite %mat3v3float %458 %459 %460 %462 = OpConstantComposite %v3float %float_0_940437257 %float_n0_0183068793 %float_0_077869609 %463 = OpConstantComposite %v3float %float_0_00837869663 %float_0_828660011 %float_0_162961304 %464 = OpConstantComposite %v3float %float_0_00054712611 %float_n0_000883374596 %float_1_00033629 %465 = OpConstantComposite %mat3v3float %462 %463 %464 %466 = OpConstantComposite %v3float %float_1_06317997 %float_0_0233955998 %float_n0_0865726024 %467 = OpConstantComposite %v3float %float_n0_0106336996 %float_1_20632005 %float_n0_195690006 %468 = OpConstantComposite %v3float %float_n0_000590886979 %float_0_00105247996 %float_0_999538004 %469 = OpConstantComposite %mat3v3float %466 %467 %468 %float_0_0533333346 = OpConstant %float 0.0533333346 %float_0_159999996 = OpConstant %float 0.159999996 %float_57_2957764 = OpConstant %float 57.2957764 %float_n67_5 = OpConstant %float -67.5 %float_67_5 = OpConstant %float 67.5 %475 = OpConstantComposite %_arr_float_uint_6 %float_n4 %float_n4 %float_n3_15737653 %float_n0_485249996 %float_1_84773242 %float_1_84773242 %476 = OpConstantComposite %_arr_float_uint_6 %float_n0_718548238 %float_2_08103061 %float_3_6681242 %float_4 %float_4 %float_4 %float_n15 = OpConstant %float -15 %float_n14 = OpConstant %float -14 %479 = OpConstantComposite %_arr_float_uint_10 %float_n4_97062206 %float_n3_02937818 %float_n2_12619996 %float_n1_51049995 %float_n1_05780005 %float_n0_466800004 %float_0_119379997 %float_0_708813429 %float_1_29118657 %float_1_29118657 %480 = OpConstantComposite %_arr_float_uint_10 %float_0_808913231 %float_1_19108677 %float_1_56830001 %float_1_9483 %float_2_30830002 %float_2_63840008 %float_2_85949993 %float_2_98726082 %float_3_01273918 %float_3_01273918 %float_n12 = OpConstant %float -12 %482 = OpConstantComposite %_arr_float_uint_10 %float_n2_30102992 %float_n2_30102992 %float_n1_93120003 %float_n1_52049994 %float_n1_05780005 %float_n0_466800004 %float_0_119379997 %float_0_708813429 %float_1_29118657 %float_1_29118657 %483 = OpConstantComposite %_arr_float_uint_10 %float_0_801995218 %float_1_19800484 %float_1_59430003 %float_1_99730003 %float_2_37829995 %float_2_76839995 %float_3_05150008 %float_3_27462935 %float_3_32743073 %float_3_32743073 %float_0_0322580636 = OpConstant %float 0.0322580636 %float_1_03225803 = OpConstant %float 1.03225803 %486 = OpConstantComposite %v2float %float_1_03225803 %float_1_03225803 %float_4_60443853e_09 = OpConstant %float 4.60443853e+09 %float_2_00528435e_09 = OpConstant %float 2.00528435e+09 %float_0_333333343 = OpConstant %float 0.333333343 %float_5 = OpConstant %float 5 %float_2_5 = OpConstant %float 2.5 %float_0_0250000004 = OpConstant %float 0.0250000004 %float_0_239999995 = OpConstant %float 0.239999995 %float_0_0148148146 = OpConstant %float 0.0148148146 %float_0_819999993 = OpConstant %float 0.819999993 %496 = OpConstantComposite %v3float %float_9_99999975en05 %float_9_99999975en05 %float_9_99999975en05 %float_0_0296296291 = OpConstant %float 0.0296296291 %float_0_952381015 = OpConstant %float 0.952381015 %499 = OpConstantComposite %v3float %float_0_952381015 %float_0_952381015 %float_0_952381015 %MainPS = OpFunction %void None %377 %500 = OpLabel %501 = OpVariable %_ptr_Function__arr_float_uint_6 Function %502 = OpVariable %_ptr_Function__arr_float_uint_6 Function %503 = OpVariable %_ptr_Function__arr_float_uint_6 Function %504 = OpVariable %_ptr_Function__arr_float_uint_6 Function %505 = OpVariable %_ptr_Function__arr_float_uint_6 Function %506 = OpVariable %_ptr_Function__arr_float_uint_6 Function %507 = OpVariable %_ptr_Function__arr_float_uint_10 Function %508 = OpVariable %_ptr_Function__arr_float_uint_10 Function %509 = OpVariable %_ptr_Function__arr_float_uint_10 Function %510 = OpVariable %_ptr_Function__arr_float_uint_10 Function %511 = OpVariable %_ptr_Function__arr_float_uint_10 Function %512 = OpVariable %_ptr_Function__arr_float_uint_10 Function %513 = OpVariable %_ptr_Function__arr_float_uint_6 Function %514 = OpVariable %_ptr_Function__arr_float_uint_6 Function %515 = OpVariable %_ptr_Function__arr_float_uint_6 Function %516 = OpVariable %_ptr_Function__arr_float_uint_6 Function %517 = OpVariable %_ptr_Function__arr_float_uint_6 Function %518 = OpVariable %_ptr_Function__arr_float_uint_6 Function %519 = OpVariable %_ptr_Function__arr_float_uint_6 Function %520 = OpVariable %_ptr_Function__arr_float_uint_6 Function %521 = OpVariable %_ptr_Function__arr_float_uint_6 Function %522 = OpVariable %_ptr_Function__arr_float_uint_6 Function %523 = OpVariable %_ptr_Function__arr_float_uint_6 Function %524 = OpVariable %_ptr_Function__arr_float_uint_6 Function %525 = OpVariable %_ptr_Function__arr_float_uint_10 Function %526 = OpVariable %_ptr_Function__arr_float_uint_10 Function %527 = OpVariable %_ptr_Function__arr_float_uint_10 Function %528 = OpVariable %_ptr_Function__arr_float_uint_10 Function %529 = OpVariable %_ptr_Function__arr_float_uint_10 Function %530 = OpVariable %_ptr_Function__arr_float_uint_10 Function %531 = OpVariable %_ptr_Function__arr_float_uint_6 Function %532 = OpVariable %_ptr_Function__arr_float_uint_6 Function %533 = OpVariable %_ptr_Function__arr_float_uint_6 Function %534 = OpVariable %_ptr_Function__arr_float_uint_6 Function %535 = OpVariable %_ptr_Function__arr_float_uint_6 Function %536 = OpVariable %_ptr_Function__arr_float_uint_6 Function %537 = OpLoad %v2float %in_var_TEXCOORD0 %538 = OpLoad %uint %gl_Layer %539 = OpFSub %v2float %537 %128 %540 = OpFMul %v2float %539 %486 %541 = OpCompositeExtract %float %540 0 %542 = OpCompositeExtract %float %540 1 %543 = OpConvertUToF %float %538 %544 = OpFMul %float %543 %float_0_0322580636 %545 = OpCompositeConstruct %v4float %541 %542 %544 %float_0 %546 = OpMatrixTimesMatrix %mat3v3float %422 %434 %547 = OpMatrixTimesMatrix %mat3v3float %546 %406 %548 = OpMatrixTimesMatrix %mat3v3float %402 %438 %549 = OpMatrixTimesMatrix %mat3v3float %548 %418 %550 = OpMatrixTimesMatrix %mat3v3float %395 %406 %551 = OpMatrixTimesMatrix %mat3v3float %402 %399 %552 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_42 %553 = OpLoad %uint %552 OpBranch %554 %554 = OpLabel OpLoopMerge %555 %556 None OpBranch %557 %557 = OpLabel %558 = OpMatrixTimesMatrix %mat3v3float %548 %430 %559 = OpMatrixTimesMatrix %mat3v3float %548 %426 %560 = OpIEqual %bool %553 %uint_1 OpSelectionMerge %561 None OpBranchConditional %560 %562 %563 %563 = OpLabel %564 = OpIEqual %bool %553 %uint_2 OpSelectionMerge %565 None OpBranchConditional %564 %566 %567 %567 = OpLabel %568 = OpIEqual %bool %553 %uint_3 OpSelectionMerge %569 None OpBranchConditional %568 %570 %571 %571 = OpLabel %572 = OpIEqual %bool %553 %uint_4 OpSelectionMerge %573 None OpBranchConditional %572 %574 %575 %575 = OpLabel OpBranch %555 %574 = OpLabel OpBranch %555 %573 = OpLabel OpUnreachable %570 = OpLabel OpBranch %555 %569 = OpLabel OpUnreachable %566 = OpLabel OpBranch %555 %565 = OpLabel OpUnreachable %562 = OpLabel OpBranch %555 %561 = OpLabel OpUnreachable %556 = OpLabel OpBranch %554 %555 = OpLabel %576 = OpPhi %mat3v3float %549 %575 %446 %574 %414 %570 %559 %566 %558 %562 %577 = OpVectorShuffle %v3float %545 %545 0 1 2 %578 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_41 %579 = OpLoad %uint %578 %580 = OpUGreaterThanEqual %bool %579 %uint_3 OpSelectionMerge %581 None OpBranchConditional %580 %582 %583 %583 = OpLabel %584 = OpFSub %v3float %577 %192 %585 = OpFMul %v3float %584 %193 %586 = OpExtInst %v3float %1 Exp2 %585 %587 = OpFMul %v3float %586 %194 %588 = OpExtInst %v3float %1 Exp2 %448 %589 = OpFMul %v3float %588 %194 %590 = OpFSub %v3float %587 %589 OpBranch %581 %582 = OpLabel %591 = OpExtInst %v3float %1 Pow %577 %182 %592 = OpFSub %v3float %591 %183 %593 = OpExtInst %v3float %1 FMax %132 %592 %594 = OpFMul %v3float %185 %591 %595 = OpFSub %v3float %184 %594 %596 = OpFDiv %v3float %593 %595 %597 = OpExtInst %v3float %1 Pow %596 %187 %598 = OpFMul %v3float %597 %188 OpBranch %581 %581 = OpLabel %599 = OpPhi %v3float %590 %583 %598 %582 %600 = OpAccessChain %_ptr_Uniform_float %_Globals %int_17 %601 = OpLoad %float %600 %602 = OpFMul %float %601 %float_1_00055635 %603 = OpFOrdLessThanEqual %bool %602 %float_7000 %604 = OpFDiv %float %float_4_60443853e_09 %601 %605 = OpFSub %float %float_2967800 %604 %606 = OpFDiv %float %605 %602 %607 = OpFAdd %float %float_99_1100006 %606 %608 = OpFDiv %float %607 %602 %609 = OpFAdd %float %float_0_244063005 %608 %610 = OpFDiv %float %float_2_00528435e_09 %601 %611 = OpFSub %float %float_1901800 %610 %612 = OpFDiv %float %611 %602 %613 = OpFAdd %float %float_247_479996 %612 %614 = OpFDiv %float %613 %602 %615 = OpFAdd %float %float_0_237039998 %614 %616 = OpSelect %float %603 %609 %615 %617 = OpFMul %float %float_n3 %616 %618 = OpFMul %float %617 %616 %619 = OpFMul %float %float_2_86999989 %616 %620 = OpFAdd %float %618 %619 %621 = OpFSub %float %620 %float_0_275000006 %622 = OpCompositeConstruct %v2float %616 %621 %623 = OpFMul %float %float_0_000154118257 %601 %624 = OpFAdd %float %float_0_860117733 %623 %625 = OpFMul %float %float_1_28641219en07 %601 %626 = OpFMul %float %625 %601 %627 = OpFAdd %float %624 %626 %628 = OpFMul %float %float_0_00084242021 %601 %629 = OpFAdd %float %float_1 %628 %630 = OpFMul %float %float_7_08145137en07 %601 %631 = OpFMul %float %630 %601 %632 = OpFAdd %float %629 %631 %633 = OpFDiv %float %627 %632 %634 = OpFMul %float %float_4_22806261en05 %601 %635 = OpFAdd %float %float_0_317398727 %634 %636 = OpFMul %float %float_4_20481676en08 %601 %637 = OpFMul %float %636 %601 %638 = OpFAdd %float %635 %637 %639 = OpFMul %float %float_2_8974182en05 %601 %640 = OpFSub %float %float_1 %639 %641 = OpFMul %float %float_1_61456057en07 %601 %642 = OpFMul %float %641 %601 %643 = OpFAdd %float %640 %642 %644 = OpFDiv %float %638 %643 %645 = OpFMul %float %float_3 %633 %646 = OpFMul %float %float_2 %633 %647 = OpFMul %float %float_8 %644 %648 = OpFSub %float %646 %647 %649 = OpFAdd %float %648 %float_4 %650 = OpFDiv %float %645 %649 %651 = OpFMul %float %float_2 %644 %652 = OpFDiv %float %651 %649 %653 = OpCompositeConstruct %v2float %650 %652 %654 = OpFOrdLessThan %bool %601 %float_4000 %655 = OpCompositeConstruct %v2bool %654 %654 %656 = OpSelect %v2float %655 %653 %622 %657 = OpAccessChain %_ptr_Uniform_float %_Globals %int_18 %658 = OpLoad %float %657 %659 = OpCompositeConstruct %v2float %633 %644 %660 = OpExtInst %v2float %1 Normalize %659 %661 = OpCompositeExtract %float %660 1 %662 = OpFNegate %float %661 %663 = OpFMul %float %662 %658 %664 = OpFMul %float %663 %float_0_0500000007 %665 = OpFAdd %float %633 %664 %666 = OpCompositeExtract %float %660 0 %667 = OpFMul %float %666 %658 %668 = OpFMul %float %667 %float_0_0500000007 %669 = OpFAdd %float %644 %668 %670 = OpFMul %float %float_3 %665 %671 = OpFMul %float %float_2 %665 %672 = OpFMul %float %float_8 %669 %673 = OpFSub %float %671 %672 %674 = OpFAdd %float %673 %float_4 %675 = OpFDiv %float %670 %674 %676 = OpFMul %float %float_2 %669 %677 = OpFDiv %float %676 %674 %678 = OpCompositeConstruct %v2float %675 %677 %679 = OpFSub %v2float %678 %653 %680 = OpFAdd %v2float %656 %679 %681 = OpCompositeExtract %float %680 0 %682 = OpCompositeExtract %float %680 1 %683 = OpExtInst %float %1 FMax %682 %float_1_00000001en10 %684 = OpFDiv %float %681 %683 %685 = OpCompositeInsert %v3float %684 %391 0 %686 = OpCompositeInsert %v3float %float_1 %685 1 %687 = OpFSub %float %float_1 %681 %688 = OpFSub %float %687 %682 %689 = OpFDiv %float %688 %683 %690 = OpCompositeInsert %v3float %689 %686 2 %691 = OpExtInst %float %1 FMax %float_0_328999996 %float_1_00000001en10 %692 = OpFDiv %float %float_0_312700003 %691 %693 = OpCompositeInsert %v3float %692 %391 0 %694 = OpCompositeInsert %v3float %float_1 %693 1 %695 = OpFDiv %float %float_0_358299971 %691 %696 = OpCompositeInsert %v3float %695 %694 2 %697 = OpVectorTimesMatrix %v3float %690 %452 %698 = OpVectorTimesMatrix %v3float %696 %452 %699 = OpCompositeExtract %float %698 0 %700 = OpCompositeExtract %float %697 0 %701 = OpFDiv %float %699 %700 %702 = OpCompositeConstruct %v3float %701 %float_0 %float_0 %703 = OpCompositeExtract %float %698 1 %704 = OpCompositeExtract %float %697 1 %705 = OpFDiv %float %703 %704 %706 = OpCompositeConstruct %v3float %float_0 %705 %float_0 %707 = OpCompositeExtract %float %698 2 %708 = OpCompositeExtract %float %697 2 %709 = OpFDiv %float %707 %708 %710 = OpCompositeConstruct %v3float %float_0 %float_0 %709 %711 = OpCompositeConstruct %mat3v3float %702 %706 %710 %712 = OpMatrixTimesMatrix %mat3v3float %452 %711 %713 = OpMatrixTimesMatrix %mat3v3float %712 %456 %714 = OpMatrixTimesMatrix %mat3v3float %422 %713 %715 = OpMatrixTimesMatrix %mat3v3float %714 %418 %716 = OpVectorTimesMatrix %v3float %599 %715 %717 = OpVectorTimesMatrix %v3float %716 %547 %718 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_9 %719 = OpAccessChain %_ptr_Uniform_float %_Globals %int_9 %int_3 %720 = OpLoad %float %719 %721 = OpFOrdNotEqual %bool %720 %float_0 OpSelectionMerge %722 None OpBranchConditional %721 %723 %722 %723 = OpLabel %724 = OpDot %float %717 %67 %725 = OpCompositeConstruct %v3float %724 %724 %724 %726 = OpFDiv %v3float %717 %725 %727 = OpFSub %v3float %726 %135 %728 = OpDot %float %727 %727 %729 = OpFMul %float %float_n4 %728 %730 = OpExtInst %float %1 Exp2 %729 %731 = OpFSub %float %float_1 %730 %732 = OpAccessChain %_ptr_Uniform_float %_Globals %int_44 %733 = OpLoad %float %732 %734 = OpFMul %float %float_n4 %733 %735 = OpFMul %float %734 %724 %736 = OpFMul %float %735 %724 %737 = OpExtInst %float %1 Exp2 %736 %738 = OpFSub %float %float_1 %737 %739 = OpFMul %float %731 %738 %740 = OpMatrixTimesMatrix %mat3v3float %461 %406 %741 = OpMatrixTimesMatrix %mat3v3float %549 %740 %742 = OpVectorTimesMatrix %v3float %717 %741 %743 = OpCompositeConstruct %v3float %739 %739 %739 %744 = OpExtInst %v3float %1 FMix %717 %742 %743 OpBranch %722 %722 = OpLabel %745 = OpPhi %v3float %717 %581 %744 %723 %746 = OpDot %float %745 %67 %747 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_24 %748 = OpLoad %v4float %747 %749 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_19 %750 = OpLoad %v4float %749 %751 = OpFMul %v4float %748 %750 %752 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_25 %753 = OpLoad %v4float %752 %754 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_20 %755 = OpLoad %v4float %754 %756 = OpFMul %v4float %753 %755 %757 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_26 %758 = OpLoad %v4float %757 %759 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_21 %760 = OpLoad %v4float %759 %761 = OpFMul %v4float %758 %760 %762 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_27 %763 = OpLoad %v4float %762 %764 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_22 %765 = OpLoad %v4float %764 %766 = OpFMul %v4float %763 %765 %767 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_28 %768 = OpLoad %v4float %767 %769 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_23 %770 = OpLoad %v4float %769 %771 = OpFAdd %v4float %768 %770 %772 = OpCompositeConstruct %v3float %746 %746 %746 %773 = OpVectorShuffle %v3float %751 %751 0 1 2 %774 = OpCompositeExtract %float %751 3 %775 = OpCompositeConstruct %v3float %774 %774 %774 %776 = OpFMul %v3float %773 %775 %777 = OpExtInst %v3float %1 FMix %772 %745 %776 %778 = OpExtInst %v3float %1 FMax %132 %777 %779 = OpFMul %v3float %778 %307 %780 = OpVectorShuffle %v3float %756 %756 0 1 2 %781 = OpCompositeExtract %float %756 3 %782 = OpCompositeConstruct %v3float %781 %781 %781 %783 = OpFMul %v3float %780 %782 %784 = OpExtInst %v3float %1 Pow %779 %783 %785 = OpFMul %v3float %784 %194 %786 = OpVectorShuffle %v3float %761 %761 0 1 2 %787 = OpCompositeExtract %float %761 3 %788 = OpCompositeConstruct %v3float %787 %787 %787 %789 = OpFMul %v3float %786 %788 %790 = OpFDiv %v3float %135 %789 %791 = OpExtInst %v3float %1 Pow %785 %790 %792 = OpVectorShuffle %v3float %766 %766 0 1 2 %793 = OpCompositeExtract %float %766 3 %794 = OpCompositeConstruct %v3float %793 %793 %793 %795 = OpFMul %v3float %792 %794 %796 = OpFMul %v3float %791 %795 %797 = OpVectorShuffle %v3float %771 %771 0 1 2 %798 = OpCompositeExtract %float %771 3 %799 = OpCompositeConstruct %v3float %798 %798 %798 %800 = OpFAdd %v3float %797 %799 %801 = OpFAdd %v3float %796 %800 %802 = OpAccessChain %_ptr_Uniform_float %_Globals %int_39 %803 = OpLoad %float %802 %804 = OpExtInst %float %1 SmoothStep %float_0 %803 %746 %805 = OpFSub %float %float_1 %804 %806 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_34 %807 = OpLoad %v4float %806 %808 = OpFMul %v4float %807 %750 %809 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_35 %810 = OpLoad %v4float %809 %811 = OpFMul %v4float %810 %755 %812 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_36 %813 = OpLoad %v4float %812 %814 = OpFMul %v4float %813 %760 %815 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_37 %816 = OpLoad %v4float %815 %817 = OpFMul %v4float %816 %765 %818 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_38 %819 = OpLoad %v4float %818 %820 = OpFAdd %v4float %819 %770 %821 = OpVectorShuffle %v3float %808 %808 0 1 2 %822 = OpCompositeExtract %float %808 3 %823 = OpCompositeConstruct %v3float %822 %822 %822 %824 = OpFMul %v3float %821 %823 %825 = OpExtInst %v3float %1 FMix %772 %745 %824 %826 = OpExtInst %v3float %1 FMax %132 %825 %827 = OpFMul %v3float %826 %307 %828 = OpVectorShuffle %v3float %811 %811 0 1 2 %829 = OpCompositeExtract %float %811 3 %830 = OpCompositeConstruct %v3float %829 %829 %829 %831 = OpFMul %v3float %828 %830 %832 = OpExtInst %v3float %1 Pow %827 %831 %833 = OpFMul %v3float %832 %194 %834 = OpVectorShuffle %v3float %814 %814 0 1 2 %835 = OpCompositeExtract %float %814 3 %836 = OpCompositeConstruct %v3float %835 %835 %835 %837 = OpFMul %v3float %834 %836 %838 = OpFDiv %v3float %135 %837 %839 = OpExtInst %v3float %1 Pow %833 %838 %840 = OpVectorShuffle %v3float %817 %817 0 1 2 %841 = OpCompositeExtract %float %817 3 %842 = OpCompositeConstruct %v3float %841 %841 %841 %843 = OpFMul %v3float %840 %842 %844 = OpFMul %v3float %839 %843 %845 = OpVectorShuffle %v3float %820 %820 0 1 2 %846 = OpCompositeExtract %float %820 3 %847 = OpCompositeConstruct %v3float %846 %846 %846 %848 = OpFAdd %v3float %845 %847 %849 = OpFAdd %v3float %844 %848 %850 = OpAccessChain %_ptr_Uniform_float %_Globals %int_40 %851 = OpLoad %float %850 %852 = OpExtInst %float %1 SmoothStep %851 %float_1 %746 %853 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_29 %854 = OpLoad %v4float %853 %855 = OpFMul %v4float %854 %750 %856 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_30 %857 = OpLoad %v4float %856 %858 = OpFMul %v4float %857 %755 %859 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_31 %860 = OpLoad %v4float %859 %861 = OpFMul %v4float %860 %760 %862 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_32 %863 = OpLoad %v4float %862 %864 = OpFMul %v4float %863 %765 %865 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_33 %866 = OpLoad %v4float %865 %867 = OpFAdd %v4float %866 %770 %868 = OpVectorShuffle %v3float %855 %855 0 1 2 %869 = OpCompositeExtract %float %855 3 %870 = OpCompositeConstruct %v3float %869 %869 %869 %871 = OpFMul %v3float %868 %870 %872 = OpExtInst %v3float %1 FMix %772 %745 %871 %873 = OpExtInst %v3float %1 FMax %132 %872 %874 = OpFMul %v3float %873 %307 %875 = OpVectorShuffle %v3float %858 %858 0 1 2 %876 = OpCompositeExtract %float %858 3 %877 = OpCompositeConstruct %v3float %876 %876 %876 %878 = OpFMul %v3float %875 %877 %879 = OpExtInst %v3float %1 Pow %874 %878 %880 = OpFMul %v3float %879 %194 %881 = OpVectorShuffle %v3float %861 %861 0 1 2 %882 = OpCompositeExtract %float %861 3 %883 = OpCompositeConstruct %v3float %882 %882 %882 %884 = OpFMul %v3float %881 %883 %885 = OpFDiv %v3float %135 %884 %886 = OpExtInst %v3float %1 Pow %880 %885 %887 = OpVectorShuffle %v3float %864 %864 0 1 2 %888 = OpCompositeExtract %float %864 3 %889 = OpCompositeConstruct %v3float %888 %888 %888 %890 = OpFMul %v3float %887 %889 %891 = OpFMul %v3float %886 %890 %892 = OpVectorShuffle %v3float %867 %867 0 1 2 %893 = OpCompositeExtract %float %867 3 %894 = OpCompositeConstruct %v3float %893 %893 %893 %895 = OpFAdd %v3float %892 %894 %896 = OpFAdd %v3float %891 %895 %897 = OpFSub %float %804 %852 %898 = OpCompositeConstruct %v3float %805 %805 %805 %899 = OpFMul %v3float %801 %898 %900 = OpCompositeConstruct %v3float %897 %897 %897 %901 = OpFMul %v3float %896 %900 %902 = OpFAdd %v3float %899 %901 %903 = OpCompositeConstruct %v3float %852 %852 %852 %904 = OpFMul %v3float %849 %903 %905 = OpFAdd %v3float %902 %904 %906 = OpVectorTimesMatrix %v3float %905 %549 %907 = OpMatrixTimesMatrix %mat3v3float %551 %465 %908 = OpMatrixTimesMatrix %mat3v3float %907 %550 %909 = OpMatrixTimesMatrix %mat3v3float %551 %469 %910 = OpMatrixTimesMatrix %mat3v3float %909 %550 %911 = OpVectorTimesMatrix %v3float %905 %908 %912 = OpAccessChain %_ptr_Uniform_float %_Globals %int_43 %913 = OpLoad %float %912 %914 = OpCompositeConstruct %v3float %913 %913 %913 %915 = OpExtInst %v3float %1 FMix %905 %911 %914 %916 = OpVectorTimesMatrix %v3float %915 %551 %917 = OpCompositeExtract %float %916 0 %918 = OpCompositeExtract %float %916 1 %919 = OpExtInst %float %1 FMin %917 %918 %920 = OpCompositeExtract %float %916 2 %921 = OpExtInst %float %1 FMin %919 %920 %922 = OpExtInst %float %1 FMax %917 %918 %923 = OpExtInst %float %1 FMax %922 %920 %924 = OpExtInst %float %1 FMax %923 %float_1_00000001en10 %925 = OpExtInst %float %1 FMax %921 %float_1_00000001en10 %926 = OpFSub %float %924 %925 %927 = OpExtInst %float %1 FMax %923 %float_0_00999999978 %928 = OpFDiv %float %926 %927 %929 = OpFSub %float %920 %918 %930 = OpFMul %float %920 %929 %931 = OpFSub %float %918 %917 %932 = OpFMul %float %918 %931 %933 = OpFAdd %float %930 %932 %934 = OpFSub %float %917 %920 %935 = OpFMul %float %917 %934 %936 = OpFAdd %float %933 %935 %937 = OpExtInst %float %1 Sqrt %936 %938 = OpFAdd %float %920 %918 %939 = OpFAdd %float %938 %917 %940 = OpFMul %float %float_1_75 %937 %941 = OpFAdd %float %939 %940 %942 = OpFMul %float %941 %float_0_333333343 %943 = OpFSub %float %928 %float_0_400000006 %944 = OpFMul %float %943 %float_5 %945 = OpFMul %float %943 %float_2_5 %946 = OpExtInst %float %1 FAbs %945 %947 = OpFSub %float %float_1 %946 %948 = OpExtInst %float %1 FMax %947 %float_0 %949 = OpExtInst %float %1 FSign %944 %950 = OpConvertFToS %int %949 %951 = OpConvertSToF %float %950 %952 = OpFMul %float %948 %948 %953 = OpFSub %float %float_1 %952 %954 = OpFMul %float %951 %953 %955 = OpFAdd %float %float_1 %954 %956 = OpFMul %float %955 %float_0_0250000004 %957 = OpFOrdLessThanEqual %bool %942 %float_0_0533333346 OpSelectionMerge %958 None OpBranchConditional %957 %959 %960 %960 = OpLabel %961 = OpFOrdGreaterThanEqual %bool %942 %float_0_159999996 OpSelectionMerge %962 None OpBranchConditional %961 %963 %964 %964 = OpLabel %965 = OpFDiv %float %float_0_239999995 %941 %966 = OpFSub %float %965 %float_0_5 %967 = OpFMul %float %956 %966 OpBranch %962 %963 = OpLabel OpBranch %962 %962 = OpLabel %968 = OpPhi %float %967 %964 %float_0 %963 OpBranch %958 %959 = OpLabel OpBranch %958 %958 = OpLabel %969 = OpPhi %float %968 %962 %956 %959 %970 = OpFAdd %float %float_1 %969 %971 = OpCompositeConstruct %v3float %970 %970 %970 %972 = OpFMul %v3float %916 %971 %973 = OpCompositeExtract %float %972 0 %974 = OpCompositeExtract %float %972 1 %975 = OpFOrdEqual %bool %973 %974 %976 = OpCompositeExtract %float %972 2 %977 = OpFOrdEqual %bool %974 %976 %978 = OpLogicalAnd %bool %975 %977 OpSelectionMerge %979 None OpBranchConditional %978 %980 %981 %981 = OpLabel %982 = OpExtInst %float %1 Sqrt %float_3 %983 = OpFSub %float %974 %976 %984 = OpFMul %float %982 %983 %985 = OpFMul %float %float_2 %973 %986 = OpFSub %float %985 %974 %987 = OpFSub %float %986 %976 %988 = OpExtInst %float %1 Atan2 %984 %987 %989 = OpFMul %float %float_57_2957764 %988 OpBranch %979 %980 = OpLabel OpBranch %979 %979 = OpLabel %990 = OpPhi %float %989 %981 %float_0 %980 %991 = OpFOrdLessThan %bool %990 %float_0 OpSelectionMerge %992 None OpBranchConditional %991 %993 %992 %993 = OpLabel %994 = OpFAdd %float %990 %float_360 OpBranch %992 %992 = OpLabel %995 = OpPhi %float %990 %979 %994 %993 %996 = OpExtInst %float %1 FClamp %995 %float_0 %float_360 %997 = OpFOrdGreaterThan %bool %996 %float_180 OpSelectionMerge %998 None OpBranchConditional %997 %999 %998 %999 = OpLabel %1000 = OpFSub %float %996 %float_360 OpBranch %998 %998 = OpLabel %1001 = OpPhi %float %996 %992 %1000 %999 %1002 = OpFMul %float %1001 %float_0_0148148146 %1003 = OpExtInst %float %1 FAbs %1002 %1004 = OpFSub %float %float_1 %1003 %1005 = OpExtInst %float %1 SmoothStep %float_0 %float_1 %1004 %1006 = OpFMul %float %1005 %1005 %1007 = OpFMul %float %1006 %928 %1008 = OpFSub %float %float_0_0299999993 %973 %1009 = OpFMul %float %1007 %1008 %1010 = OpFMul %float %1009 %float_0_180000007 %1011 = OpFAdd %float %973 %1010 %1012 = OpCompositeInsert %v3float %1011 %972 0 %1013 = OpVectorTimesMatrix %v3float %1012 %410 %1014 = OpExtInst %v3float %1 FMax %132 %1013 %1015 = OpDot %float %1014 %67 %1016 = OpCompositeConstruct %v3float %1015 %1015 %1015 %1017 = OpExtInst %v3float %1 FMix %1016 %1014 %228 %1018 = OpAccessChain %_ptr_Uniform_float %_Globals %int_13 %1019 = OpLoad %float %1018 %1020 = OpFAdd %float %float_1 %1019 %1021 = OpAccessChain %_ptr_Uniform_float %_Globals %int_11 %1022 = OpLoad %float %1021 %1023 = OpFSub %float %1020 %1022 %1024 = OpAccessChain %_ptr_Uniform_float %_Globals %int_14 %1025 = OpLoad %float %1024 %1026 = OpFAdd %float %float_1 %1025 %1027 = OpAccessChain %_ptr_Uniform_float %_Globals %int_12 %1028 = OpLoad %float %1027 %1029 = OpFSub %float %1026 %1028 %1030 = OpFOrdGreaterThan %bool %1022 %float_0_800000012 OpSelectionMerge %1031 None OpBranchConditional %1030 %1032 %1033 %1033 = OpLabel %1034 = OpFAdd %float %float_0_180000007 %1019 %1035 = OpFDiv %float %1034 %1023 %1036 = OpExtInst %float %1 Log %float_0_180000007 %1037 = OpExtInst %float %1 Log %float_10 %1038 = OpFDiv %float %1036 %1037 %1039 = OpFSub %float %float_2 %1035 %1040 = OpFDiv %float %1035 %1039 %1041 = OpExtInst %float %1 Log %1040 %1042 = OpFMul %float %float_0_5 %1041 %1043 = OpAccessChain %_ptr_Uniform_float %_Globals %int_10 %1044 = OpLoad %float %1043 %1045 = OpFDiv %float %1023 %1044 %1046 = OpFMul %float %1042 %1045 %1047 = OpFSub %float %1038 %1046 OpBranch %1031 %1032 = OpLabel %1048 = OpFSub %float %float_0_819999993 %1022 %1049 = OpAccessChain %_ptr_Uniform_float %_Globals %int_10 %1050 = OpLoad %float %1049 %1051 = OpFDiv %float %1048 %1050 %1052 = OpExtInst %float %1 Log %float_0_180000007 %1053 = OpExtInst %float %1 Log %float_10 %1054 = OpFDiv %float %1052 %1053 %1055 = OpFAdd %float %1051 %1054 OpBranch %1031 %1031 = OpLabel %1056 = OpPhi %float %1047 %1033 %1055 %1032 %1057 = OpFSub %float %float_1 %1022 %1058 = OpAccessChain %_ptr_Uniform_float %_Globals %int_10 %1059 = OpLoad %float %1058 %1060 = OpFDiv %float %1057 %1059 %1061 = OpFSub %float %1060 %1056 %1062 = OpFDiv %float %1028 %1059 %1063 = OpFSub %float %1062 %1061 %1064 = OpExtInst %v3float %1 Log %1017 %1065 = OpExtInst %float %1 Log %float_10 %1066 = OpCompositeConstruct %v3float %1065 %1065 %1065 %1067 = OpFDiv %v3float %1064 %1066 %1068 = OpCompositeConstruct %v3float %1059 %1059 %1059 %1069 = OpCompositeConstruct %v3float %1061 %1061 %1061 %1070 = OpFAdd %v3float %1067 %1069 %1071 = OpFMul %v3float %1068 %1070 %1072 = OpFNegate %float %1019 %1073 = OpCompositeConstruct %v3float %1072 %1072 %1072 %1074 = OpFMul %float %float_2 %1023 %1075 = OpCompositeConstruct %v3float %1074 %1074 %1074 %1076 = OpFMul %float %float_n2 %1059 %1077 = OpFDiv %float %1076 %1023 %1078 = OpCompositeConstruct %v3float %1077 %1077 %1077 %1079 = OpCompositeConstruct %v3float %1056 %1056 %1056 %1080 = OpFSub %v3float %1067 %1079 %1081 = OpFMul %v3float %1078 %1080 %1082 = OpExtInst %v3float %1 Exp %1081 %1083 = OpFAdd %v3float %135 %1082 %1084 = OpFDiv %v3float %1075 %1083 %1085 = OpFAdd %v3float %1073 %1084 %1086 = OpCompositeConstruct %v3float %1026 %1026 %1026 %1087 = OpFMul %float %float_2 %1029 %1088 = OpCompositeConstruct %v3float %1087 %1087 %1087 %1089 = OpFMul %float %float_2 %1059 %1090 = OpFDiv %float %1089 %1029 %1091 = OpCompositeConstruct %v3float %1090 %1090 %1090 %1092 = OpCompositeConstruct %v3float %1063 %1063 %1063 %1093 = OpFSub %v3float %1067 %1092 %1094 = OpFMul %v3float %1091 %1093 %1095 = OpExtInst %v3float %1 Exp %1094 %1096 = OpFAdd %v3float %135 %1095 %1097 = OpFDiv %v3float %1088 %1096 %1098 = OpFSub %v3float %1086 %1097 %1099 = OpFOrdLessThan %v3bool %1067 %1079 %1100 = OpSelect %v3float %1099 %1085 %1071 %1101 = OpFOrdGreaterThan %v3bool %1067 %1092 %1102 = OpSelect %v3float %1101 %1098 %1071 %1103 = OpFSub %float %1063 %1056 %1104 = OpCompositeConstruct %v3float %1103 %1103 %1103 %1105 = OpFDiv %v3float %1080 %1104 %1106 = OpExtInst %v3float %1 FClamp %1105 %132 %135 %1107 = OpFOrdLessThan %bool %1063 %1056 %1108 = OpFSub %v3float %135 %1106 %1109 = OpCompositeConstruct %v3bool %1107 %1107 %1107 %1110 = OpSelect %v3float %1109 %1108 %1106 %1111 = OpFMul %v3float %239 %1110 %1112 = OpFSub %v3float %238 %1111 %1113 = OpFMul %v3float %1112 %1110 %1114 = OpFMul %v3float %1113 %1110 %1115 = OpExtInst %v3float %1 FMix %1100 %1102 %1114 %1116 = OpDot %float %1115 %67 %1117 = OpCompositeConstruct %v3float %1116 %1116 %1116 %1118 = OpExtInst %v3float %1 FMix %1117 %1115 %241 %1119 = OpExtInst %v3float %1 FMax %132 %1118 %1120 = OpVectorTimesMatrix %v3float %1119 %910 %1121 = OpExtInst %v3float %1 FMix %1119 %1120 %914 %1122 = OpVectorTimesMatrix %v3float %1121 %549 %1123 = OpExtInst %v3float %1 FMax %132 %1122 %1124 = OpFOrdEqual %bool %720 %float_0 OpSelectionMerge %1125 DontFlatten OpBranchConditional %1124 %1126 %1125 %1126 = OpLabel %1127 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_2 %1128 = OpLoad %v4float %1127 %1129 = OpVectorShuffle %v3float %1128 %1128 0 1 2 %1130 = OpDot %float %906 %1129 %1131 = OpCompositeInsert %v3float %1130 %391 0 %1132 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_3 %1133 = OpLoad %v4float %1132 %1134 = OpVectorShuffle %v3float %1133 %1133 0 1 2 %1135 = OpDot %float %906 %1134 %1136 = OpCompositeInsert %v3float %1135 %1131 1 %1137 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_4 %1138 = OpLoad %v4float %1137 %1139 = OpVectorShuffle %v3float %1138 %1138 0 1 2 %1140 = OpDot %float %906 %1139 %1141 = OpCompositeInsert %v3float %1140 %1136 2 %1142 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_8 %1143 = OpLoad %v4float %1142 %1144 = OpVectorShuffle %v3float %1143 %1143 0 1 2 %1145 = OpLoad %v4float %718 %1146 = OpVectorShuffle %v3float %1145 %1145 0 1 2 %1147 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_7 %1148 = OpLoad %v4float %1147 %1149 = OpVectorShuffle %v3float %1148 %1148 0 1 2 %1150 = OpDot %float %906 %1149 %1151 = OpFAdd %float %1150 %float_1 %1152 = OpFDiv %float %float_1 %1151 %1153 = OpCompositeConstruct %v3float %1152 %1152 %1152 %1154 = OpFMul %v3float %1146 %1153 %1155 = OpFAdd %v3float %1144 %1154 %1156 = OpFMul %v3float %1141 %1155 %1157 = OpExtInst %v3float %1 FMax %132 %1156 %1158 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_5 %1159 = OpLoad %v4float %1158 %1160 = OpVectorShuffle %v3float %1159 %1159 0 0 0 %1161 = OpFSub %v3float %1160 %1157 %1162 = OpExtInst %v3float %1 FMax %132 %1161 %1163 = OpVectorShuffle %v3float %1159 %1159 2 2 2 %1164 = OpExtInst %v3float %1 FMax %1157 %1163 %1165 = OpExtInst %v3float %1 FClamp %1157 %1160 %1163 %1166 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_6 %1167 = OpLoad %v4float %1166 %1168 = OpVectorShuffle %v3float %1167 %1167 0 0 0 %1169 = OpFMul %v3float %1164 %1168 %1170 = OpVectorShuffle %v3float %1167 %1167 1 1 1 %1171 = OpFAdd %v3float %1169 %1170 %1172 = OpVectorShuffle %v3float %1159 %1159 3 3 3 %1173 = OpFAdd %v3float %1164 %1172 %1174 = OpFDiv %v3float %135 %1173 %1175 = OpFMul %v3float %1171 %1174 %1176 = OpVectorShuffle %v3float %1138 %1138 3 3 3 %1177 = OpFMul %v3float %1165 %1176 %1178 = OpVectorShuffle %v3float %1128 %1128 3 3 3 %1179 = OpFMul %v3float %1162 %1178 %1180 = OpVectorShuffle %v3float %1159 %1159 1 1 1 %1181 = OpFAdd %v3float %1162 %1180 %1182 = OpFDiv %v3float %135 %1181 %1183 = OpFMul %v3float %1179 %1182 %1184 = OpVectorShuffle %v3float %1133 %1133 3 3 3 %1185 = OpFAdd %v3float %1183 %1184 %1186 = OpFAdd %v3float %1177 %1185 %1187 = OpFAdd %v3float %1175 %1186 %1188 = OpFSub %v3float %1187 %248 OpBranch %1125 %1125 = OpLabel %1189 = OpPhi %v3float %1123 %1031 %1188 %1126 %1190 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_0 %1191 = OpLoad %float %1190 %1192 = OpCompositeConstruct %v3float %1191 %1191 %1191 %1193 = OpFMul %v3float %1189 %1189 %1194 = OpFMul %v3float %1192 %1193 %1195 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_1 %1196 = OpLoad %float %1195 %1197 = OpCompositeConstruct %v3float %1196 %1196 %1196 %1198 = OpFMul %v3float %1197 %1189 %1199 = OpFAdd %v3float %1194 %1198 %1200 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_2 %1201 = OpLoad %float %1200 %1202 = OpCompositeConstruct %v3float %1201 %1201 %1201 %1203 = OpFAdd %v3float %1199 %1202 %1204 = OpAccessChain %_ptr_Uniform_v3float %_Globals %int_15 %1205 = OpLoad %v3float %1204 %1206 = OpFMul %v3float %1203 %1205 %1207 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_16 %1208 = OpLoad %v4float %1207 %1209 = OpVectorShuffle %v3float %1208 %1208 0 1 2 %1210 = OpAccessChain %_ptr_Uniform_float %_Globals %int_16 %int_3 %1211 = OpLoad %float %1210 %1212 = OpCompositeConstruct %v3float %1211 %1211 %1211 %1213 = OpExtInst %v3float %1 FMix %1206 %1209 %1212 %1214 = OpExtInst %v3float %1 FMax %132 %1213 %1215 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %int_1 %1216 = OpLoad %float %1215 %1217 = OpCompositeConstruct %v3float %1216 %1216 %1216 %1218 = OpExtInst %v3float %1 Pow %1214 %1217 %1219 = OpIEqual %bool %579 %uint_0 OpSelectionMerge %1220 DontFlatten OpBranchConditional %1219 %1221 %1222 %1222 = OpLabel %1223 = OpIEqual %bool %579 %uint_1 OpSelectionMerge %1224 None OpBranchConditional %1223 %1225 %1226 %1226 = OpLabel %1227 = OpIEqual %bool %579 %uint_3 %1228 = OpIEqual %bool %579 %uint_5 %1229 = OpLogicalOr %bool %1227 %1228 OpSelectionMerge %1230 None OpBranchConditional %1229 %1231 %1232 %1232 = OpLabel %1233 = OpIEqual %bool %579 %uint_4 %1234 = OpIEqual %bool %579 %uint_6 %1235 = OpLogicalOr %bool %1233 %1234 OpSelectionMerge %1236 None OpBranchConditional %1235 %1237 %1238 %1238 = OpLabel %1239 = OpIEqual %bool %579 %uint_7 OpSelectionMerge %1240 None OpBranchConditional %1239 %1241 %1242 %1242 = OpLabel %1243 = OpVectorTimesMatrix %v3float %1218 %547 %1244 = OpVectorTimesMatrix %v3float %1243 %576 %1245 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %int_2 %1246 = OpLoad %float %1245 %1247 = OpCompositeConstruct %v3float %1246 %1246 %1246 %1248 = OpExtInst %v3float %1 Pow %1244 %1247 OpBranch %1240 %1241 = OpLabel %1249 = OpVectorTimesMatrix %v3float %906 %547 %1250 = OpVectorTimesMatrix %v3float %1249 %576 %1251 = OpFMul %v3float %1250 %496 %1252 = OpExtInst %v3float %1 Pow %1251 %263 %1253 = OpFMul %v3float %184 %1252 %1254 = OpFAdd %v3float %183 %1253 %1255 = OpFMul %v3float %185 %1252 %1256 = OpFAdd %v3float %135 %1255 %1257 = OpFDiv %v3float %135 %1256 %1258 = OpFMul %v3float %1254 %1257 %1259 = OpExtInst %v3float %1 Pow %1258 %264 OpBranch %1240 %1240 = OpLabel %1260 = OpPhi %v3float %1248 %1242 %1259 %1241 OpBranch %1236 %1237 = OpLabel %1261 = OpMatrixTimesMatrix %mat3v3float %546 %399 %1262 = OpFMul %v3float %906 %262 %1263 = OpVectorTimesMatrix %v3float %1262 %1261 %1264 = OpCompositeExtract %float %1263 0 %1265 = OpCompositeExtract %float %1263 1 %1266 = OpExtInst %float %1 FMin %1264 %1265 %1267 = OpCompositeExtract %float %1263 2 %1268 = OpExtInst %float %1 FMin %1266 %1267 %1269 = OpExtInst %float %1 FMax %1264 %1265 %1270 = OpExtInst %float %1 FMax %1269 %1267 %1271 = OpExtInst %float %1 FMax %1270 %float_1_00000001en10 %1272 = OpExtInst %float %1 FMax %1268 %float_1_00000001en10 %1273 = OpFSub %float %1271 %1272 %1274 = OpExtInst %float %1 FMax %1270 %float_0_00999999978 %1275 = OpFDiv %float %1273 %1274 %1276 = OpFSub %float %1267 %1265 %1277 = OpFMul %float %1267 %1276 %1278 = OpFSub %float %1265 %1264 %1279 = OpFMul %float %1265 %1278 %1280 = OpFAdd %float %1277 %1279 %1281 = OpFSub %float %1264 %1267 %1282 = OpFMul %float %1264 %1281 %1283 = OpFAdd %float %1280 %1282 %1284 = OpExtInst %float %1 Sqrt %1283 %1285 = OpFAdd %float %1267 %1265 %1286 = OpFAdd %float %1285 %1264 %1287 = OpFMul %float %float_1_75 %1284 %1288 = OpFAdd %float %1286 %1287 %1289 = OpFMul %float %1288 %float_0_333333343 %1290 = OpFSub %float %1275 %float_0_400000006 %1291 = OpFMul %float %1290 %float_5 %1292 = OpFMul %float %1290 %float_2_5 %1293 = OpExtInst %float %1 FAbs %1292 %1294 = OpFSub %float %float_1 %1293 %1295 = OpExtInst %float %1 FMax %1294 %float_0 %1296 = OpExtInst %float %1 FSign %1291 %1297 = OpConvertFToS %int %1296 %1298 = OpConvertSToF %float %1297 %1299 = OpFMul %float %1295 %1295 %1300 = OpFSub %float %float_1 %1299 %1301 = OpFMul %float %1298 %1300 %1302 = OpFAdd %float %float_1 %1301 %1303 = OpFMul %float %1302 %float_0_0250000004 %1304 = OpFOrdLessThanEqual %bool %1289 %float_0_0533333346 OpSelectionMerge %1305 None OpBranchConditional %1304 %1306 %1307 %1307 = OpLabel %1308 = OpFOrdGreaterThanEqual %bool %1289 %float_0_159999996 OpSelectionMerge %1309 None OpBranchConditional %1308 %1310 %1311 %1311 = OpLabel %1312 = OpFDiv %float %float_0_239999995 %1288 %1313 = OpFSub %float %1312 %float_0_5 %1314 = OpFMul %float %1303 %1313 OpBranch %1309 %1310 = OpLabel OpBranch %1309 %1309 = OpLabel %1315 = OpPhi %float %1314 %1311 %float_0 %1310 OpBranch %1305 %1306 = OpLabel OpBranch %1305 %1305 = OpLabel %1316 = OpPhi %float %1315 %1309 %1303 %1306 %1317 = OpFAdd %float %float_1 %1316 %1318 = OpCompositeConstruct %v3float %1317 %1317 %1317 %1319 = OpFMul %v3float %1263 %1318 %1320 = OpCompositeExtract %float %1319 0 %1321 = OpCompositeExtract %float %1319 1 %1322 = OpFOrdEqual %bool %1320 %1321 %1323 = OpCompositeExtract %float %1319 2 %1324 = OpFOrdEqual %bool %1321 %1323 %1325 = OpLogicalAnd %bool %1322 %1324 OpSelectionMerge %1326 None OpBranchConditional %1325 %1327 %1328 %1328 = OpLabel %1329 = OpExtInst %float %1 Sqrt %float_3 %1330 = OpFSub %float %1321 %1323 %1331 = OpFMul %float %1329 %1330 %1332 = OpFMul %float %float_2 %1320 %1333 = OpFSub %float %1332 %1321 %1334 = OpFSub %float %1333 %1323 %1335 = OpExtInst %float %1 Atan2 %1331 %1334 %1336 = OpFMul %float %float_57_2957764 %1335 OpBranch %1326 %1327 = OpLabel OpBranch %1326 %1326 = OpLabel %1337 = OpPhi %float %1336 %1328 %float_0 %1327 %1338 = OpFOrdLessThan %bool %1337 %float_0 OpSelectionMerge %1339 None OpBranchConditional %1338 %1340 %1339 %1340 = OpLabel %1341 = OpFAdd %float %1337 %float_360 OpBranch %1339 %1339 = OpLabel %1342 = OpPhi %float %1337 %1326 %1341 %1340 %1343 = OpExtInst %float %1 FClamp %1342 %float_0 %float_360 %1344 = OpFOrdGreaterThan %bool %1343 %float_180 OpSelectionMerge %1345 None OpBranchConditional %1344 %1346 %1345 %1346 = OpLabel %1347 = OpFSub %float %1343 %float_360 OpBranch %1345 %1345 = OpLabel %1348 = OpPhi %float %1343 %1339 %1347 %1346 %1349 = OpFOrdGreaterThan %bool %1348 %float_n67_5 %1350 = OpFOrdLessThan %bool %1348 %float_67_5 %1351 = OpLogicalAnd %bool %1349 %1350 OpSelectionMerge %1352 None OpBranchConditional %1351 %1353 %1352 %1353 = OpLabel %1354 = OpFSub %float %1348 %float_n67_5 %1355 = OpFMul %float %1354 %float_0_0296296291 %1356 = OpConvertFToS %int %1355 %1357 = OpConvertSToF %float %1356 %1358 = OpFSub %float %1355 %1357 %1359 = OpFMul %float %1358 %1358 %1360 = OpFMul %float %1359 %1358 %1361 = OpIEqual %bool %1356 %int_3 OpSelectionMerge %1362 None OpBranchConditional %1361 %1363 %1364 %1364 = OpLabel %1365 = OpIEqual %bool %1356 %int_2 OpSelectionMerge %1366 None OpBranchConditional %1365 %1367 %1368 %1368 = OpLabel %1369 = OpIEqual %bool %1356 %int_1 OpSelectionMerge %1370 None OpBranchConditional %1369 %1371 %1372 %1372 = OpLabel %1373 = OpIEqual %bool %1356 %int_0 OpSelectionMerge %1374 None OpBranchConditional %1373 %1375 %1376 %1376 = OpLabel OpBranch %1374 %1375 = OpLabel %1377 = OpFMul %float %1360 %float_0_166666672 OpBranch %1374 %1374 = OpLabel %1378 = OpPhi %float %float_0 %1376 %1377 %1375 OpBranch %1370 %1371 = OpLabel %1379 = OpFMul %float %1360 %float_n0_5 %1380 = OpFMul %float %1359 %float_0_5 %1381 = OpFAdd %float %1379 %1380 %1382 = OpFMul %float %1358 %float_0_5 %1383 = OpFAdd %float %1381 %1382 %1384 = OpFAdd %float %1383 %float_0_166666672 OpBranch %1370 %1370 = OpLabel %1385 = OpPhi %float %1378 %1374 %1384 %1371 OpBranch %1366 %1367 = OpLabel %1386 = OpFMul %float %1360 %float_0_5 %1387 = OpFMul %float %1359 %float_n1 %1388 = OpFAdd %float %1386 %1387 %1389 = OpFAdd %float %1388 %float_0_666666687 OpBranch %1366 %1366 = OpLabel %1390 = OpPhi %float %1385 %1370 %1389 %1367 OpBranch %1362 %1363 = OpLabel %1391 = OpFMul %float %1360 %float_n0_166666672 %1392 = OpFMul %float %1359 %float_0_5 %1393 = OpFAdd %float %1391 %1392 %1394 = OpFMul %float %1358 %float_n0_5 %1395 = OpFAdd %float %1393 %1394 %1396 = OpFAdd %float %1395 %float_0_166666672 OpBranch %1362 %1362 = OpLabel %1397 = OpPhi %float %1390 %1366 %1396 %1363 OpBranch %1352 %1352 = OpLabel %1398 = OpPhi %float %float_0 %1345 %1397 %1362 %1399 = OpFMul %float %1398 %float_1_5 %1400 = OpFMul %float %1399 %1275 %1401 = OpFSub %float %float_0_0299999993 %1320 %1402 = OpFMul %float %1400 %1401 %1403 = OpFMul %float %1402 %float_0_180000007 %1404 = OpFAdd %float %1320 %1403 %1405 = OpCompositeInsert %v3float %1404 %1319 0 %1406 = OpExtInst %v3float %1 FClamp %1405 %132 %314 %1407 = OpVectorTimesMatrix %v3float %1406 %410 %1408 = OpExtInst %v3float %1 FClamp %1407 %132 %314 %1409 = OpDot %float %1408 %67 %1410 = OpCompositeConstruct %v3float %1409 %1409 %1409 %1411 = OpExtInst %v3float %1 FMix %1410 %1408 %228 %1412 = OpCompositeExtract %float %1411 0 %1413 = OpExtInst %float %1 Exp2 %float_n15 %1414 = OpFMul %float %float_0_179999992 %1413 %1415 = OpExtInst %float %1 Exp2 %float_18 %1416 = OpFMul %float %float_0_179999992 %1415 OpStore %502 %475 OpStore %501 %476 %1417 = OpFOrdLessThanEqual %bool %1412 %float_0 %1418 = OpExtInst %float %1 Exp2 %float_n14 %1419 = OpSelect %float %1417 %1418 %1412 %1420 = OpExtInst %float %1 Log %1419 %1421 = OpFDiv %float %1420 %1065 %1422 = OpExtInst %float %1 Log %1414 %1423 = OpFDiv %float %1422 %1065 %1424 = OpFOrdLessThanEqual %bool %1421 %1423 OpSelectionMerge %1425 None OpBranchConditional %1424 %1426 %1427 %1427 = OpLabel %1428 = OpFOrdGreaterThan %bool %1421 %1423 %1429 = OpExtInst %float %1 Log %float_0_180000007 %1430 = OpFDiv %float %1429 %1065 %1431 = OpFOrdLessThan %bool %1421 %1430 %1432 = OpLogicalAnd %bool %1428 %1431 OpSelectionMerge %1433 None OpBranchConditional %1432 %1434 %1435 %1435 = OpLabel %1436 = OpFOrdGreaterThanEqual %bool %1421 %1430 %1437 = OpExtInst %float %1 Log %1416 %1438 = OpFDiv %float %1437 %1065 %1439 = OpFOrdLessThan %bool %1421 %1438 %1440 = OpLogicalAnd %bool %1436 %1439 OpSelectionMerge %1441 None OpBranchConditional %1440 %1442 %1443 %1443 = OpLabel %1444 = OpExtInst %float %1 Log %float_10000 %1445 = OpFDiv %float %1444 %1065 OpBranch %1441 %1442 = OpLabel %1446 = OpFSub %float %1421 %1430 %1447 = OpFMul %float %float_3 %1446 %1448 = OpFSub %float %1438 %1430 %1449 = OpFDiv %float %1447 %1448 %1450 = OpConvertFToS %int %1449 %1451 = OpConvertSToF %float %1450 %1452 = OpFSub %float %1449 %1451 %1453 = OpAccessChain %_ptr_Function_float %501 %1450 %1454 = OpLoad %float %1453 %1455 = OpIAdd %int %1450 %int_1 %1456 = OpAccessChain %_ptr_Function_float %501 %1455 %1457 = OpLoad %float %1456 %1458 = OpIAdd %int %1450 %int_2 %1459 = OpAccessChain %_ptr_Function_float %501 %1458 %1460 = OpLoad %float %1459 %1461 = OpCompositeConstruct %v3float %1454 %1457 %1460 %1462 = OpFMul %float %1452 %1452 %1463 = OpCompositeConstruct %v3float %1462 %1452 %float_1 %1464 = OpMatrixTimesVector %v3float %442 %1461 %1465 = OpDot %float %1463 %1464 OpBranch %1441 %1441 = OpLabel %1466 = OpPhi %float %1445 %1443 %1465 %1442 OpBranch %1433 %1434 = OpLabel %1467 = OpFSub %float %1421 %1423 %1468 = OpFMul %float %float_3 %1467 %1469 = OpFSub %float %1430 %1423 %1470 = OpFDiv %float %1468 %1469 %1471 = OpConvertFToS %int %1470 %1472 = OpConvertSToF %float %1471 %1473 = OpFSub %float %1470 %1472 %1474 = OpAccessChain %_ptr_Function_float %502 %1471 %1475 = OpLoad %float %1474 %1476 = OpIAdd %int %1471 %int_1 %1477 = OpAccessChain %_ptr_Function_float %502 %1476 %1478 = OpLoad %float %1477 %1479 = OpIAdd %int %1471 %int_2 %1480 = OpAccessChain %_ptr_Function_float %502 %1479 %1481 = OpLoad %float %1480 %1482 = OpCompositeConstruct %v3float %1475 %1478 %1481 %1483 = OpFMul %float %1473 %1473 %1484 = OpCompositeConstruct %v3float %1483 %1473 %float_1 %1485 = OpMatrixTimesVector %v3float %442 %1482 %1486 = OpDot %float %1484 %1485 OpBranch %1433 %1433 = OpLabel %1487 = OpPhi %float %1466 %1441 %1486 %1434 OpBranch %1425 %1426 = OpLabel %1488 = OpExtInst %float %1 Log %float_9_99999975en05 %1489 = OpFDiv %float %1488 %1065 OpBranch %1425 %1425 = OpLabel %1490 = OpPhi %float %1487 %1433 %1489 %1426 %1491 = OpExtInst %float %1 Pow %float_10 %1490 %1492 = OpCompositeInsert %v3float %1491 %391 0 %1493 = OpCompositeExtract %float %1411 1 OpStore %504 %475 OpStore %503 %476 %1494 = OpFOrdLessThanEqual %bool %1493 %float_0 %1495 = OpSelect %float %1494 %1418 %1493 %1496 = OpExtInst %float %1 Log %1495 %1497 = OpFDiv %float %1496 %1065 %1498 = OpFOrdLessThanEqual %bool %1497 %1423 OpSelectionMerge %1499 None OpBranchConditional %1498 %1500 %1501 %1501 = OpLabel %1502 = OpFOrdGreaterThan %bool %1497 %1423 %1503 = OpExtInst %float %1 Log %float_0_180000007 %1504 = OpFDiv %float %1503 %1065 %1505 = OpFOrdLessThan %bool %1497 %1504 %1506 = OpLogicalAnd %bool %1502 %1505 OpSelectionMerge %1507 None OpBranchConditional %1506 %1508 %1509 %1509 = OpLabel %1510 = OpFOrdGreaterThanEqual %bool %1497 %1504 %1511 = OpExtInst %float %1 Log %1416 %1512 = OpFDiv %float %1511 %1065 %1513 = OpFOrdLessThan %bool %1497 %1512 %1514 = OpLogicalAnd %bool %1510 %1513 OpSelectionMerge %1515 None OpBranchConditional %1514 %1516 %1517 %1517 = OpLabel %1518 = OpExtInst %float %1 Log %float_10000 %1519 = OpFDiv %float %1518 %1065 OpBranch %1515 %1516 = OpLabel %1520 = OpFSub %float %1497 %1504 %1521 = OpFMul %float %float_3 %1520 %1522 = OpFSub %float %1512 %1504 %1523 = OpFDiv %float %1521 %1522 %1524 = OpConvertFToS %int %1523 %1525 = OpConvertSToF %float %1524 %1526 = OpFSub %float %1523 %1525 %1527 = OpAccessChain %_ptr_Function_float %503 %1524 %1528 = OpLoad %float %1527 %1529 = OpIAdd %int %1524 %int_1 %1530 = OpAccessChain %_ptr_Function_float %503 %1529 %1531 = OpLoad %float %1530 %1532 = OpIAdd %int %1524 %int_2 %1533 = OpAccessChain %_ptr_Function_float %503 %1532 %1534 = OpLoad %float %1533 %1535 = OpCompositeConstruct %v3float %1528 %1531 %1534 %1536 = OpFMul %float %1526 %1526 %1537 = OpCompositeConstruct %v3float %1536 %1526 %float_1 %1538 = OpMatrixTimesVector %v3float %442 %1535 %1539 = OpDot %float %1537 %1538 OpBranch %1515 %1515 = OpLabel %1540 = OpPhi %float %1519 %1517 %1539 %1516 OpBranch %1507 %1508 = OpLabel %1541 = OpFSub %float %1497 %1423 %1542 = OpFMul %float %float_3 %1541 %1543 = OpFSub %float %1504 %1423 %1544 = OpFDiv %float %1542 %1543 %1545 = OpConvertFToS %int %1544 %1546 = OpConvertSToF %float %1545 %1547 = OpFSub %float %1544 %1546 %1548 = OpAccessChain %_ptr_Function_float %504 %1545 %1549 = OpLoad %float %1548 %1550 = OpIAdd %int %1545 %int_1 %1551 = OpAccessChain %_ptr_Function_float %504 %1550 %1552 = OpLoad %float %1551 %1553 = OpIAdd %int %1545 %int_2 %1554 = OpAccessChain %_ptr_Function_float %504 %1553 %1555 = OpLoad %float %1554 %1556 = OpCompositeConstruct %v3float %1549 %1552 %1555 %1557 = OpFMul %float %1547 %1547 %1558 = OpCompositeConstruct %v3float %1557 %1547 %float_1 %1559 = OpMatrixTimesVector %v3float %442 %1556 %1560 = OpDot %float %1558 %1559 OpBranch %1507 %1507 = OpLabel %1561 = OpPhi %float %1540 %1515 %1560 %1508 OpBranch %1499 %1500 = OpLabel %1562 = OpExtInst %float %1 Log %float_9_99999975en05 %1563 = OpFDiv %float %1562 %1065 OpBranch %1499 %1499 = OpLabel %1564 = OpPhi %float %1561 %1507 %1563 %1500 %1565 = OpExtInst %float %1 Pow %float_10 %1564 %1566 = OpCompositeInsert %v3float %1565 %1492 1 %1567 = OpCompositeExtract %float %1411 2 OpStore %506 %475 OpStore %505 %476 %1568 = OpFOrdLessThanEqual %bool %1567 %float_0 %1569 = OpSelect %float %1568 %1418 %1567 %1570 = OpExtInst %float %1 Log %1569 %1571 = OpFDiv %float %1570 %1065 %1572 = OpFOrdLessThanEqual %bool %1571 %1423 OpSelectionMerge %1573 None OpBranchConditional %1572 %1574 %1575 %1575 = OpLabel %1576 = OpFOrdGreaterThan %bool %1571 %1423 %1577 = OpExtInst %float %1 Log %float_0_180000007 %1578 = OpFDiv %float %1577 %1065 %1579 = OpFOrdLessThan %bool %1571 %1578 %1580 = OpLogicalAnd %bool %1576 %1579 OpSelectionMerge %1581 None OpBranchConditional %1580 %1582 %1583 %1583 = OpLabel %1584 = OpFOrdGreaterThanEqual %bool %1571 %1578 %1585 = OpExtInst %float %1 Log %1416 %1586 = OpFDiv %float %1585 %1065 %1587 = OpFOrdLessThan %bool %1571 %1586 %1588 = OpLogicalAnd %bool %1584 %1587 OpSelectionMerge %1589 None OpBranchConditional %1588 %1590 %1591 %1591 = OpLabel %1592 = OpExtInst %float %1 Log %float_10000 %1593 = OpFDiv %float %1592 %1065 OpBranch %1589 %1590 = OpLabel %1594 = OpFSub %float %1571 %1578 %1595 = OpFMul %float %float_3 %1594 %1596 = OpFSub %float %1586 %1578 %1597 = OpFDiv %float %1595 %1596 %1598 = OpConvertFToS %int %1597 %1599 = OpConvertSToF %float %1598 %1600 = OpFSub %float %1597 %1599 %1601 = OpAccessChain %_ptr_Function_float %505 %1598 %1602 = OpLoad %float %1601 %1603 = OpIAdd %int %1598 %int_1 %1604 = OpAccessChain %_ptr_Function_float %505 %1603 %1605 = OpLoad %float %1604 %1606 = OpIAdd %int %1598 %int_2 %1607 = OpAccessChain %_ptr_Function_float %505 %1606 %1608 = OpLoad %float %1607 %1609 = OpCompositeConstruct %v3float %1602 %1605 %1608 %1610 = OpFMul %float %1600 %1600 %1611 = OpCompositeConstruct %v3float %1610 %1600 %float_1 %1612 = OpMatrixTimesVector %v3float %442 %1609 %1613 = OpDot %float %1611 %1612 OpBranch %1589 %1589 = OpLabel %1614 = OpPhi %float %1593 %1591 %1613 %1590 OpBranch %1581 %1582 = OpLabel %1615 = OpFSub %float %1571 %1423 %1616 = OpFMul %float %float_3 %1615 %1617 = OpFSub %float %1578 %1423 %1618 = OpFDiv %float %1616 %1617 %1619 = OpConvertFToS %int %1618 %1620 = OpConvertSToF %float %1619 %1621 = OpFSub %float %1618 %1620 %1622 = OpAccessChain %_ptr_Function_float %506 %1619 %1623 = OpLoad %float %1622 %1624 = OpIAdd %int %1619 %int_1 %1625 = OpAccessChain %_ptr_Function_float %506 %1624 %1626 = OpLoad %float %1625 %1627 = OpIAdd %int %1619 %int_2 %1628 = OpAccessChain %_ptr_Function_float %506 %1627 %1629 = OpLoad %float %1628 %1630 = OpCompositeConstruct %v3float %1623 %1626 %1629 %1631 = OpFMul %float %1621 %1621 %1632 = OpCompositeConstruct %v3float %1631 %1621 %float_1 %1633 = OpMatrixTimesVector %v3float %442 %1630 %1634 = OpDot %float %1632 %1633 OpBranch %1581 %1581 = OpLabel %1635 = OpPhi %float %1614 %1589 %1634 %1582 OpBranch %1573 %1574 = OpLabel %1636 = OpExtInst %float %1 Log %float_9_99999975en05 %1637 = OpFDiv %float %1636 %1065 OpBranch %1573 %1573 = OpLabel %1638 = OpPhi %float %1635 %1581 %1637 %1574 %1639 = OpExtInst %float %1 Pow %float_10 %1638 %1640 = OpCompositeInsert %v3float %1639 %1566 2 %1641 = OpVectorTimesMatrix %v3float %1640 %414 %1642 = OpVectorTimesMatrix %v3float %1641 %410 %1643 = OpExtInst %float %1 Pow %float_2 %float_n12 %1644 = OpFMul %float %float_0_179999992 %1643 OpStore %514 %475 OpStore %513 %476 %1645 = OpFOrdLessThanEqual %bool %1644 %float_0 %1646 = OpSelect %float %1645 %1418 %1644 %1647 = OpExtInst %float %1 Log %1646 %1648 = OpFDiv %float %1647 %1065 %1649 = OpFOrdLessThanEqual %bool %1648 %1423 OpSelectionMerge %1650 None OpBranchConditional %1649 %1651 %1652 %1652 = OpLabel %1653 = OpFOrdGreaterThan %bool %1648 %1423 %1654 = OpExtInst %float %1 Log %float_0_180000007 %1655 = OpFDiv %float %1654 %1065 %1656 = OpFOrdLessThan %bool %1648 %1655 %1657 = OpLogicalAnd %bool %1653 %1656 OpSelectionMerge %1658 None OpBranchConditional %1657 %1659 %1660 %1660 = OpLabel %1661 = OpFOrdGreaterThanEqual %bool %1648 %1655 %1662 = OpExtInst %float %1 Log %1416 %1663 = OpFDiv %float %1662 %1065 %1664 = OpFOrdLessThan %bool %1648 %1663 %1665 = OpLogicalAnd %bool %1661 %1664 OpSelectionMerge %1666 None OpBranchConditional %1665 %1667 %1668 %1668 = OpLabel %1669 = OpExtInst %float %1 Log %float_10000 %1670 = OpFDiv %float %1669 %1065 OpBranch %1666 %1667 = OpLabel %1671 = OpFSub %float %1648 %1655 %1672 = OpFMul %float %float_3 %1671 %1673 = OpFSub %float %1663 %1655 %1674 = OpFDiv %float %1672 %1673 %1675 = OpConvertFToS %int %1674 %1676 = OpConvertSToF %float %1675 %1677 = OpFSub %float %1674 %1676 %1678 = OpAccessChain %_ptr_Function_float %513 %1675 %1679 = OpLoad %float %1678 %1680 = OpIAdd %int %1675 %int_1 %1681 = OpAccessChain %_ptr_Function_float %513 %1680 %1682 = OpLoad %float %1681 %1683 = OpIAdd %int %1675 %int_2 %1684 = OpAccessChain %_ptr_Function_float %513 %1683 %1685 = OpLoad %float %1684 %1686 = OpCompositeConstruct %v3float %1679 %1682 %1685 %1687 = OpFMul %float %1677 %1677 %1688 = OpCompositeConstruct %v3float %1687 %1677 %float_1 %1689 = OpMatrixTimesVector %v3float %442 %1686 %1690 = OpDot %float %1688 %1689 OpBranch %1666 %1666 = OpLabel %1691 = OpPhi %float %1670 %1668 %1690 %1667 OpBranch %1658 %1659 = OpLabel %1692 = OpFSub %float %1648 %1423 %1693 = OpFMul %float %float_3 %1692 %1694 = OpFSub %float %1655 %1423 %1695 = OpFDiv %float %1693 %1694 %1696 = OpConvertFToS %int %1695 %1697 = OpConvertSToF %float %1696 %1698 = OpFSub %float %1695 %1697 %1699 = OpAccessChain %_ptr_Function_float %514 %1696 %1700 = OpLoad %float %1699 %1701 = OpIAdd %int %1696 %int_1 %1702 = OpAccessChain %_ptr_Function_float %514 %1701 %1703 = OpLoad %float %1702 %1704 = OpIAdd %int %1696 %int_2 %1705 = OpAccessChain %_ptr_Function_float %514 %1704 %1706 = OpLoad %float %1705 %1707 = OpCompositeConstruct %v3float %1700 %1703 %1706 %1708 = OpFMul %float %1698 %1698 %1709 = OpCompositeConstruct %v3float %1708 %1698 %float_1 %1710 = OpMatrixTimesVector %v3float %442 %1707 %1711 = OpDot %float %1709 %1710 OpBranch %1658 %1658 = OpLabel %1712 = OpPhi %float %1691 %1666 %1711 %1659 OpBranch %1650 %1651 = OpLabel %1713 = OpExtInst %float %1 Log %float_9_99999975en05 %1714 = OpFDiv %float %1713 %1065 OpBranch %1650 %1650 = OpLabel %1715 = OpPhi %float %1712 %1658 %1714 %1651 %1716 = OpExtInst %float %1 Pow %float_10 %1715 OpStore %516 %475 OpStore %515 %476 %1717 = OpExtInst %float %1 Log %float_0_180000007 %1718 = OpFDiv %float %1717 %1065 %1719 = OpFOrdLessThanEqual %bool %1718 %1423 OpSelectionMerge %1720 None OpBranchConditional %1719 %1721 %1722 %1722 = OpLabel %1723 = OpFOrdGreaterThan %bool %1718 %1423 %1724 = OpFOrdLessThan %bool %1718 %1718 %1725 = OpLogicalAnd %bool %1723 %1724 OpSelectionMerge %1726 None OpBranchConditional %1725 %1727 %1728 %1728 = OpLabel %1729 = OpFOrdGreaterThanEqual %bool %1718 %1718 %1730 = OpExtInst %float %1 Log %1416 %1731 = OpFDiv %float %1730 %1065 %1732 = OpFOrdLessThan %bool %1718 %1731 %1733 = OpLogicalAnd %bool %1729 %1732 OpSelectionMerge %1734 None OpBranchConditional %1733 %1735 %1736 %1736 = OpLabel %1737 = OpExtInst %float %1 Log %float_10000 %1738 = OpFDiv %float %1737 %1065 OpBranch %1734 %1735 = OpLabel %1739 = OpFSub %float %1718 %1718 %1740 = OpFMul %float %float_3 %1739 %1741 = OpFSub %float %1731 %1718 %1742 = OpFDiv %float %1740 %1741 %1743 = OpConvertFToS %int %1742 %1744 = OpConvertSToF %float %1743 %1745 = OpFSub %float %1742 %1744 %1746 = OpAccessChain %_ptr_Function_float %515 %1743 %1747 = OpLoad %float %1746 %1748 = OpIAdd %int %1743 %int_1 %1749 = OpAccessChain %_ptr_Function_float %515 %1748 %1750 = OpLoad %float %1749 %1751 = OpIAdd %int %1743 %int_2 %1752 = OpAccessChain %_ptr_Function_float %515 %1751 %1753 = OpLoad %float %1752 %1754 = OpCompositeConstruct %v3float %1747 %1750 %1753 %1755 = OpFMul %float %1745 %1745 %1756 = OpCompositeConstruct %v3float %1755 %1745 %float_1 %1757 = OpMatrixTimesVector %v3float %442 %1754 %1758 = OpDot %float %1756 %1757 OpBranch %1734 %1734 = OpLabel %1759 = OpPhi %float %1738 %1736 %1758 %1735 OpBranch %1726 %1727 = OpLabel %1760 = OpFSub %float %1718 %1423 %1761 = OpFMul %float %float_3 %1760 %1762 = OpAccessChain %_ptr_Function_float %516 %int_3 %1763 = OpLoad %float %1762 %1764 = OpAccessChain %_ptr_Function_float %516 %int_4 %1765 = OpLoad %float %1764 %1766 = OpAccessChain %_ptr_Function_float %516 %int_5 %1767 = OpLoad %float %1766 %1768 = OpCompositeConstruct %v3float %1763 %1765 %1767 %1769 = OpMatrixTimesVector %v3float %442 %1768 %1770 = OpCompositeExtract %float %1769 2 OpBranch %1726 %1726 = OpLabel %1771 = OpPhi %float %1759 %1734 %1770 %1727 OpBranch %1720 %1721 = OpLabel %1772 = OpExtInst %float %1 Log %float_9_99999975en05 %1773 = OpFDiv %float %1772 %1065 OpBranch %1720 %1720 = OpLabel %1774 = OpPhi %float %1771 %1726 %1773 %1721 %1775 = OpExtInst %float %1 Pow %float_10 %1774 %1776 = OpExtInst %float %1 Pow %float_2 %float_11 %1777 = OpFMul %float %float_0_179999992 %1776 OpStore %518 %475 OpStore %517 %476 %1778 = OpFOrdLessThanEqual %bool %1777 %float_0 %1779 = OpSelect %float %1778 %1418 %1777 %1780 = OpExtInst %float %1 Log %1779 %1781 = OpFDiv %float %1780 %1065 %1782 = OpFOrdLessThanEqual %bool %1781 %1423 OpSelectionMerge %1783 None OpBranchConditional %1782 %1784 %1785 %1785 = OpLabel %1786 = OpFOrdGreaterThan %bool %1781 %1423 %1787 = OpFOrdLessThan %bool %1781 %1718 %1788 = OpLogicalAnd %bool %1786 %1787 OpSelectionMerge %1789 None OpBranchConditional %1788 %1790 %1791 %1791 = OpLabel %1792 = OpFOrdGreaterThanEqual %bool %1781 %1718 %1793 = OpExtInst %float %1 Log %1416 %1794 = OpFDiv %float %1793 %1065 %1795 = OpFOrdLessThan %bool %1781 %1794 %1796 = OpLogicalAnd %bool %1792 %1795 OpSelectionMerge %1797 None OpBranchConditional %1796 %1798 %1799 %1799 = OpLabel %1800 = OpExtInst %float %1 Log %float_10000 %1801 = OpFDiv %float %1800 %1065 OpBranch %1797 %1798 = OpLabel %1802 = OpFSub %float %1781 %1718 %1803 = OpFMul %float %float_3 %1802 %1804 = OpFSub %float %1794 %1718 %1805 = OpFDiv %float %1803 %1804 %1806 = OpConvertFToS %int %1805 %1807 = OpConvertSToF %float %1806 %1808 = OpFSub %float %1805 %1807 %1809 = OpAccessChain %_ptr_Function_float %517 %1806 %1810 = OpLoad %float %1809 %1811 = OpIAdd %int %1806 %int_1 %1812 = OpAccessChain %_ptr_Function_float %517 %1811 %1813 = OpLoad %float %1812 %1814 = OpIAdd %int %1806 %int_2 %1815 = OpAccessChain %_ptr_Function_float %517 %1814 %1816 = OpLoad %float %1815 %1817 = OpCompositeConstruct %v3float %1810 %1813 %1816 %1818 = OpFMul %float %1808 %1808 %1819 = OpCompositeConstruct %v3float %1818 %1808 %float_1 %1820 = OpMatrixTimesVector %v3float %442 %1817 %1821 = OpDot %float %1819 %1820 OpBranch %1797 %1797 = OpLabel %1822 = OpPhi %float %1801 %1799 %1821 %1798 OpBranch %1789 %1790 = OpLabel %1823 = OpFSub %float %1781 %1423 %1824 = OpFMul %float %float_3 %1823 %1825 = OpFSub %float %1718 %1423 %1826 = OpFDiv %float %1824 %1825 %1827 = OpConvertFToS %int %1826 %1828 = OpConvertSToF %float %1827 %1829 = OpFSub %float %1826 %1828 %1830 = OpAccessChain %_ptr_Function_float %518 %1827 %1831 = OpLoad %float %1830 %1832 = OpIAdd %int %1827 %int_1 %1833 = OpAccessChain %_ptr_Function_float %518 %1832 %1834 = OpLoad %float %1833 %1835 = OpIAdd %int %1827 %int_2 %1836 = OpAccessChain %_ptr_Function_float %518 %1835 %1837 = OpLoad %float %1836 %1838 = OpCompositeConstruct %v3float %1831 %1834 %1837 %1839 = OpFMul %float %1829 %1829 %1840 = OpCompositeConstruct %v3float %1839 %1829 %float_1 %1841 = OpMatrixTimesVector %v3float %442 %1838 %1842 = OpDot %float %1840 %1841 OpBranch %1789 %1789 = OpLabel %1843 = OpPhi %float %1822 %1797 %1842 %1790 OpBranch %1783 %1784 = OpLabel %1844 = OpExtInst %float %1 Log %float_9_99999975en05 %1845 = OpFDiv %float %1844 %1065 OpBranch %1783 %1783 = OpLabel %1846 = OpPhi %float %1843 %1789 %1845 %1784 %1847 = OpExtInst %float %1 Pow %float_10 %1846 %1848 = OpCompositeExtract %float %1642 0 OpStore %512 %482 OpStore %511 %483 %1849 = OpFOrdLessThanEqual %bool %1848 %float_0 %1850 = OpSelect %float %1849 %float_9_99999975en05 %1848 %1851 = OpExtInst %float %1 Log %1850 %1852 = OpFDiv %float %1851 %1065 %1853 = OpExtInst %float %1 Log %1716 %1854 = OpFDiv %float %1853 %1065 %1855 = OpFOrdLessThanEqual %bool %1852 %1854 OpSelectionMerge %1856 None OpBranchConditional %1855 %1857 %1858 %1858 = OpLabel %1859 = OpFOrdGreaterThan %bool %1852 %1854 %1860 = OpExtInst %float %1 Log %1775 %1861 = OpFDiv %float %1860 %1065 %1862 = OpFOrdLessThan %bool %1852 %1861 %1863 = OpLogicalAnd %bool %1859 %1862 OpSelectionMerge %1864 None OpBranchConditional %1863 %1865 %1866 %1866 = OpLabel %1867 = OpFOrdGreaterThanEqual %bool %1852 %1861 %1868 = OpExtInst %float %1 Log %1847 %1869 = OpFDiv %float %1868 %1065 %1870 = OpFOrdLessThan %bool %1852 %1869 %1871 = OpLogicalAnd %bool %1867 %1870 OpSelectionMerge %1872 None OpBranchConditional %1871 %1873 %1874 %1874 = OpLabel %1875 = OpFMul %float %1852 %float_0_119999997 %1876 = OpExtInst %float %1 Log %float_2000 %1877 = OpFDiv %float %1876 %1065 %1878 = OpFMul %float %float_0_119999997 %1868 %1879 = OpFDiv %float %1878 %1065 %1880 = OpFSub %float %1877 %1879 %1881 = OpFAdd %float %1875 %1880 OpBranch %1872 %1873 = OpLabel %1882 = OpFSub %float %1852 %1861 %1883 = OpFMul %float %float_7 %1882 %1884 = OpFSub %float %1869 %1861 %1885 = OpFDiv %float %1883 %1884 %1886 = OpConvertFToS %int %1885 %1887 = OpConvertSToF %float %1886 %1888 = OpFSub %float %1885 %1887 %1889 = OpAccessChain %_ptr_Function_float %511 %1886 %1890 = OpLoad %float %1889 %1891 = OpIAdd %int %1886 %int_1 %1892 = OpAccessChain %_ptr_Function_float %511 %1891 %1893 = OpLoad %float %1892 %1894 = OpIAdd %int %1886 %int_2 %1895 = OpAccessChain %_ptr_Function_float %511 %1894 %1896 = OpLoad %float %1895 %1897 = OpCompositeConstruct %v3float %1890 %1893 %1896 %1898 = OpFMul %float %1888 %1888 %1899 = OpCompositeConstruct %v3float %1898 %1888 %float_1 %1900 = OpMatrixTimesVector %v3float %442 %1897 %1901 = OpDot %float %1899 %1900 OpBranch %1872 %1872 = OpLabel %1902 = OpPhi %float %1881 %1874 %1901 %1873 OpBranch %1864 %1865 = OpLabel %1903 = OpFSub %float %1852 %1854 %1904 = OpFMul %float %float_7 %1903 %1905 = OpFSub %float %1861 %1854 %1906 = OpFDiv %float %1904 %1905 %1907 = OpConvertFToS %int %1906 %1908 = OpConvertSToF %float %1907 %1909 = OpFSub %float %1906 %1908 %1910 = OpAccessChain %_ptr_Function_float %512 %1907 %1911 = OpLoad %float %1910 %1912 = OpIAdd %int %1907 %int_1 %1913 = OpAccessChain %_ptr_Function_float %512 %1912 %1914 = OpLoad %float %1913 %1915 = OpIAdd %int %1907 %int_2 %1916 = OpAccessChain %_ptr_Function_float %512 %1915 %1917 = OpLoad %float %1916 %1918 = OpCompositeConstruct %v3float %1911 %1914 %1917 %1919 = OpFMul %float %1909 %1909 %1920 = OpCompositeConstruct %v3float %1919 %1909 %float_1 %1921 = OpMatrixTimesVector %v3float %442 %1918 %1922 = OpDot %float %1920 %1921 OpBranch %1864 %1864 = OpLabel %1923 = OpPhi %float %1902 %1872 %1922 %1865 OpBranch %1856 %1857 = OpLabel %1924 = OpExtInst %float %1 Log %float_0_00499999989 %1925 = OpFDiv %float %1924 %1065 OpBranch %1856 %1856 = OpLabel %1926 = OpPhi %float %1923 %1864 %1925 %1857 %1927 = OpExtInst %float %1 Pow %float_10 %1926 %1928 = OpCompositeInsert %v3float %1927 %391 0 %1929 = OpCompositeExtract %float %1642 1 OpStore %510 %482 OpStore %509 %483 %1930 = OpFOrdLessThanEqual %bool %1929 %float_0 %1931 = OpSelect %float %1930 %float_9_99999975en05 %1929 %1932 = OpExtInst %float %1 Log %1931 %1933 = OpFDiv %float %1932 %1065 %1934 = OpFOrdLessThanEqual %bool %1933 %1854 OpSelectionMerge %1935 None OpBranchConditional %1934 %1936 %1937 %1937 = OpLabel %1938 = OpFOrdGreaterThan %bool %1933 %1854 %1939 = OpExtInst %float %1 Log %1775 %1940 = OpFDiv %float %1939 %1065 %1941 = OpFOrdLessThan %bool %1933 %1940 %1942 = OpLogicalAnd %bool %1938 %1941 OpSelectionMerge %1943 None OpBranchConditional %1942 %1944 %1945 %1945 = OpLabel %1946 = OpFOrdGreaterThanEqual %bool %1933 %1940 %1947 = OpExtInst %float %1 Log %1847 %1948 = OpFDiv %float %1947 %1065 %1949 = OpFOrdLessThan %bool %1933 %1948 %1950 = OpLogicalAnd %bool %1946 %1949 OpSelectionMerge %1951 None OpBranchConditional %1950 %1952 %1953 %1953 = OpLabel %1954 = OpFMul %float %1933 %float_0_119999997 %1955 = OpExtInst %float %1 Log %float_2000 %1956 = OpFDiv %float %1955 %1065 %1957 = OpFMul %float %float_0_119999997 %1947 %1958 = OpFDiv %float %1957 %1065 %1959 = OpFSub %float %1956 %1958 %1960 = OpFAdd %float %1954 %1959 OpBranch %1951 %1952 = OpLabel %1961 = OpFSub %float %1933 %1940 %1962 = OpFMul %float %float_7 %1961 %1963 = OpFSub %float %1948 %1940 %1964 = OpFDiv %float %1962 %1963 %1965 = OpConvertFToS %int %1964 %1966 = OpConvertSToF %float %1965 %1967 = OpFSub %float %1964 %1966 %1968 = OpAccessChain %_ptr_Function_float %509 %1965 %1969 = OpLoad %float %1968 %1970 = OpIAdd %int %1965 %int_1 %1971 = OpAccessChain %_ptr_Function_float %509 %1970 %1972 = OpLoad %float %1971 %1973 = OpIAdd %int %1965 %int_2 %1974 = OpAccessChain %_ptr_Function_float %509 %1973 %1975 = OpLoad %float %1974 %1976 = OpCompositeConstruct %v3float %1969 %1972 %1975 %1977 = OpFMul %float %1967 %1967 %1978 = OpCompositeConstruct %v3float %1977 %1967 %float_1 %1979 = OpMatrixTimesVector %v3float %442 %1976 %1980 = OpDot %float %1978 %1979 OpBranch %1951 %1951 = OpLabel %1981 = OpPhi %float %1960 %1953 %1980 %1952 OpBranch %1943 %1944 = OpLabel %1982 = OpFSub %float %1933 %1854 %1983 = OpFMul %float %float_7 %1982 %1984 = OpFSub %float %1940 %1854 %1985 = OpFDiv %float %1983 %1984 %1986 = OpConvertFToS %int %1985 %1987 = OpConvertSToF %float %1986 %1988 = OpFSub %float %1985 %1987 %1989 = OpAccessChain %_ptr_Function_float %510 %1986 %1990 = OpLoad %float %1989 %1991 = OpIAdd %int %1986 %int_1 %1992 = OpAccessChain %_ptr_Function_float %510 %1991 %1993 = OpLoad %float %1992 %1994 = OpIAdd %int %1986 %int_2 %1995 = OpAccessChain %_ptr_Function_float %510 %1994 %1996 = OpLoad %float %1995 %1997 = OpCompositeConstruct %v3float %1990 %1993 %1996 %1998 = OpFMul %float %1988 %1988 %1999 = OpCompositeConstruct %v3float %1998 %1988 %float_1 %2000 = OpMatrixTimesVector %v3float %442 %1997 %2001 = OpDot %float %1999 %2000 OpBranch %1943 %1943 = OpLabel %2002 = OpPhi %float %1981 %1951 %2001 %1944 OpBranch %1935 %1936 = OpLabel %2003 = OpExtInst %float %1 Log %float_0_00499999989 %2004 = OpFDiv %float %2003 %1065 OpBranch %1935 %1935 = OpLabel %2005 = OpPhi %float %2002 %1943 %2004 %1936 %2006 = OpExtInst %float %1 Pow %float_10 %2005 %2007 = OpCompositeInsert %v3float %2006 %1928 1 %2008 = OpCompositeExtract %float %1642 2 OpStore %508 %482 OpStore %507 %483 %2009 = OpFOrdLessThanEqual %bool %2008 %float_0 %2010 = OpSelect %float %2009 %float_9_99999975en05 %2008 %2011 = OpExtInst %float %1 Log %2010 %2012 = OpFDiv %float %2011 %1065 %2013 = OpFOrdLessThanEqual %bool %2012 %1854 OpSelectionMerge %2014 None OpBranchConditional %2013 %2015 %2016 %2016 = OpLabel %2017 = OpFOrdGreaterThan %bool %2012 %1854 %2018 = OpExtInst %float %1 Log %1775 %2019 = OpFDiv %float %2018 %1065 %2020 = OpFOrdLessThan %bool %2012 %2019 %2021 = OpLogicalAnd %bool %2017 %2020 OpSelectionMerge %2022 None OpBranchConditional %2021 %2023 %2024 %2024 = OpLabel %2025 = OpFOrdGreaterThanEqual %bool %2012 %2019 %2026 = OpExtInst %float %1 Log %1847 %2027 = OpFDiv %float %2026 %1065 %2028 = OpFOrdLessThan %bool %2012 %2027 %2029 = OpLogicalAnd %bool %2025 %2028 OpSelectionMerge %2030 None OpBranchConditional %2029 %2031 %2032 %2032 = OpLabel %2033 = OpFMul %float %2012 %float_0_119999997 %2034 = OpExtInst %float %1 Log %float_2000 %2035 = OpFDiv %float %2034 %1065 %2036 = OpFMul %float %float_0_119999997 %2026 %2037 = OpFDiv %float %2036 %1065 %2038 = OpFSub %float %2035 %2037 %2039 = OpFAdd %float %2033 %2038 OpBranch %2030 %2031 = OpLabel %2040 = OpFSub %float %2012 %2019 %2041 = OpFMul %float %float_7 %2040 %2042 = OpFSub %float %2027 %2019 %2043 = OpFDiv %float %2041 %2042 %2044 = OpConvertFToS %int %2043 %2045 = OpConvertSToF %float %2044 %2046 = OpFSub %float %2043 %2045 %2047 = OpAccessChain %_ptr_Function_float %507 %2044 %2048 = OpLoad %float %2047 %2049 = OpIAdd %int %2044 %int_1 %2050 = OpAccessChain %_ptr_Function_float %507 %2049 %2051 = OpLoad %float %2050 %2052 = OpIAdd %int %2044 %int_2 %2053 = OpAccessChain %_ptr_Function_float %507 %2052 %2054 = OpLoad %float %2053 %2055 = OpCompositeConstruct %v3float %2048 %2051 %2054 %2056 = OpFMul %float %2046 %2046 %2057 = OpCompositeConstruct %v3float %2056 %2046 %float_1 %2058 = OpMatrixTimesVector %v3float %442 %2055 %2059 = OpDot %float %2057 %2058 OpBranch %2030 %2030 = OpLabel %2060 = OpPhi %float %2039 %2032 %2059 %2031 OpBranch %2022 %2023 = OpLabel %2061 = OpFSub %float %2012 %1854 %2062 = OpFMul %float %float_7 %2061 %2063 = OpFSub %float %2019 %1854 %2064 = OpFDiv %float %2062 %2063 %2065 = OpConvertFToS %int %2064 %2066 = OpConvertSToF %float %2065 %2067 = OpFSub %float %2064 %2066 %2068 = OpAccessChain %_ptr_Function_float %508 %2065 %2069 = OpLoad %float %2068 %2070 = OpIAdd %int %2065 %int_1 %2071 = OpAccessChain %_ptr_Function_float %508 %2070 %2072 = OpLoad %float %2071 %2073 = OpIAdd %int %2065 %int_2 %2074 = OpAccessChain %_ptr_Function_float %508 %2073 %2075 = OpLoad %float %2074 %2076 = OpCompositeConstruct %v3float %2069 %2072 %2075 %2077 = OpFMul %float %2067 %2067 %2078 = OpCompositeConstruct %v3float %2077 %2067 %float_1 %2079 = OpMatrixTimesVector %v3float %442 %2076 %2080 = OpDot %float %2078 %2079 OpBranch %2022 %2022 = OpLabel %2081 = OpPhi %float %2060 %2030 %2080 %2023 OpBranch %2014 %2015 = OpLabel %2082 = OpExtInst %float %1 Log %float_0_00499999989 %2083 = OpFDiv %float %2082 %1065 OpBranch %2014 %2014 = OpLabel %2084 = OpPhi %float %2081 %2022 %2083 %2015 %2085 = OpExtInst %float %1 Pow %float_10 %2084 %2086 = OpCompositeInsert %v3float %2085 %2007 2 %2087 = OpVectorTimesMatrix %v3float %2086 %576 %2088 = OpFMul %v3float %2087 %496 %2089 = OpExtInst %v3float %1 Pow %2088 %263 %2090 = OpFMul %v3float %184 %2089 %2091 = OpFAdd %v3float %183 %2090 %2092 = OpFMul %v3float %185 %2089 %2093 = OpFAdd %v3float %135 %2092 %2094 = OpFDiv %v3float %135 %2093 %2095 = OpFMul %v3float %2091 %2094 %2096 = OpExtInst %v3float %1 Pow %2095 %264 OpBranch %1236 %1236 = OpLabel %2097 = OpPhi %v3float %1260 %1240 %2096 %2014 OpBranch %1230 %1231 = OpLabel %2098 = OpMatrixTimesMatrix %mat3v3float %546 %399 %2099 = OpFMul %v3float %906 %262 %2100 = OpVectorTimesMatrix %v3float %2099 %2098 %2101 = OpCompositeExtract %float %2100 0 %2102 = OpCompositeExtract %float %2100 1 %2103 = OpExtInst %float %1 FMin %2101 %2102 %2104 = OpCompositeExtract %float %2100 2 %2105 = OpExtInst %float %1 FMin %2103 %2104 %2106 = OpExtInst %float %1 FMax %2101 %2102 %2107 = OpExtInst %float %1 FMax %2106 %2104 %2108 = OpExtInst %float %1 FMax %2107 %float_1_00000001en10 %2109 = OpExtInst %float %1 FMax %2105 %float_1_00000001en10 %2110 = OpFSub %float %2108 %2109 %2111 = OpExtInst %float %1 FMax %2107 %float_0_00999999978 %2112 = OpFDiv %float %2110 %2111 %2113 = OpFSub %float %2104 %2102 %2114 = OpFMul %float %2104 %2113 %2115 = OpFSub %float %2102 %2101 %2116 = OpFMul %float %2102 %2115 %2117 = OpFAdd %float %2114 %2116 %2118 = OpFSub %float %2101 %2104 %2119 = OpFMul %float %2101 %2118 %2120 = OpFAdd %float %2117 %2119 %2121 = OpExtInst %float %1 Sqrt %2120 %2122 = OpFAdd %float %2104 %2102 %2123 = OpFAdd %float %2122 %2101 %2124 = OpFMul %float %float_1_75 %2121 %2125 = OpFAdd %float %2123 %2124 %2126 = OpFMul %float %2125 %float_0_333333343 %2127 = OpFSub %float %2112 %float_0_400000006 %2128 = OpFMul %float %2127 %float_5 %2129 = OpFMul %float %2127 %float_2_5 %2130 = OpExtInst %float %1 FAbs %2129 %2131 = OpFSub %float %float_1 %2130 %2132 = OpExtInst %float %1 FMax %2131 %float_0 %2133 = OpExtInst %float %1 FSign %2128 %2134 = OpConvertFToS %int %2133 %2135 = OpConvertSToF %float %2134 %2136 = OpFMul %float %2132 %2132 %2137 = OpFSub %float %float_1 %2136 %2138 = OpFMul %float %2135 %2137 %2139 = OpFAdd %float %float_1 %2138 %2140 = OpFMul %float %2139 %float_0_0250000004 %2141 = OpFOrdLessThanEqual %bool %2126 %float_0_0533333346 OpSelectionMerge %2142 None OpBranchConditional %2141 %2143 %2144 %2144 = OpLabel %2145 = OpFOrdGreaterThanEqual %bool %2126 %float_0_159999996 OpSelectionMerge %2146 None OpBranchConditional %2145 %2147 %2148 %2148 = OpLabel %2149 = OpFDiv %float %float_0_239999995 %2125 %2150 = OpFSub %float %2149 %float_0_5 %2151 = OpFMul %float %2140 %2150 OpBranch %2146 %2147 = OpLabel OpBranch %2146 %2146 = OpLabel %2152 = OpPhi %float %2151 %2148 %float_0 %2147 OpBranch %2142 %2143 = OpLabel OpBranch %2142 %2142 = OpLabel %2153 = OpPhi %float %2152 %2146 %2140 %2143 %2154 = OpFAdd %float %float_1 %2153 %2155 = OpCompositeConstruct %v3float %2154 %2154 %2154 %2156 = OpFMul %v3float %2100 %2155 %2157 = OpCompositeExtract %float %2156 0 %2158 = OpCompositeExtract %float %2156 1 %2159 = OpFOrdEqual %bool %2157 %2158 %2160 = OpCompositeExtract %float %2156 2 %2161 = OpFOrdEqual %bool %2158 %2160 %2162 = OpLogicalAnd %bool %2159 %2161 OpSelectionMerge %2163 None OpBranchConditional %2162 %2164 %2165 %2165 = OpLabel %2166 = OpExtInst %float %1 Sqrt %float_3 %2167 = OpFSub %float %2158 %2160 %2168 = OpFMul %float %2166 %2167 %2169 = OpFMul %float %float_2 %2157 %2170 = OpFSub %float %2169 %2158 %2171 = OpFSub %float %2170 %2160 %2172 = OpExtInst %float %1 Atan2 %2168 %2171 %2173 = OpFMul %float %float_57_2957764 %2172 OpBranch %2163 %2164 = OpLabel OpBranch %2163 %2163 = OpLabel %2174 = OpPhi %float %2173 %2165 %float_0 %2164 %2175 = OpFOrdLessThan %bool %2174 %float_0 OpSelectionMerge %2176 None OpBranchConditional %2175 %2177 %2176 %2177 = OpLabel %2178 = OpFAdd %float %2174 %float_360 OpBranch %2176 %2176 = OpLabel %2179 = OpPhi %float %2174 %2163 %2178 %2177 %2180 = OpExtInst %float %1 FClamp %2179 %float_0 %float_360 %2181 = OpFOrdGreaterThan %bool %2180 %float_180 OpSelectionMerge %2182 None OpBranchConditional %2181 %2183 %2182 %2183 = OpLabel %2184 = OpFSub %float %2180 %float_360 OpBranch %2182 %2182 = OpLabel %2185 = OpPhi %float %2180 %2176 %2184 %2183 %2186 = OpFOrdGreaterThan %bool %2185 %float_n67_5 %2187 = OpFOrdLessThan %bool %2185 %float_67_5 %2188 = OpLogicalAnd %bool %2186 %2187 OpSelectionMerge %2189 None OpBranchConditional %2188 %2190 %2189 %2190 = OpLabel %2191 = OpFSub %float %2185 %float_n67_5 %2192 = OpFMul %float %2191 %float_0_0296296291 %2193 = OpConvertFToS %int %2192 %2194 = OpConvertSToF %float %2193 %2195 = OpFSub %float %2192 %2194 %2196 = OpFMul %float %2195 %2195 %2197 = OpFMul %float %2196 %2195 %2198 = OpIEqual %bool %2193 %int_3 OpSelectionMerge %2199 None OpBranchConditional %2198 %2200 %2201 %2201 = OpLabel %2202 = OpIEqual %bool %2193 %int_2 OpSelectionMerge %2203 None OpBranchConditional %2202 %2204 %2205 %2205 = OpLabel %2206 = OpIEqual %bool %2193 %int_1 OpSelectionMerge %2207 None OpBranchConditional %2206 %2208 %2209 %2209 = OpLabel %2210 = OpIEqual %bool %2193 %int_0 OpSelectionMerge %2211 None OpBranchConditional %2210 %2212 %2213 %2213 = OpLabel OpBranch %2211 %2212 = OpLabel %2214 = OpFMul %float %2197 %float_0_166666672 OpBranch %2211 %2211 = OpLabel %2215 = OpPhi %float %float_0 %2213 %2214 %2212 OpBranch %2207 %2208 = OpLabel %2216 = OpFMul %float %2197 %float_n0_5 %2217 = OpFMul %float %2196 %float_0_5 %2218 = OpFAdd %float %2216 %2217 %2219 = OpFMul %float %2195 %float_0_5 %2220 = OpFAdd %float %2218 %2219 %2221 = OpFAdd %float %2220 %float_0_166666672 OpBranch %2207 %2207 = OpLabel %2222 = OpPhi %float %2215 %2211 %2221 %2208 OpBranch %2203 %2204 = OpLabel %2223 = OpFMul %float %2197 %float_0_5 %2224 = OpFMul %float %2196 %float_n1 %2225 = OpFAdd %float %2223 %2224 %2226 = OpFAdd %float %2225 %float_0_666666687 OpBranch %2203 %2203 = OpLabel %2227 = OpPhi %float %2222 %2207 %2226 %2204 OpBranch %2199 %2200 = OpLabel %2228 = OpFMul %float %2197 %float_n0_166666672 %2229 = OpFMul %float %2196 %float_0_5 %2230 = OpFAdd %float %2228 %2229 %2231 = OpFMul %float %2195 %float_n0_5 %2232 = OpFAdd %float %2230 %2231 %2233 = OpFAdd %float %2232 %float_0_166666672 OpBranch %2199 %2199 = OpLabel %2234 = OpPhi %float %2227 %2203 %2233 %2200 OpBranch %2189 %2189 = OpLabel %2235 = OpPhi %float %float_0 %2182 %2234 %2199 %2236 = OpFMul %float %2235 %float_1_5 %2237 = OpFMul %float %2236 %2112 %2238 = OpFSub %float %float_0_0299999993 %2157 %2239 = OpFMul %float %2237 %2238 %2240 = OpFMul %float %2239 %float_0_180000007 %2241 = OpFAdd %float %2157 %2240 %2242 = OpCompositeInsert %v3float %2241 %2156 0 %2243 = OpExtInst %v3float %1 FClamp %2242 %132 %314 %2244 = OpVectorTimesMatrix %v3float %2243 %410 %2245 = OpExtInst %v3float %1 FClamp %2244 %132 %314 %2246 = OpDot %float %2245 %67 %2247 = OpCompositeConstruct %v3float %2246 %2246 %2246 %2248 = OpExtInst %v3float %1 FMix %2247 %2245 %228 %2249 = OpCompositeExtract %float %2248 0 %2250 = OpExtInst %float %1 Exp2 %float_n15 %2251 = OpFMul %float %float_0_179999992 %2250 %2252 = OpExtInst %float %1 Exp2 %float_18 %2253 = OpFMul %float %float_0_179999992 %2252 OpStore %520 %475 OpStore %519 %476 %2254 = OpFOrdLessThanEqual %bool %2249 %float_0 %2255 = OpExtInst %float %1 Exp2 %float_n14 %2256 = OpSelect %float %2254 %2255 %2249 %2257 = OpExtInst %float %1 Log %2256 %2258 = OpFDiv %float %2257 %1065 %2259 = OpExtInst %float %1 Log %2251 %2260 = OpFDiv %float %2259 %1065 %2261 = OpFOrdLessThanEqual %bool %2258 %2260 OpSelectionMerge %2262 None OpBranchConditional %2261 %2263 %2264 %2264 = OpLabel %2265 = OpFOrdGreaterThan %bool %2258 %2260 %2266 = OpExtInst %float %1 Log %float_0_180000007 %2267 = OpFDiv %float %2266 %1065 %2268 = OpFOrdLessThan %bool %2258 %2267 %2269 = OpLogicalAnd %bool %2265 %2268 OpSelectionMerge %2270 None OpBranchConditional %2269 %2271 %2272 %2272 = OpLabel %2273 = OpFOrdGreaterThanEqual %bool %2258 %2267 %2274 = OpExtInst %float %1 Log %2253 %2275 = OpFDiv %float %2274 %1065 %2276 = OpFOrdLessThan %bool %2258 %2275 %2277 = OpLogicalAnd %bool %2273 %2276 OpSelectionMerge %2278 None OpBranchConditional %2277 %2279 %2280 %2280 = OpLabel %2281 = OpExtInst %float %1 Log %float_10000 %2282 = OpFDiv %float %2281 %1065 OpBranch %2278 %2279 = OpLabel %2283 = OpFSub %float %2258 %2267 %2284 = OpFMul %float %float_3 %2283 %2285 = OpFSub %float %2275 %2267 %2286 = OpFDiv %float %2284 %2285 %2287 = OpConvertFToS %int %2286 %2288 = OpConvertSToF %float %2287 %2289 = OpFSub %float %2286 %2288 %2290 = OpAccessChain %_ptr_Function_float %519 %2287 %2291 = OpLoad %float %2290 %2292 = OpIAdd %int %2287 %int_1 %2293 = OpAccessChain %_ptr_Function_float %519 %2292 %2294 = OpLoad %float %2293 %2295 = OpIAdd %int %2287 %int_2 %2296 = OpAccessChain %_ptr_Function_float %519 %2295 %2297 = OpLoad %float %2296 %2298 = OpCompositeConstruct %v3float %2291 %2294 %2297 %2299 = OpFMul %float %2289 %2289 %2300 = OpCompositeConstruct %v3float %2299 %2289 %float_1 %2301 = OpMatrixTimesVector %v3float %442 %2298 %2302 = OpDot %float %2300 %2301 OpBranch %2278 %2278 = OpLabel %2303 = OpPhi %float %2282 %2280 %2302 %2279 OpBranch %2270 %2271 = OpLabel %2304 = OpFSub %float %2258 %2260 %2305 = OpFMul %float %float_3 %2304 %2306 = OpFSub %float %2267 %2260 %2307 = OpFDiv %float %2305 %2306 %2308 = OpConvertFToS %int %2307 %2309 = OpConvertSToF %float %2308 %2310 = OpFSub %float %2307 %2309 %2311 = OpAccessChain %_ptr_Function_float %520 %2308 %2312 = OpLoad %float %2311 %2313 = OpIAdd %int %2308 %int_1 %2314 = OpAccessChain %_ptr_Function_float %520 %2313 %2315 = OpLoad %float %2314 %2316 = OpIAdd %int %2308 %int_2 %2317 = OpAccessChain %_ptr_Function_float %520 %2316 %2318 = OpLoad %float %2317 %2319 = OpCompositeConstruct %v3float %2312 %2315 %2318 %2320 = OpFMul %float %2310 %2310 %2321 = OpCompositeConstruct %v3float %2320 %2310 %float_1 %2322 = OpMatrixTimesVector %v3float %442 %2319 %2323 = OpDot %float %2321 %2322 OpBranch %2270 %2270 = OpLabel %2324 = OpPhi %float %2303 %2278 %2323 %2271 OpBranch %2262 %2263 = OpLabel %2325 = OpExtInst %float %1 Log %float_9_99999975en05 %2326 = OpFDiv %float %2325 %1065 OpBranch %2262 %2262 = OpLabel %2327 = OpPhi %float %2324 %2270 %2326 %2263 %2328 = OpExtInst %float %1 Pow %float_10 %2327 %2329 = OpCompositeInsert %v3float %2328 %391 0 %2330 = OpCompositeExtract %float %2248 1 OpStore %522 %475 OpStore %521 %476 %2331 = OpFOrdLessThanEqual %bool %2330 %float_0 %2332 = OpSelect %float %2331 %2255 %2330 %2333 = OpExtInst %float %1 Log %2332 %2334 = OpFDiv %float %2333 %1065 %2335 = OpFOrdLessThanEqual %bool %2334 %2260 OpSelectionMerge %2336 None OpBranchConditional %2335 %2337 %2338 %2338 = OpLabel %2339 = OpFOrdGreaterThan %bool %2334 %2260 %2340 = OpExtInst %float %1 Log %float_0_180000007 %2341 = OpFDiv %float %2340 %1065 %2342 = OpFOrdLessThan %bool %2334 %2341 %2343 = OpLogicalAnd %bool %2339 %2342 OpSelectionMerge %2344 None OpBranchConditional %2343 %2345 %2346 %2346 = OpLabel %2347 = OpFOrdGreaterThanEqual %bool %2334 %2341 %2348 = OpExtInst %float %1 Log %2253 %2349 = OpFDiv %float %2348 %1065 %2350 = OpFOrdLessThan %bool %2334 %2349 %2351 = OpLogicalAnd %bool %2347 %2350 OpSelectionMerge %2352 None OpBranchConditional %2351 %2353 %2354 %2354 = OpLabel %2355 = OpExtInst %float %1 Log %float_10000 %2356 = OpFDiv %float %2355 %1065 OpBranch %2352 %2353 = OpLabel %2357 = OpFSub %float %2334 %2341 %2358 = OpFMul %float %float_3 %2357 %2359 = OpFSub %float %2349 %2341 %2360 = OpFDiv %float %2358 %2359 %2361 = OpConvertFToS %int %2360 %2362 = OpConvertSToF %float %2361 %2363 = OpFSub %float %2360 %2362 %2364 = OpAccessChain %_ptr_Function_float %521 %2361 %2365 = OpLoad %float %2364 %2366 = OpIAdd %int %2361 %int_1 %2367 = OpAccessChain %_ptr_Function_float %521 %2366 %2368 = OpLoad %float %2367 %2369 = OpIAdd %int %2361 %int_2 %2370 = OpAccessChain %_ptr_Function_float %521 %2369 %2371 = OpLoad %float %2370 %2372 = OpCompositeConstruct %v3float %2365 %2368 %2371 %2373 = OpFMul %float %2363 %2363 %2374 = OpCompositeConstruct %v3float %2373 %2363 %float_1 %2375 = OpMatrixTimesVector %v3float %442 %2372 %2376 = OpDot %float %2374 %2375 OpBranch %2352 %2352 = OpLabel %2377 = OpPhi %float %2356 %2354 %2376 %2353 OpBranch %2344 %2345 = OpLabel %2378 = OpFSub %float %2334 %2260 %2379 = OpFMul %float %float_3 %2378 %2380 = OpFSub %float %2341 %2260 %2381 = OpFDiv %float %2379 %2380 %2382 = OpConvertFToS %int %2381 %2383 = OpConvertSToF %float %2382 %2384 = OpFSub %float %2381 %2383 %2385 = OpAccessChain %_ptr_Function_float %522 %2382 %2386 = OpLoad %float %2385 %2387 = OpIAdd %int %2382 %int_1 %2388 = OpAccessChain %_ptr_Function_float %522 %2387 %2389 = OpLoad %float %2388 %2390 = OpIAdd %int %2382 %int_2 %2391 = OpAccessChain %_ptr_Function_float %522 %2390 %2392 = OpLoad %float %2391 %2393 = OpCompositeConstruct %v3float %2386 %2389 %2392 %2394 = OpFMul %float %2384 %2384 %2395 = OpCompositeConstruct %v3float %2394 %2384 %float_1 %2396 = OpMatrixTimesVector %v3float %442 %2393 %2397 = OpDot %float %2395 %2396 OpBranch %2344 %2344 = OpLabel %2398 = OpPhi %float %2377 %2352 %2397 %2345 OpBranch %2336 %2337 = OpLabel %2399 = OpExtInst %float %1 Log %float_9_99999975en05 %2400 = OpFDiv %float %2399 %1065 OpBranch %2336 %2336 = OpLabel %2401 = OpPhi %float %2398 %2344 %2400 %2337 %2402 = OpExtInst %float %1 Pow %float_10 %2401 %2403 = OpCompositeInsert %v3float %2402 %2329 1 %2404 = OpCompositeExtract %float %2248 2 OpStore %524 %475 OpStore %523 %476 %2405 = OpFOrdLessThanEqual %bool %2404 %float_0 %2406 = OpSelect %float %2405 %2255 %2404 %2407 = OpExtInst %float %1 Log %2406 %2408 = OpFDiv %float %2407 %1065 %2409 = OpFOrdLessThanEqual %bool %2408 %2260 OpSelectionMerge %2410 None OpBranchConditional %2409 %2411 %2412 %2412 = OpLabel %2413 = OpFOrdGreaterThan %bool %2408 %2260 %2414 = OpExtInst %float %1 Log %float_0_180000007 %2415 = OpFDiv %float %2414 %1065 %2416 = OpFOrdLessThan %bool %2408 %2415 %2417 = OpLogicalAnd %bool %2413 %2416 OpSelectionMerge %2418 None OpBranchConditional %2417 %2419 %2420 %2420 = OpLabel %2421 = OpFOrdGreaterThanEqual %bool %2408 %2415 %2422 = OpExtInst %float %1 Log %2253 %2423 = OpFDiv %float %2422 %1065 %2424 = OpFOrdLessThan %bool %2408 %2423 %2425 = OpLogicalAnd %bool %2421 %2424 OpSelectionMerge %2426 None OpBranchConditional %2425 %2427 %2428 %2428 = OpLabel %2429 = OpExtInst %float %1 Log %float_10000 %2430 = OpFDiv %float %2429 %1065 OpBranch %2426 %2427 = OpLabel %2431 = OpFSub %float %2408 %2415 %2432 = OpFMul %float %float_3 %2431 %2433 = OpFSub %float %2423 %2415 %2434 = OpFDiv %float %2432 %2433 %2435 = OpConvertFToS %int %2434 %2436 = OpConvertSToF %float %2435 %2437 = OpFSub %float %2434 %2436 %2438 = OpAccessChain %_ptr_Function_float %523 %2435 %2439 = OpLoad %float %2438 %2440 = OpIAdd %int %2435 %int_1 %2441 = OpAccessChain %_ptr_Function_float %523 %2440 %2442 = OpLoad %float %2441 %2443 = OpIAdd %int %2435 %int_2 %2444 = OpAccessChain %_ptr_Function_float %523 %2443 %2445 = OpLoad %float %2444 %2446 = OpCompositeConstruct %v3float %2439 %2442 %2445 %2447 = OpFMul %float %2437 %2437 %2448 = OpCompositeConstruct %v3float %2447 %2437 %float_1 %2449 = OpMatrixTimesVector %v3float %442 %2446 %2450 = OpDot %float %2448 %2449 OpBranch %2426 %2426 = OpLabel %2451 = OpPhi %float %2430 %2428 %2450 %2427 OpBranch %2418 %2419 = OpLabel %2452 = OpFSub %float %2408 %2260 %2453 = OpFMul %float %float_3 %2452 %2454 = OpFSub %float %2415 %2260 %2455 = OpFDiv %float %2453 %2454 %2456 = OpConvertFToS %int %2455 %2457 = OpConvertSToF %float %2456 %2458 = OpFSub %float %2455 %2457 %2459 = OpAccessChain %_ptr_Function_float %524 %2456 %2460 = OpLoad %float %2459 %2461 = OpIAdd %int %2456 %int_1 %2462 = OpAccessChain %_ptr_Function_float %524 %2461 %2463 = OpLoad %float %2462 %2464 = OpIAdd %int %2456 %int_2 %2465 = OpAccessChain %_ptr_Function_float %524 %2464 %2466 = OpLoad %float %2465 %2467 = OpCompositeConstruct %v3float %2460 %2463 %2466 %2468 = OpFMul %float %2458 %2458 %2469 = OpCompositeConstruct %v3float %2468 %2458 %float_1 %2470 = OpMatrixTimesVector %v3float %442 %2467 %2471 = OpDot %float %2469 %2470 OpBranch %2418 %2418 = OpLabel %2472 = OpPhi %float %2451 %2426 %2471 %2419 OpBranch %2410 %2411 = OpLabel %2473 = OpExtInst %float %1 Log %float_9_99999975en05 %2474 = OpFDiv %float %2473 %1065 OpBranch %2410 %2410 = OpLabel %2475 = OpPhi %float %2472 %2418 %2474 %2411 %2476 = OpExtInst %float %1 Pow %float_10 %2475 %2477 = OpCompositeInsert %v3float %2476 %2403 2 %2478 = OpVectorTimesMatrix %v3float %2477 %414 %2479 = OpVectorTimesMatrix %v3float %2478 %410 %2480 = OpExtInst %float %1 Pow %float_2 %float_n12 %2481 = OpFMul %float %float_0_179999992 %2480 OpStore %532 %475 OpStore %531 %476 %2482 = OpFOrdLessThanEqual %bool %2481 %float_0 %2483 = OpSelect %float %2482 %2255 %2481 %2484 = OpExtInst %float %1 Log %2483 %2485 = OpFDiv %float %2484 %1065 %2486 = OpFOrdLessThanEqual %bool %2485 %2260 OpSelectionMerge %2487 None OpBranchConditional %2486 %2488 %2489 %2489 = OpLabel %2490 = OpFOrdGreaterThan %bool %2485 %2260 %2491 = OpExtInst %float %1 Log %float_0_180000007 %2492 = OpFDiv %float %2491 %1065 %2493 = OpFOrdLessThan %bool %2485 %2492 %2494 = OpLogicalAnd %bool %2490 %2493 OpSelectionMerge %2495 None OpBranchConditional %2494 %2496 %2497 %2497 = OpLabel %2498 = OpFOrdGreaterThanEqual %bool %2485 %2492 %2499 = OpExtInst %float %1 Log %2253 %2500 = OpFDiv %float %2499 %1065 %2501 = OpFOrdLessThan %bool %2485 %2500 %2502 = OpLogicalAnd %bool %2498 %2501 OpSelectionMerge %2503 None OpBranchConditional %2502 %2504 %2505 %2505 = OpLabel %2506 = OpExtInst %float %1 Log %float_10000 %2507 = OpFDiv %float %2506 %1065 OpBranch %2503 %2504 = OpLabel %2508 = OpFSub %float %2485 %2492 %2509 = OpFMul %float %float_3 %2508 %2510 = OpFSub %float %2500 %2492 %2511 = OpFDiv %float %2509 %2510 %2512 = OpConvertFToS %int %2511 %2513 = OpConvertSToF %float %2512 %2514 = OpFSub %float %2511 %2513 %2515 = OpAccessChain %_ptr_Function_float %531 %2512 %2516 = OpLoad %float %2515 %2517 = OpIAdd %int %2512 %int_1 %2518 = OpAccessChain %_ptr_Function_float %531 %2517 %2519 = OpLoad %float %2518 %2520 = OpIAdd %int %2512 %int_2 %2521 = OpAccessChain %_ptr_Function_float %531 %2520 %2522 = OpLoad %float %2521 %2523 = OpCompositeConstruct %v3float %2516 %2519 %2522 %2524 = OpFMul %float %2514 %2514 %2525 = OpCompositeConstruct %v3float %2524 %2514 %float_1 %2526 = OpMatrixTimesVector %v3float %442 %2523 %2527 = OpDot %float %2525 %2526 OpBranch %2503 %2503 = OpLabel %2528 = OpPhi %float %2507 %2505 %2527 %2504 OpBranch %2495 %2496 = OpLabel %2529 = OpFSub %float %2485 %2260 %2530 = OpFMul %float %float_3 %2529 %2531 = OpFSub %float %2492 %2260 %2532 = OpFDiv %float %2530 %2531 %2533 = OpConvertFToS %int %2532 %2534 = OpConvertSToF %float %2533 %2535 = OpFSub %float %2532 %2534 %2536 = OpAccessChain %_ptr_Function_float %532 %2533 %2537 = OpLoad %float %2536 %2538 = OpIAdd %int %2533 %int_1 %2539 = OpAccessChain %_ptr_Function_float %532 %2538 %2540 = OpLoad %float %2539 %2541 = OpIAdd %int %2533 %int_2 %2542 = OpAccessChain %_ptr_Function_float %532 %2541 %2543 = OpLoad %float %2542 %2544 = OpCompositeConstruct %v3float %2537 %2540 %2543 %2545 = OpFMul %float %2535 %2535 %2546 = OpCompositeConstruct %v3float %2545 %2535 %float_1 %2547 = OpMatrixTimesVector %v3float %442 %2544 %2548 = OpDot %float %2546 %2547 OpBranch %2495 %2495 = OpLabel %2549 = OpPhi %float %2528 %2503 %2548 %2496 OpBranch %2487 %2488 = OpLabel %2550 = OpExtInst %float %1 Log %float_9_99999975en05 %2551 = OpFDiv %float %2550 %1065 OpBranch %2487 %2487 = OpLabel %2552 = OpPhi %float %2549 %2495 %2551 %2488 %2553 = OpExtInst %float %1 Pow %float_10 %2552 OpStore %534 %475 OpStore %533 %476 %2554 = OpExtInst %float %1 Log %float_0_180000007 %2555 = OpFDiv %float %2554 %1065 %2556 = OpFOrdLessThanEqual %bool %2555 %2260 OpSelectionMerge %2557 None OpBranchConditional %2556 %2558 %2559 %2559 = OpLabel %2560 = OpFOrdGreaterThan %bool %2555 %2260 %2561 = OpFOrdLessThan %bool %2555 %2555 %2562 = OpLogicalAnd %bool %2560 %2561 OpSelectionMerge %2563 None OpBranchConditional %2562 %2564 %2565 %2565 = OpLabel %2566 = OpFOrdGreaterThanEqual %bool %2555 %2555 %2567 = OpExtInst %float %1 Log %2253 %2568 = OpFDiv %float %2567 %1065 %2569 = OpFOrdLessThan %bool %2555 %2568 %2570 = OpLogicalAnd %bool %2566 %2569 OpSelectionMerge %2571 None OpBranchConditional %2570 %2572 %2573 %2573 = OpLabel %2574 = OpExtInst %float %1 Log %float_10000 %2575 = OpFDiv %float %2574 %1065 OpBranch %2571 %2572 = OpLabel %2576 = OpFSub %float %2555 %2555 %2577 = OpFMul %float %float_3 %2576 %2578 = OpFSub %float %2568 %2555 %2579 = OpFDiv %float %2577 %2578 %2580 = OpConvertFToS %int %2579 %2581 = OpConvertSToF %float %2580 %2582 = OpFSub %float %2579 %2581 %2583 = OpAccessChain %_ptr_Function_float %533 %2580 %2584 = OpLoad %float %2583 %2585 = OpIAdd %int %2580 %int_1 %2586 = OpAccessChain %_ptr_Function_float %533 %2585 %2587 = OpLoad %float %2586 %2588 = OpIAdd %int %2580 %int_2 %2589 = OpAccessChain %_ptr_Function_float %533 %2588 %2590 = OpLoad %float %2589 %2591 = OpCompositeConstruct %v3float %2584 %2587 %2590 %2592 = OpFMul %float %2582 %2582 %2593 = OpCompositeConstruct %v3float %2592 %2582 %float_1 %2594 = OpMatrixTimesVector %v3float %442 %2591 %2595 = OpDot %float %2593 %2594 OpBranch %2571 %2571 = OpLabel %2596 = OpPhi %float %2575 %2573 %2595 %2572 OpBranch %2563 %2564 = OpLabel %2597 = OpFSub %float %2555 %2260 %2598 = OpFMul %float %float_3 %2597 %2599 = OpAccessChain %_ptr_Function_float %534 %int_3 %2600 = OpLoad %float %2599 %2601 = OpAccessChain %_ptr_Function_float %534 %int_4 %2602 = OpLoad %float %2601 %2603 = OpAccessChain %_ptr_Function_float %534 %int_5 %2604 = OpLoad %float %2603 %2605 = OpCompositeConstruct %v3float %2600 %2602 %2604 %2606 = OpMatrixTimesVector %v3float %442 %2605 %2607 = OpCompositeExtract %float %2606 2 OpBranch %2563 %2563 = OpLabel %2608 = OpPhi %float %2596 %2571 %2607 %2564 OpBranch %2557 %2558 = OpLabel %2609 = OpExtInst %float %1 Log %float_9_99999975en05 %2610 = OpFDiv %float %2609 %1065 OpBranch %2557 %2557 = OpLabel %2611 = OpPhi %float %2608 %2563 %2610 %2558 %2612 = OpExtInst %float %1 Pow %float_10 %2611 %2613 = OpExtInst %float %1 Pow %float_2 %float_10 %2614 = OpFMul %float %float_0_179999992 %2613 OpStore %536 %475 OpStore %535 %476 %2615 = OpFOrdLessThanEqual %bool %2614 %float_0 %2616 = OpSelect %float %2615 %2255 %2614 %2617 = OpExtInst %float %1 Log %2616 %2618 = OpFDiv %float %2617 %1065 %2619 = OpFOrdLessThanEqual %bool %2618 %2260 OpSelectionMerge %2620 None OpBranchConditional %2619 %2621 %2622 %2622 = OpLabel %2623 = OpFOrdGreaterThan %bool %2618 %2260 %2624 = OpFOrdLessThan %bool %2618 %2555 %2625 = OpLogicalAnd %bool %2623 %2624 OpSelectionMerge %2626 None OpBranchConditional %2625 %2627 %2628 %2628 = OpLabel %2629 = OpFOrdGreaterThanEqual %bool %2618 %2555 %2630 = OpExtInst %float %1 Log %2253 %2631 = OpFDiv %float %2630 %1065 %2632 = OpFOrdLessThan %bool %2618 %2631 %2633 = OpLogicalAnd %bool %2629 %2632 OpSelectionMerge %2634 None OpBranchConditional %2633 %2635 %2636 %2636 = OpLabel %2637 = OpExtInst %float %1 Log %float_10000 %2638 = OpFDiv %float %2637 %1065 OpBranch %2634 %2635 = OpLabel %2639 = OpFSub %float %2618 %2555 %2640 = OpFMul %float %float_3 %2639 %2641 = OpFSub %float %2631 %2555 %2642 = OpFDiv %float %2640 %2641 %2643 = OpConvertFToS %int %2642 %2644 = OpConvertSToF %float %2643 %2645 = OpFSub %float %2642 %2644 %2646 = OpAccessChain %_ptr_Function_float %535 %2643 %2647 = OpLoad %float %2646 %2648 = OpIAdd %int %2643 %int_1 %2649 = OpAccessChain %_ptr_Function_float %535 %2648 %2650 = OpLoad %float %2649 %2651 = OpIAdd %int %2643 %int_2 %2652 = OpAccessChain %_ptr_Function_float %535 %2651 %2653 = OpLoad %float %2652 %2654 = OpCompositeConstruct %v3float %2647 %2650 %2653 %2655 = OpFMul %float %2645 %2645 %2656 = OpCompositeConstruct %v3float %2655 %2645 %float_1 %2657 = OpMatrixTimesVector %v3float %442 %2654 %2658 = OpDot %float %2656 %2657 OpBranch %2634 %2634 = OpLabel %2659 = OpPhi %float %2638 %2636 %2658 %2635 OpBranch %2626 %2627 = OpLabel %2660 = OpFSub %float %2618 %2260 %2661 = OpFMul %float %float_3 %2660 %2662 = OpFSub %float %2555 %2260 %2663 = OpFDiv %float %2661 %2662 %2664 = OpConvertFToS %int %2663 %2665 = OpConvertSToF %float %2664 %2666 = OpFSub %float %2663 %2665 %2667 = OpAccessChain %_ptr_Function_float %536 %2664 %2668 = OpLoad %float %2667 %2669 = OpIAdd %int %2664 %int_1 %2670 = OpAccessChain %_ptr_Function_float %536 %2669 %2671 = OpLoad %float %2670 %2672 = OpIAdd %int %2664 %int_2 %2673 = OpAccessChain %_ptr_Function_float %536 %2672 %2674 = OpLoad %float %2673 %2675 = OpCompositeConstruct %v3float %2668 %2671 %2674 %2676 = OpFMul %float %2666 %2666 %2677 = OpCompositeConstruct %v3float %2676 %2666 %float_1 %2678 = OpMatrixTimesVector %v3float %442 %2675 %2679 = OpDot %float %2677 %2678 OpBranch %2626 %2626 = OpLabel %2680 = OpPhi %float %2659 %2634 %2679 %2627 OpBranch %2620 %2621 = OpLabel %2681 = OpExtInst %float %1 Log %float_9_99999975en05 %2682 = OpFDiv %float %2681 %1065 OpBranch %2620 %2620 = OpLabel %2683 = OpPhi %float %2680 %2626 %2682 %2621 %2684 = OpExtInst %float %1 Pow %float_10 %2683 %2685 = OpCompositeExtract %float %2479 0 OpStore %530 %479 OpStore %529 %480 %2686 = OpFOrdLessThanEqual %bool %2685 %float_0 %2687 = OpSelect %float %2686 %float_9_99999975en05 %2685 %2688 = OpExtInst %float %1 Log %2687 %2689 = OpFDiv %float %2688 %1065 %2690 = OpExtInst %float %1 Log %2553 %2691 = OpFDiv %float %2690 %1065 %2692 = OpFOrdLessThanEqual %bool %2689 %2691 OpSelectionMerge %2693 None OpBranchConditional %2692 %2694 %2695 %2695 = OpLabel %2696 = OpFOrdGreaterThan %bool %2689 %2691 %2697 = OpExtInst %float %1 Log %2612 %2698 = OpFDiv %float %2697 %1065 %2699 = OpFOrdLessThan %bool %2689 %2698 %2700 = OpLogicalAnd %bool %2696 %2699 OpSelectionMerge %2701 None OpBranchConditional %2700 %2702 %2703 %2703 = OpLabel %2704 = OpFOrdGreaterThanEqual %bool %2689 %2698 %2705 = OpExtInst %float %1 Log %2684 %2706 = OpFDiv %float %2705 %1065 %2707 = OpFOrdLessThan %bool %2689 %2706 %2708 = OpLogicalAnd %bool %2704 %2707 OpSelectionMerge %2709 None OpBranchConditional %2708 %2710 %2711 %2711 = OpLabel %2712 = OpFMul %float %2689 %float_0_0599999987 %2713 = OpExtInst %float %1 Log %float_1000 %2714 = OpFDiv %float %2713 %1065 %2715 = OpFMul %float %float_0_0599999987 %2705 %2716 = OpFDiv %float %2715 %1065 %2717 = OpFSub %float %2714 %2716 %2718 = OpFAdd %float %2712 %2717 OpBranch %2709 %2710 = OpLabel %2719 = OpFSub %float %2689 %2698 %2720 = OpFMul %float %float_7 %2719 %2721 = OpFSub %float %2706 %2698 %2722 = OpFDiv %float %2720 %2721 %2723 = OpConvertFToS %int %2722 %2724 = OpConvertSToF %float %2723 %2725 = OpFSub %float %2722 %2724 %2726 = OpAccessChain %_ptr_Function_float %529 %2723 %2727 = OpLoad %float %2726 %2728 = OpIAdd %int %2723 %int_1 %2729 = OpAccessChain %_ptr_Function_float %529 %2728 %2730 = OpLoad %float %2729 %2731 = OpIAdd %int %2723 %int_2 %2732 = OpAccessChain %_ptr_Function_float %529 %2731 %2733 = OpLoad %float %2732 %2734 = OpCompositeConstruct %v3float %2727 %2730 %2733 %2735 = OpFMul %float %2725 %2725 %2736 = OpCompositeConstruct %v3float %2735 %2725 %float_1 %2737 = OpMatrixTimesVector %v3float %442 %2734 %2738 = OpDot %float %2736 %2737 OpBranch %2709 %2709 = OpLabel %2739 = OpPhi %float %2718 %2711 %2738 %2710 OpBranch %2701 %2702 = OpLabel %2740 = OpFSub %float %2689 %2691 %2741 = OpFMul %float %float_7 %2740 %2742 = OpFSub %float %2698 %2691 %2743 = OpFDiv %float %2741 %2742 %2744 = OpConvertFToS %int %2743 %2745 = OpConvertSToF %float %2744 %2746 = OpFSub %float %2743 %2745 %2747 = OpAccessChain %_ptr_Function_float %530 %2744 %2748 = OpLoad %float %2747 %2749 = OpIAdd %int %2744 %int_1 %2750 = OpAccessChain %_ptr_Function_float %530 %2749 %2751 = OpLoad %float %2750 %2752 = OpIAdd %int %2744 %int_2 %2753 = OpAccessChain %_ptr_Function_float %530 %2752 %2754 = OpLoad %float %2753 %2755 = OpCompositeConstruct %v3float %2748 %2751 %2754 %2756 = OpFMul %float %2746 %2746 %2757 = OpCompositeConstruct %v3float %2756 %2746 %float_1 %2758 = OpMatrixTimesVector %v3float %442 %2755 %2759 = OpDot %float %2757 %2758 OpBranch %2701 %2701 = OpLabel %2760 = OpPhi %float %2739 %2709 %2759 %2702 OpBranch %2693 %2694 = OpLabel %2761 = OpFMul %float %2689 %float_3 %2762 = OpExtInst %float %1 Log %float_9_99999975en05 %2763 = OpFDiv %float %2762 %1065 %2764 = OpFMul %float %float_3 %2690 %2765 = OpFDiv %float %2764 %1065 %2766 = OpFSub %float %2763 %2765 %2767 = OpFAdd %float %2761 %2766 OpBranch %2693 %2693 = OpLabel %2768 = OpPhi %float %2760 %2701 %2767 %2694 %2769 = OpExtInst %float %1 Pow %float_10 %2768 %2770 = OpCompositeInsert %v3float %2769 %391 0 %2771 = OpCompositeExtract %float %2479 1 OpStore %528 %479 OpStore %527 %480 %2772 = OpFOrdLessThanEqual %bool %2771 %float_0 %2773 = OpSelect %float %2772 %float_9_99999975en05 %2771 %2774 = OpExtInst %float %1 Log %2773 %2775 = OpFDiv %float %2774 %1065 %2776 = OpFOrdLessThanEqual %bool %2775 %2691 OpSelectionMerge %2777 None OpBranchConditional %2776 %2778 %2779 %2779 = OpLabel %2780 = OpFOrdGreaterThan %bool %2775 %2691 %2781 = OpExtInst %float %1 Log %2612 %2782 = OpFDiv %float %2781 %1065 %2783 = OpFOrdLessThan %bool %2775 %2782 %2784 = OpLogicalAnd %bool %2780 %2783 OpSelectionMerge %2785 None OpBranchConditional %2784 %2786 %2787 %2787 = OpLabel %2788 = OpFOrdGreaterThanEqual %bool %2775 %2782 %2789 = OpExtInst %float %1 Log %2684 %2790 = OpFDiv %float %2789 %1065 %2791 = OpFOrdLessThan %bool %2775 %2790 %2792 = OpLogicalAnd %bool %2788 %2791 OpSelectionMerge %2793 None OpBranchConditional %2792 %2794 %2795 %2795 = OpLabel %2796 = OpFMul %float %2775 %float_0_0599999987 %2797 = OpExtInst %float %1 Log %float_1000 %2798 = OpFDiv %float %2797 %1065 %2799 = OpFMul %float %float_0_0599999987 %2789 %2800 = OpFDiv %float %2799 %1065 %2801 = OpFSub %float %2798 %2800 %2802 = OpFAdd %float %2796 %2801 OpBranch %2793 %2794 = OpLabel %2803 = OpFSub %float %2775 %2782 %2804 = OpFMul %float %float_7 %2803 %2805 = OpFSub %float %2790 %2782 %2806 = OpFDiv %float %2804 %2805 %2807 = OpConvertFToS %int %2806 %2808 = OpConvertSToF %float %2807 %2809 = OpFSub %float %2806 %2808 %2810 = OpAccessChain %_ptr_Function_float %527 %2807 %2811 = OpLoad %float %2810 %2812 = OpIAdd %int %2807 %int_1 %2813 = OpAccessChain %_ptr_Function_float %527 %2812 %2814 = OpLoad %float %2813 %2815 = OpIAdd %int %2807 %int_2 %2816 = OpAccessChain %_ptr_Function_float %527 %2815 %2817 = OpLoad %float %2816 %2818 = OpCompositeConstruct %v3float %2811 %2814 %2817 %2819 = OpFMul %float %2809 %2809 %2820 = OpCompositeConstruct %v3float %2819 %2809 %float_1 %2821 = OpMatrixTimesVector %v3float %442 %2818 %2822 = OpDot %float %2820 %2821 OpBranch %2793 %2793 = OpLabel %2823 = OpPhi %float %2802 %2795 %2822 %2794 OpBranch %2785 %2786 = OpLabel %2824 = OpFSub %float %2775 %2691 %2825 = OpFMul %float %float_7 %2824 %2826 = OpFSub %float %2782 %2691 %2827 = OpFDiv %float %2825 %2826 %2828 = OpConvertFToS %int %2827 %2829 = OpConvertSToF %float %2828 %2830 = OpFSub %float %2827 %2829 %2831 = OpAccessChain %_ptr_Function_float %528 %2828 %2832 = OpLoad %float %2831 %2833 = OpIAdd %int %2828 %int_1 %2834 = OpAccessChain %_ptr_Function_float %528 %2833 %2835 = OpLoad %float %2834 %2836 = OpIAdd %int %2828 %int_2 %2837 = OpAccessChain %_ptr_Function_float %528 %2836 %2838 = OpLoad %float %2837 %2839 = OpCompositeConstruct %v3float %2832 %2835 %2838 %2840 = OpFMul %float %2830 %2830 %2841 = OpCompositeConstruct %v3float %2840 %2830 %float_1 %2842 = OpMatrixTimesVector %v3float %442 %2839 %2843 = OpDot %float %2841 %2842 OpBranch %2785 %2785 = OpLabel %2844 = OpPhi %float %2823 %2793 %2843 %2786 OpBranch %2777 %2778 = OpLabel %2845 = OpFMul %float %2775 %float_3 %2846 = OpExtInst %float %1 Log %float_9_99999975en05 %2847 = OpFDiv %float %2846 %1065 %2848 = OpFMul %float %float_3 %2690 %2849 = OpFDiv %float %2848 %1065 %2850 = OpFSub %float %2847 %2849 %2851 = OpFAdd %float %2845 %2850 OpBranch %2777 %2777 = OpLabel %2852 = OpPhi %float %2844 %2785 %2851 %2778 %2853 = OpExtInst %float %1 Pow %float_10 %2852 %2854 = OpCompositeInsert %v3float %2853 %2770 1 %2855 = OpCompositeExtract %float %2479 2 OpStore %526 %479 OpStore %525 %480 %2856 = OpFOrdLessThanEqual %bool %2855 %float_0 %2857 = OpSelect %float %2856 %float_9_99999975en05 %2855 %2858 = OpExtInst %float %1 Log %2857 %2859 = OpFDiv %float %2858 %1065 %2860 = OpFOrdLessThanEqual %bool %2859 %2691 OpSelectionMerge %2861 None OpBranchConditional %2860 %2862 %2863 %2863 = OpLabel %2864 = OpFOrdGreaterThan %bool %2859 %2691 %2865 = OpExtInst %float %1 Log %2612 %2866 = OpFDiv %float %2865 %1065 %2867 = OpFOrdLessThan %bool %2859 %2866 %2868 = OpLogicalAnd %bool %2864 %2867 OpSelectionMerge %2869 None OpBranchConditional %2868 %2870 %2871 %2871 = OpLabel %2872 = OpFOrdGreaterThanEqual %bool %2859 %2866 %2873 = OpExtInst %float %1 Log %2684 %2874 = OpFDiv %float %2873 %1065 %2875 = OpFOrdLessThan %bool %2859 %2874 %2876 = OpLogicalAnd %bool %2872 %2875 OpSelectionMerge %2877 None OpBranchConditional %2876 %2878 %2879 %2879 = OpLabel %2880 = OpFMul %float %2859 %float_0_0599999987 %2881 = OpExtInst %float %1 Log %float_1000 %2882 = OpFDiv %float %2881 %1065 %2883 = OpFMul %float %float_0_0599999987 %2873 %2884 = OpFDiv %float %2883 %1065 %2885 = OpFSub %float %2882 %2884 %2886 = OpFAdd %float %2880 %2885 OpBranch %2877 %2878 = OpLabel %2887 = OpFSub %float %2859 %2866 %2888 = OpFMul %float %float_7 %2887 %2889 = OpFSub %float %2874 %2866 %2890 = OpFDiv %float %2888 %2889 %2891 = OpConvertFToS %int %2890 %2892 = OpConvertSToF %float %2891 %2893 = OpFSub %float %2890 %2892 %2894 = OpAccessChain %_ptr_Function_float %525 %2891 %2895 = OpLoad %float %2894 %2896 = OpIAdd %int %2891 %int_1 %2897 = OpAccessChain %_ptr_Function_float %525 %2896 %2898 = OpLoad %float %2897 %2899 = OpIAdd %int %2891 %int_2 %2900 = OpAccessChain %_ptr_Function_float %525 %2899 %2901 = OpLoad %float %2900 %2902 = OpCompositeConstruct %v3float %2895 %2898 %2901 %2903 = OpFMul %float %2893 %2893 %2904 = OpCompositeConstruct %v3float %2903 %2893 %float_1 %2905 = OpMatrixTimesVector %v3float %442 %2902 %2906 = OpDot %float %2904 %2905 OpBranch %2877 %2877 = OpLabel %2907 = OpPhi %float %2886 %2879 %2906 %2878 OpBranch %2869 %2870 = OpLabel %2908 = OpFSub %float %2859 %2691 %2909 = OpFMul %float %float_7 %2908 %2910 = OpFSub %float %2866 %2691 %2911 = OpFDiv %float %2909 %2910 %2912 = OpConvertFToS %int %2911 %2913 = OpConvertSToF %float %2912 %2914 = OpFSub %float %2911 %2913 %2915 = OpAccessChain %_ptr_Function_float %526 %2912 %2916 = OpLoad %float %2915 %2917 = OpIAdd %int %2912 %int_1 %2918 = OpAccessChain %_ptr_Function_float %526 %2917 %2919 = OpLoad %float %2918 %2920 = OpIAdd %int %2912 %int_2 %2921 = OpAccessChain %_ptr_Function_float %526 %2920 %2922 = OpLoad %float %2921 %2923 = OpCompositeConstruct %v3float %2916 %2919 %2922 %2924 = OpFMul %float %2914 %2914 %2925 = OpCompositeConstruct %v3float %2924 %2914 %float_1 %2926 = OpMatrixTimesVector %v3float %442 %2923 %2927 = OpDot %float %2925 %2926 OpBranch %2869 %2869 = OpLabel %2928 = OpPhi %float %2907 %2877 %2927 %2870 OpBranch %2861 %2862 = OpLabel %2929 = OpFMul %float %2859 %float_3 %2930 = OpExtInst %float %1 Log %float_9_99999975en05 %2931 = OpFDiv %float %2930 %1065 %2932 = OpFMul %float %float_3 %2690 %2933 = OpFDiv %float %2932 %1065 %2934 = OpFSub %float %2931 %2933 %2935 = OpFAdd %float %2929 %2934 OpBranch %2861 %2861 = OpLabel %2936 = OpPhi %float %2928 %2869 %2935 %2862 %2937 = OpExtInst %float %1 Pow %float_10 %2936 %2938 = OpCompositeInsert %v3float %2937 %2854 2 %2939 = OpFSub %v3float %2938 %338 %2940 = OpVectorTimesMatrix %v3float %2939 %576 %2941 = OpFMul %v3float %2940 %496 %2942 = OpExtInst %v3float %1 Pow %2941 %263 %2943 = OpFMul %v3float %184 %2942 %2944 = OpFAdd %v3float %183 %2943 %2945 = OpFMul %v3float %185 %2942 %2946 = OpFAdd %v3float %135 %2945 %2947 = OpFDiv %v3float %135 %2946 %2948 = OpFMul %v3float %2944 %2947 %2949 = OpExtInst %v3float %1 Pow %2948 %264 OpBranch %1230 %1230 = OpLabel %2950 = OpPhi %v3float %2097 %1236 %2949 %2861 OpBranch %1224 %1225 = OpLabel %2951 = OpVectorTimesMatrix %v3float %1218 %547 %2952 = OpVectorTimesMatrix %v3float %2951 %576 %2953 = OpExtInst %v3float %1 FMax %250 %2952 %2954 = OpFMul %v3float %2953 %252 %2955 = OpExtInst %v3float %1 FMax %2953 %254 %2956 = OpExtInst %v3float %1 Pow %2955 %256 %2957 = OpFMul %v3float %2956 %258 %2958 = OpFSub %v3float %2957 %260 %2959 = OpExtInst %v3float %1 FMin %2954 %2958 OpBranch %1224 %1224 = OpLabel %2960 = OpPhi %v3float %2950 %1230 %2959 %1225 OpBranch %1220 %1221 = OpLabel %2961 = OpCompositeExtract %float %1218 0 OpBranch %2962 %2962 = OpLabel OpLoopMerge %2963 %2964 None OpBranch %2965 %2965 = OpLabel %2966 = OpFOrdLessThan %bool %2961 %float_0_00313066994 OpSelectionMerge %2967 None OpBranchConditional %2966 %2968 %2967 %2968 = OpLabel %2969 = OpFMul %float %2961 %float_12_9200001 OpBranch %2963 %2967 = OpLabel %2970 = OpExtInst %float %1 Pow %2961 %float_0_416666657 %2971 = OpFMul %float %2970 %float_1_05499995 %2972 = OpFSub %float %2971 %float_0_0549999997 OpBranch %2963 %2964 = OpLabel OpBranch %2962 %2963 = OpLabel %2973 = OpPhi %float %2969 %2968 %2972 %2967 %2974 = OpCompositeExtract %float %1218 1 OpBranch %2975 %2975 = OpLabel OpLoopMerge %2976 %2977 None OpBranch %2978 %2978 = OpLabel %2979 = OpFOrdLessThan %bool %2974 %float_0_00313066994 OpSelectionMerge %2980 None OpBranchConditional %2979 %2981 %2980 %2981 = OpLabel %2982 = OpFMul %float %2974 %float_12_9200001 OpBranch %2976 %2980 = OpLabel %2983 = OpExtInst %float %1 Pow %2974 %float_0_416666657 %2984 = OpFMul %float %2983 %float_1_05499995 %2985 = OpFSub %float %2984 %float_0_0549999997 OpBranch %2976 %2977 = OpLabel OpBranch %2975 %2976 = OpLabel %2986 = OpPhi %float %2982 %2981 %2985 %2980 %2987 = OpCompositeExtract %float %1218 2 OpBranch %2988 %2988 = OpLabel OpLoopMerge %2989 %2990 None OpBranch %2991 %2991 = OpLabel %2992 = OpFOrdLessThan %bool %2987 %float_0_00313066994 OpSelectionMerge %2993 None OpBranchConditional %2992 %2994 %2993 %2994 = OpLabel %2995 = OpFMul %float %2987 %float_12_9200001 OpBranch %2989 %2993 = OpLabel %2996 = OpExtInst %float %1 Pow %2987 %float_0_416666657 %2997 = OpFMul %float %2996 %float_1_05499995 %2998 = OpFSub %float %2997 %float_0_0549999997 OpBranch %2989 %2990 = OpLabel OpBranch %2988 %2989 = OpLabel %2999 = OpPhi %float %2995 %2994 %2998 %2993 %3000 = OpCompositeConstruct %v3float %2973 %2986 %2999 OpBranch %1220 %1220 = OpLabel %3001 = OpPhi %v3float %2960 %1224 %3000 %2989 %3002 = OpFMul %v3float %3001 %499 %3003 = OpVectorShuffle %v4float %129 %3002 4 5 6 3 %3004 = OpCompositeInsert %v4float %float_0 %3003 3 OpStore %out_var_SV_Target0 %3004 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/frag/padded-float-array-member-defef.asm.frag000066400000000000000000005246041400026215700276240ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 3107 ; Schema: 0 OpCapability Shader OpCapability Geometry OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPS "main" %in_var_TEXCOORD0 %gl_FragCoord %gl_Layer %out_var_SV_Target0 OpExecutionMode %MainPS OriginUpperLeft OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "MappingPolynomial" OpMemberName %type__Globals 1 "InverseGamma" OpMemberName %type__Globals 2 "ColorMatrixR_ColorCurveCd1" OpMemberName %type__Globals 3 "ColorMatrixG_ColorCurveCd3Cm3" OpMemberName %type__Globals 4 "ColorMatrixB_ColorCurveCm2" OpMemberName %type__Globals 5 "ColorCurve_Cm0Cd0_Cd2_Ch0Cm1_Ch3" OpMemberName %type__Globals 6 "ColorCurve_Ch1_Ch2" OpMemberName %type__Globals 7 "ColorShadow_Luma" OpMemberName %type__Globals 8 "ColorShadow_Tint1" OpMemberName %type__Globals 9 "ColorShadow_Tint2" OpMemberName %type__Globals 10 "FilmSlope" OpMemberName %type__Globals 11 "FilmToe" OpMemberName %type__Globals 12 "FilmShoulder" OpMemberName %type__Globals 13 "FilmBlackClip" OpMemberName %type__Globals 14 "FilmWhiteClip" OpMemberName %type__Globals 15 "LUTWeights" OpMemberName %type__Globals 16 "ColorScale" OpMemberName %type__Globals 17 "OverlayColor" OpMemberName %type__Globals 18 "WhiteTemp" OpMemberName %type__Globals 19 "WhiteTint" OpMemberName %type__Globals 20 "ColorSaturation" OpMemberName %type__Globals 21 "ColorContrast" OpMemberName %type__Globals 22 "ColorGamma" OpMemberName %type__Globals 23 "ColorGain" OpMemberName %type__Globals 24 "ColorOffset" OpMemberName %type__Globals 25 "ColorSaturationShadows" OpMemberName %type__Globals 26 "ColorContrastShadows" OpMemberName %type__Globals 27 "ColorGammaShadows" OpMemberName %type__Globals 28 "ColorGainShadows" OpMemberName %type__Globals 29 "ColorOffsetShadows" OpMemberName %type__Globals 30 "ColorSaturationMidtones" OpMemberName %type__Globals 31 "ColorContrastMidtones" OpMemberName %type__Globals 32 "ColorGammaMidtones" OpMemberName %type__Globals 33 "ColorGainMidtones" OpMemberName %type__Globals 34 "ColorOffsetMidtones" OpMemberName %type__Globals 35 "ColorSaturationHighlights" OpMemberName %type__Globals 36 "ColorContrastHighlights" OpMemberName %type__Globals 37 "ColorGammaHighlights" OpMemberName %type__Globals 38 "ColorGainHighlights" OpMemberName %type__Globals 39 "ColorOffsetHighlights" OpMemberName %type__Globals 40 "ColorCorrectionShadowsMax" OpMemberName %type__Globals 41 "ColorCorrectionHighlightsMin" OpMemberName %type__Globals 42 "OutputDevice" OpMemberName %type__Globals 43 "OutputGamut" OpMemberName %type__Globals 44 "BlueCorrection" OpMemberName %type__Globals 45 "ExpandGamut" OpName %_Globals "$Globals" OpName %type_2d_image "type.2d.image" OpName %Texture1 "Texture1" OpName %type_sampler "type.sampler" OpName %Texture1Sampler "Texture1Sampler" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPS "MainPS" OpName %type_sampled_image "type.sampled.image" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorate %in_var_TEXCOORD0 NoPerspective OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_POSITION" OpDecorate %gl_Layer BuiltIn Layer OpDecorateString %gl_Layer UserSemantic "SV_RenderTargetArrayIndex" OpDecorate %gl_Layer Flat OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpDecorate %Texture1 DescriptorSet 0 OpDecorate %Texture1 Binding 0 OpDecorate %Texture1Sampler DescriptorSet 0 OpDecorate %Texture1Sampler Binding 0 OpDecorate %_arr_float_uint_5 ArrayStride 16 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 32 OpMemberDecorate %type__Globals 3 Offset 48 OpMemberDecorate %type__Globals 4 Offset 64 OpMemberDecorate %type__Globals 5 Offset 80 OpMemberDecorate %type__Globals 6 Offset 96 OpMemberDecorate %type__Globals 7 Offset 112 OpMemberDecorate %type__Globals 8 Offset 128 OpMemberDecorate %type__Globals 9 Offset 144 OpMemberDecorate %type__Globals 10 Offset 160 OpMemberDecorate %type__Globals 11 Offset 164 OpMemberDecorate %type__Globals 12 Offset 168 OpMemberDecorate %type__Globals 13 Offset 172 OpMemberDecorate %type__Globals 14 Offset 176 OpMemberDecorate %type__Globals 15 Offset 192 OpMemberDecorate %type__Globals 16 Offset 272 OpMemberDecorate %type__Globals 17 Offset 288 OpMemberDecorate %type__Globals 18 Offset 304 OpMemberDecorate %type__Globals 19 Offset 308 OpMemberDecorate %type__Globals 20 Offset 320 OpMemberDecorate %type__Globals 21 Offset 336 OpMemberDecorate %type__Globals 22 Offset 352 OpMemberDecorate %type__Globals 23 Offset 368 OpMemberDecorate %type__Globals 24 Offset 384 OpMemberDecorate %type__Globals 25 Offset 400 OpMemberDecorate %type__Globals 26 Offset 416 OpMemberDecorate %type__Globals 27 Offset 432 OpMemberDecorate %type__Globals 28 Offset 448 OpMemberDecorate %type__Globals 29 Offset 464 OpMemberDecorate %type__Globals 30 Offset 480 OpMemberDecorate %type__Globals 31 Offset 496 OpMemberDecorate %type__Globals 32 Offset 512 OpMemberDecorate %type__Globals 33 Offset 528 OpMemberDecorate %type__Globals 34 Offset 544 OpMemberDecorate %type__Globals 35 Offset 560 OpMemberDecorate %type__Globals 36 Offset 576 OpMemberDecorate %type__Globals 37 Offset 592 OpMemberDecorate %type__Globals 38 Offset 608 OpMemberDecorate %type__Globals 39 Offset 624 OpMemberDecorate %type__Globals 40 Offset 640 OpMemberDecorate %type__Globals 41 Offset 644 OpMemberDecorate %type__Globals 42 Offset 648 OpMemberDecorate %type__Globals 43 Offset 652 OpMemberDecorate %type__Globals 44 Offset 656 OpMemberDecorate %type__Globals 45 Offset 660 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %float_0_952552378 = OpConstant %float 0.952552378 %float_0 = OpConstant %float 0 ; HACK: Needed to hack this constant since MSVC and GNU libc are off by 1 ULP when converting to string (it probably still works fine though in a roundtrip ...) %float_9_36786018en05 = OpConstant %float 9.25 %float_0_343966454 = OpConstant %float 0.343966454 %float_0_728166103 = OpConstant %float 0.728166103 %float_n0_0721325427 = OpConstant %float -0.0721325427 %float_1_00882518 = OpConstant %float 1.00882518 %float_1_04981101 = OpConstant %float 1.04981101 %float_n9_74845025en05 = OpConstant %float -9.74845025e-05 %float_n0_495903015 = OpConstant %float -0.495903015 %float_1_37331307 = OpConstant %float 1.37331307 %float_0_0982400328 = OpConstant %float 0.0982400328 %float_0_991252005 = OpConstant %float 0.991252005 %float_0_662454188 = OpConstant %float 0.662454188 %float_0_134004205 = OpConstant %float 0.134004205 %float_0_156187683 = OpConstant %float 0.156187683 %float_0_272228718 = OpConstant %float 0.272228718 %float_0_674081743 = OpConstant %float 0.674081743 %float_0_0536895171 = OpConstant %float 0.0536895171 %float_n0_00557464967 = OpConstant %float -0.00557464967 %float_0_0040607336 = OpConstant %float 0.0040607336 %float_1_01033914 = OpConstant %float 1.01033914 %float_1_6410234 = OpConstant %float 1.6410234 %float_n0_324803293 = OpConstant %float -0.324803293 %float_n0_236424699 = OpConstant %float -0.236424699 %float_n0_663662851 = OpConstant %float -0.663662851 %float_1_61533165 = OpConstant %float 1.61533165 %float_0_0167563483 = OpConstant %float 0.0167563483 %float_0_0117218941 = OpConstant %float 0.0117218941 %float_n0_00828444213 = OpConstant %float -0.00828444213 %float_0_988394856 = OpConstant %float 0.988394856 %float_1_45143926 = OpConstant %float 1.45143926 %float_n0_236510754 = OpConstant %float -0.236510754 %float_n0_214928567 = OpConstant %float -0.214928567 %float_n0_0765537769 = OpConstant %float -0.0765537769 %float_1_17622972 = OpConstant %float 1.17622972 %float_n0_0996759236 = OpConstant %float -0.0996759236 %float_0_00831614807 = OpConstant %float 0.00831614807 %float_n0_00603244966 = OpConstant %float -0.00603244966 %float_0_997716308 = OpConstant %float 0.997716308 %float_0_695452213 = OpConstant %float 0.695452213 %float_0_140678704 = OpConstant %float 0.140678704 %float_0_163869068 = OpConstant %float 0.163869068 %float_0_0447945632 = OpConstant %float 0.0447945632 %float_0_859671116 = OpConstant %float 0.859671116 %float_0_0955343172 = OpConstant %float 0.0955343172 %float_n0_00552588282 = OpConstant %float -0.00552588282 %float_0_00402521016 = OpConstant %float 0.00402521016 %float_1_00150073 = OpConstant %float 1.00150073 %73 = OpConstantComposite %v3float %float_0_272228718 %float_0_674081743 %float_0_0536895171 %float_3_2409699 = OpConstant %float 3.2409699 %float_n1_5373832 = OpConstant %float -1.5373832 %float_n0_498610765 = OpConstant %float -0.498610765 %float_n0_969243646 = OpConstant %float -0.969243646 %float_1_8759675 = OpConstant %float 1.8759675 %float_0_0415550582 = OpConstant %float 0.0415550582 %float_0_0556300804 = OpConstant %float 0.0556300804 %float_n0_203976959 = OpConstant %float -0.203976959 %float_1_05697155 = OpConstant %float 1.05697155 %float_0_412456393 = OpConstant %float 0.412456393 %float_0_357576102 = OpConstant %float 0.357576102 %float_0_180437505 = OpConstant %float 0.180437505 %float_0_212672904 = OpConstant %float 0.212672904 %float_0_715152204 = OpConstant %float 0.715152204 %float_0_0721750036 = OpConstant %float 0.0721750036 %float_0_0193339009 = OpConstant %float 0.0193339009 %float_0_119191997 = OpConstant %float 0.119191997 %float_0_950304091 = OpConstant %float 0.950304091 %float_1_71660841 = OpConstant %float 1.71660841 %float_n0_355662107 = OpConstant %float -0.355662107 %float_n0_253360093 = OpConstant %float -0.253360093 %float_n0_666682899 = OpConstant %float -0.666682899 %float_1_61647761 = OpConstant %float 1.61647761 %float_0_0157685 = OpConstant %float 0.0157685 %float_0_0176422 = OpConstant %float 0.0176422 %float_n0_0427763015 = OpConstant %float -0.0427763015 %float_0_942228675 = OpConstant %float 0.942228675 %float_2_49339628 = OpConstant %float 2.49339628 %float_n0_93134588 = OpConstant %float -0.93134588 %float_n0_402694494 = OpConstant %float -0.402694494 %float_n0_829486787 = OpConstant %float -0.829486787 %float_1_76265967 = OpConstant %float 1.76265967 %float_0_0236246008 = OpConstant %float 0.0236246008 %float_0_0358507 = OpConstant %float 0.0358507 %float_n0_0761827007 = OpConstant %float -0.0761827007 %float_0_957014024 = OpConstant %float 0.957014024 %float_1_01303005 = OpConstant %float 1.01303005 %float_0_00610530982 = OpConstant %float 0.00610530982 %float_n0_0149710001 = OpConstant %float -0.0149710001 %float_0_00769822998 = OpConstant %float 0.00769822998 %float_0_998165011 = OpConstant %float 0.998165011 %float_n0_00503202993 = OpConstant %float -0.00503202993 %float_n0_00284131011 = OpConstant %float -0.00284131011 %float_0_00468515977 = OpConstant %float 0.00468515977 %float_0_924507022 = OpConstant %float 0.924507022 %float_0_987223983 = OpConstant %float 0.987223983 %float_n0_00611326983 = OpConstant %float -0.00611326983 %float_0_0159533005 = OpConstant %float 0.0159533005 %float_n0_00759836007 = OpConstant %float -0.00759836007 %float_1_00186002 = OpConstant %float 1.00186002 %float_0_0053300201 = OpConstant %float 0.0053300201 %float_0_00307257008 = OpConstant %float 0.00307257008 %float_n0_00509594986 = OpConstant %float -0.00509594986 %float_1_08168006 = OpConstant %float 1.08168006 %float_0_5 = OpConstant %float 0.5 %float_n1 = OpConstant %float -1 %float_1 = OpConstant %float 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_0_015625 = OpConstant %float 0.015625 %134 = OpConstantComposite %v2float %float_0_015625 %float_0_015625 %135 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int_43 = OpConstant %int 43 %uint_3 = OpConstant %uint 3 %138 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %int_9 = OpConstant %int 9 %int_3 = OpConstant %int 3 %141 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_n4 = OpConstant %float -4 %int_45 = OpConstant %int 45 %float_0_544169128 = OpConstant %float 0.544169128 %float_0_239592597 = OpConstant %float 0.239592597 %float_0_166694298 = OpConstant %float 0.166694298 %float_0_239465594 = OpConstant %float 0.239465594 %float_0_702153027 = OpConstant %float 0.702153027 %float_0_058381401 = OpConstant %float 0.058381401 %float_n0_00234390004 = OpConstant %float -0.00234390004 %float_0_0361833982 = OpConstant %float 0.0361833982 %float_1_05521834 = OpConstant %float 1.05521834 %float_0_940437257 = OpConstant %float 0.940437257 %float_n0_0183068793 = OpConstant %float -0.0183068793 %float_0_077869609 = OpConstant %float 0.077869609 %float_0_00837869663 = OpConstant %float 0.00837869663 %float_0_828660011 = OpConstant %float 0.828660011 %float_0_162961304 = OpConstant %float 0.162961304 %float_0_00054712611 = OpConstant %float 0.00054712611 %float_n0_000883374596 = OpConstant %float -0.000883374596 %float_1_00033629 = OpConstant %float 1.00033629 %float_1_06317997 = OpConstant %float 1.06317997 %float_0_0233955998 = OpConstant %float 0.0233955998 %float_n0_0865726024 = OpConstant %float -0.0865726024 %float_n0_0106336996 = OpConstant %float -0.0106336996 %float_1_20632005 = OpConstant %float 1.20632005 %float_n0_195690006 = OpConstant %float -0.195690006 %float_n0_000590886979 = OpConstant %float -0.000590886979 %float_0_00105247996 = OpConstant %float 0.00105247996 %float_0_999538004 = OpConstant %float 0.999538004 %int_44 = OpConstant %int 44 %float_0_9375 = OpConstant %float 0.9375 %173 = OpConstantComposite %v3float %float_0_9375 %float_0_9375 %float_0_9375 %float_0_03125 = OpConstant %float 0.03125 %175 = OpConstantComposite %v3float %float_0_03125 %float_0_03125 %float_0_03125 %int_15 = OpConstant %int 15 %float_16 = OpConstant %float 16 %int_16 = OpConstant %int 16 %int_17 = OpConstant %int 17 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_5 = OpConstant %uint 5 %uint_6 = OpConstant %uint 6 %int_2 = OpConstant %int 2 %mat3v3float = OpTypeMatrix %v3float 3 %int_42 = OpConstant %int 42 %float_0_159301758 = OpConstant %float 0.159301758 %float_78_84375 = OpConstant %float 78.84375 %float_0_8359375 = OpConstant %float 0.8359375 %float_18_8515625 = OpConstant %float 18.8515625 %float_18_6875 = OpConstant %float 18.6875 %float_10000 = OpConstant %float 10000 %float_0_0126833133 = OpConstant %float 0.0126833133 %194 = OpConstantComposite %v3float %float_0_0126833133 %float_0_0126833133 %float_0_0126833133 %195 = OpConstantComposite %v3float %float_0_8359375 %float_0_8359375 %float_0_8359375 %196 = OpConstantComposite %v3float %float_18_8515625 %float_18_8515625 %float_18_8515625 %197 = OpConstantComposite %v3float %float_18_6875 %float_18_6875 %float_18_6875 %float_6_27739477 = OpConstant %float 6.27739477 %199 = OpConstantComposite %v3float %float_6_27739477 %float_6_27739477 %float_6_27739477 %200 = OpConstantComposite %v3float %float_10000 %float_10000 %float_10000 %float_14 = OpConstant %float 14 %float_0_180000007 = OpConstant %float 0.180000007 %float_0_434017599 = OpConstant %float 0.434017599 %204 = OpConstantComposite %v3float %float_0_434017599 %float_0_434017599 %float_0_434017599 %205 = OpConstantComposite %v3float %float_14 %float_14 %float_14 %206 = OpConstantComposite %v3float %float_0_180000007 %float_0_180000007 %float_0_180000007 %int_18 = OpConstant %int 18 %float_4000 = OpConstant %float 4000 %float_0_312700003 = OpConstant %float 0.312700003 %float_0_328999996 = OpConstant %float 0.328999996 %int_19 = OpConstant %int 19 %int_25 = OpConstant %int 25 %int_20 = OpConstant %int 20 %int_26 = OpConstant %int 26 %int_21 = OpConstant %int 21 %int_27 = OpConstant %int 27 %int_22 = OpConstant %int 22 %int_28 = OpConstant %int 28 %int_23 = OpConstant %int 23 %int_29 = OpConstant %int 29 %int_24 = OpConstant %int 24 %int_40 = OpConstant %int 40 %int_35 = OpConstant %int 35 %int_36 = OpConstant %int 36 %int_37 = OpConstant %int 37 %int_38 = OpConstant %int 38 %int_39 = OpConstant %int 39 %int_41 = OpConstant %int 41 %int_30 = OpConstant %int 30 %int_31 = OpConstant %int 31 %int_32 = OpConstant %int 32 %int_33 = OpConstant %int 33 %int_34 = OpConstant %int 34 %float_0_0500000007 = OpConstant %float 0.0500000007 %float_1_75 = OpConstant %float 1.75 %float_0_400000006 = OpConstant %float 0.400000006 %float_0_819999993 = OpConstant %float 0.819999993 %float_0_0299999993 = OpConstant %float 0.0299999993 %float_2 = OpConstant %float 2 %float_0_959999979 = OpConstant %float 0.959999979 %241 = OpConstantComposite %v3float %float_0_959999979 %float_0_959999979 %float_0_959999979 %int_13 = OpConstant %int 13 %int_11 = OpConstant %int 11 %int_14 = OpConstant %int 14 %int_12 = OpConstant %int 12 %float_0_800000012 = OpConstant %float 0.800000012 %int_10 = OpConstant %int 10 %float_10 = OpConstant %float 10 %float_n2 = OpConstant %float -2 %float_3 = OpConstant %float 3 %251 = OpConstantComposite %v3float %float_3 %float_3 %float_3 %252 = OpConstantComposite %v3float %float_2 %float_2 %float_2 %float_0_930000007 = OpConstant %float 0.930000007 %254 = OpConstantComposite %v3float %float_0_930000007 %float_0_930000007 %float_0_930000007 %int_4 = OpConstant %int 4 %int_8 = OpConstant %int 8 %int_7 = OpConstant %int 7 %int_5 = OpConstant %int 5 %int_6 = OpConstant %int 6 %float_0_00200000009 = OpConstant %float 0.00200000009 %261 = OpConstantComposite %v3float %float_0_00200000009 %float_0_00200000009 %float_0_00200000009 %float_6_10351999en05 = OpConstant %float 6.10351999e-05 %263 = OpConstantComposite %v3float %float_6_10351999en05 %float_6_10351999en05 %float_6_10351999en05 %float_0_0404499993 = OpConstant %float 0.0404499993 %265 = OpConstantComposite %v3float %float_0_0404499993 %float_0_0404499993 %float_0_0404499993 %float_0_947867274 = OpConstant %float 0.947867274 %267 = OpConstantComposite %v3float %float_0_947867274 %float_0_947867274 %float_0_947867274 %float_0_0521326996 = OpConstant %float 0.0521326996 %269 = OpConstantComposite %v3float %float_0_0521326996 %float_0_0521326996 %float_0_0521326996 %float_2_4000001 = OpConstant %float 2.4000001 %271 = OpConstantComposite %v3float %float_2_4000001 %float_2_4000001 %float_2_4000001 %float_0_0773993805 = OpConstant %float 0.0773993805 %273 = OpConstantComposite %v3float %float_0_0773993805 %float_0_0773993805 %float_0_0773993805 %float_4_5 = OpConstant %float 4.5 %275 = OpConstantComposite %v3float %float_4_5 %float_4_5 %float_4_5 %float_0_0179999992 = OpConstant %float 0.0179999992 %277 = OpConstantComposite %v3float %float_0_0179999992 %float_0_0179999992 %float_0_0179999992 %float_0_449999988 = OpConstant %float 0.449999988 %279 = OpConstantComposite %v3float %float_0_449999988 %float_0_449999988 %float_0_449999988 %float_1_09899998 = OpConstant %float 1.09899998 %281 = OpConstantComposite %v3float %float_1_09899998 %float_1_09899998 %float_1_09899998 %float_0_0989999995 = OpConstant %float 0.0989999995 %283 = OpConstantComposite %v3float %float_0_0989999995 %float_0_0989999995 %float_0_0989999995 %float_1_5 = OpConstant %float 1.5 %285 = OpConstantComposite %v3float %float_1_5 %float_1_5 %float_1_5 %286 = OpConstantComposite %v3float %float_0_159301758 %float_0_159301758 %float_0_159301758 %287 = OpConstantComposite %v3float %float_78_84375 %float_78_84375 %float_78_84375 %float_1_00055635 = OpConstant %float 1.00055635 %float_7000 = OpConstant %float 7000 %float_0_244063005 = OpConstant %float 0.244063005 %float_99_1100006 = OpConstant %float 99.1100006 %float_2967800 = OpConstant %float 2967800 %float_0_237039998 = OpConstant %float 0.237039998 %float_247_479996 = OpConstant %float 247.479996 %float_1901800 = OpConstant %float 1901800 %float_n3 = OpConstant %float -3 %float_2_86999989 = OpConstant %float 2.86999989 %float_0_275000006 = OpConstant %float 0.275000006 %float_0_860117733 = OpConstant %float 0.860117733 %float_0_000154118257 = OpConstant %float 0.000154118257 %float_1_28641219en07 = OpConstant %float 1.28641219e-07 %float_0_00084242021 = OpConstant %float 0.00084242021 %float_7_08145137en07 = OpConstant %float 7.08145137e-07 %float_0_317398727 = OpConstant %float 0.317398727 ; HACK: Needed to hack this constant since MSVC and GNU libc are off by 1 ULP when converting to string (it probably still works fine though in a roundtrip ...) %float_4_22806261en05 = OpConstant %float 4.25 %float_4_20481676en08 = OpConstant %float 4.20481676e-08 %float_2_8974182en05 = OpConstant %float 2.8974182e-05 %float_1_61456057en07 = OpConstant %float 1.61456057e-07 %float_8 = OpConstant %float 8 %float_4 = OpConstant %float 4 %float_0_895099998 = OpConstant %float 0.895099998 %float_0_266400009 = OpConstant %float 0.266400009 %float_n0_161400005 = OpConstant %float -0.161400005 %float_n0_750199974 = OpConstant %float -0.750199974 %float_1_71350002 = OpConstant %float 1.71350002 %float_0_0366999991 = OpConstant %float 0.0366999991 %float_0_0388999991 = OpConstant %float 0.0388999991 %float_n0_0684999973 = OpConstant %float -0.0684999973 %float_1_02960002 = OpConstant %float 1.02960002 %float_0_986992896 = OpConstant %float 0.986992896 %float_n0_1470543 = OpConstant %float -0.1470543 %float_0_159962699 = OpConstant %float 0.159962699 %float_0_432305306 = OpConstant %float 0.432305306 %float_0_518360317 = OpConstant %float 0.518360317 %float_0_0492912009 = OpConstant %float 0.0492912009 %float_n0_0085287001 = OpConstant %float -0.0085287001 %float_0_040042799 = OpConstant %float 0.040042799 %float_0_968486726 = OpConstant %float 0.968486726 %float_5_55555534 = OpConstant %float 5.55555534 %330 = OpConstantComposite %v3float %float_5_55555534 %float_5_55555534 %float_5_55555534 %float_1_00000001en10 = OpConstant %float 1.00000001e-10 %float_0_00999999978 = OpConstant %float 0.00999999978 %float_0_666666687 = OpConstant %float 0.666666687 %float_180 = OpConstant %float 180 %float_360 = OpConstant %float 360 %float_65535 = OpConstant %float 65535 %337 = OpConstantComposite %v3float %float_65535 %float_65535 %float_65535 %float_n4_97062206 = OpConstant %float -4.97062206 %float_n3_02937818 = OpConstant %float -3.02937818 %float_n2_12619996 = OpConstant %float -2.12619996 %float_n1_51049995 = OpConstant %float -1.51049995 %float_n1_05780005 = OpConstant %float -1.05780005 %float_n0_466800004 = OpConstant %float -0.466800004 %float_0_119379997 = OpConstant %float 0.119379997 %float_0_708813429 = OpConstant %float 0.708813429 %float_1_29118657 = OpConstant %float 1.29118657 %float_0_808913231 = OpConstant %float 0.808913231 %float_1_19108677 = OpConstant %float 1.19108677 %float_1_56830001 = OpConstant %float 1.56830001 %float_1_9483 = OpConstant %float 1.9483 %float_2_30830002 = OpConstant %float 2.30830002 %float_2_63840008 = OpConstant %float 2.63840008 %float_2_85949993 = OpConstant %float 2.85949993 %float_2_98726082 = OpConstant %float 2.98726082 %float_3_01273918 = OpConstant %float 3.01273918 %float_0_179999992 = OpConstant %float 0.179999992 %float_9_99999975en05 = OpConstant %float 9.99999975e-05 %float_1000 = OpConstant %float 1000 %float_0_0599999987 = OpConstant %float 0.0599999987 %float_3_50738446en05 = OpConstant %float 3.50738446e-05 %361 = OpConstantComposite %v3float %float_3_50738446en05 %float_3_50738446en05 %float_3_50738446en05 %float_n2_30102992 = OpConstant %float -2.30102992 %float_n1_93120003 = OpConstant %float -1.93120003 %float_n1_52049994 = OpConstant %float -1.52049994 %float_0_801995218 = OpConstant %float 0.801995218 %float_1_19800484 = OpConstant %float 1.19800484 %float_1_59430003 = OpConstant %float 1.59430003 %float_1_99730003 = OpConstant %float 1.99730003 %float_2_37829995 = OpConstant %float 2.37829995 %float_2_76839995 = OpConstant %float 2.76839995 %float_3_05150008 = OpConstant %float 3.05150008 %float_3_27462935 = OpConstant %float 3.27462935 %float_3_32743073 = OpConstant %float 3.32743073 %float_0_00499999989 = OpConstant %float 0.00499999989 %float_11 = OpConstant %float 11 %float_2000 = OpConstant %float 2000 %float_0_119999997 = OpConstant %float 0.119999997 %float_0_00313066994 = OpConstant %float 0.00313066994 %float_12_9200001 = OpConstant %float 12.9200001 %float_0_416666657 = OpConstant %float 0.416666657 %float_1_05499995 = OpConstant %float 1.05499995 %float_0_0549999997 = OpConstant %float 0.0549999997 %float_n0_166666672 = OpConstant %float -0.166666672 %float_n0_5 = OpConstant %float -0.5 %float_0_166666672 = OpConstant %float 0.166666672 %float_n3_15737653 = OpConstant %float -3.15737653 %float_n0_485249996 = OpConstant %float -0.485249996 %float_1_84773242 = OpConstant %float 1.84773242 %float_n0_718548238 = OpConstant %float -0.718548238 %float_2_08103061 = OpConstant %float 2.08103061 %float_3_6681242 = OpConstant %float 3.6681242 %float_18 = OpConstant %float 18 %float_7 = OpConstant %float 7 %_arr_float_uint_5 = OpTypeArray %float %uint_5 %type__Globals = OpTypeStruct %v4float %v3float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %float %float %float %float %float %_arr_float_uint_5 %v3float %v4float %float %float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %float %float %uint %uint %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %402 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %v2bool = OpTypeVector %bool 2 %v3bool = OpTypeVector %bool 3 %type_sampled_image = OpTypeSampledImage %type_2d_image %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %_arr_float_uint_6 = OpTypeArray %float %uint_6 %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %Texture1 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %Texture1Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %gl_Layer = OpVariable %_ptr_Input_uint Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %_ptr_Function__arr_float_uint_6 = OpTypePointer Function %_arr_float_uint_6 %_ptr_Function__arr_float_uint_10 = OpTypePointer Function %_arr_float_uint_10 %416 = OpConstantComposite %v3float %float_0_952552378 %float_0 %float_9_36786018en05 %417 = OpConstantComposite %v3float %float_0_343966454 %float_0_728166103 %float_n0_0721325427 %418 = OpConstantComposite %v3float %float_0 %float_0 %float_1_00882518 %419 = OpConstantComposite %mat3v3float %416 %417 %418 %420 = OpConstantComposite %v3float %float_1_04981101 %float_0 %float_n9_74845025en05 %421 = OpConstantComposite %v3float %float_n0_495903015 %float_1_37331307 %float_0_0982400328 %422 = OpConstantComposite %v3float %float_0 %float_0 %float_0_991252005 %423 = OpConstantComposite %mat3v3float %420 %421 %422 %424 = OpConstantComposite %v3float %float_0_662454188 %float_0_134004205 %float_0_156187683 %425 = OpConstantComposite %v3float %float_n0_00557464967 %float_0_0040607336 %float_1_01033914 %426 = OpConstantComposite %mat3v3float %424 %73 %425 %427 = OpConstantComposite %v3float %float_1_6410234 %float_n0_324803293 %float_n0_236424699 %428 = OpConstantComposite %v3float %float_n0_663662851 %float_1_61533165 %float_0_0167563483 %429 = OpConstantComposite %v3float %float_0_0117218941 %float_n0_00828444213 %float_0_988394856 %430 = OpConstantComposite %mat3v3float %427 %428 %429 %431 = OpConstantComposite %v3float %float_1_45143926 %float_n0_236510754 %float_n0_214928567 %432 = OpConstantComposite %v3float %float_n0_0765537769 %float_1_17622972 %float_n0_0996759236 %433 = OpConstantComposite %v3float %float_0_00831614807 %float_n0_00603244966 %float_0_997716308 %434 = OpConstantComposite %mat3v3float %431 %432 %433 %435 = OpConstantComposite %v3float %float_0_695452213 %float_0_140678704 %float_0_163869068 %436 = OpConstantComposite %v3float %float_0_0447945632 %float_0_859671116 %float_0_0955343172 %437 = OpConstantComposite %v3float %float_n0_00552588282 %float_0_00402521016 %float_1_00150073 %438 = OpConstantComposite %mat3v3float %435 %436 %437 %439 = OpConstantComposite %v3float %float_3_2409699 %float_n1_5373832 %float_n0_498610765 %440 = OpConstantComposite %v3float %float_n0_969243646 %float_1_8759675 %float_0_0415550582 %441 = OpConstantComposite %v3float %float_0_0556300804 %float_n0_203976959 %float_1_05697155 %442 = OpConstantComposite %mat3v3float %439 %440 %441 %443 = OpConstantComposite %v3float %float_0_412456393 %float_0_357576102 %float_0_180437505 %444 = OpConstantComposite %v3float %float_0_212672904 %float_0_715152204 %float_0_0721750036 %445 = OpConstantComposite %v3float %float_0_0193339009 %float_0_119191997 %float_0_950304091 %446 = OpConstantComposite %mat3v3float %443 %444 %445 %447 = OpConstantComposite %v3float %float_1_71660841 %float_n0_355662107 %float_n0_253360093 %448 = OpConstantComposite %v3float %float_n0_666682899 %float_1_61647761 %float_0_0157685 %449 = OpConstantComposite %v3float %float_0_0176422 %float_n0_0427763015 %float_0_942228675 %450 = OpConstantComposite %mat3v3float %447 %448 %449 %451 = OpConstantComposite %v3float %float_2_49339628 %float_n0_93134588 %float_n0_402694494 %452 = OpConstantComposite %v3float %float_n0_829486787 %float_1_76265967 %float_0_0236246008 %453 = OpConstantComposite %v3float %float_0_0358507 %float_n0_0761827007 %float_0_957014024 %454 = OpConstantComposite %mat3v3float %451 %452 %453 %455 = OpConstantComposite %v3float %float_1_01303005 %float_0_00610530982 %float_n0_0149710001 %456 = OpConstantComposite %v3float %float_0_00769822998 %float_0_998165011 %float_n0_00503202993 %457 = OpConstantComposite %v3float %float_n0_00284131011 %float_0_00468515977 %float_0_924507022 %458 = OpConstantComposite %mat3v3float %455 %456 %457 %459 = OpConstantComposite %v3float %float_0_987223983 %float_n0_00611326983 %float_0_0159533005 %460 = OpConstantComposite %v3float %float_n0_00759836007 %float_1_00186002 %float_0_0053300201 %461 = OpConstantComposite %v3float %float_0_00307257008 %float_n0_00509594986 %float_1_08168006 %462 = OpConstantComposite %mat3v3float %459 %460 %461 %463 = OpConstantComposite %v3float %float_0_5 %float_n1 %float_0_5 %464 = OpConstantComposite %v3float %float_n1 %float_1 %float_0_5 %465 = OpConstantComposite %v3float %float_0_5 %float_0 %float_0 %466 = OpConstantComposite %mat3v3float %463 %464 %465 %467 = OpConstantComposite %v3float %float_1 %float_0 %float_0 %468 = OpConstantComposite %v3float %float_0 %float_1 %float_0 %469 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %470 = OpConstantComposite %mat3v3float %467 %468 %469 %float_n6_07624626 = OpConstant %float -6.07624626 %472 = OpConstantComposite %v3float %float_n6_07624626 %float_n6_07624626 %float_n6_07624626 %473 = OpConstantComposite %v3float %float_0_895099998 %float_0_266400009 %float_n0_161400005 %474 = OpConstantComposite %v3float %float_n0_750199974 %float_1_71350002 %float_0_0366999991 %475 = OpConstantComposite %v3float %float_0_0388999991 %float_n0_0684999973 %float_1_02960002 %476 = OpConstantComposite %mat3v3float %473 %474 %475 %477 = OpConstantComposite %v3float %float_0_986992896 %float_n0_1470543 %float_0_159962699 %478 = OpConstantComposite %v3float %float_0_432305306 %float_0_518360317 %float_0_0492912009 %479 = OpConstantComposite %v3float %float_n0_0085287001 %float_0_040042799 %float_0_968486726 %480 = OpConstantComposite %mat3v3float %477 %478 %479 %481 = OpConstantComposite %v3float %float_0_544169128 %float_0_239592597 %float_0_166694298 %482 = OpConstantComposite %v3float %float_0_239465594 %float_0_702153027 %float_0_058381401 %483 = OpConstantComposite %v3float %float_n0_00234390004 %float_0_0361833982 %float_1_05521834 %484 = OpConstantComposite %mat3v3float %481 %482 %483 %485 = OpConstantComposite %v3float %float_0_940437257 %float_n0_0183068793 %float_0_077869609 %486 = OpConstantComposite %v3float %float_0_00837869663 %float_0_828660011 %float_0_162961304 %487 = OpConstantComposite %v3float %float_0_00054712611 %float_n0_000883374596 %float_1_00033629 %488 = OpConstantComposite %mat3v3float %485 %486 %487 %489 = OpConstantComposite %v3float %float_1_06317997 %float_0_0233955998 %float_n0_0865726024 %490 = OpConstantComposite %v3float %float_n0_0106336996 %float_1_20632005 %float_n0_195690006 %491 = OpConstantComposite %v3float %float_n0_000590886979 %float_0_00105247996 %float_0_999538004 %492 = OpConstantComposite %mat3v3float %489 %490 %491 %float_0_0533333346 = OpConstant %float 0.0533333346 %float_0_159999996 = OpConstant %float 0.159999996 %float_57_2957764 = OpConstant %float 57.2957764 %float_0_0625 = OpConstant %float 0.0625 %float_n67_5 = OpConstant %float -67.5 %float_67_5 = OpConstant %float 67.5 %499 = OpConstantComposite %_arr_float_uint_6 %float_n4 %float_n4 %float_n3_15737653 %float_n0_485249996 %float_1_84773242 %float_1_84773242 %500 = OpConstantComposite %_arr_float_uint_6 %float_n0_718548238 %float_2_08103061 %float_3_6681242 %float_4 %float_4 %float_4 %float_n15 = OpConstant %float -15 %float_n14 = OpConstant %float -14 %503 = OpConstantComposite %_arr_float_uint_10 %float_n4_97062206 %float_n3_02937818 %float_n2_12619996 %float_n1_51049995 %float_n1_05780005 %float_n0_466800004 %float_0_119379997 %float_0_708813429 %float_1_29118657 %float_1_29118657 %504 = OpConstantComposite %_arr_float_uint_10 %float_0_808913231 %float_1_19108677 %float_1_56830001 %float_1_9483 %float_2_30830002 %float_2_63840008 %float_2_85949993 %float_2_98726082 %float_3_01273918 %float_3_01273918 %float_n12 = OpConstant %float -12 %506 = OpConstantComposite %_arr_float_uint_10 %float_n2_30102992 %float_n2_30102992 %float_n1_93120003 %float_n1_52049994 %float_n1_05780005 %float_n0_466800004 %float_0_119379997 %float_0_708813429 %float_1_29118657 %float_1_29118657 %507 = OpConstantComposite %_arr_float_uint_10 %float_0_801995218 %float_1_19800484 %float_1_59430003 %float_1_99730003 %float_2_37829995 %float_2_76839995 %float_3_05150008 %float_3_27462935 %float_3_32743073 %float_3_32743073 %float_0_0322580636 = OpConstant %float 0.0322580636 %float_1_03225803 = OpConstant %float 1.03225803 %510 = OpConstantComposite %v2float %float_1_03225803 %float_1_03225803 %float_4_60443853e_09 = OpConstant %float 4.60443853e+09 %float_2_00528435e_09 = OpConstant %float 2.00528435e+09 %float_0_333333343 = OpConstant %float 0.333333343 %float_5 = OpConstant %float 5 %float_2_5 = OpConstant %float 2.5 %float_0_0250000004 = OpConstant %float 0.0250000004 %float_0_239999995 = OpConstant %float 0.239999995 %float_0_0148148146 = OpConstant %float 0.0148148146 %519 = OpConstantComposite %v3float %float_9_99999975en05 %float_9_99999975en05 %float_9_99999975en05 %float_0_0296296291 = OpConstant %float 0.0296296291 %float_0_952381015 = OpConstant %float 0.952381015 %522 = OpConstantComposite %v3float %float_0_952381015 %float_0_952381015 %float_0_952381015 %523 = OpUndef %v3float %float_0_358299971 = OpConstant %float 0.358299971 %525 = OpUndef %v3float %MainPS = OpFunction %void None %402 %526 = OpLabel %527 = OpVariable %_ptr_Function__arr_float_uint_6 Function %528 = OpVariable %_ptr_Function__arr_float_uint_6 Function %529 = OpVariable %_ptr_Function__arr_float_uint_6 Function %530 = OpVariable %_ptr_Function__arr_float_uint_6 Function %531 = OpVariable %_ptr_Function__arr_float_uint_6 Function %532 = OpVariable %_ptr_Function__arr_float_uint_6 Function %533 = OpVariable %_ptr_Function__arr_float_uint_10 Function %534 = OpVariable %_ptr_Function__arr_float_uint_10 Function %535 = OpVariable %_ptr_Function__arr_float_uint_10 Function %536 = OpVariable %_ptr_Function__arr_float_uint_10 Function %537 = OpVariable %_ptr_Function__arr_float_uint_10 Function %538 = OpVariable %_ptr_Function__arr_float_uint_10 Function %539 = OpVariable %_ptr_Function__arr_float_uint_6 Function %540 = OpVariable %_ptr_Function__arr_float_uint_6 Function %541 = OpVariable %_ptr_Function__arr_float_uint_6 Function %542 = OpVariable %_ptr_Function__arr_float_uint_6 Function %543 = OpVariable %_ptr_Function__arr_float_uint_6 Function %544 = OpVariable %_ptr_Function__arr_float_uint_6 Function %545 = OpVariable %_ptr_Function__arr_float_uint_6 Function %546 = OpVariable %_ptr_Function__arr_float_uint_6 Function %547 = OpVariable %_ptr_Function__arr_float_uint_6 Function %548 = OpVariable %_ptr_Function__arr_float_uint_6 Function %549 = OpVariable %_ptr_Function__arr_float_uint_6 Function %550 = OpVariable %_ptr_Function__arr_float_uint_6 Function %551 = OpVariable %_ptr_Function__arr_float_uint_10 Function %552 = OpVariable %_ptr_Function__arr_float_uint_10 Function %553 = OpVariable %_ptr_Function__arr_float_uint_10 Function %554 = OpVariable %_ptr_Function__arr_float_uint_10 Function %555 = OpVariable %_ptr_Function__arr_float_uint_10 Function %556 = OpVariable %_ptr_Function__arr_float_uint_10 Function %557 = OpVariable %_ptr_Function__arr_float_uint_6 Function %558 = OpVariable %_ptr_Function__arr_float_uint_6 Function %559 = OpVariable %_ptr_Function__arr_float_uint_6 Function %560 = OpVariable %_ptr_Function__arr_float_uint_6 Function %561 = OpVariable %_ptr_Function__arr_float_uint_6 Function %562 = OpVariable %_ptr_Function__arr_float_uint_6 Function %563 = OpLoad %v2float %in_var_TEXCOORD0 %564 = OpLoad %uint %gl_Layer %565 = OpFSub %v2float %563 %134 %566 = OpFMul %v2float %565 %510 %567 = OpCompositeExtract %float %566 0 %568 = OpCompositeExtract %float %566 1 %569 = OpConvertUToF %float %564 %570 = OpFMul %float %569 %float_0_0322580636 %571 = OpCompositeConstruct %v4float %567 %568 %570 %float_0 %572 = OpMatrixTimesMatrix %mat3v3float %446 %458 %573 = OpMatrixTimesMatrix %mat3v3float %572 %430 %574 = OpMatrixTimesMatrix %mat3v3float %426 %462 %575 = OpMatrixTimesMatrix %mat3v3float %574 %442 %576 = OpMatrixTimesMatrix %mat3v3float %419 %430 %577 = OpMatrixTimesMatrix %mat3v3float %426 %423 %578 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_43 %579 = OpLoad %uint %578 OpBranch %580 %580 = OpLabel OpLoopMerge %581 %582 None OpBranch %583 %583 = OpLabel %584 = OpMatrixTimesMatrix %mat3v3float %574 %454 %585 = OpMatrixTimesMatrix %mat3v3float %574 %450 %586 = OpIEqual %bool %579 %uint_1 OpSelectionMerge %587 None OpBranchConditional %586 %588 %589 %589 = OpLabel %590 = OpIEqual %bool %579 %uint_2 OpSelectionMerge %591 None OpBranchConditional %590 %592 %593 %593 = OpLabel %594 = OpIEqual %bool %579 %uint_3 OpSelectionMerge %595 None OpBranchConditional %594 %596 %597 %597 = OpLabel %598 = OpIEqual %bool %579 %uint_4 OpSelectionMerge %599 None OpBranchConditional %598 %600 %601 %601 = OpLabel OpBranch %581 %600 = OpLabel OpBranch %581 %599 = OpLabel OpUnreachable %596 = OpLabel OpBranch %581 %595 = OpLabel OpUnreachable %592 = OpLabel OpBranch %581 %591 = OpLabel OpUnreachable %588 = OpLabel OpBranch %581 %587 = OpLabel OpUnreachable %582 = OpLabel OpBranch %580 %581 = OpLabel %602 = OpPhi %mat3v3float %575 %601 %470 %600 %438 %596 %585 %592 %584 %588 %603 = OpVectorShuffle %v3float %571 %571 0 1 2 %604 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_42 %605 = OpLoad %uint %604 %606 = OpUGreaterThanEqual %bool %605 %uint_3 OpSelectionMerge %607 None OpBranchConditional %606 %608 %609 %609 = OpLabel %610 = OpFSub %v3float %603 %204 %611 = OpFMul %v3float %610 %205 %612 = OpExtInst %v3float %1 Exp2 %611 %613 = OpFMul %v3float %612 %206 %614 = OpExtInst %v3float %1 Exp2 %472 %615 = OpFMul %v3float %614 %206 %616 = OpFSub %v3float %613 %615 OpBranch %607 %608 = OpLabel %617 = OpExtInst %v3float %1 Pow %603 %194 %618 = OpFSub %v3float %617 %195 %619 = OpExtInst %v3float %1 FMax %138 %618 %620 = OpFMul %v3float %197 %617 %621 = OpFSub %v3float %196 %620 %622 = OpFDiv %v3float %619 %621 %623 = OpExtInst %v3float %1 Pow %622 %199 %624 = OpFMul %v3float %623 %200 OpBranch %607 %607 = OpLabel %625 = OpPhi %v3float %616 %609 %624 %608 %626 = OpAccessChain %_ptr_Uniform_float %_Globals %int_18 %627 = OpLoad %float %626 %628 = OpFMul %float %627 %float_1_00055635 %629 = OpFOrdLessThanEqual %bool %628 %float_7000 %630 = OpFDiv %float %float_4_60443853e_09 %627 %631 = OpFSub %float %float_2967800 %630 %632 = OpFDiv %float %631 %628 %633 = OpFAdd %float %float_99_1100006 %632 %634 = OpFDiv %float %633 %628 %635 = OpFAdd %float %float_0_244063005 %634 %636 = OpFDiv %float %float_2_00528435e_09 %627 %637 = OpFSub %float %float_1901800 %636 %638 = OpFDiv %float %637 %628 %639 = OpFAdd %float %float_247_479996 %638 %640 = OpFDiv %float %639 %628 %641 = OpFAdd %float %float_0_237039998 %640 %642 = OpSelect %float %629 %635 %641 %643 = OpFMul %float %float_n3 %642 %644 = OpFMul %float %643 %642 %645 = OpFMul %float %float_2_86999989 %642 %646 = OpFAdd %float %644 %645 %647 = OpFSub %float %646 %float_0_275000006 %648 = OpCompositeConstruct %v2float %642 %647 %649 = OpFMul %float %float_0_000154118257 %627 %650 = OpFAdd %float %float_0_860117733 %649 %651 = OpFMul %float %float_1_28641219en07 %627 %652 = OpFMul %float %651 %627 %653 = OpFAdd %float %650 %652 %654 = OpFMul %float %float_0_00084242021 %627 %655 = OpFAdd %float %float_1 %654 %656 = OpFMul %float %float_7_08145137en07 %627 %657 = OpFMul %float %656 %627 %658 = OpFAdd %float %655 %657 %659 = OpFDiv %float %653 %658 %660 = OpFMul %float %float_4_22806261en05 %627 %661 = OpFAdd %float %float_0_317398727 %660 %662 = OpFMul %float %float_4_20481676en08 %627 %663 = OpFMul %float %662 %627 %664 = OpFAdd %float %661 %663 %665 = OpFMul %float %float_2_8974182en05 %627 %666 = OpFSub %float %float_1 %665 %667 = OpFMul %float %float_1_61456057en07 %627 %668 = OpFMul %float %667 %627 %669 = OpFAdd %float %666 %668 %670 = OpFDiv %float %664 %669 %671 = OpFMul %float %float_3 %659 %672 = OpFMul %float %float_2 %659 %673 = OpFMul %float %float_8 %670 %674 = OpFSub %float %672 %673 %675 = OpFAdd %float %674 %float_4 %676 = OpFDiv %float %671 %675 %677 = OpFMul %float %float_2 %670 %678 = OpFDiv %float %677 %675 %679 = OpCompositeConstruct %v2float %676 %678 %680 = OpFOrdLessThan %bool %627 %float_4000 %681 = OpCompositeConstruct %v2bool %680 %680 %682 = OpSelect %v2float %681 %679 %648 %683 = OpAccessChain %_ptr_Uniform_float %_Globals %int_19 %684 = OpLoad %float %683 %685 = OpCompositeConstruct %v2float %659 %670 %686 = OpExtInst %v2float %1 Normalize %685 %687 = OpCompositeExtract %float %686 1 %688 = OpFNegate %float %687 %689 = OpFMul %float %688 %684 %690 = OpFMul %float %689 %float_0_0500000007 %691 = OpFAdd %float %659 %690 %692 = OpCompositeExtract %float %686 0 %693 = OpFMul %float %692 %684 %694 = OpFMul %float %693 %float_0_0500000007 %695 = OpFAdd %float %670 %694 %696 = OpFMul %float %float_3 %691 %697 = OpFMul %float %float_2 %691 %698 = OpFMul %float %float_8 %695 %699 = OpFSub %float %697 %698 %700 = OpFAdd %float %699 %float_4 %701 = OpFDiv %float %696 %700 %702 = OpFMul %float %float_2 %695 %703 = OpFDiv %float %702 %700 %704 = OpCompositeConstruct %v2float %701 %703 %705 = OpFSub %v2float %704 %679 %706 = OpFAdd %v2float %682 %705 %707 = OpCompositeExtract %float %706 0 %708 = OpCompositeExtract %float %706 1 %709 = OpExtInst %float %1 FMax %708 %float_1_00000001en10 %710 = OpFDiv %float %707 %709 %711 = OpCompositeInsert %v3float %710 %523 0 %712 = OpCompositeInsert %v3float %float_1 %711 1 %713 = OpFSub %float %float_1 %707 %714 = OpFSub %float %713 %708 %715 = OpFDiv %float %714 %709 %716 = OpCompositeInsert %v3float %715 %712 2 %717 = OpExtInst %float %1 FMax %float_0_328999996 %float_1_00000001en10 %718 = OpFDiv %float %float_0_312700003 %717 %719 = OpCompositeInsert %v3float %718 %523 0 %720 = OpCompositeInsert %v3float %float_1 %719 1 %721 = OpFDiv %float %float_0_358299971 %717 %722 = OpCompositeInsert %v3float %721 %720 2 %723 = OpVectorTimesMatrix %v3float %716 %476 %724 = OpVectorTimesMatrix %v3float %722 %476 %725 = OpCompositeExtract %float %724 0 %726 = OpCompositeExtract %float %723 0 %727 = OpFDiv %float %725 %726 %728 = OpCompositeConstruct %v3float %727 %float_0 %float_0 %729 = OpCompositeExtract %float %724 1 %730 = OpCompositeExtract %float %723 1 %731 = OpFDiv %float %729 %730 %732 = OpCompositeConstruct %v3float %float_0 %731 %float_0 %733 = OpCompositeExtract %float %724 2 %734 = OpCompositeExtract %float %723 2 %735 = OpFDiv %float %733 %734 %736 = OpCompositeConstruct %v3float %float_0 %float_0 %735 %737 = OpCompositeConstruct %mat3v3float %728 %732 %736 %738 = OpMatrixTimesMatrix %mat3v3float %476 %737 %739 = OpMatrixTimesMatrix %mat3v3float %738 %480 %740 = OpMatrixTimesMatrix %mat3v3float %446 %739 %741 = OpMatrixTimesMatrix %mat3v3float %740 %442 %742 = OpVectorTimesMatrix %v3float %625 %741 %743 = OpVectorTimesMatrix %v3float %742 %573 %744 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_9 %745 = OpAccessChain %_ptr_Uniform_float %_Globals %int_9 %int_3 %746 = OpLoad %float %745 %747 = OpFOrdNotEqual %bool %746 %float_0 OpSelectionMerge %748 None OpBranchConditional %747 %749 %748 %749 = OpLabel %750 = OpDot %float %743 %73 %751 = OpCompositeConstruct %v3float %750 %750 %750 %752 = OpFDiv %v3float %743 %751 %753 = OpFSub %v3float %752 %141 %754 = OpDot %float %753 %753 %755 = OpFMul %float %float_n4 %754 %756 = OpExtInst %float %1 Exp2 %755 %757 = OpFSub %float %float_1 %756 %758 = OpAccessChain %_ptr_Uniform_float %_Globals %int_45 %759 = OpLoad %float %758 %760 = OpFMul %float %float_n4 %759 %761 = OpFMul %float %760 %750 %762 = OpFMul %float %761 %750 %763 = OpExtInst %float %1 Exp2 %762 %764 = OpFSub %float %float_1 %763 %765 = OpFMul %float %757 %764 %766 = OpMatrixTimesMatrix %mat3v3float %484 %430 %767 = OpMatrixTimesMatrix %mat3v3float %575 %766 %768 = OpVectorTimesMatrix %v3float %743 %767 %769 = OpCompositeConstruct %v3float %765 %765 %765 %770 = OpExtInst %v3float %1 FMix %743 %768 %769 OpBranch %748 %748 = OpLabel %771 = OpPhi %v3float %743 %607 %770 %749 %772 = OpDot %float %771 %73 %773 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_25 %774 = OpLoad %v4float %773 %775 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_20 %776 = OpLoad %v4float %775 %777 = OpFMul %v4float %774 %776 %778 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_26 %779 = OpLoad %v4float %778 %780 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_21 %781 = OpLoad %v4float %780 %782 = OpFMul %v4float %779 %781 %783 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_27 %784 = OpLoad %v4float %783 %785 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_22 %786 = OpLoad %v4float %785 %787 = OpFMul %v4float %784 %786 %788 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_28 %789 = OpLoad %v4float %788 %790 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_23 %791 = OpLoad %v4float %790 %792 = OpFMul %v4float %789 %791 %793 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_29 %794 = OpLoad %v4float %793 %795 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_24 %796 = OpLoad %v4float %795 %797 = OpFAdd %v4float %794 %796 %798 = OpCompositeConstruct %v3float %772 %772 %772 %799 = OpVectorShuffle %v3float %777 %777 0 1 2 %800 = OpCompositeExtract %float %777 3 %801 = OpCompositeConstruct %v3float %800 %800 %800 %802 = OpFMul %v3float %799 %801 %803 = OpExtInst %v3float %1 FMix %798 %771 %802 %804 = OpExtInst %v3float %1 FMax %138 %803 %805 = OpFMul %v3float %804 %330 %806 = OpVectorShuffle %v3float %782 %782 0 1 2 %807 = OpCompositeExtract %float %782 3 %808 = OpCompositeConstruct %v3float %807 %807 %807 %809 = OpFMul %v3float %806 %808 %810 = OpExtInst %v3float %1 Pow %805 %809 %811 = OpFMul %v3float %810 %206 %812 = OpVectorShuffle %v3float %787 %787 0 1 2 %813 = OpCompositeExtract %float %787 3 %814 = OpCompositeConstruct %v3float %813 %813 %813 %815 = OpFMul %v3float %812 %814 %816 = OpFDiv %v3float %141 %815 %817 = OpExtInst %v3float %1 Pow %811 %816 %818 = OpVectorShuffle %v3float %792 %792 0 1 2 %819 = OpCompositeExtract %float %792 3 %820 = OpCompositeConstruct %v3float %819 %819 %819 %821 = OpFMul %v3float %818 %820 %822 = OpFMul %v3float %817 %821 %823 = OpVectorShuffle %v3float %797 %797 0 1 2 %824 = OpCompositeExtract %float %797 3 %825 = OpCompositeConstruct %v3float %824 %824 %824 %826 = OpFAdd %v3float %823 %825 %827 = OpFAdd %v3float %822 %826 %828 = OpAccessChain %_ptr_Uniform_float %_Globals %int_40 %829 = OpLoad %float %828 %830 = OpExtInst %float %1 SmoothStep %float_0 %829 %772 %831 = OpFSub %float %float_1 %830 %832 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_35 %833 = OpLoad %v4float %832 %834 = OpFMul %v4float %833 %776 %835 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_36 %836 = OpLoad %v4float %835 %837 = OpFMul %v4float %836 %781 %838 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_37 %839 = OpLoad %v4float %838 %840 = OpFMul %v4float %839 %786 %841 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_38 %842 = OpLoad %v4float %841 %843 = OpFMul %v4float %842 %791 %844 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_39 %845 = OpLoad %v4float %844 %846 = OpFAdd %v4float %845 %796 %847 = OpVectorShuffle %v3float %834 %834 0 1 2 %848 = OpCompositeExtract %float %834 3 %849 = OpCompositeConstruct %v3float %848 %848 %848 %850 = OpFMul %v3float %847 %849 %851 = OpExtInst %v3float %1 FMix %798 %771 %850 %852 = OpExtInst %v3float %1 FMax %138 %851 %853 = OpFMul %v3float %852 %330 %854 = OpVectorShuffle %v3float %837 %837 0 1 2 %855 = OpCompositeExtract %float %837 3 %856 = OpCompositeConstruct %v3float %855 %855 %855 %857 = OpFMul %v3float %854 %856 %858 = OpExtInst %v3float %1 Pow %853 %857 %859 = OpFMul %v3float %858 %206 %860 = OpVectorShuffle %v3float %840 %840 0 1 2 %861 = OpCompositeExtract %float %840 3 %862 = OpCompositeConstruct %v3float %861 %861 %861 %863 = OpFMul %v3float %860 %862 %864 = OpFDiv %v3float %141 %863 %865 = OpExtInst %v3float %1 Pow %859 %864 %866 = OpVectorShuffle %v3float %843 %843 0 1 2 %867 = OpCompositeExtract %float %843 3 %868 = OpCompositeConstruct %v3float %867 %867 %867 %869 = OpFMul %v3float %866 %868 %870 = OpFMul %v3float %865 %869 %871 = OpVectorShuffle %v3float %846 %846 0 1 2 %872 = OpCompositeExtract %float %846 3 %873 = OpCompositeConstruct %v3float %872 %872 %872 %874 = OpFAdd %v3float %871 %873 %875 = OpFAdd %v3float %870 %874 %876 = OpAccessChain %_ptr_Uniform_float %_Globals %int_41 %877 = OpLoad %float %876 %878 = OpExtInst %float %1 SmoothStep %877 %float_1 %772 %879 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_30 %880 = OpLoad %v4float %879 %881 = OpFMul %v4float %880 %776 %882 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_31 %883 = OpLoad %v4float %882 %884 = OpFMul %v4float %883 %781 %885 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_32 %886 = OpLoad %v4float %885 %887 = OpFMul %v4float %886 %786 %888 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_33 %889 = OpLoad %v4float %888 %890 = OpFMul %v4float %889 %791 %891 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_34 %892 = OpLoad %v4float %891 %893 = OpFAdd %v4float %892 %796 %894 = OpVectorShuffle %v3float %881 %881 0 1 2 %895 = OpCompositeExtract %float %881 3 %896 = OpCompositeConstruct %v3float %895 %895 %895 %897 = OpFMul %v3float %894 %896 %898 = OpExtInst %v3float %1 FMix %798 %771 %897 %899 = OpExtInst %v3float %1 FMax %138 %898 %900 = OpFMul %v3float %899 %330 %901 = OpVectorShuffle %v3float %884 %884 0 1 2 %902 = OpCompositeExtract %float %884 3 %903 = OpCompositeConstruct %v3float %902 %902 %902 %904 = OpFMul %v3float %901 %903 %905 = OpExtInst %v3float %1 Pow %900 %904 %906 = OpFMul %v3float %905 %206 %907 = OpVectorShuffle %v3float %887 %887 0 1 2 %908 = OpCompositeExtract %float %887 3 %909 = OpCompositeConstruct %v3float %908 %908 %908 %910 = OpFMul %v3float %907 %909 %911 = OpFDiv %v3float %141 %910 %912 = OpExtInst %v3float %1 Pow %906 %911 %913 = OpVectorShuffle %v3float %890 %890 0 1 2 %914 = OpCompositeExtract %float %890 3 %915 = OpCompositeConstruct %v3float %914 %914 %914 %916 = OpFMul %v3float %913 %915 %917 = OpFMul %v3float %912 %916 %918 = OpVectorShuffle %v3float %893 %893 0 1 2 %919 = OpCompositeExtract %float %893 3 %920 = OpCompositeConstruct %v3float %919 %919 %919 %921 = OpFAdd %v3float %918 %920 %922 = OpFAdd %v3float %917 %921 %923 = OpFSub %float %830 %878 %924 = OpCompositeConstruct %v3float %831 %831 %831 %925 = OpFMul %v3float %827 %924 %926 = OpCompositeConstruct %v3float %923 %923 %923 %927 = OpFMul %v3float %922 %926 %928 = OpFAdd %v3float %925 %927 %929 = OpCompositeConstruct %v3float %878 %878 %878 %930 = OpFMul %v3float %875 %929 %931 = OpFAdd %v3float %928 %930 %932 = OpVectorTimesMatrix %v3float %931 %575 %933 = OpMatrixTimesMatrix %mat3v3float %577 %488 %934 = OpMatrixTimesMatrix %mat3v3float %933 %576 %935 = OpMatrixTimesMatrix %mat3v3float %577 %492 %936 = OpMatrixTimesMatrix %mat3v3float %935 %576 %937 = OpVectorTimesMatrix %v3float %931 %934 %938 = OpAccessChain %_ptr_Uniform_float %_Globals %int_44 %939 = OpLoad %float %938 %940 = OpCompositeConstruct %v3float %939 %939 %939 %941 = OpExtInst %v3float %1 FMix %931 %937 %940 %942 = OpVectorTimesMatrix %v3float %941 %577 %943 = OpCompositeExtract %float %942 0 %944 = OpCompositeExtract %float %942 1 %945 = OpExtInst %float %1 FMin %943 %944 %946 = OpCompositeExtract %float %942 2 %947 = OpExtInst %float %1 FMin %945 %946 %948 = OpExtInst %float %1 FMax %943 %944 %949 = OpExtInst %float %1 FMax %948 %946 %950 = OpExtInst %float %1 FMax %949 %float_1_00000001en10 %951 = OpExtInst %float %1 FMax %947 %float_1_00000001en10 %952 = OpFSub %float %950 %951 %953 = OpExtInst %float %1 FMax %949 %float_0_00999999978 %954 = OpFDiv %float %952 %953 %955 = OpFSub %float %946 %944 %956 = OpFMul %float %946 %955 %957 = OpFSub %float %944 %943 %958 = OpFMul %float %944 %957 %959 = OpFAdd %float %956 %958 %960 = OpFSub %float %943 %946 %961 = OpFMul %float %943 %960 %962 = OpFAdd %float %959 %961 %963 = OpExtInst %float %1 Sqrt %962 %964 = OpFAdd %float %946 %944 %965 = OpFAdd %float %964 %943 %966 = OpFMul %float %float_1_75 %963 %967 = OpFAdd %float %965 %966 %968 = OpFMul %float %967 %float_0_333333343 %969 = OpFSub %float %954 %float_0_400000006 %970 = OpFMul %float %969 %float_5 %971 = OpFMul %float %969 %float_2_5 %972 = OpExtInst %float %1 FAbs %971 %973 = OpFSub %float %float_1 %972 %974 = OpExtInst %float %1 FMax %973 %float_0 %975 = OpExtInst %float %1 FSign %970 %976 = OpConvertFToS %int %975 %977 = OpConvertSToF %float %976 %978 = OpFMul %float %974 %974 %979 = OpFSub %float %float_1 %978 %980 = OpFMul %float %977 %979 %981 = OpFAdd %float %float_1 %980 %982 = OpFMul %float %981 %float_0_0250000004 %983 = OpFOrdLessThanEqual %bool %968 %float_0_0533333346 OpSelectionMerge %984 None OpBranchConditional %983 %985 %986 %986 = OpLabel %987 = OpFOrdGreaterThanEqual %bool %968 %float_0_159999996 OpSelectionMerge %988 None OpBranchConditional %987 %989 %990 %990 = OpLabel %991 = OpFDiv %float %float_0_239999995 %967 %992 = OpFSub %float %991 %float_0_5 %993 = OpFMul %float %982 %992 OpBranch %988 %989 = OpLabel OpBranch %988 %988 = OpLabel %994 = OpPhi %float %993 %990 %float_0 %989 OpBranch %984 %985 = OpLabel OpBranch %984 %984 = OpLabel %995 = OpPhi %float %994 %988 %982 %985 %996 = OpFAdd %float %float_1 %995 %997 = OpCompositeConstruct %v3float %996 %996 %996 %998 = OpFMul %v3float %942 %997 %999 = OpCompositeExtract %float %998 0 %1000 = OpCompositeExtract %float %998 1 %1001 = OpFOrdEqual %bool %999 %1000 %1002 = OpCompositeExtract %float %998 2 %1003 = OpFOrdEqual %bool %1000 %1002 %1004 = OpLogicalAnd %bool %1001 %1003 OpSelectionMerge %1005 None OpBranchConditional %1004 %1006 %1007 %1007 = OpLabel %1008 = OpExtInst %float %1 Sqrt %float_3 %1009 = OpFSub %float %1000 %1002 %1010 = OpFMul %float %1008 %1009 %1011 = OpFMul %float %float_2 %999 %1012 = OpFSub %float %1011 %1000 %1013 = OpFSub %float %1012 %1002 %1014 = OpExtInst %float %1 Atan2 %1010 %1013 %1015 = OpFMul %float %float_57_2957764 %1014 OpBranch %1005 %1006 = OpLabel OpBranch %1005 %1005 = OpLabel %1016 = OpPhi %float %1015 %1007 %float_0 %1006 %1017 = OpFOrdLessThan %bool %1016 %float_0 OpSelectionMerge %1018 None OpBranchConditional %1017 %1019 %1018 %1019 = OpLabel %1020 = OpFAdd %float %1016 %float_360 OpBranch %1018 %1018 = OpLabel %1021 = OpPhi %float %1016 %1005 %1020 %1019 %1022 = OpExtInst %float %1 FClamp %1021 %float_0 %float_360 %1023 = OpFOrdGreaterThan %bool %1022 %float_180 OpSelectionMerge %1024 None OpBranchConditional %1023 %1025 %1024 %1025 = OpLabel %1026 = OpFSub %float %1022 %float_360 OpBranch %1024 %1024 = OpLabel %1027 = OpPhi %float %1022 %1018 %1026 %1025 %1028 = OpFMul %float %1027 %float_0_0148148146 %1029 = OpExtInst %float %1 FAbs %1028 %1030 = OpFSub %float %float_1 %1029 %1031 = OpExtInst %float %1 SmoothStep %float_0 %float_1 %1030 %1032 = OpFMul %float %1031 %1031 %1033 = OpFMul %float %1032 %954 %1034 = OpFSub %float %float_0_0299999993 %999 %1035 = OpFMul %float %1033 %1034 %1036 = OpFMul %float %1035 %float_0_180000007 %1037 = OpFAdd %float %999 %1036 %1038 = OpCompositeInsert %v3float %1037 %998 0 %1039 = OpVectorTimesMatrix %v3float %1038 %434 %1040 = OpExtInst %v3float %1 FMax %138 %1039 %1041 = OpDot %float %1040 %73 %1042 = OpCompositeConstruct %v3float %1041 %1041 %1041 %1043 = OpExtInst %v3float %1 FMix %1042 %1040 %241 %1044 = OpAccessChain %_ptr_Uniform_float %_Globals %int_13 %1045 = OpLoad %float %1044 %1046 = OpFAdd %float %float_1 %1045 %1047 = OpAccessChain %_ptr_Uniform_float %_Globals %int_11 %1048 = OpLoad %float %1047 %1049 = OpFSub %float %1046 %1048 %1050 = OpAccessChain %_ptr_Uniform_float %_Globals %int_14 %1051 = OpLoad %float %1050 %1052 = OpFAdd %float %float_1 %1051 %1053 = OpAccessChain %_ptr_Uniform_float %_Globals %int_12 %1054 = OpLoad %float %1053 %1055 = OpFSub %float %1052 %1054 %1056 = OpFOrdGreaterThan %bool %1048 %float_0_800000012 OpSelectionMerge %1057 None OpBranchConditional %1056 %1058 %1059 %1059 = OpLabel %1060 = OpFAdd %float %float_0_180000007 %1045 %1061 = OpFDiv %float %1060 %1049 %1062 = OpExtInst %float %1 Log %float_0_180000007 %1063 = OpExtInst %float %1 Log %float_10 %1064 = OpFDiv %float %1062 %1063 %1065 = OpFSub %float %float_2 %1061 %1066 = OpFDiv %float %1061 %1065 %1067 = OpExtInst %float %1 Log %1066 %1068 = OpFMul %float %float_0_5 %1067 %1069 = OpAccessChain %_ptr_Uniform_float %_Globals %int_10 %1070 = OpLoad %float %1069 %1071 = OpFDiv %float %1049 %1070 %1072 = OpFMul %float %1068 %1071 %1073 = OpFSub %float %1064 %1072 OpBranch %1057 %1058 = OpLabel %1074 = OpFSub %float %float_0_819999993 %1048 %1075 = OpAccessChain %_ptr_Uniform_float %_Globals %int_10 %1076 = OpLoad %float %1075 %1077 = OpFDiv %float %1074 %1076 %1078 = OpExtInst %float %1 Log %float_0_180000007 %1079 = OpExtInst %float %1 Log %float_10 %1080 = OpFDiv %float %1078 %1079 %1081 = OpFAdd %float %1077 %1080 OpBranch %1057 %1057 = OpLabel %1082 = OpPhi %float %1073 %1059 %1081 %1058 %1083 = OpFSub %float %float_1 %1048 %1084 = OpAccessChain %_ptr_Uniform_float %_Globals %int_10 %1085 = OpLoad %float %1084 %1086 = OpFDiv %float %1083 %1085 %1087 = OpFSub %float %1086 %1082 %1088 = OpFDiv %float %1054 %1085 %1089 = OpFSub %float %1088 %1087 %1090 = OpExtInst %v3float %1 Log %1043 %1091 = OpExtInst %float %1 Log %float_10 %1092 = OpCompositeConstruct %v3float %1091 %1091 %1091 %1093 = OpFDiv %v3float %1090 %1092 %1094 = OpCompositeConstruct %v3float %1085 %1085 %1085 %1095 = OpCompositeConstruct %v3float %1087 %1087 %1087 %1096 = OpFAdd %v3float %1093 %1095 %1097 = OpFMul %v3float %1094 %1096 %1098 = OpFNegate %float %1045 %1099 = OpCompositeConstruct %v3float %1098 %1098 %1098 %1100 = OpFMul %float %float_2 %1049 %1101 = OpCompositeConstruct %v3float %1100 %1100 %1100 %1102 = OpFMul %float %float_n2 %1085 %1103 = OpFDiv %float %1102 %1049 %1104 = OpCompositeConstruct %v3float %1103 %1103 %1103 %1105 = OpCompositeConstruct %v3float %1082 %1082 %1082 %1106 = OpFSub %v3float %1093 %1105 %1107 = OpFMul %v3float %1104 %1106 %1108 = OpExtInst %v3float %1 Exp %1107 %1109 = OpFAdd %v3float %141 %1108 %1110 = OpFDiv %v3float %1101 %1109 %1111 = OpFAdd %v3float %1099 %1110 %1112 = OpCompositeConstruct %v3float %1052 %1052 %1052 %1113 = OpFMul %float %float_2 %1055 %1114 = OpCompositeConstruct %v3float %1113 %1113 %1113 %1115 = OpFMul %float %float_2 %1085 %1116 = OpFDiv %float %1115 %1055 %1117 = OpCompositeConstruct %v3float %1116 %1116 %1116 %1118 = OpCompositeConstruct %v3float %1089 %1089 %1089 %1119 = OpFSub %v3float %1093 %1118 %1120 = OpFMul %v3float %1117 %1119 %1121 = OpExtInst %v3float %1 Exp %1120 %1122 = OpFAdd %v3float %141 %1121 %1123 = OpFDiv %v3float %1114 %1122 %1124 = OpFSub %v3float %1112 %1123 %1125 = OpFOrdLessThan %v3bool %1093 %1105 %1126 = OpSelect %v3float %1125 %1111 %1097 %1127 = OpFOrdGreaterThan %v3bool %1093 %1118 %1128 = OpSelect %v3float %1127 %1124 %1097 %1129 = OpFSub %float %1089 %1082 %1130 = OpCompositeConstruct %v3float %1129 %1129 %1129 %1131 = OpFDiv %v3float %1106 %1130 %1132 = OpExtInst %v3float %1 FClamp %1131 %138 %141 %1133 = OpFOrdLessThan %bool %1089 %1082 %1134 = OpFSub %v3float %141 %1132 %1135 = OpCompositeConstruct %v3bool %1133 %1133 %1133 %1136 = OpSelect %v3float %1135 %1134 %1132 %1137 = OpFMul %v3float %252 %1136 %1138 = OpFSub %v3float %251 %1137 %1139 = OpFMul %v3float %1138 %1136 %1140 = OpFMul %v3float %1139 %1136 %1141 = OpExtInst %v3float %1 FMix %1126 %1128 %1140 %1142 = OpDot %float %1141 %73 %1143 = OpCompositeConstruct %v3float %1142 %1142 %1142 %1144 = OpExtInst %v3float %1 FMix %1143 %1141 %254 %1145 = OpExtInst %v3float %1 FMax %138 %1144 %1146 = OpVectorTimesMatrix %v3float %1145 %936 %1147 = OpExtInst %v3float %1 FMix %1145 %1146 %940 %1148 = OpVectorTimesMatrix %v3float %1147 %575 %1149 = OpExtInst %v3float %1 FMax %138 %1148 %1150 = OpFOrdEqual %bool %746 %float_0 OpSelectionMerge %1151 DontFlatten OpBranchConditional %1150 %1152 %1151 %1152 = OpLabel %1153 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_2 %1154 = OpLoad %v4float %1153 %1155 = OpVectorShuffle %v3float %1154 %1154 0 1 2 %1156 = OpDot %float %932 %1155 %1157 = OpCompositeInsert %v3float %1156 %525 0 %1158 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_3 %1159 = OpLoad %v4float %1158 %1160 = OpVectorShuffle %v3float %1159 %1159 0 1 2 %1161 = OpDot %float %932 %1160 %1162 = OpCompositeInsert %v3float %1161 %1157 1 %1163 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_4 %1164 = OpLoad %v4float %1163 %1165 = OpVectorShuffle %v3float %1164 %1164 0 1 2 %1166 = OpDot %float %932 %1165 %1167 = OpCompositeInsert %v3float %1166 %1162 2 %1168 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_8 %1169 = OpLoad %v4float %1168 %1170 = OpVectorShuffle %v3float %1169 %1169 0 1 2 %1171 = OpLoad %v4float %744 %1172 = OpVectorShuffle %v3float %1171 %1171 0 1 2 %1173 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_7 %1174 = OpLoad %v4float %1173 %1175 = OpVectorShuffle %v3float %1174 %1174 0 1 2 %1176 = OpDot %float %932 %1175 %1177 = OpFAdd %float %1176 %float_1 %1178 = OpFDiv %float %float_1 %1177 %1179 = OpCompositeConstruct %v3float %1178 %1178 %1178 %1180 = OpFMul %v3float %1172 %1179 %1181 = OpFAdd %v3float %1170 %1180 %1182 = OpFMul %v3float %1167 %1181 %1183 = OpExtInst %v3float %1 FMax %138 %1182 %1184 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_5 %1185 = OpLoad %v4float %1184 %1186 = OpVectorShuffle %v3float %1185 %1185 0 0 0 %1187 = OpFSub %v3float %1186 %1183 %1188 = OpExtInst %v3float %1 FMax %138 %1187 %1189 = OpVectorShuffle %v3float %1185 %1185 2 2 2 %1190 = OpExtInst %v3float %1 FMax %1183 %1189 %1191 = OpExtInst %v3float %1 FClamp %1183 %1186 %1189 %1192 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_6 %1193 = OpLoad %v4float %1192 %1194 = OpVectorShuffle %v3float %1193 %1193 0 0 0 %1195 = OpFMul %v3float %1190 %1194 %1196 = OpVectorShuffle %v3float %1193 %1193 1 1 1 %1197 = OpFAdd %v3float %1195 %1196 %1198 = OpVectorShuffle %v3float %1185 %1185 3 3 3 %1199 = OpFAdd %v3float %1190 %1198 %1200 = OpFDiv %v3float %141 %1199 %1201 = OpFMul %v3float %1197 %1200 %1202 = OpVectorShuffle %v3float %1164 %1164 3 3 3 %1203 = OpFMul %v3float %1191 %1202 %1204 = OpVectorShuffle %v3float %1154 %1154 3 3 3 %1205 = OpFMul %v3float %1188 %1204 %1206 = OpVectorShuffle %v3float %1185 %1185 1 1 1 %1207 = OpFAdd %v3float %1188 %1206 %1208 = OpFDiv %v3float %141 %1207 %1209 = OpFMul %v3float %1205 %1208 %1210 = OpVectorShuffle %v3float %1159 %1159 3 3 3 %1211 = OpFAdd %v3float %1209 %1210 %1212 = OpFAdd %v3float %1203 %1211 %1213 = OpFAdd %v3float %1201 %1212 %1214 = OpFSub %v3float %1213 %261 OpBranch %1151 %1151 = OpLabel %1215 = OpPhi %v3float %1149 %1057 %1214 %1152 %1216 = OpExtInst %v3float %1 FClamp %1215 %138 %141 %1217 = OpCompositeExtract %float %1216 0 OpBranch %1218 %1218 = OpLabel OpLoopMerge %1219 %1220 None OpBranch %1221 %1221 = OpLabel %1222 = OpFOrdLessThan %bool %1217 %float_0_00313066994 OpSelectionMerge %1223 None OpBranchConditional %1222 %1224 %1223 %1224 = OpLabel %1225 = OpFMul %float %1217 %float_12_9200001 OpBranch %1219 %1223 = OpLabel %1226 = OpExtInst %float %1 Pow %1217 %float_0_416666657 %1227 = OpFMul %float %1226 %float_1_05499995 %1228 = OpFSub %float %1227 %float_0_0549999997 OpBranch %1219 %1220 = OpLabel OpBranch %1218 %1219 = OpLabel %1229 = OpPhi %float %1225 %1224 %1228 %1223 %1230 = OpCompositeExtract %float %1216 1 OpBranch %1231 %1231 = OpLabel OpLoopMerge %1232 %1233 None OpBranch %1234 %1234 = OpLabel %1235 = OpFOrdLessThan %bool %1230 %float_0_00313066994 OpSelectionMerge %1236 None OpBranchConditional %1235 %1237 %1236 %1237 = OpLabel %1238 = OpFMul %float %1230 %float_12_9200001 OpBranch %1232 %1236 = OpLabel %1239 = OpExtInst %float %1 Pow %1230 %float_0_416666657 %1240 = OpFMul %float %1239 %float_1_05499995 %1241 = OpFSub %float %1240 %float_0_0549999997 OpBranch %1232 %1233 = OpLabel OpBranch %1231 %1232 = OpLabel %1242 = OpPhi %float %1238 %1237 %1241 %1236 %1243 = OpCompositeExtract %float %1216 2 OpBranch %1244 %1244 = OpLabel OpLoopMerge %1245 %1246 None OpBranch %1247 %1247 = OpLabel %1248 = OpFOrdLessThan %bool %1243 %float_0_00313066994 OpSelectionMerge %1249 None OpBranchConditional %1248 %1250 %1249 %1250 = OpLabel %1251 = OpFMul %float %1243 %float_12_9200001 OpBranch %1245 %1249 = OpLabel %1252 = OpExtInst %float %1 Pow %1243 %float_0_416666657 %1253 = OpFMul %float %1252 %float_1_05499995 %1254 = OpFSub %float %1253 %float_0_0549999997 OpBranch %1245 %1246 = OpLabel OpBranch %1244 %1245 = OpLabel %1255 = OpPhi %float %1251 %1250 %1254 %1249 %1256 = OpCompositeConstruct %v3float %1229 %1242 %1255 %1257 = OpFMul %v3float %1256 %173 %1258 = OpFAdd %v3float %1257 %175 %1259 = OpAccessChain %_ptr_Uniform_float %_Globals %int_15 %int_0 %1260 = OpLoad %float %1259 %1261 = OpCompositeConstruct %v3float %1260 %1260 %1260 %1262 = OpFMul %v3float %1261 %1256 %1263 = OpAccessChain %_ptr_Uniform_float %_Globals %int_15 %int_1 %1264 = OpLoad %float %1263 %1265 = OpCompositeConstruct %v3float %1264 %1264 %1264 %1266 = OpLoad %type_2d_image %Texture1 %1267 = OpLoad %type_sampler %Texture1Sampler %1268 = OpCompositeExtract %float %1258 2 %1269 = OpFMul %float %1268 %float_16 %1270 = OpFSub %float %1269 %float_0_5 %1271 = OpExtInst %float %1 Floor %1270 %1272 = OpFSub %float %1270 %1271 %1273 = OpCompositeExtract %float %1258 0 %1274 = OpFAdd %float %1273 %1271 %1275 = OpFMul %float %1274 %float_0_0625 %1276 = OpCompositeExtract %float %1258 1 %1277 = OpCompositeConstruct %v2float %1275 %1276 %1278 = OpSampledImage %type_sampled_image %1266 %1267 %1279 = OpImageSampleImplicitLod %v4float %1278 %1277 None %1280 = OpFAdd %float %1275 %float_0_0625 %1281 = OpCompositeConstruct %v2float %1280 %1276 %1282 = OpSampledImage %type_sampled_image %1266 %1267 %1283 = OpImageSampleImplicitLod %v4float %1282 %1281 None %1284 = OpCompositeConstruct %v4float %1272 %1272 %1272 %1272 %1285 = OpExtInst %v4float %1 FMix %1279 %1283 %1284 %1286 = OpVectorShuffle %v3float %1285 %1285 0 1 2 %1287 = OpFMul %v3float %1265 %1286 %1288 = OpFAdd %v3float %1262 %1287 %1289 = OpExtInst %v3float %1 FMax %263 %1288 %1290 = OpFOrdGreaterThan %v3bool %1289 %265 %1291 = OpFMul %v3float %1289 %267 %1292 = OpFAdd %v3float %1291 %269 %1293 = OpExtInst %v3float %1 Pow %1292 %271 %1294 = OpFMul %v3float %1289 %273 %1295 = OpSelect %v3float %1290 %1293 %1294 %1296 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_0 %1297 = OpLoad %float %1296 %1298 = OpCompositeConstruct %v3float %1297 %1297 %1297 %1299 = OpFMul %v3float %1295 %1295 %1300 = OpFMul %v3float %1298 %1299 %1301 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_1 %1302 = OpLoad %float %1301 %1303 = OpCompositeConstruct %v3float %1302 %1302 %1302 %1304 = OpFMul %v3float %1303 %1295 %1305 = OpFAdd %v3float %1300 %1304 %1306 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_2 %1307 = OpLoad %float %1306 %1308 = OpCompositeConstruct %v3float %1307 %1307 %1307 %1309 = OpFAdd %v3float %1305 %1308 %1310 = OpAccessChain %_ptr_Uniform_v3float %_Globals %int_16 %1311 = OpLoad %v3float %1310 %1312 = OpFMul %v3float %1309 %1311 %1313 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_17 %1314 = OpLoad %v4float %1313 %1315 = OpVectorShuffle %v3float %1314 %1314 0 1 2 %1316 = OpAccessChain %_ptr_Uniform_float %_Globals %int_17 %int_3 %1317 = OpLoad %float %1316 %1318 = OpCompositeConstruct %v3float %1317 %1317 %1317 %1319 = OpExtInst %v3float %1 FMix %1312 %1315 %1318 %1320 = OpExtInst %v3float %1 FMax %138 %1319 %1321 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %int_1 %1322 = OpLoad %float %1321 %1323 = OpCompositeConstruct %v3float %1322 %1322 %1322 %1324 = OpExtInst %v3float %1 Pow %1320 %1323 %1325 = OpIEqual %bool %605 %uint_0 OpSelectionMerge %1326 DontFlatten OpBranchConditional %1325 %1327 %1328 %1328 = OpLabel %1329 = OpIEqual %bool %605 %uint_1 OpSelectionMerge %1330 None OpBranchConditional %1329 %1331 %1332 %1332 = OpLabel %1333 = OpIEqual %bool %605 %uint_3 %1334 = OpIEqual %bool %605 %uint_5 %1335 = OpLogicalOr %bool %1333 %1334 OpSelectionMerge %1336 None OpBranchConditional %1335 %1337 %1338 %1338 = OpLabel %1339 = OpIEqual %bool %605 %uint_4 %1340 = OpIEqual %bool %605 %uint_6 %1341 = OpLogicalOr %bool %1339 %1340 OpSelectionMerge %1342 None OpBranchConditional %1341 %1343 %1344 %1344 = OpLabel %1345 = OpIEqual %bool %605 %uint_7 OpSelectionMerge %1346 None OpBranchConditional %1345 %1347 %1348 %1348 = OpLabel %1349 = OpVectorTimesMatrix %v3float %1324 %573 %1350 = OpVectorTimesMatrix %v3float %1349 %602 %1351 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %int_2 %1352 = OpLoad %float %1351 %1353 = OpCompositeConstruct %v3float %1352 %1352 %1352 %1354 = OpExtInst %v3float %1 Pow %1350 %1353 OpBranch %1346 %1347 = OpLabel %1355 = OpVectorTimesMatrix %v3float %932 %573 %1356 = OpVectorTimesMatrix %v3float %1355 %602 %1357 = OpFMul %v3float %1356 %519 %1358 = OpExtInst %v3float %1 Pow %1357 %286 %1359 = OpFMul %v3float %196 %1358 %1360 = OpFAdd %v3float %195 %1359 %1361 = OpFMul %v3float %197 %1358 %1362 = OpFAdd %v3float %141 %1361 %1363 = OpFDiv %v3float %141 %1362 %1364 = OpFMul %v3float %1360 %1363 %1365 = OpExtInst %v3float %1 Pow %1364 %287 OpBranch %1346 %1346 = OpLabel %1366 = OpPhi %v3float %1354 %1348 %1365 %1347 OpBranch %1342 %1343 = OpLabel %1367 = OpMatrixTimesMatrix %mat3v3float %572 %423 %1368 = OpFMul %v3float %932 %285 %1369 = OpVectorTimesMatrix %v3float %1368 %1367 %1370 = OpCompositeExtract %float %1369 0 %1371 = OpCompositeExtract %float %1369 1 %1372 = OpExtInst %float %1 FMin %1370 %1371 %1373 = OpCompositeExtract %float %1369 2 %1374 = OpExtInst %float %1 FMin %1372 %1373 %1375 = OpExtInst %float %1 FMax %1370 %1371 %1376 = OpExtInst %float %1 FMax %1375 %1373 %1377 = OpExtInst %float %1 FMax %1376 %float_1_00000001en10 %1378 = OpExtInst %float %1 FMax %1374 %float_1_00000001en10 %1379 = OpFSub %float %1377 %1378 %1380 = OpExtInst %float %1 FMax %1376 %float_0_00999999978 %1381 = OpFDiv %float %1379 %1380 %1382 = OpFSub %float %1373 %1371 %1383 = OpFMul %float %1373 %1382 %1384 = OpFSub %float %1371 %1370 %1385 = OpFMul %float %1371 %1384 %1386 = OpFAdd %float %1383 %1385 %1387 = OpFSub %float %1370 %1373 %1388 = OpFMul %float %1370 %1387 %1389 = OpFAdd %float %1386 %1388 %1390 = OpExtInst %float %1 Sqrt %1389 %1391 = OpFAdd %float %1373 %1371 %1392 = OpFAdd %float %1391 %1370 %1393 = OpFMul %float %float_1_75 %1390 %1394 = OpFAdd %float %1392 %1393 %1395 = OpFMul %float %1394 %float_0_333333343 %1396 = OpFSub %float %1381 %float_0_400000006 %1397 = OpFMul %float %1396 %float_5 %1398 = OpFMul %float %1396 %float_2_5 %1399 = OpExtInst %float %1 FAbs %1398 %1400 = OpFSub %float %float_1 %1399 %1401 = OpExtInst %float %1 FMax %1400 %float_0 %1402 = OpExtInst %float %1 FSign %1397 %1403 = OpConvertFToS %int %1402 %1404 = OpConvertSToF %float %1403 %1405 = OpFMul %float %1401 %1401 %1406 = OpFSub %float %float_1 %1405 %1407 = OpFMul %float %1404 %1406 %1408 = OpFAdd %float %float_1 %1407 %1409 = OpFMul %float %1408 %float_0_0250000004 %1410 = OpFOrdLessThanEqual %bool %1395 %float_0_0533333346 OpSelectionMerge %1411 None OpBranchConditional %1410 %1412 %1413 %1413 = OpLabel %1414 = OpFOrdGreaterThanEqual %bool %1395 %float_0_159999996 OpSelectionMerge %1415 None OpBranchConditional %1414 %1416 %1417 %1417 = OpLabel %1418 = OpFDiv %float %float_0_239999995 %1394 %1419 = OpFSub %float %1418 %float_0_5 %1420 = OpFMul %float %1409 %1419 OpBranch %1415 %1416 = OpLabel OpBranch %1415 %1415 = OpLabel %1421 = OpPhi %float %1420 %1417 %float_0 %1416 OpBranch %1411 %1412 = OpLabel OpBranch %1411 %1411 = OpLabel %1422 = OpPhi %float %1421 %1415 %1409 %1412 %1423 = OpFAdd %float %float_1 %1422 %1424 = OpCompositeConstruct %v3float %1423 %1423 %1423 %1425 = OpFMul %v3float %1369 %1424 %1426 = OpCompositeExtract %float %1425 0 %1427 = OpCompositeExtract %float %1425 1 %1428 = OpFOrdEqual %bool %1426 %1427 %1429 = OpCompositeExtract %float %1425 2 %1430 = OpFOrdEqual %bool %1427 %1429 %1431 = OpLogicalAnd %bool %1428 %1430 OpSelectionMerge %1432 None OpBranchConditional %1431 %1433 %1434 %1434 = OpLabel %1435 = OpExtInst %float %1 Sqrt %float_3 %1436 = OpFSub %float %1427 %1429 %1437 = OpFMul %float %1435 %1436 %1438 = OpFMul %float %float_2 %1426 %1439 = OpFSub %float %1438 %1427 %1440 = OpFSub %float %1439 %1429 %1441 = OpExtInst %float %1 Atan2 %1437 %1440 %1442 = OpFMul %float %float_57_2957764 %1441 OpBranch %1432 %1433 = OpLabel OpBranch %1432 %1432 = OpLabel %1443 = OpPhi %float %1442 %1434 %float_0 %1433 %1444 = OpFOrdLessThan %bool %1443 %float_0 OpSelectionMerge %1445 None OpBranchConditional %1444 %1446 %1445 %1446 = OpLabel %1447 = OpFAdd %float %1443 %float_360 OpBranch %1445 %1445 = OpLabel %1448 = OpPhi %float %1443 %1432 %1447 %1446 %1449 = OpExtInst %float %1 FClamp %1448 %float_0 %float_360 %1450 = OpFOrdGreaterThan %bool %1449 %float_180 OpSelectionMerge %1451 None OpBranchConditional %1450 %1452 %1451 %1452 = OpLabel %1453 = OpFSub %float %1449 %float_360 OpBranch %1451 %1451 = OpLabel %1454 = OpPhi %float %1449 %1445 %1453 %1452 %1455 = OpFOrdGreaterThan %bool %1454 %float_n67_5 %1456 = OpFOrdLessThan %bool %1454 %float_67_5 %1457 = OpLogicalAnd %bool %1455 %1456 OpSelectionMerge %1458 None OpBranchConditional %1457 %1459 %1458 %1459 = OpLabel %1460 = OpFSub %float %1454 %float_n67_5 %1461 = OpFMul %float %1460 %float_0_0296296291 %1462 = OpConvertFToS %int %1461 %1463 = OpConvertSToF %float %1462 %1464 = OpFSub %float %1461 %1463 %1465 = OpFMul %float %1464 %1464 %1466 = OpFMul %float %1465 %1464 %1467 = OpIEqual %bool %1462 %int_3 OpSelectionMerge %1468 None OpBranchConditional %1467 %1469 %1470 %1470 = OpLabel %1471 = OpIEqual %bool %1462 %int_2 OpSelectionMerge %1472 None OpBranchConditional %1471 %1473 %1474 %1474 = OpLabel %1475 = OpIEqual %bool %1462 %int_1 OpSelectionMerge %1476 None OpBranchConditional %1475 %1477 %1478 %1478 = OpLabel %1479 = OpIEqual %bool %1462 %int_0 OpSelectionMerge %1480 None OpBranchConditional %1479 %1481 %1482 %1482 = OpLabel OpBranch %1480 %1481 = OpLabel %1483 = OpFMul %float %1466 %float_0_166666672 OpBranch %1480 %1480 = OpLabel %1484 = OpPhi %float %float_0 %1482 %1483 %1481 OpBranch %1476 %1477 = OpLabel %1485 = OpFMul %float %1466 %float_n0_5 %1486 = OpFMul %float %1465 %float_0_5 %1487 = OpFAdd %float %1485 %1486 %1488 = OpFMul %float %1464 %float_0_5 %1489 = OpFAdd %float %1487 %1488 %1490 = OpFAdd %float %1489 %float_0_166666672 OpBranch %1476 %1476 = OpLabel %1491 = OpPhi %float %1484 %1480 %1490 %1477 OpBranch %1472 %1473 = OpLabel %1492 = OpFMul %float %1466 %float_0_5 %1493 = OpFMul %float %1465 %float_n1 %1494 = OpFAdd %float %1492 %1493 %1495 = OpFAdd %float %1494 %float_0_666666687 OpBranch %1472 %1472 = OpLabel %1496 = OpPhi %float %1491 %1476 %1495 %1473 OpBranch %1468 %1469 = OpLabel %1497 = OpFMul %float %1466 %float_n0_166666672 %1498 = OpFMul %float %1465 %float_0_5 %1499 = OpFAdd %float %1497 %1498 %1500 = OpFMul %float %1464 %float_n0_5 %1501 = OpFAdd %float %1499 %1500 %1502 = OpFAdd %float %1501 %float_0_166666672 OpBranch %1468 %1468 = OpLabel %1503 = OpPhi %float %1496 %1472 %1502 %1469 OpBranch %1458 %1458 = OpLabel %1504 = OpPhi %float %float_0 %1451 %1503 %1468 %1505 = OpFMul %float %1504 %float_1_5 %1506 = OpFMul %float %1505 %1381 %1507 = OpFSub %float %float_0_0299999993 %1426 %1508 = OpFMul %float %1506 %1507 %1509 = OpFMul %float %1508 %float_0_180000007 %1510 = OpFAdd %float %1426 %1509 %1511 = OpCompositeInsert %v3float %1510 %1425 0 %1512 = OpExtInst %v3float %1 FClamp %1511 %138 %337 %1513 = OpVectorTimesMatrix %v3float %1512 %434 %1514 = OpExtInst %v3float %1 FClamp %1513 %138 %337 %1515 = OpDot %float %1514 %73 %1516 = OpCompositeConstruct %v3float %1515 %1515 %1515 %1517 = OpExtInst %v3float %1 FMix %1516 %1514 %241 %1518 = OpCompositeExtract %float %1517 0 %1519 = OpExtInst %float %1 Exp2 %float_n15 %1520 = OpFMul %float %float_0_179999992 %1519 %1521 = OpExtInst %float %1 Exp2 %float_18 %1522 = OpFMul %float %float_0_179999992 %1521 OpStore %528 %499 OpStore %527 %500 %1523 = OpFOrdLessThanEqual %bool %1518 %float_0 %1524 = OpExtInst %float %1 Exp2 %float_n14 %1525 = OpSelect %float %1523 %1524 %1518 %1526 = OpExtInst %float %1 Log %1525 %1527 = OpFDiv %float %1526 %1091 %1528 = OpExtInst %float %1 Log %1520 %1529 = OpFDiv %float %1528 %1091 %1530 = OpFOrdLessThanEqual %bool %1527 %1529 OpSelectionMerge %1531 None OpBranchConditional %1530 %1532 %1533 %1533 = OpLabel %1534 = OpFOrdGreaterThan %bool %1527 %1529 %1535 = OpExtInst %float %1 Log %float_0_180000007 %1536 = OpFDiv %float %1535 %1091 %1537 = OpFOrdLessThan %bool %1527 %1536 %1538 = OpLogicalAnd %bool %1534 %1537 OpSelectionMerge %1539 None OpBranchConditional %1538 %1540 %1541 %1541 = OpLabel %1542 = OpFOrdGreaterThanEqual %bool %1527 %1536 %1543 = OpExtInst %float %1 Log %1522 %1544 = OpFDiv %float %1543 %1091 %1545 = OpFOrdLessThan %bool %1527 %1544 %1546 = OpLogicalAnd %bool %1542 %1545 OpSelectionMerge %1547 None OpBranchConditional %1546 %1548 %1549 %1549 = OpLabel %1550 = OpExtInst %float %1 Log %float_10000 %1551 = OpFDiv %float %1550 %1091 OpBranch %1547 %1548 = OpLabel %1552 = OpFSub %float %1527 %1536 %1553 = OpFMul %float %float_3 %1552 %1554 = OpFSub %float %1544 %1536 %1555 = OpFDiv %float %1553 %1554 %1556 = OpConvertFToS %int %1555 %1557 = OpConvertSToF %float %1556 %1558 = OpFSub %float %1555 %1557 %1559 = OpAccessChain %_ptr_Function_float %527 %1556 %1560 = OpLoad %float %1559 %1561 = OpIAdd %int %1556 %int_1 %1562 = OpAccessChain %_ptr_Function_float %527 %1561 %1563 = OpLoad %float %1562 %1564 = OpIAdd %int %1556 %int_2 %1565 = OpAccessChain %_ptr_Function_float %527 %1564 %1566 = OpLoad %float %1565 %1567 = OpCompositeConstruct %v3float %1560 %1563 %1566 %1568 = OpFMul %float %1558 %1558 %1569 = OpCompositeConstruct %v3float %1568 %1558 %float_1 %1570 = OpMatrixTimesVector %v3float %466 %1567 %1571 = OpDot %float %1569 %1570 OpBranch %1547 %1547 = OpLabel %1572 = OpPhi %float %1551 %1549 %1571 %1548 OpBranch %1539 %1540 = OpLabel %1573 = OpFSub %float %1527 %1529 %1574 = OpFMul %float %float_3 %1573 %1575 = OpFSub %float %1536 %1529 %1576 = OpFDiv %float %1574 %1575 %1577 = OpConvertFToS %int %1576 %1578 = OpConvertSToF %float %1577 %1579 = OpFSub %float %1576 %1578 %1580 = OpAccessChain %_ptr_Function_float %528 %1577 %1581 = OpLoad %float %1580 %1582 = OpIAdd %int %1577 %int_1 %1583 = OpAccessChain %_ptr_Function_float %528 %1582 %1584 = OpLoad %float %1583 %1585 = OpIAdd %int %1577 %int_2 %1586 = OpAccessChain %_ptr_Function_float %528 %1585 %1587 = OpLoad %float %1586 %1588 = OpCompositeConstruct %v3float %1581 %1584 %1587 %1589 = OpFMul %float %1579 %1579 %1590 = OpCompositeConstruct %v3float %1589 %1579 %float_1 %1591 = OpMatrixTimesVector %v3float %466 %1588 %1592 = OpDot %float %1590 %1591 OpBranch %1539 %1539 = OpLabel %1593 = OpPhi %float %1572 %1547 %1592 %1540 OpBranch %1531 %1532 = OpLabel %1594 = OpExtInst %float %1 Log %float_9_99999975en05 %1595 = OpFDiv %float %1594 %1091 OpBranch %1531 %1531 = OpLabel %1596 = OpPhi %float %1593 %1539 %1595 %1532 %1597 = OpExtInst %float %1 Pow %float_10 %1596 %1598 = OpCompositeInsert %v3float %1597 %523 0 %1599 = OpCompositeExtract %float %1517 1 OpStore %530 %499 OpStore %529 %500 %1600 = OpFOrdLessThanEqual %bool %1599 %float_0 %1601 = OpSelect %float %1600 %1524 %1599 %1602 = OpExtInst %float %1 Log %1601 %1603 = OpFDiv %float %1602 %1091 %1604 = OpFOrdLessThanEqual %bool %1603 %1529 OpSelectionMerge %1605 None OpBranchConditional %1604 %1606 %1607 %1607 = OpLabel %1608 = OpFOrdGreaterThan %bool %1603 %1529 %1609 = OpExtInst %float %1 Log %float_0_180000007 %1610 = OpFDiv %float %1609 %1091 %1611 = OpFOrdLessThan %bool %1603 %1610 %1612 = OpLogicalAnd %bool %1608 %1611 OpSelectionMerge %1613 None OpBranchConditional %1612 %1614 %1615 %1615 = OpLabel %1616 = OpFOrdGreaterThanEqual %bool %1603 %1610 %1617 = OpExtInst %float %1 Log %1522 %1618 = OpFDiv %float %1617 %1091 %1619 = OpFOrdLessThan %bool %1603 %1618 %1620 = OpLogicalAnd %bool %1616 %1619 OpSelectionMerge %1621 None OpBranchConditional %1620 %1622 %1623 %1623 = OpLabel %1624 = OpExtInst %float %1 Log %float_10000 %1625 = OpFDiv %float %1624 %1091 OpBranch %1621 %1622 = OpLabel %1626 = OpFSub %float %1603 %1610 %1627 = OpFMul %float %float_3 %1626 %1628 = OpFSub %float %1618 %1610 %1629 = OpFDiv %float %1627 %1628 %1630 = OpConvertFToS %int %1629 %1631 = OpConvertSToF %float %1630 %1632 = OpFSub %float %1629 %1631 %1633 = OpAccessChain %_ptr_Function_float %529 %1630 %1634 = OpLoad %float %1633 %1635 = OpIAdd %int %1630 %int_1 %1636 = OpAccessChain %_ptr_Function_float %529 %1635 %1637 = OpLoad %float %1636 %1638 = OpIAdd %int %1630 %int_2 %1639 = OpAccessChain %_ptr_Function_float %529 %1638 %1640 = OpLoad %float %1639 %1641 = OpCompositeConstruct %v3float %1634 %1637 %1640 %1642 = OpFMul %float %1632 %1632 %1643 = OpCompositeConstruct %v3float %1642 %1632 %float_1 %1644 = OpMatrixTimesVector %v3float %466 %1641 %1645 = OpDot %float %1643 %1644 OpBranch %1621 %1621 = OpLabel %1646 = OpPhi %float %1625 %1623 %1645 %1622 OpBranch %1613 %1614 = OpLabel %1647 = OpFSub %float %1603 %1529 %1648 = OpFMul %float %float_3 %1647 %1649 = OpFSub %float %1610 %1529 %1650 = OpFDiv %float %1648 %1649 %1651 = OpConvertFToS %int %1650 %1652 = OpConvertSToF %float %1651 %1653 = OpFSub %float %1650 %1652 %1654 = OpAccessChain %_ptr_Function_float %530 %1651 %1655 = OpLoad %float %1654 %1656 = OpIAdd %int %1651 %int_1 %1657 = OpAccessChain %_ptr_Function_float %530 %1656 %1658 = OpLoad %float %1657 %1659 = OpIAdd %int %1651 %int_2 %1660 = OpAccessChain %_ptr_Function_float %530 %1659 %1661 = OpLoad %float %1660 %1662 = OpCompositeConstruct %v3float %1655 %1658 %1661 %1663 = OpFMul %float %1653 %1653 %1664 = OpCompositeConstruct %v3float %1663 %1653 %float_1 %1665 = OpMatrixTimesVector %v3float %466 %1662 %1666 = OpDot %float %1664 %1665 OpBranch %1613 %1613 = OpLabel %1667 = OpPhi %float %1646 %1621 %1666 %1614 OpBranch %1605 %1606 = OpLabel %1668 = OpExtInst %float %1 Log %float_9_99999975en05 %1669 = OpFDiv %float %1668 %1091 OpBranch %1605 %1605 = OpLabel %1670 = OpPhi %float %1667 %1613 %1669 %1606 %1671 = OpExtInst %float %1 Pow %float_10 %1670 %1672 = OpCompositeInsert %v3float %1671 %1598 1 %1673 = OpCompositeExtract %float %1517 2 OpStore %532 %499 OpStore %531 %500 %1674 = OpFOrdLessThanEqual %bool %1673 %float_0 %1675 = OpSelect %float %1674 %1524 %1673 %1676 = OpExtInst %float %1 Log %1675 %1677 = OpFDiv %float %1676 %1091 %1678 = OpFOrdLessThanEqual %bool %1677 %1529 OpSelectionMerge %1679 None OpBranchConditional %1678 %1680 %1681 %1681 = OpLabel %1682 = OpFOrdGreaterThan %bool %1677 %1529 %1683 = OpExtInst %float %1 Log %float_0_180000007 %1684 = OpFDiv %float %1683 %1091 %1685 = OpFOrdLessThan %bool %1677 %1684 %1686 = OpLogicalAnd %bool %1682 %1685 OpSelectionMerge %1687 None OpBranchConditional %1686 %1688 %1689 %1689 = OpLabel %1690 = OpFOrdGreaterThanEqual %bool %1677 %1684 %1691 = OpExtInst %float %1 Log %1522 %1692 = OpFDiv %float %1691 %1091 %1693 = OpFOrdLessThan %bool %1677 %1692 %1694 = OpLogicalAnd %bool %1690 %1693 OpSelectionMerge %1695 None OpBranchConditional %1694 %1696 %1697 %1697 = OpLabel %1698 = OpExtInst %float %1 Log %float_10000 %1699 = OpFDiv %float %1698 %1091 OpBranch %1695 %1696 = OpLabel %1700 = OpFSub %float %1677 %1684 %1701 = OpFMul %float %float_3 %1700 %1702 = OpFSub %float %1692 %1684 %1703 = OpFDiv %float %1701 %1702 %1704 = OpConvertFToS %int %1703 %1705 = OpConvertSToF %float %1704 %1706 = OpFSub %float %1703 %1705 %1707 = OpAccessChain %_ptr_Function_float %531 %1704 %1708 = OpLoad %float %1707 %1709 = OpIAdd %int %1704 %int_1 %1710 = OpAccessChain %_ptr_Function_float %531 %1709 %1711 = OpLoad %float %1710 %1712 = OpIAdd %int %1704 %int_2 %1713 = OpAccessChain %_ptr_Function_float %531 %1712 %1714 = OpLoad %float %1713 %1715 = OpCompositeConstruct %v3float %1708 %1711 %1714 %1716 = OpFMul %float %1706 %1706 %1717 = OpCompositeConstruct %v3float %1716 %1706 %float_1 %1718 = OpMatrixTimesVector %v3float %466 %1715 %1719 = OpDot %float %1717 %1718 OpBranch %1695 %1695 = OpLabel %1720 = OpPhi %float %1699 %1697 %1719 %1696 OpBranch %1687 %1688 = OpLabel %1721 = OpFSub %float %1677 %1529 %1722 = OpFMul %float %float_3 %1721 %1723 = OpFSub %float %1684 %1529 %1724 = OpFDiv %float %1722 %1723 %1725 = OpConvertFToS %int %1724 %1726 = OpConvertSToF %float %1725 %1727 = OpFSub %float %1724 %1726 %1728 = OpAccessChain %_ptr_Function_float %532 %1725 %1729 = OpLoad %float %1728 %1730 = OpIAdd %int %1725 %int_1 %1731 = OpAccessChain %_ptr_Function_float %532 %1730 %1732 = OpLoad %float %1731 %1733 = OpIAdd %int %1725 %int_2 %1734 = OpAccessChain %_ptr_Function_float %532 %1733 %1735 = OpLoad %float %1734 %1736 = OpCompositeConstruct %v3float %1729 %1732 %1735 %1737 = OpFMul %float %1727 %1727 %1738 = OpCompositeConstruct %v3float %1737 %1727 %float_1 %1739 = OpMatrixTimesVector %v3float %466 %1736 %1740 = OpDot %float %1738 %1739 OpBranch %1687 %1687 = OpLabel %1741 = OpPhi %float %1720 %1695 %1740 %1688 OpBranch %1679 %1680 = OpLabel %1742 = OpExtInst %float %1 Log %float_9_99999975en05 %1743 = OpFDiv %float %1742 %1091 OpBranch %1679 %1679 = OpLabel %1744 = OpPhi %float %1741 %1687 %1743 %1680 %1745 = OpExtInst %float %1 Pow %float_10 %1744 %1746 = OpCompositeInsert %v3float %1745 %1672 2 %1747 = OpVectorTimesMatrix %v3float %1746 %438 %1748 = OpVectorTimesMatrix %v3float %1747 %434 %1749 = OpExtInst %float %1 Pow %float_2 %float_n12 %1750 = OpFMul %float %float_0_179999992 %1749 OpStore %540 %499 OpStore %539 %500 %1751 = OpFOrdLessThanEqual %bool %1750 %float_0 %1752 = OpSelect %float %1751 %1524 %1750 %1753 = OpExtInst %float %1 Log %1752 %1754 = OpFDiv %float %1753 %1091 %1755 = OpFOrdLessThanEqual %bool %1754 %1529 OpSelectionMerge %1756 None OpBranchConditional %1755 %1757 %1758 %1758 = OpLabel %1759 = OpFOrdGreaterThan %bool %1754 %1529 %1760 = OpExtInst %float %1 Log %float_0_180000007 %1761 = OpFDiv %float %1760 %1091 %1762 = OpFOrdLessThan %bool %1754 %1761 %1763 = OpLogicalAnd %bool %1759 %1762 OpSelectionMerge %1764 None OpBranchConditional %1763 %1765 %1766 %1766 = OpLabel %1767 = OpFOrdGreaterThanEqual %bool %1754 %1761 %1768 = OpExtInst %float %1 Log %1522 %1769 = OpFDiv %float %1768 %1091 %1770 = OpFOrdLessThan %bool %1754 %1769 %1771 = OpLogicalAnd %bool %1767 %1770 OpSelectionMerge %1772 None OpBranchConditional %1771 %1773 %1774 %1774 = OpLabel %1775 = OpExtInst %float %1 Log %float_10000 %1776 = OpFDiv %float %1775 %1091 OpBranch %1772 %1773 = OpLabel %1777 = OpFSub %float %1754 %1761 %1778 = OpFMul %float %float_3 %1777 %1779 = OpFSub %float %1769 %1761 %1780 = OpFDiv %float %1778 %1779 %1781 = OpConvertFToS %int %1780 %1782 = OpConvertSToF %float %1781 %1783 = OpFSub %float %1780 %1782 %1784 = OpAccessChain %_ptr_Function_float %539 %1781 %1785 = OpLoad %float %1784 %1786 = OpIAdd %int %1781 %int_1 %1787 = OpAccessChain %_ptr_Function_float %539 %1786 %1788 = OpLoad %float %1787 %1789 = OpIAdd %int %1781 %int_2 %1790 = OpAccessChain %_ptr_Function_float %539 %1789 %1791 = OpLoad %float %1790 %1792 = OpCompositeConstruct %v3float %1785 %1788 %1791 %1793 = OpFMul %float %1783 %1783 %1794 = OpCompositeConstruct %v3float %1793 %1783 %float_1 %1795 = OpMatrixTimesVector %v3float %466 %1792 %1796 = OpDot %float %1794 %1795 OpBranch %1772 %1772 = OpLabel %1797 = OpPhi %float %1776 %1774 %1796 %1773 OpBranch %1764 %1765 = OpLabel %1798 = OpFSub %float %1754 %1529 %1799 = OpFMul %float %float_3 %1798 %1800 = OpFSub %float %1761 %1529 %1801 = OpFDiv %float %1799 %1800 %1802 = OpConvertFToS %int %1801 %1803 = OpConvertSToF %float %1802 %1804 = OpFSub %float %1801 %1803 %1805 = OpAccessChain %_ptr_Function_float %540 %1802 %1806 = OpLoad %float %1805 %1807 = OpIAdd %int %1802 %int_1 %1808 = OpAccessChain %_ptr_Function_float %540 %1807 %1809 = OpLoad %float %1808 %1810 = OpIAdd %int %1802 %int_2 %1811 = OpAccessChain %_ptr_Function_float %540 %1810 %1812 = OpLoad %float %1811 %1813 = OpCompositeConstruct %v3float %1806 %1809 %1812 %1814 = OpFMul %float %1804 %1804 %1815 = OpCompositeConstruct %v3float %1814 %1804 %float_1 %1816 = OpMatrixTimesVector %v3float %466 %1813 %1817 = OpDot %float %1815 %1816 OpBranch %1764 %1764 = OpLabel %1818 = OpPhi %float %1797 %1772 %1817 %1765 OpBranch %1756 %1757 = OpLabel %1819 = OpExtInst %float %1 Log %float_9_99999975en05 %1820 = OpFDiv %float %1819 %1091 OpBranch %1756 %1756 = OpLabel %1821 = OpPhi %float %1818 %1764 %1820 %1757 %1822 = OpExtInst %float %1 Pow %float_10 %1821 OpStore %542 %499 OpStore %541 %500 %1823 = OpExtInst %float %1 Log %float_0_180000007 %1824 = OpFDiv %float %1823 %1091 %1825 = OpFOrdLessThanEqual %bool %1824 %1529 OpSelectionMerge %1826 None OpBranchConditional %1825 %1827 %1828 %1828 = OpLabel %1829 = OpFOrdGreaterThan %bool %1824 %1529 %1830 = OpFOrdLessThan %bool %1824 %1824 %1831 = OpLogicalAnd %bool %1829 %1830 OpSelectionMerge %1832 None OpBranchConditional %1831 %1833 %1834 %1834 = OpLabel %1835 = OpFOrdGreaterThanEqual %bool %1824 %1824 %1836 = OpExtInst %float %1 Log %1522 %1837 = OpFDiv %float %1836 %1091 %1838 = OpFOrdLessThan %bool %1824 %1837 %1839 = OpLogicalAnd %bool %1835 %1838 OpSelectionMerge %1840 None OpBranchConditional %1839 %1841 %1842 %1842 = OpLabel %1843 = OpExtInst %float %1 Log %float_10000 %1844 = OpFDiv %float %1843 %1091 OpBranch %1840 %1841 = OpLabel %1845 = OpFSub %float %1824 %1824 %1846 = OpFMul %float %float_3 %1845 %1847 = OpFSub %float %1837 %1824 %1848 = OpFDiv %float %1846 %1847 %1849 = OpConvertFToS %int %1848 %1850 = OpConvertSToF %float %1849 %1851 = OpFSub %float %1848 %1850 %1852 = OpAccessChain %_ptr_Function_float %541 %1849 %1853 = OpLoad %float %1852 %1854 = OpIAdd %int %1849 %int_1 %1855 = OpAccessChain %_ptr_Function_float %541 %1854 %1856 = OpLoad %float %1855 %1857 = OpIAdd %int %1849 %int_2 %1858 = OpAccessChain %_ptr_Function_float %541 %1857 %1859 = OpLoad %float %1858 %1860 = OpCompositeConstruct %v3float %1853 %1856 %1859 %1861 = OpFMul %float %1851 %1851 %1862 = OpCompositeConstruct %v3float %1861 %1851 %float_1 %1863 = OpMatrixTimesVector %v3float %466 %1860 %1864 = OpDot %float %1862 %1863 OpBranch %1840 %1840 = OpLabel %1865 = OpPhi %float %1844 %1842 %1864 %1841 OpBranch %1832 %1833 = OpLabel %1866 = OpAccessChain %_ptr_Function_float %542 %int_3 %1867 = OpLoad %float %1866 %1868 = OpAccessChain %_ptr_Function_float %542 %int_4 %1869 = OpLoad %float %1868 %1870 = OpAccessChain %_ptr_Function_float %542 %int_5 %1871 = OpLoad %float %1870 %1872 = OpCompositeConstruct %v3float %1867 %1869 %1871 %1873 = OpMatrixTimesVector %v3float %466 %1872 %1874 = OpCompositeExtract %float %1873 2 OpBranch %1832 %1832 = OpLabel %1875 = OpPhi %float %1865 %1840 %1874 %1833 OpBranch %1826 %1827 = OpLabel %1876 = OpExtInst %float %1 Log %float_9_99999975en05 %1877 = OpFDiv %float %1876 %1091 OpBranch %1826 %1826 = OpLabel %1878 = OpPhi %float %1875 %1832 %1877 %1827 %1879 = OpExtInst %float %1 Pow %float_10 %1878 %1880 = OpExtInst %float %1 Pow %float_2 %float_11 %1881 = OpFMul %float %float_0_179999992 %1880 OpStore %544 %499 OpStore %543 %500 %1882 = OpFOrdLessThanEqual %bool %1881 %float_0 %1883 = OpSelect %float %1882 %1524 %1881 %1884 = OpExtInst %float %1 Log %1883 %1885 = OpFDiv %float %1884 %1091 %1886 = OpFOrdLessThanEqual %bool %1885 %1529 OpSelectionMerge %1887 None OpBranchConditional %1886 %1888 %1889 %1889 = OpLabel %1890 = OpFOrdGreaterThan %bool %1885 %1529 %1891 = OpFOrdLessThan %bool %1885 %1824 %1892 = OpLogicalAnd %bool %1890 %1891 OpSelectionMerge %1893 None OpBranchConditional %1892 %1894 %1895 %1895 = OpLabel %1896 = OpFOrdGreaterThanEqual %bool %1885 %1824 %1897 = OpExtInst %float %1 Log %1522 %1898 = OpFDiv %float %1897 %1091 %1899 = OpFOrdLessThan %bool %1885 %1898 %1900 = OpLogicalAnd %bool %1896 %1899 OpSelectionMerge %1901 None OpBranchConditional %1900 %1902 %1903 %1903 = OpLabel %1904 = OpExtInst %float %1 Log %float_10000 %1905 = OpFDiv %float %1904 %1091 OpBranch %1901 %1902 = OpLabel %1906 = OpFSub %float %1885 %1824 %1907 = OpFMul %float %float_3 %1906 %1908 = OpFSub %float %1898 %1824 %1909 = OpFDiv %float %1907 %1908 %1910 = OpConvertFToS %int %1909 %1911 = OpConvertSToF %float %1910 %1912 = OpFSub %float %1909 %1911 %1913 = OpAccessChain %_ptr_Function_float %543 %1910 %1914 = OpLoad %float %1913 %1915 = OpIAdd %int %1910 %int_1 %1916 = OpAccessChain %_ptr_Function_float %543 %1915 %1917 = OpLoad %float %1916 %1918 = OpIAdd %int %1910 %int_2 %1919 = OpAccessChain %_ptr_Function_float %543 %1918 %1920 = OpLoad %float %1919 %1921 = OpCompositeConstruct %v3float %1914 %1917 %1920 %1922 = OpFMul %float %1912 %1912 %1923 = OpCompositeConstruct %v3float %1922 %1912 %float_1 %1924 = OpMatrixTimesVector %v3float %466 %1921 %1925 = OpDot %float %1923 %1924 OpBranch %1901 %1901 = OpLabel %1926 = OpPhi %float %1905 %1903 %1925 %1902 OpBranch %1893 %1894 = OpLabel %1927 = OpFSub %float %1885 %1529 %1928 = OpFMul %float %float_3 %1927 %1929 = OpFSub %float %1824 %1529 %1930 = OpFDiv %float %1928 %1929 %1931 = OpConvertFToS %int %1930 %1932 = OpConvertSToF %float %1931 %1933 = OpFSub %float %1930 %1932 %1934 = OpAccessChain %_ptr_Function_float %544 %1931 %1935 = OpLoad %float %1934 %1936 = OpIAdd %int %1931 %int_1 %1937 = OpAccessChain %_ptr_Function_float %544 %1936 %1938 = OpLoad %float %1937 %1939 = OpIAdd %int %1931 %int_2 %1940 = OpAccessChain %_ptr_Function_float %544 %1939 %1941 = OpLoad %float %1940 %1942 = OpCompositeConstruct %v3float %1935 %1938 %1941 %1943 = OpFMul %float %1933 %1933 %1944 = OpCompositeConstruct %v3float %1943 %1933 %float_1 %1945 = OpMatrixTimesVector %v3float %466 %1942 %1946 = OpDot %float %1944 %1945 OpBranch %1893 %1893 = OpLabel %1947 = OpPhi %float %1926 %1901 %1946 %1894 OpBranch %1887 %1888 = OpLabel %1948 = OpExtInst %float %1 Log %float_9_99999975en05 %1949 = OpFDiv %float %1948 %1091 OpBranch %1887 %1887 = OpLabel %1950 = OpPhi %float %1947 %1893 %1949 %1888 %1951 = OpExtInst %float %1 Pow %float_10 %1950 %1952 = OpCompositeExtract %float %1748 0 OpStore %538 %506 OpStore %537 %507 %1953 = OpFOrdLessThanEqual %bool %1952 %float_0 %1954 = OpSelect %float %1953 %float_9_99999975en05 %1952 %1955 = OpExtInst %float %1 Log %1954 %1956 = OpFDiv %float %1955 %1091 %1957 = OpExtInst %float %1 Log %1822 %1958 = OpFDiv %float %1957 %1091 %1959 = OpFOrdLessThanEqual %bool %1956 %1958 OpSelectionMerge %1960 None OpBranchConditional %1959 %1961 %1962 %1962 = OpLabel %1963 = OpFOrdGreaterThan %bool %1956 %1958 %1964 = OpExtInst %float %1 Log %1879 %1965 = OpFDiv %float %1964 %1091 %1966 = OpFOrdLessThan %bool %1956 %1965 %1967 = OpLogicalAnd %bool %1963 %1966 OpSelectionMerge %1968 None OpBranchConditional %1967 %1969 %1970 %1970 = OpLabel %1971 = OpFOrdGreaterThanEqual %bool %1956 %1965 %1972 = OpExtInst %float %1 Log %1951 %1973 = OpFDiv %float %1972 %1091 %1974 = OpFOrdLessThan %bool %1956 %1973 %1975 = OpLogicalAnd %bool %1971 %1974 OpSelectionMerge %1976 None OpBranchConditional %1975 %1977 %1978 %1978 = OpLabel %1979 = OpFMul %float %1956 %float_0_119999997 %1980 = OpExtInst %float %1 Log %float_2000 %1981 = OpFDiv %float %1980 %1091 %1982 = OpFMul %float %float_0_119999997 %1972 %1983 = OpFDiv %float %1982 %1091 %1984 = OpFSub %float %1981 %1983 %1985 = OpFAdd %float %1979 %1984 OpBranch %1976 %1977 = OpLabel %1986 = OpFSub %float %1956 %1965 %1987 = OpFMul %float %float_7 %1986 %1988 = OpFSub %float %1973 %1965 %1989 = OpFDiv %float %1987 %1988 %1990 = OpConvertFToS %int %1989 %1991 = OpConvertSToF %float %1990 %1992 = OpFSub %float %1989 %1991 %1993 = OpAccessChain %_ptr_Function_float %537 %1990 %1994 = OpLoad %float %1993 %1995 = OpIAdd %int %1990 %int_1 %1996 = OpAccessChain %_ptr_Function_float %537 %1995 %1997 = OpLoad %float %1996 %1998 = OpIAdd %int %1990 %int_2 %1999 = OpAccessChain %_ptr_Function_float %537 %1998 %2000 = OpLoad %float %1999 %2001 = OpCompositeConstruct %v3float %1994 %1997 %2000 %2002 = OpFMul %float %1992 %1992 %2003 = OpCompositeConstruct %v3float %2002 %1992 %float_1 %2004 = OpMatrixTimesVector %v3float %466 %2001 %2005 = OpDot %float %2003 %2004 OpBranch %1976 %1976 = OpLabel %2006 = OpPhi %float %1985 %1978 %2005 %1977 OpBranch %1968 %1969 = OpLabel %2007 = OpFSub %float %1956 %1958 %2008 = OpFMul %float %float_7 %2007 %2009 = OpFSub %float %1965 %1958 %2010 = OpFDiv %float %2008 %2009 %2011 = OpConvertFToS %int %2010 %2012 = OpConvertSToF %float %2011 %2013 = OpFSub %float %2010 %2012 %2014 = OpAccessChain %_ptr_Function_float %538 %2011 %2015 = OpLoad %float %2014 %2016 = OpIAdd %int %2011 %int_1 %2017 = OpAccessChain %_ptr_Function_float %538 %2016 %2018 = OpLoad %float %2017 %2019 = OpIAdd %int %2011 %int_2 %2020 = OpAccessChain %_ptr_Function_float %538 %2019 %2021 = OpLoad %float %2020 %2022 = OpCompositeConstruct %v3float %2015 %2018 %2021 %2023 = OpFMul %float %2013 %2013 %2024 = OpCompositeConstruct %v3float %2023 %2013 %float_1 %2025 = OpMatrixTimesVector %v3float %466 %2022 %2026 = OpDot %float %2024 %2025 OpBranch %1968 %1968 = OpLabel %2027 = OpPhi %float %2006 %1976 %2026 %1969 OpBranch %1960 %1961 = OpLabel %2028 = OpExtInst %float %1 Log %float_0_00499999989 %2029 = OpFDiv %float %2028 %1091 OpBranch %1960 %1960 = OpLabel %2030 = OpPhi %float %2027 %1968 %2029 %1961 %2031 = OpExtInst %float %1 Pow %float_10 %2030 %2032 = OpCompositeInsert %v3float %2031 %523 0 %2033 = OpCompositeExtract %float %1748 1 OpStore %536 %506 OpStore %535 %507 %2034 = OpFOrdLessThanEqual %bool %2033 %float_0 %2035 = OpSelect %float %2034 %float_9_99999975en05 %2033 %2036 = OpExtInst %float %1 Log %2035 %2037 = OpFDiv %float %2036 %1091 %2038 = OpFOrdLessThanEqual %bool %2037 %1958 OpSelectionMerge %2039 None OpBranchConditional %2038 %2040 %2041 %2041 = OpLabel %2042 = OpFOrdGreaterThan %bool %2037 %1958 %2043 = OpExtInst %float %1 Log %1879 %2044 = OpFDiv %float %2043 %1091 %2045 = OpFOrdLessThan %bool %2037 %2044 %2046 = OpLogicalAnd %bool %2042 %2045 OpSelectionMerge %2047 None OpBranchConditional %2046 %2048 %2049 %2049 = OpLabel %2050 = OpFOrdGreaterThanEqual %bool %2037 %2044 %2051 = OpExtInst %float %1 Log %1951 %2052 = OpFDiv %float %2051 %1091 %2053 = OpFOrdLessThan %bool %2037 %2052 %2054 = OpLogicalAnd %bool %2050 %2053 OpSelectionMerge %2055 None OpBranchConditional %2054 %2056 %2057 %2057 = OpLabel %2058 = OpFMul %float %2037 %float_0_119999997 %2059 = OpExtInst %float %1 Log %float_2000 %2060 = OpFDiv %float %2059 %1091 %2061 = OpFMul %float %float_0_119999997 %2051 %2062 = OpFDiv %float %2061 %1091 %2063 = OpFSub %float %2060 %2062 %2064 = OpFAdd %float %2058 %2063 OpBranch %2055 %2056 = OpLabel %2065 = OpFSub %float %2037 %2044 %2066 = OpFMul %float %float_7 %2065 %2067 = OpFSub %float %2052 %2044 %2068 = OpFDiv %float %2066 %2067 %2069 = OpConvertFToS %int %2068 %2070 = OpConvertSToF %float %2069 %2071 = OpFSub %float %2068 %2070 %2072 = OpAccessChain %_ptr_Function_float %535 %2069 %2073 = OpLoad %float %2072 %2074 = OpIAdd %int %2069 %int_1 %2075 = OpAccessChain %_ptr_Function_float %535 %2074 %2076 = OpLoad %float %2075 %2077 = OpIAdd %int %2069 %int_2 %2078 = OpAccessChain %_ptr_Function_float %535 %2077 %2079 = OpLoad %float %2078 %2080 = OpCompositeConstruct %v3float %2073 %2076 %2079 %2081 = OpFMul %float %2071 %2071 %2082 = OpCompositeConstruct %v3float %2081 %2071 %float_1 %2083 = OpMatrixTimesVector %v3float %466 %2080 %2084 = OpDot %float %2082 %2083 OpBranch %2055 %2055 = OpLabel %2085 = OpPhi %float %2064 %2057 %2084 %2056 OpBranch %2047 %2048 = OpLabel %2086 = OpFSub %float %2037 %1958 %2087 = OpFMul %float %float_7 %2086 %2088 = OpFSub %float %2044 %1958 %2089 = OpFDiv %float %2087 %2088 %2090 = OpConvertFToS %int %2089 %2091 = OpConvertSToF %float %2090 %2092 = OpFSub %float %2089 %2091 %2093 = OpAccessChain %_ptr_Function_float %536 %2090 %2094 = OpLoad %float %2093 %2095 = OpIAdd %int %2090 %int_1 %2096 = OpAccessChain %_ptr_Function_float %536 %2095 %2097 = OpLoad %float %2096 %2098 = OpIAdd %int %2090 %int_2 %2099 = OpAccessChain %_ptr_Function_float %536 %2098 %2100 = OpLoad %float %2099 %2101 = OpCompositeConstruct %v3float %2094 %2097 %2100 %2102 = OpFMul %float %2092 %2092 %2103 = OpCompositeConstruct %v3float %2102 %2092 %float_1 %2104 = OpMatrixTimesVector %v3float %466 %2101 %2105 = OpDot %float %2103 %2104 OpBranch %2047 %2047 = OpLabel %2106 = OpPhi %float %2085 %2055 %2105 %2048 OpBranch %2039 %2040 = OpLabel %2107 = OpExtInst %float %1 Log %float_0_00499999989 %2108 = OpFDiv %float %2107 %1091 OpBranch %2039 %2039 = OpLabel %2109 = OpPhi %float %2106 %2047 %2108 %2040 %2110 = OpExtInst %float %1 Pow %float_10 %2109 %2111 = OpCompositeInsert %v3float %2110 %2032 1 %2112 = OpCompositeExtract %float %1748 2 OpStore %534 %506 OpStore %533 %507 %2113 = OpFOrdLessThanEqual %bool %2112 %float_0 %2114 = OpSelect %float %2113 %float_9_99999975en05 %2112 %2115 = OpExtInst %float %1 Log %2114 %2116 = OpFDiv %float %2115 %1091 %2117 = OpFOrdLessThanEqual %bool %2116 %1958 OpSelectionMerge %2118 None OpBranchConditional %2117 %2119 %2120 %2120 = OpLabel %2121 = OpFOrdGreaterThan %bool %2116 %1958 %2122 = OpExtInst %float %1 Log %1879 %2123 = OpFDiv %float %2122 %1091 %2124 = OpFOrdLessThan %bool %2116 %2123 %2125 = OpLogicalAnd %bool %2121 %2124 OpSelectionMerge %2126 None OpBranchConditional %2125 %2127 %2128 %2128 = OpLabel %2129 = OpFOrdGreaterThanEqual %bool %2116 %2123 %2130 = OpExtInst %float %1 Log %1951 %2131 = OpFDiv %float %2130 %1091 %2132 = OpFOrdLessThan %bool %2116 %2131 %2133 = OpLogicalAnd %bool %2129 %2132 OpSelectionMerge %2134 None OpBranchConditional %2133 %2135 %2136 %2136 = OpLabel %2137 = OpFMul %float %2116 %float_0_119999997 %2138 = OpExtInst %float %1 Log %float_2000 %2139 = OpFDiv %float %2138 %1091 %2140 = OpFMul %float %float_0_119999997 %2130 %2141 = OpFDiv %float %2140 %1091 %2142 = OpFSub %float %2139 %2141 %2143 = OpFAdd %float %2137 %2142 OpBranch %2134 %2135 = OpLabel %2144 = OpFSub %float %2116 %2123 %2145 = OpFMul %float %float_7 %2144 %2146 = OpFSub %float %2131 %2123 %2147 = OpFDiv %float %2145 %2146 %2148 = OpConvertFToS %int %2147 %2149 = OpConvertSToF %float %2148 %2150 = OpFSub %float %2147 %2149 %2151 = OpAccessChain %_ptr_Function_float %533 %2148 %2152 = OpLoad %float %2151 %2153 = OpIAdd %int %2148 %int_1 %2154 = OpAccessChain %_ptr_Function_float %533 %2153 %2155 = OpLoad %float %2154 %2156 = OpIAdd %int %2148 %int_2 %2157 = OpAccessChain %_ptr_Function_float %533 %2156 %2158 = OpLoad %float %2157 %2159 = OpCompositeConstruct %v3float %2152 %2155 %2158 %2160 = OpFMul %float %2150 %2150 %2161 = OpCompositeConstruct %v3float %2160 %2150 %float_1 %2162 = OpMatrixTimesVector %v3float %466 %2159 %2163 = OpDot %float %2161 %2162 OpBranch %2134 %2134 = OpLabel %2164 = OpPhi %float %2143 %2136 %2163 %2135 OpBranch %2126 %2127 = OpLabel %2165 = OpFSub %float %2116 %1958 %2166 = OpFMul %float %float_7 %2165 %2167 = OpFSub %float %2123 %1958 %2168 = OpFDiv %float %2166 %2167 %2169 = OpConvertFToS %int %2168 %2170 = OpConvertSToF %float %2169 %2171 = OpFSub %float %2168 %2170 %2172 = OpAccessChain %_ptr_Function_float %534 %2169 %2173 = OpLoad %float %2172 %2174 = OpIAdd %int %2169 %int_1 %2175 = OpAccessChain %_ptr_Function_float %534 %2174 %2176 = OpLoad %float %2175 %2177 = OpIAdd %int %2169 %int_2 %2178 = OpAccessChain %_ptr_Function_float %534 %2177 %2179 = OpLoad %float %2178 %2180 = OpCompositeConstruct %v3float %2173 %2176 %2179 %2181 = OpFMul %float %2171 %2171 %2182 = OpCompositeConstruct %v3float %2181 %2171 %float_1 %2183 = OpMatrixTimesVector %v3float %466 %2180 %2184 = OpDot %float %2182 %2183 OpBranch %2126 %2126 = OpLabel %2185 = OpPhi %float %2164 %2134 %2184 %2127 OpBranch %2118 %2119 = OpLabel %2186 = OpExtInst %float %1 Log %float_0_00499999989 %2187 = OpFDiv %float %2186 %1091 OpBranch %2118 %2118 = OpLabel %2188 = OpPhi %float %2185 %2126 %2187 %2119 %2189 = OpExtInst %float %1 Pow %float_10 %2188 %2190 = OpCompositeInsert %v3float %2189 %2111 2 %2191 = OpVectorTimesMatrix %v3float %2190 %602 %2192 = OpFMul %v3float %2191 %519 %2193 = OpExtInst %v3float %1 Pow %2192 %286 %2194 = OpFMul %v3float %196 %2193 %2195 = OpFAdd %v3float %195 %2194 %2196 = OpFMul %v3float %197 %2193 %2197 = OpFAdd %v3float %141 %2196 %2198 = OpFDiv %v3float %141 %2197 %2199 = OpFMul %v3float %2195 %2198 %2200 = OpExtInst %v3float %1 Pow %2199 %287 OpBranch %1342 %1342 = OpLabel %2201 = OpPhi %v3float %1366 %1346 %2200 %2118 OpBranch %1336 %1337 = OpLabel %2202 = OpMatrixTimesMatrix %mat3v3float %572 %423 %2203 = OpFMul %v3float %932 %285 %2204 = OpVectorTimesMatrix %v3float %2203 %2202 %2205 = OpCompositeExtract %float %2204 0 %2206 = OpCompositeExtract %float %2204 1 %2207 = OpExtInst %float %1 FMin %2205 %2206 %2208 = OpCompositeExtract %float %2204 2 %2209 = OpExtInst %float %1 FMin %2207 %2208 %2210 = OpExtInst %float %1 FMax %2205 %2206 %2211 = OpExtInst %float %1 FMax %2210 %2208 %2212 = OpExtInst %float %1 FMax %2211 %float_1_00000001en10 %2213 = OpExtInst %float %1 FMax %2209 %float_1_00000001en10 %2214 = OpFSub %float %2212 %2213 %2215 = OpExtInst %float %1 FMax %2211 %float_0_00999999978 %2216 = OpFDiv %float %2214 %2215 %2217 = OpFSub %float %2208 %2206 %2218 = OpFMul %float %2208 %2217 %2219 = OpFSub %float %2206 %2205 %2220 = OpFMul %float %2206 %2219 %2221 = OpFAdd %float %2218 %2220 %2222 = OpFSub %float %2205 %2208 %2223 = OpFMul %float %2205 %2222 %2224 = OpFAdd %float %2221 %2223 %2225 = OpExtInst %float %1 Sqrt %2224 %2226 = OpFAdd %float %2208 %2206 %2227 = OpFAdd %float %2226 %2205 %2228 = OpFMul %float %float_1_75 %2225 %2229 = OpFAdd %float %2227 %2228 %2230 = OpFMul %float %2229 %float_0_333333343 %2231 = OpFSub %float %2216 %float_0_400000006 %2232 = OpFMul %float %2231 %float_5 %2233 = OpFMul %float %2231 %float_2_5 %2234 = OpExtInst %float %1 FAbs %2233 %2235 = OpFSub %float %float_1 %2234 %2236 = OpExtInst %float %1 FMax %2235 %float_0 %2237 = OpExtInst %float %1 FSign %2232 %2238 = OpConvertFToS %int %2237 %2239 = OpConvertSToF %float %2238 %2240 = OpFMul %float %2236 %2236 %2241 = OpFSub %float %float_1 %2240 %2242 = OpFMul %float %2239 %2241 %2243 = OpFAdd %float %float_1 %2242 %2244 = OpFMul %float %2243 %float_0_0250000004 %2245 = OpFOrdLessThanEqual %bool %2230 %float_0_0533333346 OpSelectionMerge %2246 None OpBranchConditional %2245 %2247 %2248 %2248 = OpLabel %2249 = OpFOrdGreaterThanEqual %bool %2230 %float_0_159999996 OpSelectionMerge %2250 None OpBranchConditional %2249 %2251 %2252 %2252 = OpLabel %2253 = OpFDiv %float %float_0_239999995 %2229 %2254 = OpFSub %float %2253 %float_0_5 %2255 = OpFMul %float %2244 %2254 OpBranch %2250 %2251 = OpLabel OpBranch %2250 %2250 = OpLabel %2256 = OpPhi %float %2255 %2252 %float_0 %2251 OpBranch %2246 %2247 = OpLabel OpBranch %2246 %2246 = OpLabel %2257 = OpPhi %float %2256 %2250 %2244 %2247 %2258 = OpFAdd %float %float_1 %2257 %2259 = OpCompositeConstruct %v3float %2258 %2258 %2258 %2260 = OpFMul %v3float %2204 %2259 %2261 = OpCompositeExtract %float %2260 0 %2262 = OpCompositeExtract %float %2260 1 %2263 = OpFOrdEqual %bool %2261 %2262 %2264 = OpCompositeExtract %float %2260 2 %2265 = OpFOrdEqual %bool %2262 %2264 %2266 = OpLogicalAnd %bool %2263 %2265 OpSelectionMerge %2267 None OpBranchConditional %2266 %2268 %2269 %2269 = OpLabel %2270 = OpExtInst %float %1 Sqrt %float_3 %2271 = OpFSub %float %2262 %2264 %2272 = OpFMul %float %2270 %2271 %2273 = OpFMul %float %float_2 %2261 %2274 = OpFSub %float %2273 %2262 %2275 = OpFSub %float %2274 %2264 %2276 = OpExtInst %float %1 Atan2 %2272 %2275 %2277 = OpFMul %float %float_57_2957764 %2276 OpBranch %2267 %2268 = OpLabel OpBranch %2267 %2267 = OpLabel %2278 = OpPhi %float %2277 %2269 %float_0 %2268 %2279 = OpFOrdLessThan %bool %2278 %float_0 OpSelectionMerge %2280 None OpBranchConditional %2279 %2281 %2280 %2281 = OpLabel %2282 = OpFAdd %float %2278 %float_360 OpBranch %2280 %2280 = OpLabel %2283 = OpPhi %float %2278 %2267 %2282 %2281 %2284 = OpExtInst %float %1 FClamp %2283 %float_0 %float_360 %2285 = OpFOrdGreaterThan %bool %2284 %float_180 OpSelectionMerge %2286 None OpBranchConditional %2285 %2287 %2286 %2287 = OpLabel %2288 = OpFSub %float %2284 %float_360 OpBranch %2286 %2286 = OpLabel %2289 = OpPhi %float %2284 %2280 %2288 %2287 %2290 = OpFOrdGreaterThan %bool %2289 %float_n67_5 %2291 = OpFOrdLessThan %bool %2289 %float_67_5 %2292 = OpLogicalAnd %bool %2290 %2291 OpSelectionMerge %2293 None OpBranchConditional %2292 %2294 %2293 %2294 = OpLabel %2295 = OpFSub %float %2289 %float_n67_5 %2296 = OpFMul %float %2295 %float_0_0296296291 %2297 = OpConvertFToS %int %2296 %2298 = OpConvertSToF %float %2297 %2299 = OpFSub %float %2296 %2298 %2300 = OpFMul %float %2299 %2299 %2301 = OpFMul %float %2300 %2299 %2302 = OpIEqual %bool %2297 %int_3 OpSelectionMerge %2303 None OpBranchConditional %2302 %2304 %2305 %2305 = OpLabel %2306 = OpIEqual %bool %2297 %int_2 OpSelectionMerge %2307 None OpBranchConditional %2306 %2308 %2309 %2309 = OpLabel %2310 = OpIEqual %bool %2297 %int_1 OpSelectionMerge %2311 None OpBranchConditional %2310 %2312 %2313 %2313 = OpLabel %2314 = OpIEqual %bool %2297 %int_0 OpSelectionMerge %2315 None OpBranchConditional %2314 %2316 %2317 %2317 = OpLabel OpBranch %2315 %2316 = OpLabel %2318 = OpFMul %float %2301 %float_0_166666672 OpBranch %2315 %2315 = OpLabel %2319 = OpPhi %float %float_0 %2317 %2318 %2316 OpBranch %2311 %2312 = OpLabel %2320 = OpFMul %float %2301 %float_n0_5 %2321 = OpFMul %float %2300 %float_0_5 %2322 = OpFAdd %float %2320 %2321 %2323 = OpFMul %float %2299 %float_0_5 %2324 = OpFAdd %float %2322 %2323 %2325 = OpFAdd %float %2324 %float_0_166666672 OpBranch %2311 %2311 = OpLabel %2326 = OpPhi %float %2319 %2315 %2325 %2312 OpBranch %2307 %2308 = OpLabel %2327 = OpFMul %float %2301 %float_0_5 %2328 = OpFMul %float %2300 %float_n1 %2329 = OpFAdd %float %2327 %2328 %2330 = OpFAdd %float %2329 %float_0_666666687 OpBranch %2307 %2307 = OpLabel %2331 = OpPhi %float %2326 %2311 %2330 %2308 OpBranch %2303 %2304 = OpLabel %2332 = OpFMul %float %2301 %float_n0_166666672 %2333 = OpFMul %float %2300 %float_0_5 %2334 = OpFAdd %float %2332 %2333 %2335 = OpFMul %float %2299 %float_n0_5 %2336 = OpFAdd %float %2334 %2335 %2337 = OpFAdd %float %2336 %float_0_166666672 OpBranch %2303 %2303 = OpLabel %2338 = OpPhi %float %2331 %2307 %2337 %2304 OpBranch %2293 %2293 = OpLabel %2339 = OpPhi %float %float_0 %2286 %2338 %2303 %2340 = OpFMul %float %2339 %float_1_5 %2341 = OpFMul %float %2340 %2216 %2342 = OpFSub %float %float_0_0299999993 %2261 %2343 = OpFMul %float %2341 %2342 %2344 = OpFMul %float %2343 %float_0_180000007 %2345 = OpFAdd %float %2261 %2344 %2346 = OpCompositeInsert %v3float %2345 %2260 0 %2347 = OpExtInst %v3float %1 FClamp %2346 %138 %337 %2348 = OpVectorTimesMatrix %v3float %2347 %434 %2349 = OpExtInst %v3float %1 FClamp %2348 %138 %337 %2350 = OpDot %float %2349 %73 %2351 = OpCompositeConstruct %v3float %2350 %2350 %2350 %2352 = OpExtInst %v3float %1 FMix %2351 %2349 %241 %2353 = OpCompositeExtract %float %2352 0 %2354 = OpExtInst %float %1 Exp2 %float_n15 %2355 = OpFMul %float %float_0_179999992 %2354 %2356 = OpExtInst %float %1 Exp2 %float_18 %2357 = OpFMul %float %float_0_179999992 %2356 OpStore %546 %499 OpStore %545 %500 %2358 = OpFOrdLessThanEqual %bool %2353 %float_0 %2359 = OpExtInst %float %1 Exp2 %float_n14 %2360 = OpSelect %float %2358 %2359 %2353 %2361 = OpExtInst %float %1 Log %2360 %2362 = OpFDiv %float %2361 %1091 %2363 = OpExtInst %float %1 Log %2355 %2364 = OpFDiv %float %2363 %1091 %2365 = OpFOrdLessThanEqual %bool %2362 %2364 OpSelectionMerge %2366 None OpBranchConditional %2365 %2367 %2368 %2368 = OpLabel %2369 = OpFOrdGreaterThan %bool %2362 %2364 %2370 = OpExtInst %float %1 Log %float_0_180000007 %2371 = OpFDiv %float %2370 %1091 %2372 = OpFOrdLessThan %bool %2362 %2371 %2373 = OpLogicalAnd %bool %2369 %2372 OpSelectionMerge %2374 None OpBranchConditional %2373 %2375 %2376 %2376 = OpLabel %2377 = OpFOrdGreaterThanEqual %bool %2362 %2371 %2378 = OpExtInst %float %1 Log %2357 %2379 = OpFDiv %float %2378 %1091 %2380 = OpFOrdLessThan %bool %2362 %2379 %2381 = OpLogicalAnd %bool %2377 %2380 OpSelectionMerge %2382 None OpBranchConditional %2381 %2383 %2384 %2384 = OpLabel %2385 = OpExtInst %float %1 Log %float_10000 %2386 = OpFDiv %float %2385 %1091 OpBranch %2382 %2383 = OpLabel %2387 = OpFSub %float %2362 %2371 %2388 = OpFMul %float %float_3 %2387 %2389 = OpFSub %float %2379 %2371 %2390 = OpFDiv %float %2388 %2389 %2391 = OpConvertFToS %int %2390 %2392 = OpConvertSToF %float %2391 %2393 = OpFSub %float %2390 %2392 %2394 = OpAccessChain %_ptr_Function_float %545 %2391 %2395 = OpLoad %float %2394 %2396 = OpIAdd %int %2391 %int_1 %2397 = OpAccessChain %_ptr_Function_float %545 %2396 %2398 = OpLoad %float %2397 %2399 = OpIAdd %int %2391 %int_2 %2400 = OpAccessChain %_ptr_Function_float %545 %2399 %2401 = OpLoad %float %2400 %2402 = OpCompositeConstruct %v3float %2395 %2398 %2401 %2403 = OpFMul %float %2393 %2393 %2404 = OpCompositeConstruct %v3float %2403 %2393 %float_1 %2405 = OpMatrixTimesVector %v3float %466 %2402 %2406 = OpDot %float %2404 %2405 OpBranch %2382 %2382 = OpLabel %2407 = OpPhi %float %2386 %2384 %2406 %2383 OpBranch %2374 %2375 = OpLabel %2408 = OpFSub %float %2362 %2364 %2409 = OpFMul %float %float_3 %2408 %2410 = OpFSub %float %2371 %2364 %2411 = OpFDiv %float %2409 %2410 %2412 = OpConvertFToS %int %2411 %2413 = OpConvertSToF %float %2412 %2414 = OpFSub %float %2411 %2413 %2415 = OpAccessChain %_ptr_Function_float %546 %2412 %2416 = OpLoad %float %2415 %2417 = OpIAdd %int %2412 %int_1 %2418 = OpAccessChain %_ptr_Function_float %546 %2417 %2419 = OpLoad %float %2418 %2420 = OpIAdd %int %2412 %int_2 %2421 = OpAccessChain %_ptr_Function_float %546 %2420 %2422 = OpLoad %float %2421 %2423 = OpCompositeConstruct %v3float %2416 %2419 %2422 %2424 = OpFMul %float %2414 %2414 %2425 = OpCompositeConstruct %v3float %2424 %2414 %float_1 %2426 = OpMatrixTimesVector %v3float %466 %2423 %2427 = OpDot %float %2425 %2426 OpBranch %2374 %2374 = OpLabel %2428 = OpPhi %float %2407 %2382 %2427 %2375 OpBranch %2366 %2367 = OpLabel %2429 = OpExtInst %float %1 Log %float_9_99999975en05 %2430 = OpFDiv %float %2429 %1091 OpBranch %2366 %2366 = OpLabel %2431 = OpPhi %float %2428 %2374 %2430 %2367 %2432 = OpExtInst %float %1 Pow %float_10 %2431 %2433 = OpCompositeInsert %v3float %2432 %523 0 %2434 = OpCompositeExtract %float %2352 1 OpStore %548 %499 OpStore %547 %500 %2435 = OpFOrdLessThanEqual %bool %2434 %float_0 %2436 = OpSelect %float %2435 %2359 %2434 %2437 = OpExtInst %float %1 Log %2436 %2438 = OpFDiv %float %2437 %1091 %2439 = OpFOrdLessThanEqual %bool %2438 %2364 OpSelectionMerge %2440 None OpBranchConditional %2439 %2441 %2442 %2442 = OpLabel %2443 = OpFOrdGreaterThan %bool %2438 %2364 %2444 = OpExtInst %float %1 Log %float_0_180000007 %2445 = OpFDiv %float %2444 %1091 %2446 = OpFOrdLessThan %bool %2438 %2445 %2447 = OpLogicalAnd %bool %2443 %2446 OpSelectionMerge %2448 None OpBranchConditional %2447 %2449 %2450 %2450 = OpLabel %2451 = OpFOrdGreaterThanEqual %bool %2438 %2445 %2452 = OpExtInst %float %1 Log %2357 %2453 = OpFDiv %float %2452 %1091 %2454 = OpFOrdLessThan %bool %2438 %2453 %2455 = OpLogicalAnd %bool %2451 %2454 OpSelectionMerge %2456 None OpBranchConditional %2455 %2457 %2458 %2458 = OpLabel %2459 = OpExtInst %float %1 Log %float_10000 %2460 = OpFDiv %float %2459 %1091 OpBranch %2456 %2457 = OpLabel %2461 = OpFSub %float %2438 %2445 %2462 = OpFMul %float %float_3 %2461 %2463 = OpFSub %float %2453 %2445 %2464 = OpFDiv %float %2462 %2463 %2465 = OpConvertFToS %int %2464 %2466 = OpConvertSToF %float %2465 %2467 = OpFSub %float %2464 %2466 %2468 = OpAccessChain %_ptr_Function_float %547 %2465 %2469 = OpLoad %float %2468 %2470 = OpIAdd %int %2465 %int_1 %2471 = OpAccessChain %_ptr_Function_float %547 %2470 %2472 = OpLoad %float %2471 %2473 = OpIAdd %int %2465 %int_2 %2474 = OpAccessChain %_ptr_Function_float %547 %2473 %2475 = OpLoad %float %2474 %2476 = OpCompositeConstruct %v3float %2469 %2472 %2475 %2477 = OpFMul %float %2467 %2467 %2478 = OpCompositeConstruct %v3float %2477 %2467 %float_1 %2479 = OpMatrixTimesVector %v3float %466 %2476 %2480 = OpDot %float %2478 %2479 OpBranch %2456 %2456 = OpLabel %2481 = OpPhi %float %2460 %2458 %2480 %2457 OpBranch %2448 %2449 = OpLabel %2482 = OpFSub %float %2438 %2364 %2483 = OpFMul %float %float_3 %2482 %2484 = OpFSub %float %2445 %2364 %2485 = OpFDiv %float %2483 %2484 %2486 = OpConvertFToS %int %2485 %2487 = OpConvertSToF %float %2486 %2488 = OpFSub %float %2485 %2487 %2489 = OpAccessChain %_ptr_Function_float %548 %2486 %2490 = OpLoad %float %2489 %2491 = OpIAdd %int %2486 %int_1 %2492 = OpAccessChain %_ptr_Function_float %548 %2491 %2493 = OpLoad %float %2492 %2494 = OpIAdd %int %2486 %int_2 %2495 = OpAccessChain %_ptr_Function_float %548 %2494 %2496 = OpLoad %float %2495 %2497 = OpCompositeConstruct %v3float %2490 %2493 %2496 %2498 = OpFMul %float %2488 %2488 %2499 = OpCompositeConstruct %v3float %2498 %2488 %float_1 %2500 = OpMatrixTimesVector %v3float %466 %2497 %2501 = OpDot %float %2499 %2500 OpBranch %2448 %2448 = OpLabel %2502 = OpPhi %float %2481 %2456 %2501 %2449 OpBranch %2440 %2441 = OpLabel %2503 = OpExtInst %float %1 Log %float_9_99999975en05 %2504 = OpFDiv %float %2503 %1091 OpBranch %2440 %2440 = OpLabel %2505 = OpPhi %float %2502 %2448 %2504 %2441 %2506 = OpExtInst %float %1 Pow %float_10 %2505 %2507 = OpCompositeInsert %v3float %2506 %2433 1 %2508 = OpCompositeExtract %float %2352 2 OpStore %550 %499 OpStore %549 %500 %2509 = OpFOrdLessThanEqual %bool %2508 %float_0 %2510 = OpSelect %float %2509 %2359 %2508 %2511 = OpExtInst %float %1 Log %2510 %2512 = OpFDiv %float %2511 %1091 %2513 = OpFOrdLessThanEqual %bool %2512 %2364 OpSelectionMerge %2514 None OpBranchConditional %2513 %2515 %2516 %2516 = OpLabel %2517 = OpFOrdGreaterThan %bool %2512 %2364 %2518 = OpExtInst %float %1 Log %float_0_180000007 %2519 = OpFDiv %float %2518 %1091 %2520 = OpFOrdLessThan %bool %2512 %2519 %2521 = OpLogicalAnd %bool %2517 %2520 OpSelectionMerge %2522 None OpBranchConditional %2521 %2523 %2524 %2524 = OpLabel %2525 = OpFOrdGreaterThanEqual %bool %2512 %2519 %2526 = OpExtInst %float %1 Log %2357 %2527 = OpFDiv %float %2526 %1091 %2528 = OpFOrdLessThan %bool %2512 %2527 %2529 = OpLogicalAnd %bool %2525 %2528 OpSelectionMerge %2530 None OpBranchConditional %2529 %2531 %2532 %2532 = OpLabel %2533 = OpExtInst %float %1 Log %float_10000 %2534 = OpFDiv %float %2533 %1091 OpBranch %2530 %2531 = OpLabel %2535 = OpFSub %float %2512 %2519 %2536 = OpFMul %float %float_3 %2535 %2537 = OpFSub %float %2527 %2519 %2538 = OpFDiv %float %2536 %2537 %2539 = OpConvertFToS %int %2538 %2540 = OpConvertSToF %float %2539 %2541 = OpFSub %float %2538 %2540 %2542 = OpAccessChain %_ptr_Function_float %549 %2539 %2543 = OpLoad %float %2542 %2544 = OpIAdd %int %2539 %int_1 %2545 = OpAccessChain %_ptr_Function_float %549 %2544 %2546 = OpLoad %float %2545 %2547 = OpIAdd %int %2539 %int_2 %2548 = OpAccessChain %_ptr_Function_float %549 %2547 %2549 = OpLoad %float %2548 %2550 = OpCompositeConstruct %v3float %2543 %2546 %2549 %2551 = OpFMul %float %2541 %2541 %2552 = OpCompositeConstruct %v3float %2551 %2541 %float_1 %2553 = OpMatrixTimesVector %v3float %466 %2550 %2554 = OpDot %float %2552 %2553 OpBranch %2530 %2530 = OpLabel %2555 = OpPhi %float %2534 %2532 %2554 %2531 OpBranch %2522 %2523 = OpLabel %2556 = OpFSub %float %2512 %2364 %2557 = OpFMul %float %float_3 %2556 %2558 = OpFSub %float %2519 %2364 %2559 = OpFDiv %float %2557 %2558 %2560 = OpConvertFToS %int %2559 %2561 = OpConvertSToF %float %2560 %2562 = OpFSub %float %2559 %2561 %2563 = OpAccessChain %_ptr_Function_float %550 %2560 %2564 = OpLoad %float %2563 %2565 = OpIAdd %int %2560 %int_1 %2566 = OpAccessChain %_ptr_Function_float %550 %2565 %2567 = OpLoad %float %2566 %2568 = OpIAdd %int %2560 %int_2 %2569 = OpAccessChain %_ptr_Function_float %550 %2568 %2570 = OpLoad %float %2569 %2571 = OpCompositeConstruct %v3float %2564 %2567 %2570 %2572 = OpFMul %float %2562 %2562 %2573 = OpCompositeConstruct %v3float %2572 %2562 %float_1 %2574 = OpMatrixTimesVector %v3float %466 %2571 %2575 = OpDot %float %2573 %2574 OpBranch %2522 %2522 = OpLabel %2576 = OpPhi %float %2555 %2530 %2575 %2523 OpBranch %2514 %2515 = OpLabel %2577 = OpExtInst %float %1 Log %float_9_99999975en05 %2578 = OpFDiv %float %2577 %1091 OpBranch %2514 %2514 = OpLabel %2579 = OpPhi %float %2576 %2522 %2578 %2515 %2580 = OpExtInst %float %1 Pow %float_10 %2579 %2581 = OpCompositeInsert %v3float %2580 %2507 2 %2582 = OpVectorTimesMatrix %v3float %2581 %438 %2583 = OpVectorTimesMatrix %v3float %2582 %434 %2584 = OpExtInst %float %1 Pow %float_2 %float_n12 %2585 = OpFMul %float %float_0_179999992 %2584 OpStore %558 %499 OpStore %557 %500 %2586 = OpFOrdLessThanEqual %bool %2585 %float_0 %2587 = OpSelect %float %2586 %2359 %2585 %2588 = OpExtInst %float %1 Log %2587 %2589 = OpFDiv %float %2588 %1091 %2590 = OpFOrdLessThanEqual %bool %2589 %2364 OpSelectionMerge %2591 None OpBranchConditional %2590 %2592 %2593 %2593 = OpLabel %2594 = OpFOrdGreaterThan %bool %2589 %2364 %2595 = OpExtInst %float %1 Log %float_0_180000007 %2596 = OpFDiv %float %2595 %1091 %2597 = OpFOrdLessThan %bool %2589 %2596 %2598 = OpLogicalAnd %bool %2594 %2597 OpSelectionMerge %2599 None OpBranchConditional %2598 %2600 %2601 %2601 = OpLabel %2602 = OpFOrdGreaterThanEqual %bool %2589 %2596 %2603 = OpExtInst %float %1 Log %2357 %2604 = OpFDiv %float %2603 %1091 %2605 = OpFOrdLessThan %bool %2589 %2604 %2606 = OpLogicalAnd %bool %2602 %2605 OpSelectionMerge %2607 None OpBranchConditional %2606 %2608 %2609 %2609 = OpLabel %2610 = OpExtInst %float %1 Log %float_10000 %2611 = OpFDiv %float %2610 %1091 OpBranch %2607 %2608 = OpLabel %2612 = OpFSub %float %2589 %2596 %2613 = OpFMul %float %float_3 %2612 %2614 = OpFSub %float %2604 %2596 %2615 = OpFDiv %float %2613 %2614 %2616 = OpConvertFToS %int %2615 %2617 = OpConvertSToF %float %2616 %2618 = OpFSub %float %2615 %2617 %2619 = OpAccessChain %_ptr_Function_float %557 %2616 %2620 = OpLoad %float %2619 %2621 = OpIAdd %int %2616 %int_1 %2622 = OpAccessChain %_ptr_Function_float %557 %2621 %2623 = OpLoad %float %2622 %2624 = OpIAdd %int %2616 %int_2 %2625 = OpAccessChain %_ptr_Function_float %557 %2624 %2626 = OpLoad %float %2625 %2627 = OpCompositeConstruct %v3float %2620 %2623 %2626 %2628 = OpFMul %float %2618 %2618 %2629 = OpCompositeConstruct %v3float %2628 %2618 %float_1 %2630 = OpMatrixTimesVector %v3float %466 %2627 %2631 = OpDot %float %2629 %2630 OpBranch %2607 %2607 = OpLabel %2632 = OpPhi %float %2611 %2609 %2631 %2608 OpBranch %2599 %2600 = OpLabel %2633 = OpFSub %float %2589 %2364 %2634 = OpFMul %float %float_3 %2633 %2635 = OpFSub %float %2596 %2364 %2636 = OpFDiv %float %2634 %2635 %2637 = OpConvertFToS %int %2636 %2638 = OpConvertSToF %float %2637 %2639 = OpFSub %float %2636 %2638 %2640 = OpAccessChain %_ptr_Function_float %558 %2637 %2641 = OpLoad %float %2640 %2642 = OpIAdd %int %2637 %int_1 %2643 = OpAccessChain %_ptr_Function_float %558 %2642 %2644 = OpLoad %float %2643 %2645 = OpIAdd %int %2637 %int_2 %2646 = OpAccessChain %_ptr_Function_float %558 %2645 %2647 = OpLoad %float %2646 %2648 = OpCompositeConstruct %v3float %2641 %2644 %2647 %2649 = OpFMul %float %2639 %2639 %2650 = OpCompositeConstruct %v3float %2649 %2639 %float_1 %2651 = OpMatrixTimesVector %v3float %466 %2648 %2652 = OpDot %float %2650 %2651 OpBranch %2599 %2599 = OpLabel %2653 = OpPhi %float %2632 %2607 %2652 %2600 OpBranch %2591 %2592 = OpLabel %2654 = OpExtInst %float %1 Log %float_9_99999975en05 %2655 = OpFDiv %float %2654 %1091 OpBranch %2591 %2591 = OpLabel %2656 = OpPhi %float %2653 %2599 %2655 %2592 %2657 = OpExtInst %float %1 Pow %float_10 %2656 OpStore %560 %499 OpStore %559 %500 %2658 = OpExtInst %float %1 Log %float_0_180000007 %2659 = OpFDiv %float %2658 %1091 %2660 = OpFOrdLessThanEqual %bool %2659 %2364 OpSelectionMerge %2661 None OpBranchConditional %2660 %2662 %2663 %2663 = OpLabel %2664 = OpFOrdGreaterThan %bool %2659 %2364 %2665 = OpFOrdLessThan %bool %2659 %2659 %2666 = OpLogicalAnd %bool %2664 %2665 OpSelectionMerge %2667 None OpBranchConditional %2666 %2668 %2669 %2669 = OpLabel %2670 = OpFOrdGreaterThanEqual %bool %2659 %2659 %2671 = OpExtInst %float %1 Log %2357 %2672 = OpFDiv %float %2671 %1091 %2673 = OpFOrdLessThan %bool %2659 %2672 %2674 = OpLogicalAnd %bool %2670 %2673 OpSelectionMerge %2675 None OpBranchConditional %2674 %2676 %2677 %2677 = OpLabel %2678 = OpExtInst %float %1 Log %float_10000 %2679 = OpFDiv %float %2678 %1091 OpBranch %2675 %2676 = OpLabel %2680 = OpFSub %float %2659 %2659 %2681 = OpFMul %float %float_3 %2680 %2682 = OpFSub %float %2672 %2659 %2683 = OpFDiv %float %2681 %2682 %2684 = OpConvertFToS %int %2683 %2685 = OpConvertSToF %float %2684 %2686 = OpFSub %float %2683 %2685 %2687 = OpAccessChain %_ptr_Function_float %559 %2684 %2688 = OpLoad %float %2687 %2689 = OpIAdd %int %2684 %int_1 %2690 = OpAccessChain %_ptr_Function_float %559 %2689 %2691 = OpLoad %float %2690 %2692 = OpIAdd %int %2684 %int_2 %2693 = OpAccessChain %_ptr_Function_float %559 %2692 %2694 = OpLoad %float %2693 %2695 = OpCompositeConstruct %v3float %2688 %2691 %2694 %2696 = OpFMul %float %2686 %2686 %2697 = OpCompositeConstruct %v3float %2696 %2686 %float_1 %2698 = OpMatrixTimesVector %v3float %466 %2695 %2699 = OpDot %float %2697 %2698 OpBranch %2675 %2675 = OpLabel %2700 = OpPhi %float %2679 %2677 %2699 %2676 OpBranch %2667 %2668 = OpLabel %2701 = OpAccessChain %_ptr_Function_float %560 %int_3 %2702 = OpLoad %float %2701 %2703 = OpAccessChain %_ptr_Function_float %560 %int_4 %2704 = OpLoad %float %2703 %2705 = OpAccessChain %_ptr_Function_float %560 %int_5 %2706 = OpLoad %float %2705 %2707 = OpCompositeConstruct %v3float %2702 %2704 %2706 %2708 = OpMatrixTimesVector %v3float %466 %2707 %2709 = OpCompositeExtract %float %2708 2 OpBranch %2667 %2667 = OpLabel %2710 = OpPhi %float %2700 %2675 %2709 %2668 OpBranch %2661 %2662 = OpLabel %2711 = OpExtInst %float %1 Log %float_9_99999975en05 %2712 = OpFDiv %float %2711 %1091 OpBranch %2661 %2661 = OpLabel %2713 = OpPhi %float %2710 %2667 %2712 %2662 %2714 = OpExtInst %float %1 Pow %float_10 %2713 %2715 = OpExtInst %float %1 Pow %float_2 %float_10 %2716 = OpFMul %float %float_0_179999992 %2715 OpStore %562 %499 OpStore %561 %500 %2717 = OpFOrdLessThanEqual %bool %2716 %float_0 %2718 = OpSelect %float %2717 %2359 %2716 %2719 = OpExtInst %float %1 Log %2718 %2720 = OpFDiv %float %2719 %1091 %2721 = OpFOrdLessThanEqual %bool %2720 %2364 OpSelectionMerge %2722 None OpBranchConditional %2721 %2723 %2724 %2724 = OpLabel %2725 = OpFOrdGreaterThan %bool %2720 %2364 %2726 = OpFOrdLessThan %bool %2720 %2659 %2727 = OpLogicalAnd %bool %2725 %2726 OpSelectionMerge %2728 None OpBranchConditional %2727 %2729 %2730 %2730 = OpLabel %2731 = OpFOrdGreaterThanEqual %bool %2720 %2659 %2732 = OpExtInst %float %1 Log %2357 %2733 = OpFDiv %float %2732 %1091 %2734 = OpFOrdLessThan %bool %2720 %2733 %2735 = OpLogicalAnd %bool %2731 %2734 OpSelectionMerge %2736 None OpBranchConditional %2735 %2737 %2738 %2738 = OpLabel %2739 = OpExtInst %float %1 Log %float_10000 %2740 = OpFDiv %float %2739 %1091 OpBranch %2736 %2737 = OpLabel %2741 = OpFSub %float %2720 %2659 %2742 = OpFMul %float %float_3 %2741 %2743 = OpFSub %float %2733 %2659 %2744 = OpFDiv %float %2742 %2743 %2745 = OpConvertFToS %int %2744 %2746 = OpConvertSToF %float %2745 %2747 = OpFSub %float %2744 %2746 %2748 = OpAccessChain %_ptr_Function_float %561 %2745 %2749 = OpLoad %float %2748 %2750 = OpIAdd %int %2745 %int_1 %2751 = OpAccessChain %_ptr_Function_float %561 %2750 %2752 = OpLoad %float %2751 %2753 = OpIAdd %int %2745 %int_2 %2754 = OpAccessChain %_ptr_Function_float %561 %2753 %2755 = OpLoad %float %2754 %2756 = OpCompositeConstruct %v3float %2749 %2752 %2755 %2757 = OpFMul %float %2747 %2747 %2758 = OpCompositeConstruct %v3float %2757 %2747 %float_1 %2759 = OpMatrixTimesVector %v3float %466 %2756 %2760 = OpDot %float %2758 %2759 OpBranch %2736 %2736 = OpLabel %2761 = OpPhi %float %2740 %2738 %2760 %2737 OpBranch %2728 %2729 = OpLabel %2762 = OpFSub %float %2720 %2364 %2763 = OpFMul %float %float_3 %2762 %2764 = OpFSub %float %2659 %2364 %2765 = OpFDiv %float %2763 %2764 %2766 = OpConvertFToS %int %2765 %2767 = OpConvertSToF %float %2766 %2768 = OpFSub %float %2765 %2767 %2769 = OpAccessChain %_ptr_Function_float %562 %2766 %2770 = OpLoad %float %2769 %2771 = OpIAdd %int %2766 %int_1 %2772 = OpAccessChain %_ptr_Function_float %562 %2771 %2773 = OpLoad %float %2772 %2774 = OpIAdd %int %2766 %int_2 %2775 = OpAccessChain %_ptr_Function_float %562 %2774 %2776 = OpLoad %float %2775 %2777 = OpCompositeConstruct %v3float %2770 %2773 %2776 %2778 = OpFMul %float %2768 %2768 %2779 = OpCompositeConstruct %v3float %2778 %2768 %float_1 %2780 = OpMatrixTimesVector %v3float %466 %2777 %2781 = OpDot %float %2779 %2780 OpBranch %2728 %2728 = OpLabel %2782 = OpPhi %float %2761 %2736 %2781 %2729 OpBranch %2722 %2723 = OpLabel %2783 = OpExtInst %float %1 Log %float_9_99999975en05 %2784 = OpFDiv %float %2783 %1091 OpBranch %2722 %2722 = OpLabel %2785 = OpPhi %float %2782 %2728 %2784 %2723 %2786 = OpExtInst %float %1 Pow %float_10 %2785 %2787 = OpCompositeExtract %float %2583 0 OpStore %556 %503 OpStore %555 %504 %2788 = OpFOrdLessThanEqual %bool %2787 %float_0 %2789 = OpSelect %float %2788 %float_9_99999975en05 %2787 %2790 = OpExtInst %float %1 Log %2789 %2791 = OpFDiv %float %2790 %1091 %2792 = OpExtInst %float %1 Log %2657 %2793 = OpFDiv %float %2792 %1091 %2794 = OpFOrdLessThanEqual %bool %2791 %2793 OpSelectionMerge %2795 None OpBranchConditional %2794 %2796 %2797 %2797 = OpLabel %2798 = OpFOrdGreaterThan %bool %2791 %2793 %2799 = OpExtInst %float %1 Log %2714 %2800 = OpFDiv %float %2799 %1091 %2801 = OpFOrdLessThan %bool %2791 %2800 %2802 = OpLogicalAnd %bool %2798 %2801 OpSelectionMerge %2803 None OpBranchConditional %2802 %2804 %2805 %2805 = OpLabel %2806 = OpFOrdGreaterThanEqual %bool %2791 %2800 %2807 = OpExtInst %float %1 Log %2786 %2808 = OpFDiv %float %2807 %1091 %2809 = OpFOrdLessThan %bool %2791 %2808 %2810 = OpLogicalAnd %bool %2806 %2809 OpSelectionMerge %2811 None OpBranchConditional %2810 %2812 %2813 %2813 = OpLabel %2814 = OpFMul %float %2791 %float_0_0599999987 %2815 = OpExtInst %float %1 Log %float_1000 %2816 = OpFDiv %float %2815 %1091 %2817 = OpFMul %float %float_0_0599999987 %2807 %2818 = OpFDiv %float %2817 %1091 %2819 = OpFSub %float %2816 %2818 %2820 = OpFAdd %float %2814 %2819 OpBranch %2811 %2812 = OpLabel %2821 = OpFSub %float %2791 %2800 %2822 = OpFMul %float %float_7 %2821 %2823 = OpFSub %float %2808 %2800 %2824 = OpFDiv %float %2822 %2823 %2825 = OpConvertFToS %int %2824 %2826 = OpConvertSToF %float %2825 %2827 = OpFSub %float %2824 %2826 %2828 = OpAccessChain %_ptr_Function_float %555 %2825 %2829 = OpLoad %float %2828 %2830 = OpIAdd %int %2825 %int_1 %2831 = OpAccessChain %_ptr_Function_float %555 %2830 %2832 = OpLoad %float %2831 %2833 = OpIAdd %int %2825 %int_2 %2834 = OpAccessChain %_ptr_Function_float %555 %2833 %2835 = OpLoad %float %2834 %2836 = OpCompositeConstruct %v3float %2829 %2832 %2835 %2837 = OpFMul %float %2827 %2827 %2838 = OpCompositeConstruct %v3float %2837 %2827 %float_1 %2839 = OpMatrixTimesVector %v3float %466 %2836 %2840 = OpDot %float %2838 %2839 OpBranch %2811 %2811 = OpLabel %2841 = OpPhi %float %2820 %2813 %2840 %2812 OpBranch %2803 %2804 = OpLabel %2842 = OpFSub %float %2791 %2793 %2843 = OpFMul %float %float_7 %2842 %2844 = OpFSub %float %2800 %2793 %2845 = OpFDiv %float %2843 %2844 %2846 = OpConvertFToS %int %2845 %2847 = OpConvertSToF %float %2846 %2848 = OpFSub %float %2845 %2847 %2849 = OpAccessChain %_ptr_Function_float %556 %2846 %2850 = OpLoad %float %2849 %2851 = OpIAdd %int %2846 %int_1 %2852 = OpAccessChain %_ptr_Function_float %556 %2851 %2853 = OpLoad %float %2852 %2854 = OpIAdd %int %2846 %int_2 %2855 = OpAccessChain %_ptr_Function_float %556 %2854 %2856 = OpLoad %float %2855 %2857 = OpCompositeConstruct %v3float %2850 %2853 %2856 %2858 = OpFMul %float %2848 %2848 %2859 = OpCompositeConstruct %v3float %2858 %2848 %float_1 %2860 = OpMatrixTimesVector %v3float %466 %2857 %2861 = OpDot %float %2859 %2860 OpBranch %2803 %2803 = OpLabel %2862 = OpPhi %float %2841 %2811 %2861 %2804 OpBranch %2795 %2796 = OpLabel %2863 = OpFMul %float %2791 %float_3 %2864 = OpExtInst %float %1 Log %float_9_99999975en05 %2865 = OpFDiv %float %2864 %1091 %2866 = OpFMul %float %float_3 %2792 %2867 = OpFDiv %float %2866 %1091 %2868 = OpFSub %float %2865 %2867 %2869 = OpFAdd %float %2863 %2868 OpBranch %2795 %2795 = OpLabel %2870 = OpPhi %float %2862 %2803 %2869 %2796 %2871 = OpExtInst %float %1 Pow %float_10 %2870 %2872 = OpCompositeInsert %v3float %2871 %523 0 %2873 = OpCompositeExtract %float %2583 1 OpStore %554 %503 OpStore %553 %504 %2874 = OpFOrdLessThanEqual %bool %2873 %float_0 %2875 = OpSelect %float %2874 %float_9_99999975en05 %2873 %2876 = OpExtInst %float %1 Log %2875 %2877 = OpFDiv %float %2876 %1091 %2878 = OpFOrdLessThanEqual %bool %2877 %2793 OpSelectionMerge %2879 None OpBranchConditional %2878 %2880 %2881 %2881 = OpLabel %2882 = OpFOrdGreaterThan %bool %2877 %2793 %2883 = OpExtInst %float %1 Log %2714 %2884 = OpFDiv %float %2883 %1091 %2885 = OpFOrdLessThan %bool %2877 %2884 %2886 = OpLogicalAnd %bool %2882 %2885 OpSelectionMerge %2887 None OpBranchConditional %2886 %2888 %2889 %2889 = OpLabel %2890 = OpFOrdGreaterThanEqual %bool %2877 %2884 %2891 = OpExtInst %float %1 Log %2786 %2892 = OpFDiv %float %2891 %1091 %2893 = OpFOrdLessThan %bool %2877 %2892 %2894 = OpLogicalAnd %bool %2890 %2893 OpSelectionMerge %2895 None OpBranchConditional %2894 %2896 %2897 %2897 = OpLabel %2898 = OpFMul %float %2877 %float_0_0599999987 %2899 = OpExtInst %float %1 Log %float_1000 %2900 = OpFDiv %float %2899 %1091 %2901 = OpFMul %float %float_0_0599999987 %2891 %2902 = OpFDiv %float %2901 %1091 %2903 = OpFSub %float %2900 %2902 %2904 = OpFAdd %float %2898 %2903 OpBranch %2895 %2896 = OpLabel %2905 = OpFSub %float %2877 %2884 %2906 = OpFMul %float %float_7 %2905 %2907 = OpFSub %float %2892 %2884 %2908 = OpFDiv %float %2906 %2907 %2909 = OpConvertFToS %int %2908 %2910 = OpConvertSToF %float %2909 %2911 = OpFSub %float %2908 %2910 %2912 = OpAccessChain %_ptr_Function_float %553 %2909 %2913 = OpLoad %float %2912 %2914 = OpIAdd %int %2909 %int_1 %2915 = OpAccessChain %_ptr_Function_float %553 %2914 %2916 = OpLoad %float %2915 %2917 = OpIAdd %int %2909 %int_2 %2918 = OpAccessChain %_ptr_Function_float %553 %2917 %2919 = OpLoad %float %2918 %2920 = OpCompositeConstruct %v3float %2913 %2916 %2919 %2921 = OpFMul %float %2911 %2911 %2922 = OpCompositeConstruct %v3float %2921 %2911 %float_1 %2923 = OpMatrixTimesVector %v3float %466 %2920 %2924 = OpDot %float %2922 %2923 OpBranch %2895 %2895 = OpLabel %2925 = OpPhi %float %2904 %2897 %2924 %2896 OpBranch %2887 %2888 = OpLabel %2926 = OpFSub %float %2877 %2793 %2927 = OpFMul %float %float_7 %2926 %2928 = OpFSub %float %2884 %2793 %2929 = OpFDiv %float %2927 %2928 %2930 = OpConvertFToS %int %2929 %2931 = OpConvertSToF %float %2930 %2932 = OpFSub %float %2929 %2931 %2933 = OpAccessChain %_ptr_Function_float %554 %2930 %2934 = OpLoad %float %2933 %2935 = OpIAdd %int %2930 %int_1 %2936 = OpAccessChain %_ptr_Function_float %554 %2935 %2937 = OpLoad %float %2936 %2938 = OpIAdd %int %2930 %int_2 %2939 = OpAccessChain %_ptr_Function_float %554 %2938 %2940 = OpLoad %float %2939 %2941 = OpCompositeConstruct %v3float %2934 %2937 %2940 %2942 = OpFMul %float %2932 %2932 %2943 = OpCompositeConstruct %v3float %2942 %2932 %float_1 %2944 = OpMatrixTimesVector %v3float %466 %2941 %2945 = OpDot %float %2943 %2944 OpBranch %2887 %2887 = OpLabel %2946 = OpPhi %float %2925 %2895 %2945 %2888 OpBranch %2879 %2880 = OpLabel %2947 = OpFMul %float %2877 %float_3 %2948 = OpExtInst %float %1 Log %float_9_99999975en05 %2949 = OpFDiv %float %2948 %1091 %2950 = OpFMul %float %float_3 %2792 %2951 = OpFDiv %float %2950 %1091 %2952 = OpFSub %float %2949 %2951 %2953 = OpFAdd %float %2947 %2952 OpBranch %2879 %2879 = OpLabel %2954 = OpPhi %float %2946 %2887 %2953 %2880 %2955 = OpExtInst %float %1 Pow %float_10 %2954 %2956 = OpCompositeInsert %v3float %2955 %2872 1 %2957 = OpCompositeExtract %float %2583 2 OpStore %552 %503 OpStore %551 %504 %2958 = OpFOrdLessThanEqual %bool %2957 %float_0 %2959 = OpSelect %float %2958 %float_9_99999975en05 %2957 %2960 = OpExtInst %float %1 Log %2959 %2961 = OpFDiv %float %2960 %1091 %2962 = OpFOrdLessThanEqual %bool %2961 %2793 OpSelectionMerge %2963 None OpBranchConditional %2962 %2964 %2965 %2965 = OpLabel %2966 = OpFOrdGreaterThan %bool %2961 %2793 %2967 = OpExtInst %float %1 Log %2714 %2968 = OpFDiv %float %2967 %1091 %2969 = OpFOrdLessThan %bool %2961 %2968 %2970 = OpLogicalAnd %bool %2966 %2969 OpSelectionMerge %2971 None OpBranchConditional %2970 %2972 %2973 %2973 = OpLabel %2974 = OpFOrdGreaterThanEqual %bool %2961 %2968 %2975 = OpExtInst %float %1 Log %2786 %2976 = OpFDiv %float %2975 %1091 %2977 = OpFOrdLessThan %bool %2961 %2976 %2978 = OpLogicalAnd %bool %2974 %2977 OpSelectionMerge %2979 None OpBranchConditional %2978 %2980 %2981 %2981 = OpLabel %2982 = OpFMul %float %2961 %float_0_0599999987 %2983 = OpExtInst %float %1 Log %float_1000 %2984 = OpFDiv %float %2983 %1091 %2985 = OpFMul %float %float_0_0599999987 %2975 %2986 = OpFDiv %float %2985 %1091 %2987 = OpFSub %float %2984 %2986 %2988 = OpFAdd %float %2982 %2987 OpBranch %2979 %2980 = OpLabel %2989 = OpFSub %float %2961 %2968 %2990 = OpFMul %float %float_7 %2989 %2991 = OpFSub %float %2976 %2968 %2992 = OpFDiv %float %2990 %2991 %2993 = OpConvertFToS %int %2992 %2994 = OpConvertSToF %float %2993 %2995 = OpFSub %float %2992 %2994 %2996 = OpAccessChain %_ptr_Function_float %551 %2993 %2997 = OpLoad %float %2996 %2998 = OpIAdd %int %2993 %int_1 %2999 = OpAccessChain %_ptr_Function_float %551 %2998 %3000 = OpLoad %float %2999 %3001 = OpIAdd %int %2993 %int_2 %3002 = OpAccessChain %_ptr_Function_float %551 %3001 %3003 = OpLoad %float %3002 %3004 = OpCompositeConstruct %v3float %2997 %3000 %3003 %3005 = OpFMul %float %2995 %2995 %3006 = OpCompositeConstruct %v3float %3005 %2995 %float_1 %3007 = OpMatrixTimesVector %v3float %466 %3004 %3008 = OpDot %float %3006 %3007 OpBranch %2979 %2979 = OpLabel %3009 = OpPhi %float %2988 %2981 %3008 %2980 OpBranch %2971 %2972 = OpLabel %3010 = OpFSub %float %2961 %2793 %3011 = OpFMul %float %float_7 %3010 %3012 = OpFSub %float %2968 %2793 %3013 = OpFDiv %float %3011 %3012 %3014 = OpConvertFToS %int %3013 %3015 = OpConvertSToF %float %3014 %3016 = OpFSub %float %3013 %3015 %3017 = OpAccessChain %_ptr_Function_float %552 %3014 %3018 = OpLoad %float %3017 %3019 = OpIAdd %int %3014 %int_1 %3020 = OpAccessChain %_ptr_Function_float %552 %3019 %3021 = OpLoad %float %3020 %3022 = OpIAdd %int %3014 %int_2 %3023 = OpAccessChain %_ptr_Function_float %552 %3022 %3024 = OpLoad %float %3023 %3025 = OpCompositeConstruct %v3float %3018 %3021 %3024 %3026 = OpFMul %float %3016 %3016 %3027 = OpCompositeConstruct %v3float %3026 %3016 %float_1 %3028 = OpMatrixTimesVector %v3float %466 %3025 %3029 = OpDot %float %3027 %3028 OpBranch %2971 %2971 = OpLabel %3030 = OpPhi %float %3009 %2979 %3029 %2972 OpBranch %2963 %2964 = OpLabel %3031 = OpFMul %float %2961 %float_3 %3032 = OpExtInst %float %1 Log %float_9_99999975en05 %3033 = OpFDiv %float %3032 %1091 %3034 = OpFMul %float %float_3 %2792 %3035 = OpFDiv %float %3034 %1091 %3036 = OpFSub %float %3033 %3035 %3037 = OpFAdd %float %3031 %3036 OpBranch %2963 %2963 = OpLabel %3038 = OpPhi %float %3030 %2971 %3037 %2964 %3039 = OpExtInst %float %1 Pow %float_10 %3038 %3040 = OpCompositeInsert %v3float %3039 %2956 2 %3041 = OpFSub %v3float %3040 %361 %3042 = OpVectorTimesMatrix %v3float %3041 %602 %3043 = OpFMul %v3float %3042 %519 %3044 = OpExtInst %v3float %1 Pow %3043 %286 %3045 = OpFMul %v3float %196 %3044 %3046 = OpFAdd %v3float %195 %3045 %3047 = OpFMul %v3float %197 %3044 %3048 = OpFAdd %v3float %141 %3047 %3049 = OpFDiv %v3float %141 %3048 %3050 = OpFMul %v3float %3046 %3049 %3051 = OpExtInst %v3float %1 Pow %3050 %287 OpBranch %1336 %1336 = OpLabel %3052 = OpPhi %v3float %2201 %1342 %3051 %2963 OpBranch %1330 %1331 = OpLabel %3053 = OpVectorTimesMatrix %v3float %1324 %573 %3054 = OpVectorTimesMatrix %v3float %3053 %602 %3055 = OpExtInst %v3float %1 FMax %263 %3054 %3056 = OpFMul %v3float %3055 %275 %3057 = OpExtInst %v3float %1 FMax %3055 %277 %3058 = OpExtInst %v3float %1 Pow %3057 %279 %3059 = OpFMul %v3float %3058 %281 %3060 = OpFSub %v3float %3059 %283 %3061 = OpExtInst %v3float %1 FMin %3056 %3060 OpBranch %1330 %1330 = OpLabel %3062 = OpPhi %v3float %3052 %1336 %3061 %1331 OpBranch %1326 %1327 = OpLabel %3063 = OpCompositeExtract %float %1324 0 OpBranch %3064 %3064 = OpLabel OpLoopMerge %3065 %3066 None OpBranch %3067 %3067 = OpLabel %3068 = OpFOrdLessThan %bool %3063 %float_0_00313066994 OpSelectionMerge %3069 None OpBranchConditional %3068 %3070 %3069 %3070 = OpLabel %3071 = OpFMul %float %3063 %float_12_9200001 OpBranch %3065 %3069 = OpLabel %3072 = OpExtInst %float %1 Pow %3063 %float_0_416666657 %3073 = OpFMul %float %3072 %float_1_05499995 %3074 = OpFSub %float %3073 %float_0_0549999997 OpBranch %3065 %3066 = OpLabel OpBranch %3064 %3065 = OpLabel %3075 = OpPhi %float %3071 %3070 %3074 %3069 %3076 = OpCompositeExtract %float %1324 1 OpBranch %3077 %3077 = OpLabel OpLoopMerge %3078 %3079 None OpBranch %3080 %3080 = OpLabel %3081 = OpFOrdLessThan %bool %3076 %float_0_00313066994 OpSelectionMerge %3082 None OpBranchConditional %3081 %3083 %3082 %3083 = OpLabel %3084 = OpFMul %float %3076 %float_12_9200001 OpBranch %3078 %3082 = OpLabel %3085 = OpExtInst %float %1 Pow %3076 %float_0_416666657 %3086 = OpFMul %float %3085 %float_1_05499995 %3087 = OpFSub %float %3086 %float_0_0549999997 OpBranch %3078 %3079 = OpLabel OpBranch %3077 %3078 = OpLabel %3088 = OpPhi %float %3084 %3083 %3087 %3082 %3089 = OpCompositeExtract %float %1324 2 OpBranch %3090 %3090 = OpLabel OpLoopMerge %3091 %3092 None OpBranch %3093 %3093 = OpLabel %3094 = OpFOrdLessThan %bool %3089 %float_0_00313066994 OpSelectionMerge %3095 None OpBranchConditional %3094 %3096 %3095 %3096 = OpLabel %3097 = OpFMul %float %3089 %float_12_9200001 OpBranch %3091 %3095 = OpLabel %3098 = OpExtInst %float %1 Pow %3089 %float_0_416666657 %3099 = OpFMul %float %3098 %float_1_05499995 %3100 = OpFSub %float %3099 %float_0_0549999997 OpBranch %3091 %3092 = OpLabel OpBranch %3090 %3091 = OpLabel %3101 = OpPhi %float %3097 %3096 %3100 %3095 %3102 = OpCompositeConstruct %v3float %3075 %3088 %3101 OpBranch %1326 %1326 = OpLabel %3103 = OpPhi %v3float %3062 %1330 %3102 %3091 %3104 = OpFMul %v3float %3103 %522 %3105 = OpVectorShuffle %v4float %135 %3104 4 5 6 3 %3106 = OpCompositeInsert %v4float %float_0 %3105 3 OpStore %out_var_SV_Target0 %3106 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/frag/sample-mask-not-array.asm.frag000066400000000000000000002600161400026215700257660ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 271 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPS "main" %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_PRIMITIVE_ID %in_var_TEXCOORD7 %gl_FragCoord %gl_FrontFacing %gl_SampleMask %out_var_SV_Target0 %gl_SampleMask_0 OpExecutionMode %MainPS OriginUpperLeft OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_TranslatedWorldToView" OpMemberName %type_View 3 "View_ViewToTranslatedWorld" OpMemberName %type_View 4 "View_TranslatedWorldToCameraView" OpMemberName %type_View 5 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 6 "View_ViewToClip" OpMemberName %type_View 7 "View_ViewToClipNoAA" OpMemberName %type_View 8 "View_ClipToView" OpMemberName %type_View 9 "View_ClipToTranslatedWorld" OpMemberName %type_View 10 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 11 "View_ScreenToWorld" OpMemberName %type_View 12 "View_ScreenToTranslatedWorld" OpMemberName %type_View 13 "View_ViewForward" OpMemberName %type_View 14 "PrePadding_View_844" OpMemberName %type_View 15 "View_ViewUp" OpMemberName %type_View 16 "PrePadding_View_860" OpMemberName %type_View 17 "View_ViewRight" OpMemberName %type_View 18 "PrePadding_View_876" OpMemberName %type_View 19 "View_HMDViewNoRollUp" OpMemberName %type_View 20 "PrePadding_View_892" OpMemberName %type_View 21 "View_HMDViewNoRollRight" OpMemberName %type_View 22 "PrePadding_View_908" OpMemberName %type_View 23 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 24 "View_ScreenPositionScaleBias" OpMemberName %type_View 25 "View_WorldCameraOrigin" OpMemberName %type_View 26 "PrePadding_View_956" OpMemberName %type_View 27 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 28 "PrePadding_View_972" OpMemberName %type_View 29 "View_WorldViewOrigin" OpMemberName %type_View 30 "PrePadding_View_988" OpMemberName %type_View 31 "View_PreViewTranslation" OpMemberName %type_View 32 "PrePadding_View_1004" OpMemberName %type_View 33 "View_PrevProjection" OpMemberName %type_View 34 "View_PrevViewProj" OpMemberName %type_View 35 "View_PrevViewRotationProj" OpMemberName %type_View 36 "View_PrevViewToClip" OpMemberName %type_View 37 "View_PrevClipToView" OpMemberName %type_View 38 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 39 "View_PrevTranslatedWorldToView" OpMemberName %type_View 40 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 41 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 42 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 43 "View_PrevWorldCameraOrigin" OpMemberName %type_View 44 "PrePadding_View_1660" OpMemberName %type_View 45 "View_PrevWorldViewOrigin" OpMemberName %type_View 46 "PrePadding_View_1676" OpMemberName %type_View 47 "View_PrevPreViewTranslation" OpMemberName %type_View 48 "PrePadding_View_1692" OpMemberName %type_View 49 "View_PrevInvViewProj" OpMemberName %type_View 50 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 51 "View_ClipToPrevClip" OpMemberName %type_View 52 "View_TemporalAAJitter" OpMemberName %type_View 53 "View_GlobalClippingPlane" OpMemberName %type_View 54 "View_FieldOfViewWideAngles" OpMemberName %type_View 55 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 56 "View_ViewRectMin" OpMemberName %type_View 57 "View_ViewSizeAndInvSize" OpMemberName %type_View 58 "View_BufferSizeAndInvSize" OpMemberName %type_View 59 "View_BufferBilinearUVMinMax" OpMemberName %type_View 60 "View_NumSceneColorMSAASamples" OpMemberName %type_View 61 "View_PreExposure" OpMemberName %type_View 62 "View_OneOverPreExposure" OpMemberName %type_View 63 "PrePadding_View_2012" OpMemberName %type_View 64 "View_DiffuseOverrideParameter" OpMemberName %type_View 65 "View_SpecularOverrideParameter" OpMemberName %type_View 66 "View_NormalOverrideParameter" OpMemberName %type_View 67 "View_RoughnessOverrideParameter" OpMemberName %type_View 68 "View_PrevFrameGameTime" OpMemberName %type_View 69 "View_PrevFrameRealTime" OpMemberName %type_View 70 "View_OutOfBoundsMask" OpMemberName %type_View 71 "PrePadding_View_2084" OpMemberName %type_View 72 "PrePadding_View_2088" OpMemberName %type_View 73 "PrePadding_View_2092" OpMemberName %type_View 74 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 75 "View_CullingSign" OpMemberName %type_View 76 "View_NearPlane" OpMemberName %type_View 77 "View_AdaptiveTessellationFactor" OpMemberName %type_View 78 "View_GameTime" OpMemberName %type_View 79 "View_RealTime" OpMemberName %type_View 80 "View_DeltaTime" OpMemberName %type_View 81 "View_MaterialTextureMipBias" OpMemberName %type_View 82 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 83 "View_Random" OpMemberName %type_View 84 "View_FrameNumber" OpMemberName %type_View 85 "View_StateFrameIndexMod8" OpMemberName %type_View 86 "View_StateFrameIndex" OpMemberName %type_View 87 "View_CameraCut" OpMemberName %type_View 88 "View_UnlitViewmodeMask" OpMemberName %type_View 89 "PrePadding_View_2164" OpMemberName %type_View 90 "PrePadding_View_2168" OpMemberName %type_View 91 "PrePadding_View_2172" OpMemberName %type_View 92 "View_DirectionalLightColor" OpMemberName %type_View 93 "View_DirectionalLightDirection" OpMemberName %type_View 94 "PrePadding_View_2204" OpMemberName %type_View 95 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 97 "View_TemporalAAParams" OpMemberName %type_View 98 "View_CircleDOFParams" OpMemberName %type_View 99 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 100 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 101 "View_DepthOfFieldScale" OpMemberName %type_View 102 "View_DepthOfFieldFocalLength" OpMemberName %type_View 103 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 104 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 105 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 106 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 107 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 108 "View_GeneralPurposeTweak" OpMemberName %type_View 109 "View_DemosaicVposOffset" OpMemberName %type_View 110 "PrePadding_View_2348" OpMemberName %type_View 111 "View_IndirectLightingColorScale" OpMemberName %type_View 112 "View_HDR32bppEncodingMode" OpMemberName %type_View 113 "View_AtmosphericFogSunDirection" OpMemberName %type_View 114 "View_AtmosphericFogSunPower" OpMemberName %type_View 115 "View_AtmosphericFogPower" OpMemberName %type_View 116 "View_AtmosphericFogDensityScale" OpMemberName %type_View 117 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 118 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 119 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 120 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 121 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 122 "View_AtmosphericFogStartDistance" OpMemberName %type_View 123 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 124 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 125 "View_AtmosphericFogRenderMask" OpMemberName %type_View 126 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 127 "View_AtmosphericFogSunColor" OpMemberName %type_View 128 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 129 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 130 "View_AmbientCubemapTint" OpMemberName %type_View 131 "View_AmbientCubemapIntensity" OpMemberName %type_View 132 "View_SkyLightParameters" OpMemberName %type_View 133 "PrePadding_View_2488" OpMemberName %type_View 134 "PrePadding_View_2492" OpMemberName %type_View 135 "View_SkyLightColor" OpMemberName %type_View 136 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 137 "View_MobilePreviewMode" OpMemberName %type_View 138 "View_HMDEyePaddingOffset" OpMemberName %type_View 139 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 140 "View_ShowDecalsMask" OpMemberName %type_View 141 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 142 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 143 "PrePadding_View_2648" OpMemberName %type_View 144 "PrePadding_View_2652" OpMemberName %type_View 145 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 146 "View_StereoPassIndex" OpMemberName %type_View 147 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 148 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 149 "View_GlobalVolumeDimension" OpMemberName %type_View 150 "View_GlobalVolumeTexelSize" OpMemberName %type_View 151 "View_MaxGlobalDistance" OpMemberName %type_View 152 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 153 "View_VolumetricFogInvGridSize" OpMemberName %type_View 154 "PrePadding_View_2828" OpMemberName %type_View 155 "View_VolumetricFogGridZParams" OpMemberName %type_View 156 "PrePadding_View_2844" OpMemberName %type_View 157 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 158 "View_VolumetricFogMaxDistance" OpMemberName %type_View 159 "PrePadding_View_2860" OpMemberName %type_View 160 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 161 "PrePadding_View_2876" OpMemberName %type_View 162 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 163 "PrePadding_View_2892" OpMemberName %type_View 164 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 165 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 166 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 167 "View_StereoIPD" OpMemberName %type_View 168 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 169 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_3d_image "type.3d.image" OpName %type_sampler "type.sampler" OpName %View_SharedBilinearClampedSampler "View_SharedBilinearClampedSampler" OpName %type_StructuredBuffer_v4float "type.StructuredBuffer.v4float" OpName %View_PrimitiveSceneData "View_PrimitiveSceneData" OpName %type_TranslucentBasePass "type.TranslucentBasePass" OpMemberName %type_TranslucentBasePass 0 "TranslucentBasePass_Shared_Forward_NumLocalLights" OpMemberName %type_TranslucentBasePass 1 "TranslucentBasePass_Shared_Forward_NumReflectionCaptures" OpMemberName %type_TranslucentBasePass 2 "TranslucentBasePass_Shared_Forward_HasDirectionalLight" OpMemberName %type_TranslucentBasePass 3 "TranslucentBasePass_Shared_Forward_NumGridCells" OpMemberName %type_TranslucentBasePass 4 "TranslucentBasePass_Shared_Forward_CulledGridSize" OpMemberName %type_TranslucentBasePass 5 "TranslucentBasePass_Shared_Forward_MaxCulledLightsPerCell" OpMemberName %type_TranslucentBasePass 6 "TranslucentBasePass_Shared_Forward_LightGridPixelSizeShift" OpMemberName %type_TranslucentBasePass 7 "PrePadding_TranslucentBasePass_Shared_Forward_36" OpMemberName %type_TranslucentBasePass 8 "PrePadding_TranslucentBasePass_Shared_Forward_40" OpMemberName %type_TranslucentBasePass 9 "PrePadding_TranslucentBasePass_Shared_Forward_44" OpMemberName %type_TranslucentBasePass 10 "TranslucentBasePass_Shared_Forward_LightGridZParams" OpMemberName %type_TranslucentBasePass 11 "PrePadding_TranslucentBasePass_Shared_Forward_60" OpMemberName %type_TranslucentBasePass 12 "TranslucentBasePass_Shared_Forward_DirectionalLightDirection" OpMemberName %type_TranslucentBasePass 13 "PrePadding_TranslucentBasePass_Shared_Forward_76" OpMemberName %type_TranslucentBasePass 14 "TranslucentBasePass_Shared_Forward_DirectionalLightColor" OpMemberName %type_TranslucentBasePass 15 "TranslucentBasePass_Shared_Forward_DirectionalLightVolumetricScatteringIntensity" OpMemberName %type_TranslucentBasePass 16 "TranslucentBasePass_Shared_Forward_DirectionalLightShadowMapChannelMask" OpMemberName %type_TranslucentBasePass 17 "PrePadding_TranslucentBasePass_Shared_Forward_100" OpMemberName %type_TranslucentBasePass 18 "TranslucentBasePass_Shared_Forward_DirectionalLightDistanceFadeMAD" OpMemberName %type_TranslucentBasePass 19 "TranslucentBasePass_Shared_Forward_NumDirectionalLightCascades" OpMemberName %type_TranslucentBasePass 20 "PrePadding_TranslucentBasePass_Shared_Forward_116" OpMemberName %type_TranslucentBasePass 21 "PrePadding_TranslucentBasePass_Shared_Forward_120" OpMemberName %type_TranslucentBasePass 22 "PrePadding_TranslucentBasePass_Shared_Forward_124" OpMemberName %type_TranslucentBasePass 23 "TranslucentBasePass_Shared_Forward_CascadeEndDepths" OpMemberName %type_TranslucentBasePass 24 "TranslucentBasePass_Shared_Forward_DirectionalLightWorldToShadowMatrix" OpMemberName %type_TranslucentBasePass 25 "TranslucentBasePass_Shared_Forward_DirectionalLightShadowmapMinMax" OpMemberName %type_TranslucentBasePass 26 "TranslucentBasePass_Shared_Forward_DirectionalLightShadowmapAtlasBufferSize" OpMemberName %type_TranslucentBasePass 27 "TranslucentBasePass_Shared_Forward_DirectionalLightDepthBias" OpMemberName %type_TranslucentBasePass 28 "TranslucentBasePass_Shared_Forward_DirectionalLightUseStaticShadowing" OpMemberName %type_TranslucentBasePass 29 "PrePadding_TranslucentBasePass_Shared_Forward_488" OpMemberName %type_TranslucentBasePass 30 "PrePadding_TranslucentBasePass_Shared_Forward_492" OpMemberName %type_TranslucentBasePass 31 "TranslucentBasePass_Shared_Forward_DirectionalLightStaticShadowBufferSize" OpMemberName %type_TranslucentBasePass 32 "TranslucentBasePass_Shared_Forward_DirectionalLightWorldToStaticShadow" OpMemberName %type_TranslucentBasePass 33 "PrePadding_TranslucentBasePass_Shared_ForwardISR_576" OpMemberName %type_TranslucentBasePass 34 "PrePadding_TranslucentBasePass_Shared_ForwardISR_580" OpMemberName %type_TranslucentBasePass 35 "PrePadding_TranslucentBasePass_Shared_ForwardISR_584" OpMemberName %type_TranslucentBasePass 36 "PrePadding_TranslucentBasePass_Shared_ForwardISR_588" OpMemberName %type_TranslucentBasePass 37 "PrePadding_TranslucentBasePass_Shared_ForwardISR_592" OpMemberName %type_TranslucentBasePass 38 "PrePadding_TranslucentBasePass_Shared_ForwardISR_596" OpMemberName %type_TranslucentBasePass 39 "PrePadding_TranslucentBasePass_Shared_ForwardISR_600" OpMemberName %type_TranslucentBasePass 40 "PrePadding_TranslucentBasePass_Shared_ForwardISR_604" OpMemberName %type_TranslucentBasePass 41 "PrePadding_TranslucentBasePass_Shared_ForwardISR_608" OpMemberName %type_TranslucentBasePass 42 "PrePadding_TranslucentBasePass_Shared_ForwardISR_612" OpMemberName %type_TranslucentBasePass 43 "PrePadding_TranslucentBasePass_Shared_ForwardISR_616" OpMemberName %type_TranslucentBasePass 44 "PrePadding_TranslucentBasePass_Shared_ForwardISR_620" OpMemberName %type_TranslucentBasePass 45 "PrePadding_TranslucentBasePass_Shared_ForwardISR_624" OpMemberName %type_TranslucentBasePass 46 "PrePadding_TranslucentBasePass_Shared_ForwardISR_628" OpMemberName %type_TranslucentBasePass 47 "PrePadding_TranslucentBasePass_Shared_ForwardISR_632" OpMemberName %type_TranslucentBasePass 48 "PrePadding_TranslucentBasePass_Shared_ForwardISR_636" OpMemberName %type_TranslucentBasePass 49 "TranslucentBasePass_Shared_ForwardISR_NumLocalLights" OpMemberName %type_TranslucentBasePass 50 "TranslucentBasePass_Shared_ForwardISR_NumReflectionCaptures" OpMemberName %type_TranslucentBasePass 51 "TranslucentBasePass_Shared_ForwardISR_HasDirectionalLight" OpMemberName %type_TranslucentBasePass 52 "TranslucentBasePass_Shared_ForwardISR_NumGridCells" OpMemberName %type_TranslucentBasePass 53 "TranslucentBasePass_Shared_ForwardISR_CulledGridSize" OpMemberName %type_TranslucentBasePass 54 "TranslucentBasePass_Shared_ForwardISR_MaxCulledLightsPerCell" OpMemberName %type_TranslucentBasePass 55 "TranslucentBasePass_Shared_ForwardISR_LightGridPixelSizeShift" OpMemberName %type_TranslucentBasePass 56 "PrePadding_TranslucentBasePass_Shared_ForwardISR_676" OpMemberName %type_TranslucentBasePass 57 "PrePadding_TranslucentBasePass_Shared_ForwardISR_680" OpMemberName %type_TranslucentBasePass 58 "PrePadding_TranslucentBasePass_Shared_ForwardISR_684" OpMemberName %type_TranslucentBasePass 59 "TranslucentBasePass_Shared_ForwardISR_LightGridZParams" OpMemberName %type_TranslucentBasePass 60 "PrePadding_TranslucentBasePass_Shared_ForwardISR_700" OpMemberName %type_TranslucentBasePass 61 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightDirection" OpMemberName %type_TranslucentBasePass 62 "PrePadding_TranslucentBasePass_Shared_ForwardISR_716" OpMemberName %type_TranslucentBasePass 63 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightColor" OpMemberName %type_TranslucentBasePass 64 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightVolumetricScatteringIntensity" OpMemberName %type_TranslucentBasePass 65 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightShadowMapChannelMask" OpMemberName %type_TranslucentBasePass 66 "PrePadding_TranslucentBasePass_Shared_ForwardISR_740" OpMemberName %type_TranslucentBasePass 67 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightDistanceFadeMAD" OpMemberName %type_TranslucentBasePass 68 "TranslucentBasePass_Shared_ForwardISR_NumDirectionalLightCascades" OpMemberName %type_TranslucentBasePass 69 "PrePadding_TranslucentBasePass_Shared_ForwardISR_756" OpMemberName %type_TranslucentBasePass 70 "PrePadding_TranslucentBasePass_Shared_ForwardISR_760" OpMemberName %type_TranslucentBasePass 71 "PrePadding_TranslucentBasePass_Shared_ForwardISR_764" OpMemberName %type_TranslucentBasePass 72 "TranslucentBasePass_Shared_ForwardISR_CascadeEndDepths" OpMemberName %type_TranslucentBasePass 73 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightWorldToShadowMatrix" OpMemberName %type_TranslucentBasePass 74 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightShadowmapMinMax" OpMemberName %type_TranslucentBasePass 75 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightShadowmapAtlasBufferSize" OpMemberName %type_TranslucentBasePass 76 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightDepthBias" OpMemberName %type_TranslucentBasePass 77 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightUseStaticShadowing" OpMemberName %type_TranslucentBasePass 78 "PrePadding_TranslucentBasePass_Shared_ForwardISR_1128" OpMemberName %type_TranslucentBasePass 79 "PrePadding_TranslucentBasePass_Shared_ForwardISR_1132" OpMemberName %type_TranslucentBasePass 80 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightStaticShadowBufferSize" OpMemberName %type_TranslucentBasePass 81 "TranslucentBasePass_Shared_ForwardISR_DirectionalLightWorldToStaticShadow" OpMemberName %type_TranslucentBasePass 82 "PrePadding_TranslucentBasePass_Shared_Reflection_1216" OpMemberName %type_TranslucentBasePass 83 "PrePadding_TranslucentBasePass_Shared_Reflection_1220" OpMemberName %type_TranslucentBasePass 84 "PrePadding_TranslucentBasePass_Shared_Reflection_1224" OpMemberName %type_TranslucentBasePass 85 "PrePadding_TranslucentBasePass_Shared_Reflection_1228" OpMemberName %type_TranslucentBasePass 86 "PrePadding_TranslucentBasePass_Shared_Reflection_1232" OpMemberName %type_TranslucentBasePass 87 "PrePadding_TranslucentBasePass_Shared_Reflection_1236" OpMemberName %type_TranslucentBasePass 88 "PrePadding_TranslucentBasePass_Shared_Reflection_1240" OpMemberName %type_TranslucentBasePass 89 "PrePadding_TranslucentBasePass_Shared_Reflection_1244" OpMemberName %type_TranslucentBasePass 90 "PrePadding_TranslucentBasePass_Shared_Reflection_1248" OpMemberName %type_TranslucentBasePass 91 "PrePadding_TranslucentBasePass_Shared_Reflection_1252" OpMemberName %type_TranslucentBasePass 92 "PrePadding_TranslucentBasePass_Shared_Reflection_1256" OpMemberName %type_TranslucentBasePass 93 "PrePadding_TranslucentBasePass_Shared_Reflection_1260" OpMemberName %type_TranslucentBasePass 94 "PrePadding_TranslucentBasePass_Shared_Reflection_1264" OpMemberName %type_TranslucentBasePass 95 "PrePadding_TranslucentBasePass_Shared_Reflection_1268" OpMemberName %type_TranslucentBasePass 96 "PrePadding_TranslucentBasePass_Shared_Reflection_1272" OpMemberName %type_TranslucentBasePass 97 "PrePadding_TranslucentBasePass_Shared_Reflection_1276" OpMemberName %type_TranslucentBasePass 98 "TranslucentBasePass_Shared_Reflection_SkyLightParameters" OpMemberName %type_TranslucentBasePass 99 "TranslucentBasePass_Shared_Reflection_SkyLightCubemapBrightness" OpMemberName %type_TranslucentBasePass 100 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1300" OpMemberName %type_TranslucentBasePass 101 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1304" OpMemberName %type_TranslucentBasePass 102 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1308" OpMemberName %type_TranslucentBasePass 103 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1312" OpMemberName %type_TranslucentBasePass 104 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1316" OpMemberName %type_TranslucentBasePass 105 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1320" OpMemberName %type_TranslucentBasePass 106 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1324" OpMemberName %type_TranslucentBasePass 107 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1328" OpMemberName %type_TranslucentBasePass 108 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1332" OpMemberName %type_TranslucentBasePass 109 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1336" OpMemberName %type_TranslucentBasePass 110 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1340" OpMemberName %type_TranslucentBasePass 111 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1344" OpMemberName %type_TranslucentBasePass 112 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1348" OpMemberName %type_TranslucentBasePass 113 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1352" OpMemberName %type_TranslucentBasePass 114 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1356" OpMemberName %type_TranslucentBasePass 115 "TranslucentBasePass_Shared_PlanarReflection_ReflectionPlane" OpMemberName %type_TranslucentBasePass 116 "TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionOrigin" OpMemberName %type_TranslucentBasePass 117 "TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionXAxis" OpMemberName %type_TranslucentBasePass 118 "TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionYAxis" OpMemberName %type_TranslucentBasePass 119 "TranslucentBasePass_Shared_PlanarReflection_InverseTransposeMirrorMatrix" OpMemberName %type_TranslucentBasePass 120 "TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionParameters" OpMemberName %type_TranslucentBasePass 121 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1484" OpMemberName %type_TranslucentBasePass 122 "TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionParameters2" OpMemberName %type_TranslucentBasePass 123 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1496" OpMemberName %type_TranslucentBasePass 124 "PrePadding_TranslucentBasePass_Shared_PlanarReflection_1500" OpMemberName %type_TranslucentBasePass 125 "TranslucentBasePass_Shared_PlanarReflection_ProjectionWithExtraFOV" OpMemberName %type_TranslucentBasePass 126 "TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionScreenScaleBias" OpMemberName %type_TranslucentBasePass 127 "TranslucentBasePass_Shared_PlanarReflection_PlanarReflectionScreenBound" OpMemberName %type_TranslucentBasePass 128 "TranslucentBasePass_Shared_PlanarReflection_bIsStereo" OpMemberName %type_TranslucentBasePass 129 "PrePadding_TranslucentBasePass_Shared_Fog_1676" OpMemberName %type_TranslucentBasePass 130 "PrePadding_TranslucentBasePass_Shared_Fog_1680" OpMemberName %type_TranslucentBasePass 131 "PrePadding_TranslucentBasePass_Shared_Fog_1684" OpMemberName %type_TranslucentBasePass 132 "PrePadding_TranslucentBasePass_Shared_Fog_1688" OpMemberName %type_TranslucentBasePass 133 "PrePadding_TranslucentBasePass_Shared_Fog_1692" OpMemberName %type_TranslucentBasePass 134 "TranslucentBasePass_Shared_Fog_ExponentialFogParameters" OpMemberName %type_TranslucentBasePass 135 "TranslucentBasePass_Shared_Fog_ExponentialFogParameters2" OpMemberName %type_TranslucentBasePass 136 "TranslucentBasePass_Shared_Fog_ExponentialFogColorParameter" OpMemberName %type_TranslucentBasePass 137 "TranslucentBasePass_Shared_Fog_ExponentialFogParameters3" OpMemberName %type_TranslucentBasePass 138 "TranslucentBasePass_Shared_Fog_InscatteringLightDirection" OpMemberName %type_TranslucentBasePass 139 "TranslucentBasePass_Shared_Fog_DirectionalInscatteringColor" OpMemberName %type_TranslucentBasePass 140 "TranslucentBasePass_Shared_Fog_SinCosInscatteringColorCubemapRotation" OpMemberName %type_TranslucentBasePass 141 "PrePadding_TranslucentBasePass_Shared_Fog_1800" OpMemberName %type_TranslucentBasePass 142 "PrePadding_TranslucentBasePass_Shared_Fog_1804" OpMemberName %type_TranslucentBasePass 143 "TranslucentBasePass_Shared_Fog_FogInscatteringTextureParameters" OpMemberName %type_TranslucentBasePass 144 "TranslucentBasePass_Shared_Fog_ApplyVolumetricFog" OpMemberName %type_TranslucentBasePass 145 "PrePadding_TranslucentBasePass_1824" OpMemberName %type_TranslucentBasePass 146 "PrePadding_TranslucentBasePass_1828" OpMemberName %type_TranslucentBasePass 147 "PrePadding_TranslucentBasePass_1832" OpMemberName %type_TranslucentBasePass 148 "PrePadding_TranslucentBasePass_1836" OpMemberName %type_TranslucentBasePass 149 "PrePadding_TranslucentBasePass_1840" OpMemberName %type_TranslucentBasePass 150 "PrePadding_TranslucentBasePass_1844" OpMemberName %type_TranslucentBasePass 151 "PrePadding_TranslucentBasePass_1848" OpMemberName %type_TranslucentBasePass 152 "PrePadding_TranslucentBasePass_1852" OpMemberName %type_TranslucentBasePass 153 "PrePadding_TranslucentBasePass_1856" OpMemberName %type_TranslucentBasePass 154 "PrePadding_TranslucentBasePass_1860" OpMemberName %type_TranslucentBasePass 155 "PrePadding_TranslucentBasePass_1864" OpMemberName %type_TranslucentBasePass 156 "PrePadding_TranslucentBasePass_1868" OpMemberName %type_TranslucentBasePass 157 "PrePadding_TranslucentBasePass_1872" OpMemberName %type_TranslucentBasePass 158 "PrePadding_TranslucentBasePass_1876" OpMemberName %type_TranslucentBasePass 159 "PrePadding_TranslucentBasePass_1880" OpMemberName %type_TranslucentBasePass 160 "PrePadding_TranslucentBasePass_1884" OpMemberName %type_TranslucentBasePass 161 "PrePadding_TranslucentBasePass_1888" OpMemberName %type_TranslucentBasePass 162 "PrePadding_TranslucentBasePass_1892" OpMemberName %type_TranslucentBasePass 163 "PrePadding_TranslucentBasePass_1896" OpMemberName %type_TranslucentBasePass 164 "PrePadding_TranslucentBasePass_1900" OpMemberName %type_TranslucentBasePass 165 "PrePadding_TranslucentBasePass_1904" OpMemberName %type_TranslucentBasePass 166 "PrePadding_TranslucentBasePass_1908" OpMemberName %type_TranslucentBasePass 167 "PrePadding_TranslucentBasePass_1912" OpMemberName %type_TranslucentBasePass 168 "PrePadding_TranslucentBasePass_1916" OpMemberName %type_TranslucentBasePass 169 "PrePadding_TranslucentBasePass_1920" OpMemberName %type_TranslucentBasePass 170 "PrePadding_TranslucentBasePass_1924" OpMemberName %type_TranslucentBasePass 171 "PrePadding_TranslucentBasePass_1928" OpMemberName %type_TranslucentBasePass 172 "PrePadding_TranslucentBasePass_1932" OpMemberName %type_TranslucentBasePass 173 "PrePadding_TranslucentBasePass_1936" OpMemberName %type_TranslucentBasePass 174 "PrePadding_TranslucentBasePass_1940" OpMemberName %type_TranslucentBasePass 175 "PrePadding_TranslucentBasePass_1944" OpMemberName %type_TranslucentBasePass 176 "PrePadding_TranslucentBasePass_1948" OpMemberName %type_TranslucentBasePass 177 "PrePadding_TranslucentBasePass_1952" OpMemberName %type_TranslucentBasePass 178 "PrePadding_TranslucentBasePass_1956" OpMemberName %type_TranslucentBasePass 179 "PrePadding_TranslucentBasePass_1960" OpMemberName %type_TranslucentBasePass 180 "PrePadding_TranslucentBasePass_1964" OpMemberName %type_TranslucentBasePass 181 "PrePadding_TranslucentBasePass_1968" OpMemberName %type_TranslucentBasePass 182 "PrePadding_TranslucentBasePass_1972" OpMemberName %type_TranslucentBasePass 183 "PrePadding_TranslucentBasePass_1976" OpMemberName %type_TranslucentBasePass 184 "PrePadding_TranslucentBasePass_1980" OpMemberName %type_TranslucentBasePass 185 "PrePadding_TranslucentBasePass_1984" OpMemberName %type_TranslucentBasePass 186 "PrePadding_TranslucentBasePass_1988" OpMemberName %type_TranslucentBasePass 187 "PrePadding_TranslucentBasePass_1992" OpMemberName %type_TranslucentBasePass 188 "PrePadding_TranslucentBasePass_1996" OpMemberName %type_TranslucentBasePass 189 "PrePadding_TranslucentBasePass_2000" OpMemberName %type_TranslucentBasePass 190 "PrePadding_TranslucentBasePass_2004" OpMemberName %type_TranslucentBasePass 191 "PrePadding_TranslucentBasePass_2008" OpMemberName %type_TranslucentBasePass 192 "PrePadding_TranslucentBasePass_2012" OpMemberName %type_TranslucentBasePass 193 "PrePadding_TranslucentBasePass_2016" OpMemberName %type_TranslucentBasePass 194 "PrePadding_TranslucentBasePass_2020" OpMemberName %type_TranslucentBasePass 195 "PrePadding_TranslucentBasePass_2024" OpMemberName %type_TranslucentBasePass 196 "PrePadding_TranslucentBasePass_2028" OpMemberName %type_TranslucentBasePass 197 "PrePadding_TranslucentBasePass_2032" OpMemberName %type_TranslucentBasePass 198 "PrePadding_TranslucentBasePass_2036" OpMemberName %type_TranslucentBasePass 199 "PrePadding_TranslucentBasePass_2040" OpMemberName %type_TranslucentBasePass 200 "PrePadding_TranslucentBasePass_2044" OpMemberName %type_TranslucentBasePass 201 "PrePadding_TranslucentBasePass_2048" OpMemberName %type_TranslucentBasePass 202 "PrePadding_TranslucentBasePass_2052" OpMemberName %type_TranslucentBasePass 203 "PrePadding_TranslucentBasePass_2056" OpMemberName %type_TranslucentBasePass 204 "PrePadding_TranslucentBasePass_2060" OpMemberName %type_TranslucentBasePass 205 "PrePadding_TranslucentBasePass_2064" OpMemberName %type_TranslucentBasePass 206 "PrePadding_TranslucentBasePass_2068" OpMemberName %type_TranslucentBasePass 207 "PrePadding_TranslucentBasePass_2072" OpMemberName %type_TranslucentBasePass 208 "PrePadding_TranslucentBasePass_2076" OpMemberName %type_TranslucentBasePass 209 "PrePadding_TranslucentBasePass_2080" OpMemberName %type_TranslucentBasePass 210 "PrePadding_TranslucentBasePass_2084" OpMemberName %type_TranslucentBasePass 211 "PrePadding_TranslucentBasePass_2088" OpMemberName %type_TranslucentBasePass 212 "PrePadding_TranslucentBasePass_2092" OpMemberName %type_TranslucentBasePass 213 "PrePadding_TranslucentBasePass_2096" OpMemberName %type_TranslucentBasePass 214 "PrePadding_TranslucentBasePass_2100" OpMemberName %type_TranslucentBasePass 215 "PrePadding_TranslucentBasePass_2104" OpMemberName %type_TranslucentBasePass 216 "PrePadding_TranslucentBasePass_2108" OpMemberName %type_TranslucentBasePass 217 "PrePadding_TranslucentBasePass_2112" OpMemberName %type_TranslucentBasePass 218 "PrePadding_TranslucentBasePass_2116" OpMemberName %type_TranslucentBasePass 219 "PrePadding_TranslucentBasePass_2120" OpMemberName %type_TranslucentBasePass 220 "PrePadding_TranslucentBasePass_2124" OpMemberName %type_TranslucentBasePass 221 "PrePadding_TranslucentBasePass_2128" OpMemberName %type_TranslucentBasePass 222 "PrePadding_TranslucentBasePass_2132" OpMemberName %type_TranslucentBasePass 223 "PrePadding_TranslucentBasePass_2136" OpMemberName %type_TranslucentBasePass 224 "PrePadding_TranslucentBasePass_2140" OpMemberName %type_TranslucentBasePass 225 "TranslucentBasePass_HZBUvFactorAndInvFactor" OpMemberName %type_TranslucentBasePass 226 "TranslucentBasePass_PrevScreenPositionScaleBias" OpMemberName %type_TranslucentBasePass 227 "TranslucentBasePass_PrevSceneColorPreExposureInv" OpName %TranslucentBasePass "TranslucentBasePass" OpName %TranslucentBasePass_Shared_Fog_IntegratedLightScattering "TranslucentBasePass_Shared_Fog_IntegratedLightScattering" OpName %type_Material "type.Material" OpMemberName %type_Material 0 "Material_VectorExpressions" OpMemberName %type_Material 1 "Material_ScalarExpressions" OpName %Material "Material" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_PRIMITIVE_ID "in.var.PRIMITIVE_ID" OpName %in_var_TEXCOORD7 "in.var.TEXCOORD7" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPS "MainPS" OpName %type_sampled_image "type.sampled.image" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_PRIMITIVE_ID UserSemantic "PRIMITIVE_ID" OpDecorate %in_var_PRIMITIVE_ID Flat OpDecorateString %in_var_TEXCOORD7 UserSemantic "TEXCOORD7" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_Position" OpDecorate %gl_FrontFacing BuiltIn FrontFacing OpDecorateString %gl_FrontFacing UserSemantic "SV_IsFrontFace" OpDecorate %gl_FrontFacing Flat OpDecorate %gl_SampleMask BuiltIn SampleMask OpDecorateString %gl_SampleMask UserSemantic "SV_Coverage" OpDecorate %gl_SampleMask Flat OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %gl_SampleMask_0 BuiltIn SampleMask OpDecorateString %gl_SampleMask_0 UserSemantic "SV_Coverage" OpDecorate %in_var_TEXCOORD10_centroid Location 0 OpDecorate %in_var_TEXCOORD11_centroid Location 1 OpDecorate %in_var_PRIMITIVE_ID Location 2 OpDecorate %in_var_TEXCOORD7 Location 3 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 1 OpDecorate %View_SharedBilinearClampedSampler DescriptorSet 0 OpDecorate %View_SharedBilinearClampedSampler Binding 0 OpDecorate %View_PrimitiveSceneData DescriptorSet 0 OpDecorate %View_PrimitiveSceneData Binding 0 OpDecorate %TranslucentBasePass DescriptorSet 0 OpDecorate %TranslucentBasePass Binding 2 OpDecorate %TranslucentBasePass_Shared_Fog_IntegratedLightScattering DescriptorSet 0 OpDecorate %TranslucentBasePass_Shared_Fog_IntegratedLightScattering Binding 0 OpDecorate %Material DescriptorSet 0 OpDecorate %Material Binding 3 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 14 Offset 844 OpMemberDecorate %type_View 15 Offset 848 OpMemberDecorate %type_View 16 Offset 860 OpMemberDecorate %type_View 17 Offset 864 OpMemberDecorate %type_View 18 Offset 876 OpMemberDecorate %type_View 19 Offset 880 OpMemberDecorate %type_View 20 Offset 892 OpMemberDecorate %type_View 21 Offset 896 OpMemberDecorate %type_View 22 Offset 908 OpMemberDecorate %type_View 23 Offset 912 OpMemberDecorate %type_View 24 Offset 928 OpMemberDecorate %type_View 25 Offset 944 OpMemberDecorate %type_View 26 Offset 956 OpMemberDecorate %type_View 27 Offset 960 OpMemberDecorate %type_View 28 Offset 972 OpMemberDecorate %type_View 29 Offset 976 OpMemberDecorate %type_View 30 Offset 988 OpMemberDecorate %type_View 31 Offset 992 OpMemberDecorate %type_View 32 Offset 1004 OpMemberDecorate %type_View 33 Offset 1008 OpMemberDecorate %type_View 33 MatrixStride 16 OpMemberDecorate %type_View 33 ColMajor OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 44 Offset 1660 OpMemberDecorate %type_View 45 Offset 1664 OpMemberDecorate %type_View 46 Offset 1676 OpMemberDecorate %type_View 47 Offset 1680 OpMemberDecorate %type_View 48 Offset 1692 OpMemberDecorate %type_View 49 Offset 1696 OpMemberDecorate %type_View 49 MatrixStride 16 OpMemberDecorate %type_View 49 ColMajor OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 53 Offset 1904 OpMemberDecorate %type_View 54 Offset 1920 OpMemberDecorate %type_View 55 Offset 1928 OpMemberDecorate %type_View 56 Offset 1936 OpMemberDecorate %type_View 57 Offset 1952 OpMemberDecorate %type_View 58 Offset 1968 OpMemberDecorate %type_View 59 Offset 1984 OpMemberDecorate %type_View 60 Offset 2000 OpMemberDecorate %type_View 61 Offset 2004 OpMemberDecorate %type_View 62 Offset 2008 OpMemberDecorate %type_View 63 Offset 2012 OpMemberDecorate %type_View 64 Offset 2016 OpMemberDecorate %type_View 65 Offset 2032 OpMemberDecorate %type_View 66 Offset 2048 OpMemberDecorate %type_View 67 Offset 2064 OpMemberDecorate %type_View 68 Offset 2072 OpMemberDecorate %type_View 69 Offset 2076 OpMemberDecorate %type_View 70 Offset 2080 OpMemberDecorate %type_View 71 Offset 2084 OpMemberDecorate %type_View 72 Offset 2088 OpMemberDecorate %type_View 73 Offset 2092 OpMemberDecorate %type_View 74 Offset 2096 OpMemberDecorate %type_View 75 Offset 2108 OpMemberDecorate %type_View 76 Offset 2112 OpMemberDecorate %type_View 77 Offset 2116 OpMemberDecorate %type_View 78 Offset 2120 OpMemberDecorate %type_View 79 Offset 2124 OpMemberDecorate %type_View 80 Offset 2128 OpMemberDecorate %type_View 81 Offset 2132 OpMemberDecorate %type_View 82 Offset 2136 OpMemberDecorate %type_View 83 Offset 2140 OpMemberDecorate %type_View 84 Offset 2144 OpMemberDecorate %type_View 85 Offset 2148 OpMemberDecorate %type_View 86 Offset 2152 OpMemberDecorate %type_View 87 Offset 2156 OpMemberDecorate %type_View 88 Offset 2160 OpMemberDecorate %type_View 89 Offset 2164 OpMemberDecorate %type_View 90 Offset 2168 OpMemberDecorate %type_View 91 Offset 2172 OpMemberDecorate %type_View 92 Offset 2176 OpMemberDecorate %type_View 93 Offset 2192 OpMemberDecorate %type_View 94 Offset 2204 OpMemberDecorate %type_View 95 Offset 2208 OpMemberDecorate %type_View 96 Offset 2240 OpMemberDecorate %type_View 97 Offset 2272 OpMemberDecorate %type_View 98 Offset 2288 OpMemberDecorate %type_View 99 Offset 2304 OpMemberDecorate %type_View 100 Offset 2308 OpMemberDecorate %type_View 101 Offset 2312 OpMemberDecorate %type_View 102 Offset 2316 OpMemberDecorate %type_View 103 Offset 2320 OpMemberDecorate %type_View 104 Offset 2324 OpMemberDecorate %type_View 105 Offset 2328 OpMemberDecorate %type_View 106 Offset 2332 OpMemberDecorate %type_View 107 Offset 2336 OpMemberDecorate %type_View 108 Offset 2340 OpMemberDecorate %type_View 109 Offset 2344 OpMemberDecorate %type_View 110 Offset 2348 OpMemberDecorate %type_View 111 Offset 2352 OpMemberDecorate %type_View 112 Offset 2364 OpMemberDecorate %type_View 113 Offset 2368 OpMemberDecorate %type_View 114 Offset 2380 OpMemberDecorate %type_View 115 Offset 2384 OpMemberDecorate %type_View 116 Offset 2388 OpMemberDecorate %type_View 117 Offset 2392 OpMemberDecorate %type_View 118 Offset 2396 OpMemberDecorate %type_View 119 Offset 2400 OpMemberDecorate %type_View 120 Offset 2404 OpMemberDecorate %type_View 121 Offset 2408 OpMemberDecorate %type_View 122 Offset 2412 OpMemberDecorate %type_View 123 Offset 2416 OpMemberDecorate %type_View 124 Offset 2420 OpMemberDecorate %type_View 125 Offset 2424 OpMemberDecorate %type_View 126 Offset 2428 OpMemberDecorate %type_View 127 Offset 2432 OpMemberDecorate %type_View 128 Offset 2448 OpMemberDecorate %type_View 129 Offset 2460 OpMemberDecorate %type_View 130 Offset 2464 OpMemberDecorate %type_View 131 Offset 2480 OpMemberDecorate %type_View 132 Offset 2484 OpMemberDecorate %type_View 133 Offset 2488 OpMemberDecorate %type_View 134 Offset 2492 OpMemberDecorate %type_View 135 Offset 2496 OpMemberDecorate %type_View 136 Offset 2512 OpMemberDecorate %type_View 137 Offset 2624 OpMemberDecorate %type_View 138 Offset 2628 OpMemberDecorate %type_View 139 Offset 2632 OpMemberDecorate %type_View 140 Offset 2636 OpMemberDecorate %type_View 141 Offset 2640 OpMemberDecorate %type_View 142 Offset 2644 OpMemberDecorate %type_View 143 Offset 2648 OpMemberDecorate %type_View 144 Offset 2652 OpMemberDecorate %type_View 145 Offset 2656 OpMemberDecorate %type_View 146 Offset 2668 OpMemberDecorate %type_View 147 Offset 2672 OpMemberDecorate %type_View 148 Offset 2736 OpMemberDecorate %type_View 149 Offset 2800 OpMemberDecorate %type_View 150 Offset 2804 OpMemberDecorate %type_View 151 Offset 2808 OpMemberDecorate %type_View 152 Offset 2812 OpMemberDecorate %type_View 153 Offset 2816 OpMemberDecorate %type_View 154 Offset 2828 OpMemberDecorate %type_View 155 Offset 2832 OpMemberDecorate %type_View 156 Offset 2844 OpMemberDecorate %type_View 157 Offset 2848 OpMemberDecorate %type_View 158 Offset 2856 OpMemberDecorate %type_View 159 Offset 2860 OpMemberDecorate %type_View 160 Offset 2864 OpMemberDecorate %type_View 161 Offset 2876 OpMemberDecorate %type_View 162 Offset 2880 OpMemberDecorate %type_View 163 Offset 2892 OpMemberDecorate %type_View 164 Offset 2896 OpMemberDecorate %type_View 165 Offset 2908 OpMemberDecorate %type_View 166 Offset 2912 OpMemberDecorate %type_View 167 Offset 2924 OpMemberDecorate %type_View 168 Offset 2928 OpMemberDecorate %type_View 169 Offset 2932 OpDecorate %type_View Block OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %type_StructuredBuffer_v4float 0 Offset 0 OpMemberDecorate %type_StructuredBuffer_v4float 0 NonWritable OpDecorate %type_StructuredBuffer_v4float BufferBlock OpDecorate %_arr_mat4v4float_uint_4 ArrayStride 64 OpDecorate %_arr_mat4v4float_uint_2 ArrayStride 64 OpMemberDecorate %type_TranslucentBasePass 0 Offset 0 OpMemberDecorate %type_TranslucentBasePass 1 Offset 4 OpMemberDecorate %type_TranslucentBasePass 2 Offset 8 OpMemberDecorate %type_TranslucentBasePass 3 Offset 12 OpMemberDecorate %type_TranslucentBasePass 4 Offset 16 OpMemberDecorate %type_TranslucentBasePass 5 Offset 28 OpMemberDecorate %type_TranslucentBasePass 6 Offset 32 OpMemberDecorate %type_TranslucentBasePass 7 Offset 36 OpMemberDecorate %type_TranslucentBasePass 8 Offset 40 OpMemberDecorate %type_TranslucentBasePass 9 Offset 44 OpMemberDecorate %type_TranslucentBasePass 10 Offset 48 OpMemberDecorate %type_TranslucentBasePass 11 Offset 60 OpMemberDecorate %type_TranslucentBasePass 12 Offset 64 OpMemberDecorate %type_TranslucentBasePass 13 Offset 76 OpMemberDecorate %type_TranslucentBasePass 14 Offset 80 OpMemberDecorate %type_TranslucentBasePass 15 Offset 92 OpMemberDecorate %type_TranslucentBasePass 16 Offset 96 OpMemberDecorate %type_TranslucentBasePass 17 Offset 100 OpMemberDecorate %type_TranslucentBasePass 18 Offset 104 OpMemberDecorate %type_TranslucentBasePass 19 Offset 112 OpMemberDecorate %type_TranslucentBasePass 20 Offset 116 OpMemberDecorate %type_TranslucentBasePass 21 Offset 120 OpMemberDecorate %type_TranslucentBasePass 22 Offset 124 OpMemberDecorate %type_TranslucentBasePass 23 Offset 128 OpMemberDecorate %type_TranslucentBasePass 24 Offset 144 OpMemberDecorate %type_TranslucentBasePass 24 MatrixStride 16 OpMemberDecorate %type_TranslucentBasePass 24 ColMajor OpMemberDecorate %type_TranslucentBasePass 25 Offset 400 OpMemberDecorate %type_TranslucentBasePass 26 Offset 464 OpMemberDecorate %type_TranslucentBasePass 27 Offset 480 OpMemberDecorate %type_TranslucentBasePass 28 Offset 484 OpMemberDecorate %type_TranslucentBasePass 29 Offset 488 OpMemberDecorate %type_TranslucentBasePass 30 Offset 492 OpMemberDecorate %type_TranslucentBasePass 31 Offset 496 OpMemberDecorate %type_TranslucentBasePass 32 Offset 512 OpMemberDecorate %type_TranslucentBasePass 32 MatrixStride 16 OpMemberDecorate %type_TranslucentBasePass 32 ColMajor OpMemberDecorate %type_TranslucentBasePass 33 Offset 576 OpMemberDecorate %type_TranslucentBasePass 34 Offset 580 OpMemberDecorate %type_TranslucentBasePass 35 Offset 584 OpMemberDecorate %type_TranslucentBasePass 36 Offset 588 OpMemberDecorate %type_TranslucentBasePass 37 Offset 592 OpMemberDecorate %type_TranslucentBasePass 38 Offset 596 OpMemberDecorate %type_TranslucentBasePass 39 Offset 600 OpMemberDecorate %type_TranslucentBasePass 40 Offset 604 OpMemberDecorate %type_TranslucentBasePass 41 Offset 608 OpMemberDecorate %type_TranslucentBasePass 42 Offset 612 OpMemberDecorate %type_TranslucentBasePass 43 Offset 616 OpMemberDecorate %type_TranslucentBasePass 44 Offset 620 OpMemberDecorate %type_TranslucentBasePass 45 Offset 624 OpMemberDecorate %type_TranslucentBasePass 46 Offset 628 OpMemberDecorate %type_TranslucentBasePass 47 Offset 632 OpMemberDecorate %type_TranslucentBasePass 48 Offset 636 OpMemberDecorate %type_TranslucentBasePass 49 Offset 640 OpMemberDecorate %type_TranslucentBasePass 50 Offset 644 OpMemberDecorate %type_TranslucentBasePass 51 Offset 648 OpMemberDecorate %type_TranslucentBasePass 52 Offset 652 OpMemberDecorate %type_TranslucentBasePass 53 Offset 656 OpMemberDecorate %type_TranslucentBasePass 54 Offset 668 OpMemberDecorate %type_TranslucentBasePass 55 Offset 672 OpMemberDecorate %type_TranslucentBasePass 56 Offset 676 OpMemberDecorate %type_TranslucentBasePass 57 Offset 680 OpMemberDecorate %type_TranslucentBasePass 58 Offset 684 OpMemberDecorate %type_TranslucentBasePass 59 Offset 688 OpMemberDecorate %type_TranslucentBasePass 60 Offset 700 OpMemberDecorate %type_TranslucentBasePass 61 Offset 704 OpMemberDecorate %type_TranslucentBasePass 62 Offset 716 OpMemberDecorate %type_TranslucentBasePass 63 Offset 720 OpMemberDecorate %type_TranslucentBasePass 64 Offset 732 OpMemberDecorate %type_TranslucentBasePass 65 Offset 736 OpMemberDecorate %type_TranslucentBasePass 66 Offset 740 OpMemberDecorate %type_TranslucentBasePass 67 Offset 744 OpMemberDecorate %type_TranslucentBasePass 68 Offset 752 OpMemberDecorate %type_TranslucentBasePass 69 Offset 756 OpMemberDecorate %type_TranslucentBasePass 70 Offset 760 OpMemberDecorate %type_TranslucentBasePass 71 Offset 764 OpMemberDecorate %type_TranslucentBasePass 72 Offset 768 OpMemberDecorate %type_TranslucentBasePass 73 Offset 784 OpMemberDecorate %type_TranslucentBasePass 73 MatrixStride 16 OpMemberDecorate %type_TranslucentBasePass 73 ColMajor OpMemberDecorate %type_TranslucentBasePass 74 Offset 1040 OpMemberDecorate %type_TranslucentBasePass 75 Offset 1104 OpMemberDecorate %type_TranslucentBasePass 76 Offset 1120 OpMemberDecorate %type_TranslucentBasePass 77 Offset 1124 OpMemberDecorate %type_TranslucentBasePass 78 Offset 1128 OpMemberDecorate %type_TranslucentBasePass 79 Offset 1132 OpMemberDecorate %type_TranslucentBasePass 80 Offset 1136 OpMemberDecorate %type_TranslucentBasePass 81 Offset 1152 OpMemberDecorate %type_TranslucentBasePass 81 MatrixStride 16 OpMemberDecorate %type_TranslucentBasePass 81 ColMajor OpMemberDecorate %type_TranslucentBasePass 82 Offset 1216 OpMemberDecorate %type_TranslucentBasePass 83 Offset 1220 OpMemberDecorate %type_TranslucentBasePass 84 Offset 1224 OpMemberDecorate %type_TranslucentBasePass 85 Offset 1228 OpMemberDecorate %type_TranslucentBasePass 86 Offset 1232 OpMemberDecorate %type_TranslucentBasePass 87 Offset 1236 OpMemberDecorate %type_TranslucentBasePass 88 Offset 1240 OpMemberDecorate %type_TranslucentBasePass 89 Offset 1244 OpMemberDecorate %type_TranslucentBasePass 90 Offset 1248 OpMemberDecorate %type_TranslucentBasePass 91 Offset 1252 OpMemberDecorate %type_TranslucentBasePass 92 Offset 1256 OpMemberDecorate %type_TranslucentBasePass 93 Offset 1260 OpMemberDecorate %type_TranslucentBasePass 94 Offset 1264 OpMemberDecorate %type_TranslucentBasePass 95 Offset 1268 OpMemberDecorate %type_TranslucentBasePass 96 Offset 1272 OpMemberDecorate %type_TranslucentBasePass 97 Offset 1276 OpMemberDecorate %type_TranslucentBasePass 98 Offset 1280 OpMemberDecorate %type_TranslucentBasePass 99 Offset 1296 OpMemberDecorate %type_TranslucentBasePass 100 Offset 1300 OpMemberDecorate %type_TranslucentBasePass 101 Offset 1304 OpMemberDecorate %type_TranslucentBasePass 102 Offset 1308 OpMemberDecorate %type_TranslucentBasePass 103 Offset 1312 OpMemberDecorate %type_TranslucentBasePass 104 Offset 1316 OpMemberDecorate %type_TranslucentBasePass 105 Offset 1320 OpMemberDecorate %type_TranslucentBasePass 106 Offset 1324 OpMemberDecorate %type_TranslucentBasePass 107 Offset 1328 OpMemberDecorate %type_TranslucentBasePass 108 Offset 1332 OpMemberDecorate %type_TranslucentBasePass 109 Offset 1336 OpMemberDecorate %type_TranslucentBasePass 110 Offset 1340 OpMemberDecorate %type_TranslucentBasePass 111 Offset 1344 OpMemberDecorate %type_TranslucentBasePass 112 Offset 1348 OpMemberDecorate %type_TranslucentBasePass 113 Offset 1352 OpMemberDecorate %type_TranslucentBasePass 114 Offset 1356 OpMemberDecorate %type_TranslucentBasePass 115 Offset 1360 OpMemberDecorate %type_TranslucentBasePass 116 Offset 1376 OpMemberDecorate %type_TranslucentBasePass 117 Offset 1392 OpMemberDecorate %type_TranslucentBasePass 118 Offset 1408 OpMemberDecorate %type_TranslucentBasePass 119 Offset 1424 OpMemberDecorate %type_TranslucentBasePass 119 MatrixStride 16 OpMemberDecorate %type_TranslucentBasePass 119 ColMajor OpMemberDecorate %type_TranslucentBasePass 120 Offset 1472 OpMemberDecorate %type_TranslucentBasePass 121 Offset 1484 OpMemberDecorate %type_TranslucentBasePass 122 Offset 1488 OpMemberDecorate %type_TranslucentBasePass 123 Offset 1496 OpMemberDecorate %type_TranslucentBasePass 124 Offset 1500 OpMemberDecorate %type_TranslucentBasePass 125 Offset 1504 OpMemberDecorate %type_TranslucentBasePass 125 MatrixStride 16 OpMemberDecorate %type_TranslucentBasePass 125 ColMajor OpMemberDecorate %type_TranslucentBasePass 126 Offset 1632 OpMemberDecorate %type_TranslucentBasePass 127 Offset 1664 OpMemberDecorate %type_TranslucentBasePass 128 Offset 1672 OpMemberDecorate %type_TranslucentBasePass 129 Offset 1676 OpMemberDecorate %type_TranslucentBasePass 130 Offset 1680 OpMemberDecorate %type_TranslucentBasePass 131 Offset 1684 OpMemberDecorate %type_TranslucentBasePass 132 Offset 1688 OpMemberDecorate %type_TranslucentBasePass 133 Offset 1692 OpMemberDecorate %type_TranslucentBasePass 134 Offset 1696 OpMemberDecorate %type_TranslucentBasePass 135 Offset 1712 OpMemberDecorate %type_TranslucentBasePass 136 Offset 1728 OpMemberDecorate %type_TranslucentBasePass 137 Offset 1744 OpMemberDecorate %type_TranslucentBasePass 138 Offset 1760 OpMemberDecorate %type_TranslucentBasePass 139 Offset 1776 OpMemberDecorate %type_TranslucentBasePass 140 Offset 1792 OpMemberDecorate %type_TranslucentBasePass 141 Offset 1800 OpMemberDecorate %type_TranslucentBasePass 142 Offset 1804 OpMemberDecorate %type_TranslucentBasePass 143 Offset 1808 OpMemberDecorate %type_TranslucentBasePass 144 Offset 1820 OpMemberDecorate %type_TranslucentBasePass 145 Offset 1824 OpMemberDecorate %type_TranslucentBasePass 146 Offset 1828 OpMemberDecorate %type_TranslucentBasePass 147 Offset 1832 OpMemberDecorate %type_TranslucentBasePass 148 Offset 1836 OpMemberDecorate %type_TranslucentBasePass 149 Offset 1840 OpMemberDecorate %type_TranslucentBasePass 150 Offset 1844 OpMemberDecorate %type_TranslucentBasePass 151 Offset 1848 OpMemberDecorate %type_TranslucentBasePass 152 Offset 1852 OpMemberDecorate %type_TranslucentBasePass 153 Offset 1856 OpMemberDecorate %type_TranslucentBasePass 154 Offset 1860 OpMemberDecorate %type_TranslucentBasePass 155 Offset 1864 OpMemberDecorate %type_TranslucentBasePass 156 Offset 1868 OpMemberDecorate %type_TranslucentBasePass 157 Offset 1872 OpMemberDecorate %type_TranslucentBasePass 158 Offset 1876 OpMemberDecorate %type_TranslucentBasePass 159 Offset 1880 OpMemberDecorate %type_TranslucentBasePass 160 Offset 1884 OpMemberDecorate %type_TranslucentBasePass 161 Offset 1888 OpMemberDecorate %type_TranslucentBasePass 162 Offset 1892 OpMemberDecorate %type_TranslucentBasePass 163 Offset 1896 OpMemberDecorate %type_TranslucentBasePass 164 Offset 1900 OpMemberDecorate %type_TranslucentBasePass 165 Offset 1904 OpMemberDecorate %type_TranslucentBasePass 166 Offset 1908 OpMemberDecorate %type_TranslucentBasePass 167 Offset 1912 OpMemberDecorate %type_TranslucentBasePass 168 Offset 1916 OpMemberDecorate %type_TranslucentBasePass 169 Offset 1920 OpMemberDecorate %type_TranslucentBasePass 170 Offset 1924 OpMemberDecorate %type_TranslucentBasePass 171 Offset 1928 OpMemberDecorate %type_TranslucentBasePass 172 Offset 1932 OpMemberDecorate %type_TranslucentBasePass 173 Offset 1936 OpMemberDecorate %type_TranslucentBasePass 174 Offset 1940 OpMemberDecorate %type_TranslucentBasePass 175 Offset 1944 OpMemberDecorate %type_TranslucentBasePass 176 Offset 1948 OpMemberDecorate %type_TranslucentBasePass 177 Offset 1952 OpMemberDecorate %type_TranslucentBasePass 178 Offset 1956 OpMemberDecorate %type_TranslucentBasePass 179 Offset 1960 OpMemberDecorate %type_TranslucentBasePass 180 Offset 1964 OpMemberDecorate %type_TranslucentBasePass 181 Offset 1968 OpMemberDecorate %type_TranslucentBasePass 182 Offset 1972 OpMemberDecorate %type_TranslucentBasePass 183 Offset 1976 OpMemberDecorate %type_TranslucentBasePass 184 Offset 1980 OpMemberDecorate %type_TranslucentBasePass 185 Offset 1984 OpMemberDecorate %type_TranslucentBasePass 186 Offset 1988 OpMemberDecorate %type_TranslucentBasePass 187 Offset 1992 OpMemberDecorate %type_TranslucentBasePass 188 Offset 1996 OpMemberDecorate %type_TranslucentBasePass 189 Offset 2000 OpMemberDecorate %type_TranslucentBasePass 190 Offset 2004 OpMemberDecorate %type_TranslucentBasePass 191 Offset 2008 OpMemberDecorate %type_TranslucentBasePass 192 Offset 2012 OpMemberDecorate %type_TranslucentBasePass 193 Offset 2016 OpMemberDecorate %type_TranslucentBasePass 194 Offset 2020 OpMemberDecorate %type_TranslucentBasePass 195 Offset 2024 OpMemberDecorate %type_TranslucentBasePass 196 Offset 2028 OpMemberDecorate %type_TranslucentBasePass 197 Offset 2032 OpMemberDecorate %type_TranslucentBasePass 198 Offset 2036 OpMemberDecorate %type_TranslucentBasePass 199 Offset 2040 OpMemberDecorate %type_TranslucentBasePass 200 Offset 2044 OpMemberDecorate %type_TranslucentBasePass 201 Offset 2048 OpMemberDecorate %type_TranslucentBasePass 202 Offset 2052 OpMemberDecorate %type_TranslucentBasePass 203 Offset 2056 OpMemberDecorate %type_TranslucentBasePass 204 Offset 2060 OpMemberDecorate %type_TranslucentBasePass 205 Offset 2064 OpMemberDecorate %type_TranslucentBasePass 206 Offset 2068 OpMemberDecorate %type_TranslucentBasePass 207 Offset 2072 OpMemberDecorate %type_TranslucentBasePass 208 Offset 2076 OpMemberDecorate %type_TranslucentBasePass 209 Offset 2080 OpMemberDecorate %type_TranslucentBasePass 210 Offset 2084 OpMemberDecorate %type_TranslucentBasePass 211 Offset 2088 OpMemberDecorate %type_TranslucentBasePass 212 Offset 2092 OpMemberDecorate %type_TranslucentBasePass 213 Offset 2096 OpMemberDecorate %type_TranslucentBasePass 214 Offset 2100 OpMemberDecorate %type_TranslucentBasePass 215 Offset 2104 OpMemberDecorate %type_TranslucentBasePass 216 Offset 2108 OpMemberDecorate %type_TranslucentBasePass 217 Offset 2112 OpMemberDecorate %type_TranslucentBasePass 218 Offset 2116 OpMemberDecorate %type_TranslucentBasePass 219 Offset 2120 OpMemberDecorate %type_TranslucentBasePass 220 Offset 2124 OpMemberDecorate %type_TranslucentBasePass 221 Offset 2128 OpMemberDecorate %type_TranslucentBasePass 222 Offset 2132 OpMemberDecorate %type_TranslucentBasePass 223 Offset 2136 OpMemberDecorate %type_TranslucentBasePass 224 Offset 2140 OpMemberDecorate %type_TranslucentBasePass 225 Offset 2144 OpMemberDecorate %type_TranslucentBasePass 226 Offset 2160 OpMemberDecorate %type_TranslucentBasePass 227 Offset 2176 OpDecorate %type_TranslucentBasePass Block OpDecorate %_arr_v4float_uint_1 ArrayStride 16 OpMemberDecorate %type_Material 0 Offset 0 OpMemberDecorate %type_Material 1 Offset 32 OpDecorate %type_Material Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %float_0 = OpConstant %float 0 %48 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %int_10 = OpConstant %int 10 %int_144 = OpConstant %int 144 %int_70 = OpConstant %int 70 %float_1 = OpConstant %float 1 %53 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_0_577000022 = OpConstant %float 0.577000022 %55 = OpConstantComposite %v3float %float_0_577000022 %float_0_577000022 %float_0_577000022 %56 = OpConstantComposite %v3float %float_1 %float_1 %float_0 %57 = OpConstantComposite %v3float %float_0 %float_1 %float_1 %float_0_5 = OpConstant %float 0.5 %59 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %int_60 = OpConstant %int 60 %61 = OpConstantComposite %v2float %float_0_5 %float_0_5 %uint_26 = OpConstant %uint 26 %uint_1 = OpConstant %uint 1 %uint_5 = OpConstant %uint 5 %uint_19 = OpConstant %uint 19 %float_n0_5 = OpConstant %float -0.5 %67 = OpConstantComposite %v2float %float_0_5 %float_n0_5 %68 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1 %float_0_25 = OpConstant %float 0.25 %int_31 = OpConstant %int 31 %int_66 = OpConstant %int 66 %int_153 = OpConstant %int 153 %int_155 = OpConstant %int 155 %mat3v3float = OpTypeMatrix %v3float 3 %75 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %float_n1 = OpConstant %float -1 %float_0_200000003 = OpConstant %float 0.200000003 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_3d_image = OpTypeImage %float 3D 2 0 0 1 Unknown %_ptr_UniformConstant_type_3d_image = OpTypePointer UniformConstant %type_3d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %_runtimearr_v4float = OpTypeRuntimeArray %v4float %type_StructuredBuffer_v4float = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_type_StructuredBuffer_v4float = OpTypePointer Uniform %type_StructuredBuffer_v4float %v3int = OpTypeVector %int 3 %_arr_mat4v4float_uint_4 = OpTypeArray %mat4v4float %uint_4 %mat3v4float = OpTypeMatrix %v4float 3 %_arr_mat4v4float_uint_2 = OpTypeArray %mat4v4float %uint_2 %type_TranslucentBasePass = OpTypeStruct %uint %uint %uint %uint %v3int %uint %uint %uint %uint %uint %v3float %float %v3float %float %v3float %float %uint %uint %v2float %uint %uint %uint %uint %v4float %_arr_mat4v4float_uint_4 %_arr_v4float_uint_4 %v4float %float %uint %uint %uint %v4float %mat4v4float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %v3int %uint %uint %uint %uint %uint %v3float %float %v3float %float %v3float %float %uint %uint %v2float %uint %uint %uint %uint %v4float %_arr_mat4v4float_uint_4 %_arr_v4float_uint_4 %v4float %float %uint %uint %uint %v4float %mat4v4float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %v4float %v4float %v4float %mat3v4float %v3float %float %v2float %float %float %_arr_mat4v4float_uint_2 %_arr_v4float_uint_2 %v2float %uint %float %float %float %float %float %v4float %v4float %v4float %v4float %v4float %v4float %v2float %float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %v4float %float %_ptr_Uniform_type_TranslucentBasePass = OpTypePointer Uniform %type_TranslucentBasePass %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %type_Material = OpTypeStruct %_arr_v4float_uint_2 %_arr_v4float_uint_1 %_ptr_Uniform_type_Material = OpTypePointer Uniform %type_Material %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Input_bool = OpTypePointer Input %bool %_arr_uint_uint_1 = OpTypeArray %uint %uint_1 %_ptr_Input__arr_uint_uint_1 = OpTypePointer Input %_arr_uint_uint_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Output__arr_uint_uint_1 = OpTypePointer Output %_arr_uint_uint_1 %void = OpTypeVoid %94 = OpTypeFunction %void %_ptr_Output_uint = OpTypePointer Output %uint %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %v3bool = OpTypeVector %bool 3 %_ptr_Uniform_int = OpTypePointer Uniform %int %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %type_sampled_image = OpTypeSampledImage %type_3d_image %View = OpVariable %_ptr_Uniform_type_View Uniform %View_SharedBilinearClampedSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %View_PrimitiveSceneData = OpVariable %_ptr_Uniform_type_StructuredBuffer_v4float Uniform %TranslucentBasePass = OpVariable %_ptr_Uniform_type_TranslucentBasePass Uniform %TranslucentBasePass_Shared_Fog_IntegratedLightScattering = OpVariable %_ptr_UniformConstant_type_3d_image UniformConstant %Material = OpVariable %_ptr_Uniform_type_Material Uniform %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input_v4float Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input_v4float Input %in_var_PRIMITIVE_ID = OpVariable %_ptr_Input_uint Input %in_var_TEXCOORD7 = OpVariable %_ptr_Input_v4float Input %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %gl_FrontFacing = OpVariable %_ptr_Input_bool Input %gl_SampleMask = OpVariable %_ptr_Input__arr_uint_uint_1 Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %gl_SampleMask_0 = OpVariable %_ptr_Output__arr_uint_uint_1 Output %102 = OpConstantNull %v4float %float_n1_5 = OpConstant %float -1.5 %float_3 = OpConstant %float 3 %105 = OpConstantComposite %v3float %float_n1 %float_n1_5 %float_3 %float_12_25 = OpConstant %float 12.25 %float_0_00200000009 = OpConstant %float 0.00200000009 %108 = OpUndef %float %uint_15 = OpConstant %uint 15 %MainPS = OpFunction %void None %94 %110 = OpLabel %111 = OpLoad %v4float %in_var_TEXCOORD10_centroid %112 = OpLoad %v4float %in_var_TEXCOORD11_centroid %113 = OpLoad %uint %in_var_PRIMITIVE_ID %114 = OpLoad %v4float %in_var_TEXCOORD7 %115 = OpLoad %v4float %gl_FragCoord %116 = OpLoad %_arr_uint_uint_1 %gl_SampleMask %117 = OpCompositeExtract %uint %116 0 %118 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_1 %119 = OpLoad %mat4v4float %118 %120 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_10 %121 = OpLoad %mat4v4float %120 %122 = OpAccessChain %_ptr_Uniform_v3float %View %int_31 %123 = OpLoad %v3float %122 %124 = OpAccessChain %_ptr_Uniform_v4float %View %int_66 %125 = OpLoad %v4float %124 %126 = OpVectorShuffle %v3float %111 %111 0 1 2 %127 = OpVectorShuffle %v3float %112 %112 0 1 2 %128 = OpExtInst %v3float %1 Cross %127 %126 %129 = OpCompositeExtract %float %112 3 %130 = OpCompositeConstruct %v3float %129 %129 %129 %131 = OpFMul %v3float %128 %130 %132 = OpCompositeConstruct %mat3v3float %126 %131 %127 %133 = OpCompositeExtract %float %115 0 %134 = OpCompositeExtract %float %115 1 %135 = OpCompositeExtract %float %115 2 %136 = OpCompositeConstruct %v4float %133 %134 %135 %float_1 %137 = OpMatrixTimesVector %v4float %121 %136 %138 = OpVectorShuffle %v3float %137 %137 0 1 2 %139 = OpCompositeExtract %float %137 3 %140 = OpCompositeConstruct %v3float %139 %139 %139 %141 = OpFDiv %v3float %138 %140 %142 = OpFSub %v3float %141 %123 %143 = OpVectorShuffle %v3float %125 %125 0 1 2 %144 = OpCompositeExtract %float %125 3 %145 = OpCompositeConstruct %v3float %144 %144 %144 %146 = OpFMul %v3float %75 %145 %147 = OpFAdd %v3float %146 %143 %148 = OpExtInst %v3float %1 Normalize %147 %149 = OpMatrixTimesVector %v3float %132 %148 %150 = OpExtInst %v3float %1 Normalize %149 %151 = OpExtInst %float %1 Sqrt %float_12_25 %152 = OpCompositeConstruct %v3float %151 %151 %151 %153 = OpFDiv %v3float %105 %152 %154 = OpDot %float %153 %150 %155 = OpFAdd %float %float_1 %154 %156 = OpFMul %float %155 %float_0_5 %157 = OpFAdd %float %156 %float_0_200000003 %158 = OpAccessChain %_ptr_Uniform_v4float %Material %int_0 %int_1 %159 = OpLoad %v4float %158 %160 = OpVectorShuffle %v3float %159 %159 0 1 2 %161 = OpCompositeConstruct %v3float %157 %157 %157 %162 = OpFMul %v3float %160 %161 %163 = OpAccessChain %_ptr_Uniform_float %TranslucentBasePass %int_144 %164 = OpLoad %float %163 %165 = OpFOrdGreaterThan %bool %164 %float_0 OpSelectionMerge %166 None OpBranchConditional %165 %167 %166 %167 = OpLabel %168 = OpCompositeExtract %float %142 0 %169 = OpCompositeExtract %float %142 1 %170 = OpCompositeExtract %float %142 2 %171 = OpCompositeConstruct %v4float %168 %169 %170 %float_1 %172 = OpMatrixTimesVector %v4float %119 %171 %173 = OpCompositeExtract %float %172 3 %174 = OpCompositeConstruct %v2float %173 %173 %175 = OpVectorShuffle %v2float %172 %172 0 1 %176 = OpFDiv %v2float %175 %174 %177 = OpVectorShuffle %v2float %176 %102 0 1 %178 = OpFMul %v2float %177 %67 %179 = OpFAdd %v2float %178 %61 %180 = OpCompositeExtract %float %179 0 %181 = OpCompositeExtract %float %179 1 %182 = OpAccessChain %_ptr_Uniform_float %View %int_155 %int_0 %183 = OpLoad %float %182 %184 = OpFMul %float %173 %183 %185 = OpAccessChain %_ptr_Uniform_float %View %int_155 %int_1 %186 = OpLoad %float %185 %187 = OpFAdd %float %184 %186 %188 = OpExtInst %float %1 Log2 %187 %189 = OpAccessChain %_ptr_Uniform_float %View %int_155 %int_2 %190 = OpLoad %float %189 %191 = OpFMul %float %188 %190 %192 = OpAccessChain %_ptr_Uniform_float %View %int_153 %int_2 %193 = OpLoad %float %192 %194 = OpFMul %float %191 %193 %195 = OpCompositeConstruct %v3float %180 %181 %194 OpSelectionMerge %196 None OpBranchConditional %165 %197 %196 %197 = OpLabel %198 = OpLoad %type_3d_image %TranslucentBasePass_Shared_Fog_IntegratedLightScattering %199 = OpLoad %type_sampler %View_SharedBilinearClampedSampler %200 = OpSampledImage %type_sampled_image %198 %199 %201 = OpImageSampleExplicitLod %v4float %200 %195 Lod %float_0 OpBranch %196 %196 = OpLabel %202 = OpPhi %v4float %68 %167 %201 %197 %203 = OpVectorShuffle %v3float %202 %202 0 1 2 %204 = OpVectorShuffle %v3float %114 %114 0 1 2 %205 = OpCompositeExtract %float %202 3 %206 = OpCompositeConstruct %v3float %205 %205 %205 %207 = OpFMul %v3float %204 %206 %208 = OpFAdd %v3float %203 %207 %209 = OpCompositeExtract %float %208 0 %210 = OpCompositeExtract %float %208 1 %211 = OpCompositeExtract %float %208 2 %212 = OpCompositeExtract %float %114 3 %213 = OpFMul %float %205 %212 %214 = OpCompositeConstruct %v4float %209 %210 %211 %213 OpBranch %166 %166 = OpLabel %215 = OpPhi %v4float %114 %110 %214 %196 %216 = OpExtInst %v3float %1 FMax %162 %48 %217 = OpAccessChain %_ptr_Uniform_float %View %int_70 %218 = OpLoad %float %217 %219 = OpFOrdGreaterThan %bool %218 %float_0 OpSelectionMerge %220 DontFlatten OpBranchConditional %219 %221 %220 %221 = OpLabel %222 = OpIMul %uint %113 %uint_26 %223 = OpIAdd %uint %222 %uint_5 %224 = OpAccessChain %_ptr_Uniform_v4float %View_PrimitiveSceneData %int_0 %223 %225 = OpLoad %v4float %224 %226 = OpVectorShuffle %v3float %225 %225 0 1 2 %227 = OpFSub %v3float %142 %226 %228 = OpExtInst %v3float %1 FAbs %227 %229 = OpIAdd %uint %222 %uint_19 %230 = OpAccessChain %_ptr_Uniform_v4float %View_PrimitiveSceneData %int_0 %229 %231 = OpLoad %v4float %230 %232 = OpVectorShuffle %v3float %231 %231 0 1 2 %233 = OpFAdd %v3float %232 %53 %234 = OpFOrdGreaterThan %v3bool %228 %233 %235 = OpAny %bool %234 OpSelectionMerge %236 None OpBranchConditional %235 %237 %236 %237 = OpLabel %238 = OpDot %float %142 %55 %239 = OpFMul %float %238 %float_0_00200000009 %240 = OpExtInst %float %1 Fract %239 %241 = OpCompositeConstruct %v3float %240 %240 %240 %242 = OpFOrdGreaterThan %v3bool %241 %59 %243 = OpSelect %v3float %242 %53 %48 %244 = OpExtInst %v3float %1 FMix %56 %57 %243 OpBranch %236 %236 = OpLabel %245 = OpPhi %v3float %216 %221 %244 %237 OpBranch %220 %220 = OpLabel %246 = OpPhi %v3float %216 %166 %245 %236 %247 = OpCompositeExtract %float %215 3 %248 = OpCompositeConstruct %v3float %247 %247 %247 %249 = OpFMul %v3float %246 %248 %250 = OpVectorShuffle %v3float %215 %215 0 1 2 %251 = OpFAdd %v3float %249 %250 %252 = OpCompositeExtract %float %251 0 %253 = OpCompositeExtract %float %251 1 %254 = OpCompositeExtract %float %251 2 %255 = OpCompositeConstruct %v4float %252 %253 %254 %108 %256 = OpCompositeInsert %v4float %float_1 %255 3 %257 = OpAccessChain %_ptr_Uniform_int %View %int_60 %258 = OpLoad %int %257 %259 = OpSGreaterThan %bool %258 %int_1 OpSelectionMerge %260 None OpBranchConditional %259 %261 %262 %262 = OpLabel OpBranch %260 %261 = OpLabel %263 = OpConvertSToF %float %258 %264 = OpFMul %float %263 %float_0_25 %265 = OpCompositeConstruct %v4float %264 %264 %264 %264 %266 = OpFMul %v4float %256 %265 %267 = OpBitwiseAnd %uint %117 %uint_15 OpBranch %260 %260 = OpLabel %268 = OpPhi %v4float %266 %261 %256 %262 %269 = OpPhi %uint %267 %261 %117 %262 OpStore %out_var_SV_Target0 %268 %270 = OpAccessChain %_ptr_Output_uint %gl_SampleMask_0 %uint_0 OpStore %270 %269 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/frag/subpass-input.ios.framebuffer-fetch.asm.frag000066400000000000000000001073721400026215700306270ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 130 ; Schema: 0 OpCapability Shader OpCapability InputAttachment OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %Main "main" %gl_FragCoord %out_var_SV_Target0 OpExecutionMode %Main OriginUpperLeft OpSource HLSL 600 OpName %type_subpass_image "type.subpass.image" OpName %gl_LastFragData "gl_LastFragData" OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_TranslatedWorldToView" OpMemberName %type_View 3 "View_ViewToTranslatedWorld" OpMemberName %type_View 4 "View_TranslatedWorldToCameraView" OpMemberName %type_View 5 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 6 "View_ViewToClip" OpMemberName %type_View 7 "View_ViewToClipNoAA" OpMemberName %type_View 8 "View_ClipToView" OpMemberName %type_View 9 "View_ClipToTranslatedWorld" OpMemberName %type_View 10 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 11 "View_ScreenToWorld" OpMemberName %type_View 12 "View_ScreenToTranslatedWorld" OpMemberName %type_View 13 "View_ViewForward" OpMemberName %type_View 14 "PrePadding_View_844" OpMemberName %type_View 15 "View_ViewUp" OpMemberName %type_View 16 "PrePadding_View_860" OpMemberName %type_View 17 "View_ViewRight" OpMemberName %type_View 18 "PrePadding_View_876" OpMemberName %type_View 19 "View_HMDViewNoRollUp" OpMemberName %type_View 20 "PrePadding_View_892" OpMemberName %type_View 21 "View_HMDViewNoRollRight" OpMemberName %type_View 22 "PrePadding_View_908" OpMemberName %type_View 23 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 24 "View_ScreenPositionScaleBias" OpMemberName %type_View 25 "View_WorldCameraOrigin" OpMemberName %type_View 26 "PrePadding_View_956" OpMemberName %type_View 27 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 28 "PrePadding_View_972" OpMemberName %type_View 29 "View_WorldViewOrigin" OpMemberName %type_View 30 "PrePadding_View_988" OpMemberName %type_View 31 "View_PreViewTranslation" OpMemberName %type_View 32 "PrePadding_View_1004" OpMemberName %type_View 33 "View_PrevProjection" OpMemberName %type_View 34 "View_PrevViewProj" OpMemberName %type_View 35 "View_PrevViewRotationProj" OpMemberName %type_View 36 "View_PrevViewToClip" OpMemberName %type_View 37 "View_PrevClipToView" OpMemberName %type_View 38 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 39 "View_PrevTranslatedWorldToView" OpMemberName %type_View 40 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 41 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 42 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 43 "View_PrevWorldCameraOrigin" OpMemberName %type_View 44 "PrePadding_View_1660" OpMemberName %type_View 45 "View_PrevWorldViewOrigin" OpMemberName %type_View 46 "PrePadding_View_1676" OpMemberName %type_View 47 "View_PrevPreViewTranslation" OpMemberName %type_View 48 "PrePadding_View_1692" OpMemberName %type_View 49 "View_PrevInvViewProj" OpMemberName %type_View 50 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 51 "View_ClipToPrevClip" OpMemberName %type_View 52 "View_TemporalAAJitter" OpMemberName %type_View 53 "View_GlobalClippingPlane" OpMemberName %type_View 54 "View_FieldOfViewWideAngles" OpMemberName %type_View 55 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 56 "View_ViewRectMin" OpMemberName %type_View 57 "View_ViewSizeAndInvSize" OpMemberName %type_View 58 "View_BufferSizeAndInvSize" OpMemberName %type_View 59 "View_BufferBilinearUVMinMax" OpMemberName %type_View 60 "View_NumSceneColorMSAASamples" OpMemberName %type_View 61 "View_PreExposure" OpMemberName %type_View 62 "View_OneOverPreExposure" OpMemberName %type_View 63 "PrePadding_View_2012" OpMemberName %type_View 64 "View_DiffuseOverrideParameter" OpMemberName %type_View 65 "View_SpecularOverrideParameter" OpMemberName %type_View 66 "View_NormalOverrideParameter" OpMemberName %type_View 67 "View_RoughnessOverrideParameter" OpMemberName %type_View 68 "View_PrevFrameGameTime" OpMemberName %type_View 69 "View_PrevFrameRealTime" OpMemberName %type_View 70 "View_OutOfBoundsMask" OpMemberName %type_View 71 "PrePadding_View_2084" OpMemberName %type_View 72 "PrePadding_View_2088" OpMemberName %type_View 73 "PrePadding_View_2092" OpMemberName %type_View 74 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 75 "View_CullingSign" OpMemberName %type_View 76 "View_NearPlane" OpMemberName %type_View 77 "View_AdaptiveTessellationFactor" OpMemberName %type_View 78 "View_GameTime" OpMemberName %type_View 79 "View_RealTime" OpMemberName %type_View 80 "View_DeltaTime" OpMemberName %type_View 81 "View_MaterialTextureMipBias" OpMemberName %type_View 82 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 83 "View_Random" OpMemberName %type_View 84 "View_FrameNumber" OpMemberName %type_View 85 "View_StateFrameIndexMod8" OpMemberName %type_View 86 "View_StateFrameIndex" OpMemberName %type_View 87 "View_CameraCut" OpMemberName %type_View 88 "View_UnlitViewmodeMask" OpMemberName %type_View 89 "PrePadding_View_2164" OpMemberName %type_View 90 "PrePadding_View_2168" OpMemberName %type_View 91 "PrePadding_View_2172" OpMemberName %type_View 92 "View_DirectionalLightColor" OpMemberName %type_View 93 "View_DirectionalLightDirection" OpMemberName %type_View 94 "PrePadding_View_2204" OpMemberName %type_View 95 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 97 "View_TemporalAAParams" OpMemberName %type_View 98 "View_CircleDOFParams" OpMemberName %type_View 99 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 100 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 101 "View_DepthOfFieldScale" OpMemberName %type_View 102 "View_DepthOfFieldFocalLength" OpMemberName %type_View 103 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 104 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 105 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 106 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 107 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 108 "View_GeneralPurposeTweak" OpMemberName %type_View 109 "View_DemosaicVposOffset" OpMemberName %type_View 110 "PrePadding_View_2348" OpMemberName %type_View 111 "View_IndirectLightingColorScale" OpMemberName %type_View 112 "View_HDR32bppEncodingMode" OpMemberName %type_View 113 "View_AtmosphericFogSunDirection" OpMemberName %type_View 114 "View_AtmosphericFogSunPower" OpMemberName %type_View 115 "View_AtmosphericFogPower" OpMemberName %type_View 116 "View_AtmosphericFogDensityScale" OpMemberName %type_View 117 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 118 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 119 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 120 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 121 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 122 "View_AtmosphericFogStartDistance" OpMemberName %type_View 123 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 124 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 125 "View_AtmosphericFogRenderMask" OpMemberName %type_View 126 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 127 "View_AtmosphericFogSunColor" OpMemberName %type_View 128 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 129 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 130 "View_AmbientCubemapTint" OpMemberName %type_View 131 "View_AmbientCubemapIntensity" OpMemberName %type_View 132 "View_SkyLightParameters" OpMemberName %type_View 133 "PrePadding_View_2488" OpMemberName %type_View 134 "PrePadding_View_2492" OpMemberName %type_View 135 "View_SkyLightColor" OpMemberName %type_View 136 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 137 "View_MobilePreviewMode" OpMemberName %type_View 138 "View_HMDEyePaddingOffset" OpMemberName %type_View 139 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 140 "View_ShowDecalsMask" OpMemberName %type_View 141 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 142 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 143 "PrePadding_View_2648" OpMemberName %type_View 144 "PrePadding_View_2652" OpMemberName %type_View 145 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 146 "View_StereoPassIndex" OpMemberName %type_View 147 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 148 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 149 "View_GlobalVolumeDimension" OpMemberName %type_View 150 "View_GlobalVolumeTexelSize" OpMemberName %type_View 151 "View_MaxGlobalDistance" OpMemberName %type_View 152 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 153 "View_VolumetricFogInvGridSize" OpMemberName %type_View 154 "PrePadding_View_2828" OpMemberName %type_View 155 "View_VolumetricFogGridZParams" OpMemberName %type_View 156 "PrePadding_View_2844" OpMemberName %type_View 157 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 158 "View_VolumetricFogMaxDistance" OpMemberName %type_View 159 "PrePadding_View_2860" OpMemberName %type_View 160 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 161 "PrePadding_View_2876" OpMemberName %type_View 162 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 163 "PrePadding_View_2892" OpMemberName %type_View 164 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 165 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 166 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 167 "View_StereoIPD" OpMemberName %type_View 168 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 169 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_sampler "type.sampler" OpName %type_2d_image "type.2d.image" OpName %ShadowDepthTexture "ShadowDepthTexture" OpName %ShadowDepthTextureSampler "ShadowDepthTextureSampler" OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "SoftTransitionScale" OpMemberName %type__Globals 1 "ShadowBufferSize" OpMemberName %type__Globals 2 "ShadowFadeFraction" OpMemberName %type__Globals 3 "ShadowSharpen" OpMemberName %type__Globals 4 "LightPositionAndInvRadius" OpMemberName %type__Globals 5 "ScreenToShadowMatrix" OpMemberName %type__Globals 6 "ProjectionDepthBiasParameters" OpMemberName %type__Globals 7 "ModulatedShadowColor" OpMemberName %type__Globals 8 "ShadowTileOffsetAndSize" OpName %_Globals "$Globals" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %Main "Main" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_LastFragData InputAttachmentIndex 0 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_POSITION" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %gl_LastFragData DescriptorSet 0 OpDecorate %gl_LastFragData Binding 0 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %ShadowDepthTexture DescriptorSet 0 OpDecorate %ShadowDepthTexture Binding 0 OpDecorate %ShadowDepthTextureSampler DescriptorSet 0 OpDecorate %ShadowDepthTextureSampler Binding 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 1 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 14 Offset 844 OpMemberDecorate %type_View 15 Offset 848 OpMemberDecorate %type_View 16 Offset 860 OpMemberDecorate %type_View 17 Offset 864 OpMemberDecorate %type_View 18 Offset 876 OpMemberDecorate %type_View 19 Offset 880 OpMemberDecorate %type_View 20 Offset 892 OpMemberDecorate %type_View 21 Offset 896 OpMemberDecorate %type_View 22 Offset 908 OpMemberDecorate %type_View 23 Offset 912 OpMemberDecorate %type_View 24 Offset 928 OpMemberDecorate %type_View 25 Offset 944 OpMemberDecorate %type_View 26 Offset 956 OpMemberDecorate %type_View 27 Offset 960 OpMemberDecorate %type_View 28 Offset 972 OpMemberDecorate %type_View 29 Offset 976 OpMemberDecorate %type_View 30 Offset 988 OpMemberDecorate %type_View 31 Offset 992 OpMemberDecorate %type_View 32 Offset 1004 OpMemberDecorate %type_View 33 Offset 1008 OpMemberDecorate %type_View 33 MatrixStride 16 OpMemberDecorate %type_View 33 ColMajor OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 44 Offset 1660 OpMemberDecorate %type_View 45 Offset 1664 OpMemberDecorate %type_View 46 Offset 1676 OpMemberDecorate %type_View 47 Offset 1680 OpMemberDecorate %type_View 48 Offset 1692 OpMemberDecorate %type_View 49 Offset 1696 OpMemberDecorate %type_View 49 MatrixStride 16 OpMemberDecorate %type_View 49 ColMajor OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 53 Offset 1904 OpMemberDecorate %type_View 54 Offset 1920 OpMemberDecorate %type_View 55 Offset 1928 OpMemberDecorate %type_View 56 Offset 1936 OpMemberDecorate %type_View 57 Offset 1952 OpMemberDecorate %type_View 58 Offset 1968 OpMemberDecorate %type_View 59 Offset 1984 OpMemberDecorate %type_View 60 Offset 2000 OpMemberDecorate %type_View 61 Offset 2004 OpMemberDecorate %type_View 62 Offset 2008 OpMemberDecorate %type_View 63 Offset 2012 OpMemberDecorate %type_View 64 Offset 2016 OpMemberDecorate %type_View 65 Offset 2032 OpMemberDecorate %type_View 66 Offset 2048 OpMemberDecorate %type_View 67 Offset 2064 OpMemberDecorate %type_View 68 Offset 2072 OpMemberDecorate %type_View 69 Offset 2076 OpMemberDecorate %type_View 70 Offset 2080 OpMemberDecorate %type_View 71 Offset 2084 OpMemberDecorate %type_View 72 Offset 2088 OpMemberDecorate %type_View 73 Offset 2092 OpMemberDecorate %type_View 74 Offset 2096 OpMemberDecorate %type_View 75 Offset 2108 OpMemberDecorate %type_View 76 Offset 2112 OpMemberDecorate %type_View 77 Offset 2116 OpMemberDecorate %type_View 78 Offset 2120 OpMemberDecorate %type_View 79 Offset 2124 OpMemberDecorate %type_View 80 Offset 2128 OpMemberDecorate %type_View 81 Offset 2132 OpMemberDecorate %type_View 82 Offset 2136 OpMemberDecorate %type_View 83 Offset 2140 OpMemberDecorate %type_View 84 Offset 2144 OpMemberDecorate %type_View 85 Offset 2148 OpMemberDecorate %type_View 86 Offset 2152 OpMemberDecorate %type_View 87 Offset 2156 OpMemberDecorate %type_View 88 Offset 2160 OpMemberDecorate %type_View 89 Offset 2164 OpMemberDecorate %type_View 90 Offset 2168 OpMemberDecorate %type_View 91 Offset 2172 OpMemberDecorate %type_View 92 Offset 2176 OpMemberDecorate %type_View 93 Offset 2192 OpMemberDecorate %type_View 94 Offset 2204 OpMemberDecorate %type_View 95 Offset 2208 OpMemberDecorate %type_View 96 Offset 2240 OpMemberDecorate %type_View 97 Offset 2272 OpMemberDecorate %type_View 98 Offset 2288 OpMemberDecorate %type_View 99 Offset 2304 OpMemberDecorate %type_View 100 Offset 2308 OpMemberDecorate %type_View 101 Offset 2312 OpMemberDecorate %type_View 102 Offset 2316 OpMemberDecorate %type_View 103 Offset 2320 OpMemberDecorate %type_View 104 Offset 2324 OpMemberDecorate %type_View 105 Offset 2328 OpMemberDecorate %type_View 106 Offset 2332 OpMemberDecorate %type_View 107 Offset 2336 OpMemberDecorate %type_View 108 Offset 2340 OpMemberDecorate %type_View 109 Offset 2344 OpMemberDecorate %type_View 110 Offset 2348 OpMemberDecorate %type_View 111 Offset 2352 OpMemberDecorate %type_View 112 Offset 2364 OpMemberDecorate %type_View 113 Offset 2368 OpMemberDecorate %type_View 114 Offset 2380 OpMemberDecorate %type_View 115 Offset 2384 OpMemberDecorate %type_View 116 Offset 2388 OpMemberDecorate %type_View 117 Offset 2392 OpMemberDecorate %type_View 118 Offset 2396 OpMemberDecorate %type_View 119 Offset 2400 OpMemberDecorate %type_View 120 Offset 2404 OpMemberDecorate %type_View 121 Offset 2408 OpMemberDecorate %type_View 122 Offset 2412 OpMemberDecorate %type_View 123 Offset 2416 OpMemberDecorate %type_View 124 Offset 2420 OpMemberDecorate %type_View 125 Offset 2424 OpMemberDecorate %type_View 126 Offset 2428 OpMemberDecorate %type_View 127 Offset 2432 OpMemberDecorate %type_View 128 Offset 2448 OpMemberDecorate %type_View 129 Offset 2460 OpMemberDecorate %type_View 130 Offset 2464 OpMemberDecorate %type_View 131 Offset 2480 OpMemberDecorate %type_View 132 Offset 2484 OpMemberDecorate %type_View 133 Offset 2488 OpMemberDecorate %type_View 134 Offset 2492 OpMemberDecorate %type_View 135 Offset 2496 OpMemberDecorate %type_View 136 Offset 2512 OpMemberDecorate %type_View 137 Offset 2624 OpMemberDecorate %type_View 138 Offset 2628 OpMemberDecorate %type_View 139 Offset 2632 OpMemberDecorate %type_View 140 Offset 2636 OpMemberDecorate %type_View 141 Offset 2640 OpMemberDecorate %type_View 142 Offset 2644 OpMemberDecorate %type_View 143 Offset 2648 OpMemberDecorate %type_View 144 Offset 2652 OpMemberDecorate %type_View 145 Offset 2656 OpMemberDecorate %type_View 146 Offset 2668 OpMemberDecorate %type_View 147 Offset 2672 OpMemberDecorate %type_View 148 Offset 2736 OpMemberDecorate %type_View 149 Offset 2800 OpMemberDecorate %type_View 150 Offset 2804 OpMemberDecorate %type_View 151 Offset 2808 OpMemberDecorate %type_View 152 Offset 2812 OpMemberDecorate %type_View 153 Offset 2816 OpMemberDecorate %type_View 154 Offset 2828 OpMemberDecorate %type_View 155 Offset 2832 OpMemberDecorate %type_View 156 Offset 2844 OpMemberDecorate %type_View 157 Offset 2848 OpMemberDecorate %type_View 158 Offset 2856 OpMemberDecorate %type_View 159 Offset 2860 OpMemberDecorate %type_View 160 Offset 2864 OpMemberDecorate %type_View 161 Offset 2876 OpMemberDecorate %type_View 162 Offset 2880 OpMemberDecorate %type_View 163 Offset 2892 OpMemberDecorate %type_View 164 Offset 2896 OpMemberDecorate %type_View 165 Offset 2908 OpMemberDecorate %type_View 166 Offset 2912 OpMemberDecorate %type_View 167 Offset 2924 OpMemberDecorate %type_View 168 Offset 2928 OpMemberDecorate %type_View 169 Offset 2932 OpDecorate %type_View Block OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 32 OpMemberDecorate %type__Globals 3 Offset 36 OpMemberDecorate %type__Globals 4 Offset 48 OpMemberDecorate %type__Globals 5 Offset 64 OpMemberDecorate %type__Globals 5 MatrixStride 16 OpMemberDecorate %type__Globals 5 ColMajor OpMemberDecorate %type__Globals 6 Offset 128 OpMemberDecorate %type__Globals 7 Offset 144 OpMemberDecorate %type__Globals 8 Offset 160 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %float_1 = OpConstant %float 1 %int_58 = OpConstant %int 58 %int_24 = OpConstant %int 24 %int_5 = OpConstant %int 5 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_8 = OpConstant %int 8 %float_0_999989986 = OpConstant %float 0.999989986 %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %int_7 = OpConstant %int 7 %float_0_5 = OpConstant %float 0.5 %41 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %v2int = OpTypeVector %int 2 %43 = OpConstantComposite %v2int %int_0 %int_0 %44 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %type_subpass_image = OpTypeImage %float SubpassData 2 0 0 2 Unknown %_ptr_UniformConstant_type_subpass_image = OpTypePointer UniformConstant %type_subpass_image %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type__Globals = OpTypeStruct %v3float %v4float %float %float %v4float %mat4v4float %v2float %v4float %v4float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %53 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %type_sampled_image = OpTypeSampledImage %type_2d_image %gl_LastFragData = OpVariable %_ptr_UniformConstant_type_subpass_image UniformConstant %View = OpVariable %_ptr_Uniform_type_View Uniform %ShadowDepthTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %ShadowDepthTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %57 = OpConstantNull %v4float %58 = OpUndef %v4float %Main = OpFunction %void None %53 %59 = OpLabel %60 = OpLoad %v4float %gl_FragCoord %61 = OpVectorShuffle %v2float %60 %60 0 1 %62 = OpAccessChain %_ptr_Uniform_v4float %View %int_58 %63 = OpLoad %v4float %62 %64 = OpVectorShuffle %v2float %63 %63 2 3 %65 = OpFMul %v2float %61 %64 %66 = OpLoad %type_subpass_image %gl_LastFragData %67 = OpImageRead %v4float %66 %43 None %68 = OpCompositeExtract %float %67 3 %69 = OpAccessChain %_ptr_Uniform_v4float %View %int_24 %70 = OpLoad %v4float %69 %71 = OpVectorShuffle %v2float %70 %70 3 2 %72 = OpFSub %v2float %65 %71 %73 = OpVectorShuffle %v2float %70 %70 0 1 %74 = OpFDiv %v2float %72 %73 %75 = OpCompositeConstruct %v2float %68 %68 %76 = OpFMul %v2float %74 %75 %77 = OpCompositeExtract %float %76 0 %78 = OpCompositeExtract %float %76 1 %79 = OpCompositeConstruct %v4float %77 %78 %68 %float_1 %80 = OpAccessChain %_ptr_Uniform_mat4v4float %_Globals %int_5 %81 = OpLoad %mat4v4float %80 %82 = OpMatrixTimesVector %v4float %81 %79 %83 = OpCompositeExtract %float %82 2 %84 = OpCompositeExtract %float %82 3 %85 = OpCompositeConstruct %v3float %84 %84 %84 %86 = OpVectorShuffle %v3float %82 %82 0 1 2 %87 = OpFDiv %v3float %86 %85 %88 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_8 %89 = OpLoad %v4float %88 %90 = OpVectorShuffle %v2float %89 %89 2 3 %91 = OpVectorShuffle %v2float %87 %57 0 1 %92 = OpFMul %v2float %91 %90 %93 = OpVectorShuffle %v2float %89 %89 0 1 %94 = OpVectorShuffle %v2float %92 %57 0 1 %95 = OpFAdd %v2float %94 %93 %96 = OpExtInst %float %1 FMin %83 %float_0_999989986 %97 = OpLoad %type_2d_image %ShadowDepthTexture %98 = OpLoad %type_sampler %ShadowDepthTextureSampler %99 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_2 %100 = OpLoad %float %99 %101 = OpVectorShuffle %v2float %95 %57 0 1 %102 = OpSampledImage %type_sampled_image %97 %98 %103 = OpImageSampleExplicitLod %v4float %102 %101 Lod %float_0 %104 = OpVectorShuffle %v3float %103 %103 0 0 0 %105 = OpFMul %float %96 %100 %106 = OpFSub %float %105 %float_1 %107 = OpCompositeConstruct %v3float %100 %100 %100 %108 = OpFMul %v3float %104 %107 %109 = OpCompositeConstruct %v3float %106 %106 %106 %110 = OpFSub %v3float %108 %109 %111 = OpExtInst %v3float %1 FClamp %110 %44 %41 %112 = OpCompositeExtract %float %111 0 %113 = OpFSub %float %112 %float_0_5 %114 = OpAccessChain %_ptr_Uniform_float %_Globals %int_3 %115 = OpLoad %float %114 %116 = OpFMul %float %113 %115 %117 = OpFAdd %float %116 %float_0_5 %118 = OpExtInst %float %1 FClamp %117 %float_0 %float_1 %119 = OpFMul %float %118 %118 %120 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %121 = OpLoad %float %120 %122 = OpExtInst %float %1 FMix %float_1 %119 %121 %123 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_7 %124 = OpLoad %v4float %123 %125 = OpVectorShuffle %v3float %124 %124 0 1 2 %126 = OpCompositeConstruct %v3float %122 %122 %122 %127 = OpExtInst %v3float %1 FMix %125 %41 %126 %128 = OpVectorShuffle %v4float %58 %127 4 5 6 3 %129 = OpCompositeInsert %v4float %float_0 %128 3 OpStore %out_var_SV_Target0 %129 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/frag/subpass-input.msl23.framebuffer-fetch.asm.frag000066400000000000000000001073721400026215700307750ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 130 ; Schema: 0 OpCapability Shader OpCapability InputAttachment OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %Main "main" %gl_FragCoord %out_var_SV_Target0 OpExecutionMode %Main OriginUpperLeft OpSource HLSL 600 OpName %type_subpass_image "type.subpass.image" OpName %gl_LastFragData "gl_LastFragData" OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_TranslatedWorldToView" OpMemberName %type_View 3 "View_ViewToTranslatedWorld" OpMemberName %type_View 4 "View_TranslatedWorldToCameraView" OpMemberName %type_View 5 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 6 "View_ViewToClip" OpMemberName %type_View 7 "View_ViewToClipNoAA" OpMemberName %type_View 8 "View_ClipToView" OpMemberName %type_View 9 "View_ClipToTranslatedWorld" OpMemberName %type_View 10 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 11 "View_ScreenToWorld" OpMemberName %type_View 12 "View_ScreenToTranslatedWorld" OpMemberName %type_View 13 "View_ViewForward" OpMemberName %type_View 14 "PrePadding_View_844" OpMemberName %type_View 15 "View_ViewUp" OpMemberName %type_View 16 "PrePadding_View_860" OpMemberName %type_View 17 "View_ViewRight" OpMemberName %type_View 18 "PrePadding_View_876" OpMemberName %type_View 19 "View_HMDViewNoRollUp" OpMemberName %type_View 20 "PrePadding_View_892" OpMemberName %type_View 21 "View_HMDViewNoRollRight" OpMemberName %type_View 22 "PrePadding_View_908" OpMemberName %type_View 23 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 24 "View_ScreenPositionScaleBias" OpMemberName %type_View 25 "View_WorldCameraOrigin" OpMemberName %type_View 26 "PrePadding_View_956" OpMemberName %type_View 27 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 28 "PrePadding_View_972" OpMemberName %type_View 29 "View_WorldViewOrigin" OpMemberName %type_View 30 "PrePadding_View_988" OpMemberName %type_View 31 "View_PreViewTranslation" OpMemberName %type_View 32 "PrePadding_View_1004" OpMemberName %type_View 33 "View_PrevProjection" OpMemberName %type_View 34 "View_PrevViewProj" OpMemberName %type_View 35 "View_PrevViewRotationProj" OpMemberName %type_View 36 "View_PrevViewToClip" OpMemberName %type_View 37 "View_PrevClipToView" OpMemberName %type_View 38 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 39 "View_PrevTranslatedWorldToView" OpMemberName %type_View 40 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 41 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 42 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 43 "View_PrevWorldCameraOrigin" OpMemberName %type_View 44 "PrePadding_View_1660" OpMemberName %type_View 45 "View_PrevWorldViewOrigin" OpMemberName %type_View 46 "PrePadding_View_1676" OpMemberName %type_View 47 "View_PrevPreViewTranslation" OpMemberName %type_View 48 "PrePadding_View_1692" OpMemberName %type_View 49 "View_PrevInvViewProj" OpMemberName %type_View 50 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 51 "View_ClipToPrevClip" OpMemberName %type_View 52 "View_TemporalAAJitter" OpMemberName %type_View 53 "View_GlobalClippingPlane" OpMemberName %type_View 54 "View_FieldOfViewWideAngles" OpMemberName %type_View 55 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 56 "View_ViewRectMin" OpMemberName %type_View 57 "View_ViewSizeAndInvSize" OpMemberName %type_View 58 "View_BufferSizeAndInvSize" OpMemberName %type_View 59 "View_BufferBilinearUVMinMax" OpMemberName %type_View 60 "View_NumSceneColorMSAASamples" OpMemberName %type_View 61 "View_PreExposure" OpMemberName %type_View 62 "View_OneOverPreExposure" OpMemberName %type_View 63 "PrePadding_View_2012" OpMemberName %type_View 64 "View_DiffuseOverrideParameter" OpMemberName %type_View 65 "View_SpecularOverrideParameter" OpMemberName %type_View 66 "View_NormalOverrideParameter" OpMemberName %type_View 67 "View_RoughnessOverrideParameter" OpMemberName %type_View 68 "View_PrevFrameGameTime" OpMemberName %type_View 69 "View_PrevFrameRealTime" OpMemberName %type_View 70 "View_OutOfBoundsMask" OpMemberName %type_View 71 "PrePadding_View_2084" OpMemberName %type_View 72 "PrePadding_View_2088" OpMemberName %type_View 73 "PrePadding_View_2092" OpMemberName %type_View 74 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 75 "View_CullingSign" OpMemberName %type_View 76 "View_NearPlane" OpMemberName %type_View 77 "View_AdaptiveTessellationFactor" OpMemberName %type_View 78 "View_GameTime" OpMemberName %type_View 79 "View_RealTime" OpMemberName %type_View 80 "View_DeltaTime" OpMemberName %type_View 81 "View_MaterialTextureMipBias" OpMemberName %type_View 82 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 83 "View_Random" OpMemberName %type_View 84 "View_FrameNumber" OpMemberName %type_View 85 "View_StateFrameIndexMod8" OpMemberName %type_View 86 "View_StateFrameIndex" OpMemberName %type_View 87 "View_CameraCut" OpMemberName %type_View 88 "View_UnlitViewmodeMask" OpMemberName %type_View 89 "PrePadding_View_2164" OpMemberName %type_View 90 "PrePadding_View_2168" OpMemberName %type_View 91 "PrePadding_View_2172" OpMemberName %type_View 92 "View_DirectionalLightColor" OpMemberName %type_View 93 "View_DirectionalLightDirection" OpMemberName %type_View 94 "PrePadding_View_2204" OpMemberName %type_View 95 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 97 "View_TemporalAAParams" OpMemberName %type_View 98 "View_CircleDOFParams" OpMemberName %type_View 99 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 100 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 101 "View_DepthOfFieldScale" OpMemberName %type_View 102 "View_DepthOfFieldFocalLength" OpMemberName %type_View 103 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 104 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 105 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 106 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 107 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 108 "View_GeneralPurposeTweak" OpMemberName %type_View 109 "View_DemosaicVposOffset" OpMemberName %type_View 110 "PrePadding_View_2348" OpMemberName %type_View 111 "View_IndirectLightingColorScale" OpMemberName %type_View 112 "View_HDR32bppEncodingMode" OpMemberName %type_View 113 "View_AtmosphericFogSunDirection" OpMemberName %type_View 114 "View_AtmosphericFogSunPower" OpMemberName %type_View 115 "View_AtmosphericFogPower" OpMemberName %type_View 116 "View_AtmosphericFogDensityScale" OpMemberName %type_View 117 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 118 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 119 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 120 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 121 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 122 "View_AtmosphericFogStartDistance" OpMemberName %type_View 123 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 124 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 125 "View_AtmosphericFogRenderMask" OpMemberName %type_View 126 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 127 "View_AtmosphericFogSunColor" OpMemberName %type_View 128 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 129 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 130 "View_AmbientCubemapTint" OpMemberName %type_View 131 "View_AmbientCubemapIntensity" OpMemberName %type_View 132 "View_SkyLightParameters" OpMemberName %type_View 133 "PrePadding_View_2488" OpMemberName %type_View 134 "PrePadding_View_2492" OpMemberName %type_View 135 "View_SkyLightColor" OpMemberName %type_View 136 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 137 "View_MobilePreviewMode" OpMemberName %type_View 138 "View_HMDEyePaddingOffset" OpMemberName %type_View 139 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 140 "View_ShowDecalsMask" OpMemberName %type_View 141 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 142 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 143 "PrePadding_View_2648" OpMemberName %type_View 144 "PrePadding_View_2652" OpMemberName %type_View 145 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 146 "View_StereoPassIndex" OpMemberName %type_View 147 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 148 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 149 "View_GlobalVolumeDimension" OpMemberName %type_View 150 "View_GlobalVolumeTexelSize" OpMemberName %type_View 151 "View_MaxGlobalDistance" OpMemberName %type_View 152 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 153 "View_VolumetricFogInvGridSize" OpMemberName %type_View 154 "PrePadding_View_2828" OpMemberName %type_View 155 "View_VolumetricFogGridZParams" OpMemberName %type_View 156 "PrePadding_View_2844" OpMemberName %type_View 157 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 158 "View_VolumetricFogMaxDistance" OpMemberName %type_View 159 "PrePadding_View_2860" OpMemberName %type_View 160 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 161 "PrePadding_View_2876" OpMemberName %type_View 162 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 163 "PrePadding_View_2892" OpMemberName %type_View 164 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 165 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 166 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 167 "View_StereoIPD" OpMemberName %type_View 168 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 169 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_sampler "type.sampler" OpName %type_2d_image "type.2d.image" OpName %ShadowDepthTexture "ShadowDepthTexture" OpName %ShadowDepthTextureSampler "ShadowDepthTextureSampler" OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "SoftTransitionScale" OpMemberName %type__Globals 1 "ShadowBufferSize" OpMemberName %type__Globals 2 "ShadowFadeFraction" OpMemberName %type__Globals 3 "ShadowSharpen" OpMemberName %type__Globals 4 "LightPositionAndInvRadius" OpMemberName %type__Globals 5 "ScreenToShadowMatrix" OpMemberName %type__Globals 6 "ProjectionDepthBiasParameters" OpMemberName %type__Globals 7 "ModulatedShadowColor" OpMemberName %type__Globals 8 "ShadowTileOffsetAndSize" OpName %_Globals "$Globals" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %Main "Main" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_LastFragData InputAttachmentIndex 0 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_POSITION" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %gl_LastFragData DescriptorSet 0 OpDecorate %gl_LastFragData Binding 0 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %ShadowDepthTexture DescriptorSet 0 OpDecorate %ShadowDepthTexture Binding 0 OpDecorate %ShadowDepthTextureSampler DescriptorSet 0 OpDecorate %ShadowDepthTextureSampler Binding 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 1 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 14 Offset 844 OpMemberDecorate %type_View 15 Offset 848 OpMemberDecorate %type_View 16 Offset 860 OpMemberDecorate %type_View 17 Offset 864 OpMemberDecorate %type_View 18 Offset 876 OpMemberDecorate %type_View 19 Offset 880 OpMemberDecorate %type_View 20 Offset 892 OpMemberDecorate %type_View 21 Offset 896 OpMemberDecorate %type_View 22 Offset 908 OpMemberDecorate %type_View 23 Offset 912 OpMemberDecorate %type_View 24 Offset 928 OpMemberDecorate %type_View 25 Offset 944 OpMemberDecorate %type_View 26 Offset 956 OpMemberDecorate %type_View 27 Offset 960 OpMemberDecorate %type_View 28 Offset 972 OpMemberDecorate %type_View 29 Offset 976 OpMemberDecorate %type_View 30 Offset 988 OpMemberDecorate %type_View 31 Offset 992 OpMemberDecorate %type_View 32 Offset 1004 OpMemberDecorate %type_View 33 Offset 1008 OpMemberDecorate %type_View 33 MatrixStride 16 OpMemberDecorate %type_View 33 ColMajor OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 44 Offset 1660 OpMemberDecorate %type_View 45 Offset 1664 OpMemberDecorate %type_View 46 Offset 1676 OpMemberDecorate %type_View 47 Offset 1680 OpMemberDecorate %type_View 48 Offset 1692 OpMemberDecorate %type_View 49 Offset 1696 OpMemberDecorate %type_View 49 MatrixStride 16 OpMemberDecorate %type_View 49 ColMajor OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 53 Offset 1904 OpMemberDecorate %type_View 54 Offset 1920 OpMemberDecorate %type_View 55 Offset 1928 OpMemberDecorate %type_View 56 Offset 1936 OpMemberDecorate %type_View 57 Offset 1952 OpMemberDecorate %type_View 58 Offset 1968 OpMemberDecorate %type_View 59 Offset 1984 OpMemberDecorate %type_View 60 Offset 2000 OpMemberDecorate %type_View 61 Offset 2004 OpMemberDecorate %type_View 62 Offset 2008 OpMemberDecorate %type_View 63 Offset 2012 OpMemberDecorate %type_View 64 Offset 2016 OpMemberDecorate %type_View 65 Offset 2032 OpMemberDecorate %type_View 66 Offset 2048 OpMemberDecorate %type_View 67 Offset 2064 OpMemberDecorate %type_View 68 Offset 2072 OpMemberDecorate %type_View 69 Offset 2076 OpMemberDecorate %type_View 70 Offset 2080 OpMemberDecorate %type_View 71 Offset 2084 OpMemberDecorate %type_View 72 Offset 2088 OpMemberDecorate %type_View 73 Offset 2092 OpMemberDecorate %type_View 74 Offset 2096 OpMemberDecorate %type_View 75 Offset 2108 OpMemberDecorate %type_View 76 Offset 2112 OpMemberDecorate %type_View 77 Offset 2116 OpMemberDecorate %type_View 78 Offset 2120 OpMemberDecorate %type_View 79 Offset 2124 OpMemberDecorate %type_View 80 Offset 2128 OpMemberDecorate %type_View 81 Offset 2132 OpMemberDecorate %type_View 82 Offset 2136 OpMemberDecorate %type_View 83 Offset 2140 OpMemberDecorate %type_View 84 Offset 2144 OpMemberDecorate %type_View 85 Offset 2148 OpMemberDecorate %type_View 86 Offset 2152 OpMemberDecorate %type_View 87 Offset 2156 OpMemberDecorate %type_View 88 Offset 2160 OpMemberDecorate %type_View 89 Offset 2164 OpMemberDecorate %type_View 90 Offset 2168 OpMemberDecorate %type_View 91 Offset 2172 OpMemberDecorate %type_View 92 Offset 2176 OpMemberDecorate %type_View 93 Offset 2192 OpMemberDecorate %type_View 94 Offset 2204 OpMemberDecorate %type_View 95 Offset 2208 OpMemberDecorate %type_View 96 Offset 2240 OpMemberDecorate %type_View 97 Offset 2272 OpMemberDecorate %type_View 98 Offset 2288 OpMemberDecorate %type_View 99 Offset 2304 OpMemberDecorate %type_View 100 Offset 2308 OpMemberDecorate %type_View 101 Offset 2312 OpMemberDecorate %type_View 102 Offset 2316 OpMemberDecorate %type_View 103 Offset 2320 OpMemberDecorate %type_View 104 Offset 2324 OpMemberDecorate %type_View 105 Offset 2328 OpMemberDecorate %type_View 106 Offset 2332 OpMemberDecorate %type_View 107 Offset 2336 OpMemberDecorate %type_View 108 Offset 2340 OpMemberDecorate %type_View 109 Offset 2344 OpMemberDecorate %type_View 110 Offset 2348 OpMemberDecorate %type_View 111 Offset 2352 OpMemberDecorate %type_View 112 Offset 2364 OpMemberDecorate %type_View 113 Offset 2368 OpMemberDecorate %type_View 114 Offset 2380 OpMemberDecorate %type_View 115 Offset 2384 OpMemberDecorate %type_View 116 Offset 2388 OpMemberDecorate %type_View 117 Offset 2392 OpMemberDecorate %type_View 118 Offset 2396 OpMemberDecorate %type_View 119 Offset 2400 OpMemberDecorate %type_View 120 Offset 2404 OpMemberDecorate %type_View 121 Offset 2408 OpMemberDecorate %type_View 122 Offset 2412 OpMemberDecorate %type_View 123 Offset 2416 OpMemberDecorate %type_View 124 Offset 2420 OpMemberDecorate %type_View 125 Offset 2424 OpMemberDecorate %type_View 126 Offset 2428 OpMemberDecorate %type_View 127 Offset 2432 OpMemberDecorate %type_View 128 Offset 2448 OpMemberDecorate %type_View 129 Offset 2460 OpMemberDecorate %type_View 130 Offset 2464 OpMemberDecorate %type_View 131 Offset 2480 OpMemberDecorate %type_View 132 Offset 2484 OpMemberDecorate %type_View 133 Offset 2488 OpMemberDecorate %type_View 134 Offset 2492 OpMemberDecorate %type_View 135 Offset 2496 OpMemberDecorate %type_View 136 Offset 2512 OpMemberDecorate %type_View 137 Offset 2624 OpMemberDecorate %type_View 138 Offset 2628 OpMemberDecorate %type_View 139 Offset 2632 OpMemberDecorate %type_View 140 Offset 2636 OpMemberDecorate %type_View 141 Offset 2640 OpMemberDecorate %type_View 142 Offset 2644 OpMemberDecorate %type_View 143 Offset 2648 OpMemberDecorate %type_View 144 Offset 2652 OpMemberDecorate %type_View 145 Offset 2656 OpMemberDecorate %type_View 146 Offset 2668 OpMemberDecorate %type_View 147 Offset 2672 OpMemberDecorate %type_View 148 Offset 2736 OpMemberDecorate %type_View 149 Offset 2800 OpMemberDecorate %type_View 150 Offset 2804 OpMemberDecorate %type_View 151 Offset 2808 OpMemberDecorate %type_View 152 Offset 2812 OpMemberDecorate %type_View 153 Offset 2816 OpMemberDecorate %type_View 154 Offset 2828 OpMemberDecorate %type_View 155 Offset 2832 OpMemberDecorate %type_View 156 Offset 2844 OpMemberDecorate %type_View 157 Offset 2848 OpMemberDecorate %type_View 158 Offset 2856 OpMemberDecorate %type_View 159 Offset 2860 OpMemberDecorate %type_View 160 Offset 2864 OpMemberDecorate %type_View 161 Offset 2876 OpMemberDecorate %type_View 162 Offset 2880 OpMemberDecorate %type_View 163 Offset 2892 OpMemberDecorate %type_View 164 Offset 2896 OpMemberDecorate %type_View 165 Offset 2908 OpMemberDecorate %type_View 166 Offset 2912 OpMemberDecorate %type_View 167 Offset 2924 OpMemberDecorate %type_View 168 Offset 2928 OpMemberDecorate %type_View 169 Offset 2932 OpDecorate %type_View Block OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 32 OpMemberDecorate %type__Globals 3 Offset 36 OpMemberDecorate %type__Globals 4 Offset 48 OpMemberDecorate %type__Globals 5 Offset 64 OpMemberDecorate %type__Globals 5 MatrixStride 16 OpMemberDecorate %type__Globals 5 ColMajor OpMemberDecorate %type__Globals 6 Offset 128 OpMemberDecorate %type__Globals 7 Offset 144 OpMemberDecorate %type__Globals 8 Offset 160 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %float_1 = OpConstant %float 1 %int_58 = OpConstant %int 58 %int_24 = OpConstant %int 24 %int_5 = OpConstant %int 5 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_8 = OpConstant %int 8 %float_0_999989986 = OpConstant %float 0.999989986 %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %int_7 = OpConstant %int 7 %float_0_5 = OpConstant %float 0.5 %41 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %v2int = OpTypeVector %int 2 %43 = OpConstantComposite %v2int %int_0 %int_0 %44 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %type_subpass_image = OpTypeImage %float SubpassData 2 0 0 2 Unknown %_ptr_UniformConstant_type_subpass_image = OpTypePointer UniformConstant %type_subpass_image %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type__Globals = OpTypeStruct %v3float %v4float %float %float %v4float %mat4v4float %v2float %v4float %v4float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %53 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %type_sampled_image = OpTypeSampledImage %type_2d_image %gl_LastFragData = OpVariable %_ptr_UniformConstant_type_subpass_image UniformConstant %View = OpVariable %_ptr_Uniform_type_View Uniform %ShadowDepthTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %ShadowDepthTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %57 = OpConstantNull %v4float %58 = OpUndef %v4float %Main = OpFunction %void None %53 %59 = OpLabel %60 = OpLoad %v4float %gl_FragCoord %61 = OpVectorShuffle %v2float %60 %60 0 1 %62 = OpAccessChain %_ptr_Uniform_v4float %View %int_58 %63 = OpLoad %v4float %62 %64 = OpVectorShuffle %v2float %63 %63 2 3 %65 = OpFMul %v2float %61 %64 %66 = OpLoad %type_subpass_image %gl_LastFragData %67 = OpImageRead %v4float %66 %43 None %68 = OpCompositeExtract %float %67 3 %69 = OpAccessChain %_ptr_Uniform_v4float %View %int_24 %70 = OpLoad %v4float %69 %71 = OpVectorShuffle %v2float %70 %70 3 2 %72 = OpFSub %v2float %65 %71 %73 = OpVectorShuffle %v2float %70 %70 0 1 %74 = OpFDiv %v2float %72 %73 %75 = OpCompositeConstruct %v2float %68 %68 %76 = OpFMul %v2float %74 %75 %77 = OpCompositeExtract %float %76 0 %78 = OpCompositeExtract %float %76 1 %79 = OpCompositeConstruct %v4float %77 %78 %68 %float_1 %80 = OpAccessChain %_ptr_Uniform_mat4v4float %_Globals %int_5 %81 = OpLoad %mat4v4float %80 %82 = OpMatrixTimesVector %v4float %81 %79 %83 = OpCompositeExtract %float %82 2 %84 = OpCompositeExtract %float %82 3 %85 = OpCompositeConstruct %v3float %84 %84 %84 %86 = OpVectorShuffle %v3float %82 %82 0 1 2 %87 = OpFDiv %v3float %86 %85 %88 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_8 %89 = OpLoad %v4float %88 %90 = OpVectorShuffle %v2float %89 %89 2 3 %91 = OpVectorShuffle %v2float %87 %57 0 1 %92 = OpFMul %v2float %91 %90 %93 = OpVectorShuffle %v2float %89 %89 0 1 %94 = OpVectorShuffle %v2float %92 %57 0 1 %95 = OpFAdd %v2float %94 %93 %96 = OpExtInst %float %1 FMin %83 %float_0_999989986 %97 = OpLoad %type_2d_image %ShadowDepthTexture %98 = OpLoad %type_sampler %ShadowDepthTextureSampler %99 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %int_2 %100 = OpLoad %float %99 %101 = OpVectorShuffle %v2float %95 %57 0 1 %102 = OpSampledImage %type_sampled_image %97 %98 %103 = OpImageSampleExplicitLod %v4float %102 %101 Lod %float_0 %104 = OpVectorShuffle %v3float %103 %103 0 0 0 %105 = OpFMul %float %96 %100 %106 = OpFSub %float %105 %float_1 %107 = OpCompositeConstruct %v3float %100 %100 %100 %108 = OpFMul %v3float %104 %107 %109 = OpCompositeConstruct %v3float %106 %106 %106 %110 = OpFSub %v3float %108 %109 %111 = OpExtInst %v3float %1 FClamp %110 %44 %41 %112 = OpCompositeExtract %float %111 0 %113 = OpFSub %float %112 %float_0_5 %114 = OpAccessChain %_ptr_Uniform_float %_Globals %int_3 %115 = OpLoad %float %114 %116 = OpFMul %float %113 %115 %117 = OpFAdd %float %116 %float_0_5 %118 = OpExtInst %float %1 FClamp %117 %float_0 %float_1 %119 = OpFMul %float %118 %118 %120 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %121 = OpLoad %float %120 %122 = OpExtInst %float %1 FMix %float_1 %119 %121 %123 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_7 %124 = OpLoad %v4float %123 %125 = OpVectorShuffle %v3float %124 %124 0 1 2 %126 = OpCompositeConstruct %v3float %122 %122 %122 %127 = OpExtInst %v3float %1 FMix %125 %41 %126 %128 = OpVectorShuffle %v4float %58 %127 4 5 6 3 %129 = OpCompositeInsert %v4float %float_0 %128 3 OpStore %out_var_SV_Target0 %129 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/frag/texture-atomics.asm.argument.msl2.frag000066400000000000000000000270631400026215700274770ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 180 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %ShadowObjectCullPS "main" %in_var_TEXCOORD0 %gl_FragCoord %out_var_SV_Target0 OpExecutionMode %ShadowObjectCullPS OriginUpperLeft OpSource HLSL 600 OpName %type_StructuredBuffer_v4float "type.StructuredBuffer.v4float" OpName %CulledObjectBoxBounds "CulledObjectBoxBounds" OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "ShadowTileListGroupSize" OpName %_Globals "$Globals" OpName %type_buffer_image "type.buffer.image" OpName %RWShadowTileNumCulledObjects "RWShadowTileNumCulledObjects" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %ShadowObjectCullPS "ShadowObjectCullPS" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorate %in_var_TEXCOORD0 Flat OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_POSITION" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %CulledObjectBoxBounds DescriptorSet 0 OpDecorate %CulledObjectBoxBounds Binding 1 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 2 OpDecorate %RWShadowTileNumCulledObjects DescriptorSet 0 OpDecorate %RWShadowTileNumCulledObjects Binding 0 OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %type_StructuredBuffer_v4float 0 Offset 0 OpMemberDecorate %type_StructuredBuffer_v4float 0 NonWritable OpDecorate %type_StructuredBuffer_v4float BufferBlock OpMemberDecorate %type__Globals 0 Offset 0 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_4 = OpConstant %uint 4 %float_0 = OpConstant %float 0 %22 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %float_2 = OpConstant %float 2 %27 = OpConstantComposite %v2float %float_2 %float_2 %float_1 = OpConstant %float 1 %29 = OpConstantComposite %v2float %float_1 %float_1 %float_n1000 = OpConstant %float -1000 %int_2 = OpConstant %int 2 %float_0_5 = OpConstant %float 0.5 %33 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %float_500000 = OpConstant %float 500000 %35 = OpConstantComposite %v3float %float_500000 %float_500000 %float_500000 %float_n500000 = OpConstant %float -500000 %37 = OpConstantComposite %v3float %float_n500000 %float_n500000 %float_n500000 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %int_6 = OpConstant %int 6 %int_7 = OpConstant %int 7 %int_8 = OpConstant %int 8 %44 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_n1 = OpConstant %float -1 %46 = OpConstantComposite %v3float %float_n1 %float_n1 %float_n1 %uint_5 = OpConstant %uint 5 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %type_StructuredBuffer_v4float = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_type_StructuredBuffer_v4float = OpTypePointer Uniform %type_StructuredBuffer_v4float %v2uint = OpTypeVector %uint 2 %type__Globals = OpTypeStruct %v2uint %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %type_buffer_image = OpTypeImage %uint Buffer 2 0 0 2 R32ui %_ptr_UniformConstant_type_buffer_image = OpTypePointer UniformConstant %type_buffer_image %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %58 = OpTypeFunction %void %_ptr_Function_v3float = OpTypePointer Function %v3float %uint_8 = OpConstant %uint 8 %_arr_v3float_uint_8 = OpTypeArray %v3float %uint_8 %_ptr_Function__arr_v3float_uint_8 = OpTypePointer Function %_arr_v3float_uint_8 %_ptr_Uniform_v2uint = OpTypePointer Uniform %v2uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %v2bool = OpTypeVector %bool 2 %v3bool = OpTypeVector %bool 3 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Image_uint = OpTypePointer Image %uint %CulledObjectBoxBounds = OpVariable %_ptr_Uniform_type_StructuredBuffer_v4float Uniform %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %RWShadowTileNumCulledObjects = OpVariable %_ptr_UniformConstant_type_buffer_image UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_uint Input %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %70 = OpUndef %v3float %71 = OpConstantNull %v3float %ShadowObjectCullPS = OpFunction %void None %58 %72 = OpLabel %73 = OpVariable %_ptr_Function__arr_v3float_uint_8 Function %74 = OpLoad %uint %in_var_TEXCOORD0 %75 = OpLoad %v4float %gl_FragCoord %76 = OpVectorShuffle %v2float %75 %75 0 1 %77 = OpConvertFToU %v2uint %76 %78 = OpCompositeExtract %uint %77 1 %79 = OpAccessChain %_ptr_Uniform_v2uint %_Globals %int_0 %80 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_0 %int_0 %81 = OpLoad %uint %80 %82 = OpIMul %uint %78 %81 %83 = OpCompositeExtract %uint %77 0 %84 = OpIAdd %uint %82 %83 %85 = OpConvertUToF %float %83 %86 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_0 %int_1 %87 = OpLoad %uint %86 %88 = OpISub %uint %87 %uint_1 %89 = OpISub %uint %88 %78 %90 = OpConvertUToF %float %89 %91 = OpCompositeConstruct %v2float %85 %90 %92 = OpLoad %v2uint %79 %93 = OpConvertUToF %v2float %92 %94 = OpFDiv %v2float %91 %93 %95 = OpFMul %v2float %94 %27 %96 = OpFSub %v2float %95 %29 %97 = OpFAdd %v2float %91 %29 %98 = OpFDiv %v2float %97 %93 %99 = OpFMul %v2float %98 %27 %100 = OpFSub %v2float %99 %29 %101 = OpVectorShuffle %v3float %70 %100 3 4 2 %102 = OpCompositeInsert %v3float %float_1 %101 2 %103 = OpIMul %uint %74 %uint_5 %104 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %103 %105 = OpLoad %v4float %104 %106 = OpVectorShuffle %v3float %105 %105 0 1 2 %107 = OpIAdd %uint %103 %uint_1 %108 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %107 %109 = OpLoad %v4float %108 %110 = OpVectorShuffle %v3float %109 %109 0 1 2 %111 = OpVectorShuffle %v2float %109 %71 0 1 %112 = OpVectorShuffle %v2float %96 %71 0 1 %113 = OpFOrdGreaterThan %v2bool %111 %112 %114 = OpAll %bool %113 %115 = OpFOrdLessThan %v3bool %106 %102 %116 = OpAll %bool %115 %117 = OpLogicalAnd %bool %114 %116 OpSelectionMerge %118 DontFlatten OpBranchConditional %117 %119 %118 %119 = OpLabel %120 = OpFAdd %v3float %106 %110 %121 = OpFMul %v3float %33 %120 %122 = OpCompositeExtract %float %96 0 %123 = OpCompositeExtract %float %96 1 %124 = OpCompositeConstruct %v3float %122 %123 %float_n1000 %125 = OpAccessChain %_ptr_Function_v3float %73 %int_0 OpStore %125 %124 %126 = OpCompositeExtract %float %100 0 %127 = OpCompositeConstruct %v3float %126 %123 %float_n1000 %128 = OpAccessChain %_ptr_Function_v3float %73 %int_1 OpStore %128 %127 %129 = OpCompositeExtract %float %100 1 %130 = OpCompositeConstruct %v3float %122 %129 %float_n1000 %131 = OpAccessChain %_ptr_Function_v3float %73 %int_2 OpStore %131 %130 %132 = OpCompositeConstruct %v3float %126 %129 %float_n1000 %133 = OpAccessChain %_ptr_Function_v3float %73 %int_3 OpStore %133 %132 %134 = OpCompositeConstruct %v3float %122 %123 %float_1 %135 = OpAccessChain %_ptr_Function_v3float %73 %int_4 OpStore %135 %134 %136 = OpCompositeConstruct %v3float %126 %123 %float_1 %137 = OpAccessChain %_ptr_Function_v3float %73 %int_5 OpStore %137 %136 %138 = OpCompositeConstruct %v3float %122 %129 %float_1 %139 = OpAccessChain %_ptr_Function_v3float %73 %int_6 OpStore %139 %138 %140 = OpCompositeConstruct %v3float %126 %129 %float_1 %141 = OpAccessChain %_ptr_Function_v3float %73 %int_7 OpStore %141 %140 %142 = OpIAdd %uint %103 %uint_2 %143 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %142 %144 = OpLoad %v4float %143 %145 = OpVectorShuffle %v3float %144 %144 0 1 2 %146 = OpIAdd %uint %103 %uint_3 %147 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %146 %148 = OpLoad %v4float %147 %149 = OpVectorShuffle %v3float %148 %148 0 1 2 %150 = OpIAdd %uint %103 %uint_4 %151 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %150 %152 = OpLoad %v4float %151 %153 = OpVectorShuffle %v3float %152 %152 0 1 2 OpBranch %154 %154 = OpLabel %155 = OpPhi %v3float %37 %119 %156 %157 %158 = OpPhi %v3float %35 %119 %159 %157 %160 = OpPhi %int %int_0 %119 %161 %157 %162 = OpSLessThan %bool %160 %int_8 OpLoopMerge %163 %157 Unroll OpBranchConditional %162 %157 %163 %157 = OpLabel %164 = OpAccessChain %_ptr_Function_v3float %73 %160 %165 = OpLoad %v3float %164 %166 = OpFSub %v3float %165 %121 %167 = OpDot %float %166 %145 %168 = OpDot %float %166 %149 %169 = OpDot %float %166 %153 %170 = OpCompositeConstruct %v3float %167 %168 %169 %159 = OpExtInst %v3float %1 FMin %158 %170 %156 = OpExtInst %v3float %1 FMax %155 %170 %161 = OpIAdd %int %160 %int_1 OpBranch %154 %163 = OpLabel %171 = OpFOrdLessThan %v3bool %158 %44 %172 = OpAll %bool %171 %173 = OpFOrdGreaterThan %v3bool %155 %46 %174 = OpAll %bool %173 %175 = OpLogicalAnd %bool %172 %174 OpSelectionMerge %176 DontFlatten OpBranchConditional %175 %177 %176 %177 = OpLabel %178 = OpImageTexelPointer %_ptr_Image_uint %RWShadowTileNumCulledObjects %84 %uint_0 %179 = OpAtomicIAdd %uint %178 %uint_1 %uint_0 %uint_1 OpBranch %176 %176 = OpLabel OpBranch %118 %118 = OpLabel OpStore %out_var_SV_Target0 %22 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/frag/texture-atomics.asm.frag000066400000000000000000000270631400026215700250020ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 180 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %ShadowObjectCullPS "main" %in_var_TEXCOORD0 %gl_FragCoord %out_var_SV_Target0 OpExecutionMode %ShadowObjectCullPS OriginUpperLeft OpSource HLSL 600 OpName %type_StructuredBuffer_v4float "type.StructuredBuffer.v4float" OpName %CulledObjectBoxBounds "CulledObjectBoxBounds" OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "ShadowTileListGroupSize" OpName %_Globals "$Globals" OpName %type_buffer_image "type.buffer.image" OpName %RWShadowTileNumCulledObjects "RWShadowTileNumCulledObjects" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %ShadowObjectCullPS "ShadowObjectCullPS" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorate %in_var_TEXCOORD0 Flat OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_POSITION" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %CulledObjectBoxBounds DescriptorSet 0 OpDecorate %CulledObjectBoxBounds Binding 1 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 2 OpDecorate %RWShadowTileNumCulledObjects DescriptorSet 0 OpDecorate %RWShadowTileNumCulledObjects Binding 0 OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %type_StructuredBuffer_v4float 0 Offset 0 OpMemberDecorate %type_StructuredBuffer_v4float 0 NonWritable OpDecorate %type_StructuredBuffer_v4float BufferBlock OpMemberDecorate %type__Globals 0 Offset 0 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_4 = OpConstant %uint 4 %float_0 = OpConstant %float 0 %22 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %float_2 = OpConstant %float 2 %27 = OpConstantComposite %v2float %float_2 %float_2 %float_1 = OpConstant %float 1 %29 = OpConstantComposite %v2float %float_1 %float_1 %float_n1000 = OpConstant %float -1000 %int_2 = OpConstant %int 2 %float_0_5 = OpConstant %float 0.5 %33 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %float_500000 = OpConstant %float 500000 %35 = OpConstantComposite %v3float %float_500000 %float_500000 %float_500000 %float_n500000 = OpConstant %float -500000 %37 = OpConstantComposite %v3float %float_n500000 %float_n500000 %float_n500000 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %int_6 = OpConstant %int 6 %int_7 = OpConstant %int 7 %int_8 = OpConstant %int 8 %44 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_n1 = OpConstant %float -1 %46 = OpConstantComposite %v3float %float_n1 %float_n1 %float_n1 %uint_5 = OpConstant %uint 5 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %type_StructuredBuffer_v4float = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_type_StructuredBuffer_v4float = OpTypePointer Uniform %type_StructuredBuffer_v4float %v2uint = OpTypeVector %uint 2 %type__Globals = OpTypeStruct %v2uint %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %type_buffer_image = OpTypeImage %uint Buffer 2 0 0 2 R32ui %_ptr_UniformConstant_type_buffer_image = OpTypePointer UniformConstant %type_buffer_image %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %58 = OpTypeFunction %void %_ptr_Function_v3float = OpTypePointer Function %v3float %uint_8 = OpConstant %uint 8 %_arr_v3float_uint_8 = OpTypeArray %v3float %uint_8 %_ptr_Function__arr_v3float_uint_8 = OpTypePointer Function %_arr_v3float_uint_8 %_ptr_Uniform_v2uint = OpTypePointer Uniform %v2uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %v2bool = OpTypeVector %bool 2 %v3bool = OpTypeVector %bool 3 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Image_uint = OpTypePointer Image %uint %CulledObjectBoxBounds = OpVariable %_ptr_Uniform_type_StructuredBuffer_v4float Uniform %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %RWShadowTileNumCulledObjects = OpVariable %_ptr_UniformConstant_type_buffer_image UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_uint Input %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %70 = OpUndef %v3float %71 = OpConstantNull %v3float %ShadowObjectCullPS = OpFunction %void None %58 %72 = OpLabel %73 = OpVariable %_ptr_Function__arr_v3float_uint_8 Function %74 = OpLoad %uint %in_var_TEXCOORD0 %75 = OpLoad %v4float %gl_FragCoord %76 = OpVectorShuffle %v2float %75 %75 0 1 %77 = OpConvertFToU %v2uint %76 %78 = OpCompositeExtract %uint %77 1 %79 = OpAccessChain %_ptr_Uniform_v2uint %_Globals %int_0 %80 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_0 %int_0 %81 = OpLoad %uint %80 %82 = OpIMul %uint %78 %81 %83 = OpCompositeExtract %uint %77 0 %84 = OpIAdd %uint %82 %83 %85 = OpConvertUToF %float %83 %86 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_0 %int_1 %87 = OpLoad %uint %86 %88 = OpISub %uint %87 %uint_1 %89 = OpISub %uint %88 %78 %90 = OpConvertUToF %float %89 %91 = OpCompositeConstruct %v2float %85 %90 %92 = OpLoad %v2uint %79 %93 = OpConvertUToF %v2float %92 %94 = OpFDiv %v2float %91 %93 %95 = OpFMul %v2float %94 %27 %96 = OpFSub %v2float %95 %29 %97 = OpFAdd %v2float %91 %29 %98 = OpFDiv %v2float %97 %93 %99 = OpFMul %v2float %98 %27 %100 = OpFSub %v2float %99 %29 %101 = OpVectorShuffle %v3float %70 %100 3 4 2 %102 = OpCompositeInsert %v3float %float_1 %101 2 %103 = OpIMul %uint %74 %uint_5 %104 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %103 %105 = OpLoad %v4float %104 %106 = OpVectorShuffle %v3float %105 %105 0 1 2 %107 = OpIAdd %uint %103 %uint_1 %108 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %107 %109 = OpLoad %v4float %108 %110 = OpVectorShuffle %v3float %109 %109 0 1 2 %111 = OpVectorShuffle %v2float %109 %71 0 1 %112 = OpVectorShuffle %v2float %96 %71 0 1 %113 = OpFOrdGreaterThan %v2bool %111 %112 %114 = OpAll %bool %113 %115 = OpFOrdLessThan %v3bool %106 %102 %116 = OpAll %bool %115 %117 = OpLogicalAnd %bool %114 %116 OpSelectionMerge %118 DontFlatten OpBranchConditional %117 %119 %118 %119 = OpLabel %120 = OpFAdd %v3float %106 %110 %121 = OpFMul %v3float %33 %120 %122 = OpCompositeExtract %float %96 0 %123 = OpCompositeExtract %float %96 1 %124 = OpCompositeConstruct %v3float %122 %123 %float_n1000 %125 = OpAccessChain %_ptr_Function_v3float %73 %int_0 OpStore %125 %124 %126 = OpCompositeExtract %float %100 0 %127 = OpCompositeConstruct %v3float %126 %123 %float_n1000 %128 = OpAccessChain %_ptr_Function_v3float %73 %int_1 OpStore %128 %127 %129 = OpCompositeExtract %float %100 1 %130 = OpCompositeConstruct %v3float %122 %129 %float_n1000 %131 = OpAccessChain %_ptr_Function_v3float %73 %int_2 OpStore %131 %130 %132 = OpCompositeConstruct %v3float %126 %129 %float_n1000 %133 = OpAccessChain %_ptr_Function_v3float %73 %int_3 OpStore %133 %132 %134 = OpCompositeConstruct %v3float %122 %123 %float_1 %135 = OpAccessChain %_ptr_Function_v3float %73 %int_4 OpStore %135 %134 %136 = OpCompositeConstruct %v3float %126 %123 %float_1 %137 = OpAccessChain %_ptr_Function_v3float %73 %int_5 OpStore %137 %136 %138 = OpCompositeConstruct %v3float %122 %129 %float_1 %139 = OpAccessChain %_ptr_Function_v3float %73 %int_6 OpStore %139 %138 %140 = OpCompositeConstruct %v3float %126 %129 %float_1 %141 = OpAccessChain %_ptr_Function_v3float %73 %int_7 OpStore %141 %140 %142 = OpIAdd %uint %103 %uint_2 %143 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %142 %144 = OpLoad %v4float %143 %145 = OpVectorShuffle %v3float %144 %144 0 1 2 %146 = OpIAdd %uint %103 %uint_3 %147 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %146 %148 = OpLoad %v4float %147 %149 = OpVectorShuffle %v3float %148 %148 0 1 2 %150 = OpIAdd %uint %103 %uint_4 %151 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %150 %152 = OpLoad %v4float %151 %153 = OpVectorShuffle %v3float %152 %152 0 1 2 OpBranch %154 %154 = OpLabel %155 = OpPhi %v3float %37 %119 %156 %157 %158 = OpPhi %v3float %35 %119 %159 %157 %160 = OpPhi %int %int_0 %119 %161 %157 %162 = OpSLessThan %bool %160 %int_8 OpLoopMerge %163 %157 Unroll OpBranchConditional %162 %157 %163 %157 = OpLabel %164 = OpAccessChain %_ptr_Function_v3float %73 %160 %165 = OpLoad %v3float %164 %166 = OpFSub %v3float %165 %121 %167 = OpDot %float %166 %145 %168 = OpDot %float %166 %149 %169 = OpDot %float %166 %153 %170 = OpCompositeConstruct %v3float %167 %168 %169 %159 = OpExtInst %v3float %1 FMin %158 %170 %156 = OpExtInst %v3float %1 FMax %155 %170 %161 = OpIAdd %int %160 %int_1 OpBranch %154 %163 = OpLabel %171 = OpFOrdLessThan %v3bool %158 %44 %172 = OpAll %bool %171 %173 = OpFOrdGreaterThan %v3bool %155 %46 %174 = OpAll %bool %173 %175 = OpLogicalAnd %bool %172 %174 OpSelectionMerge %176 DontFlatten OpBranchConditional %175 %177 %176 %177 = OpLabel %178 = OpImageTexelPointer %_ptr_Image_uint %RWShadowTileNumCulledObjects %84 %uint_0 %179 = OpAtomicIAdd %uint %178 %uint_1 %uint_0 %uint_1 OpBranch %176 %176 = OpLabel OpBranch %118 %118 = OpLabel OpStore %out_var_SV_Target0 %22 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/frag/texture-atomics.asm.graphics-robust-access.frag000066400000000000000000000270631400026215700313540ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 180 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %ShadowObjectCullPS "main" %in_var_TEXCOORD0 %gl_FragCoord %out_var_SV_Target0 OpExecutionMode %ShadowObjectCullPS OriginUpperLeft OpSource HLSL 600 OpName %type_StructuredBuffer_v4float "type.StructuredBuffer.v4float" OpName %CulledObjectBoxBounds "CulledObjectBoxBounds" OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "ShadowTileListGroupSize" OpName %_Globals "$Globals" OpName %type_buffer_image "type.buffer.image" OpName %RWShadowTileNumCulledObjects "RWShadowTileNumCulledObjects" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %ShadowObjectCullPS "ShadowObjectCullPS" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorate %in_var_TEXCOORD0 Flat OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_POSITION" OpDecorateString %out_var_SV_Target0 UserSemantic "SV_Target0" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %CulledObjectBoxBounds DescriptorSet 0 OpDecorate %CulledObjectBoxBounds Binding 1 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 2 OpDecorate %RWShadowTileNumCulledObjects DescriptorSet 0 OpDecorate %RWShadowTileNumCulledObjects Binding 0 OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %type_StructuredBuffer_v4float 0 Offset 0 OpMemberDecorate %type_StructuredBuffer_v4float 0 NonWritable OpDecorate %type_StructuredBuffer_v4float BufferBlock OpMemberDecorate %type__Globals 0 Offset 0 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_4 = OpConstant %uint 4 %float_0 = OpConstant %float 0 %22 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %float_2 = OpConstant %float 2 %27 = OpConstantComposite %v2float %float_2 %float_2 %float_1 = OpConstant %float 1 %29 = OpConstantComposite %v2float %float_1 %float_1 %float_n1000 = OpConstant %float -1000 %int_2 = OpConstant %int 2 %float_0_5 = OpConstant %float 0.5 %33 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %float_500000 = OpConstant %float 500000 %35 = OpConstantComposite %v3float %float_500000 %float_500000 %float_500000 %float_n500000 = OpConstant %float -500000 %37 = OpConstantComposite %v3float %float_n500000 %float_n500000 %float_n500000 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %int_6 = OpConstant %int 6 %int_7 = OpConstant %int 7 %int_8 = OpConstant %int 8 %44 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_n1 = OpConstant %float -1 %46 = OpConstantComposite %v3float %float_n1 %float_n1 %float_n1 %uint_5 = OpConstant %uint 5 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %type_StructuredBuffer_v4float = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_type_StructuredBuffer_v4float = OpTypePointer Uniform %type_StructuredBuffer_v4float %v2uint = OpTypeVector %uint 2 %type__Globals = OpTypeStruct %v2uint %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %type_buffer_image = OpTypeImage %uint Buffer 2 0 0 2 R32ui %_ptr_UniformConstant_type_buffer_image = OpTypePointer UniformConstant %type_buffer_image %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %58 = OpTypeFunction %void %_ptr_Function_v3float = OpTypePointer Function %v3float %uint_8 = OpConstant %uint 8 %_arr_v3float_uint_8 = OpTypeArray %v3float %uint_8 %_ptr_Function__arr_v3float_uint_8 = OpTypePointer Function %_arr_v3float_uint_8 %_ptr_Uniform_v2uint = OpTypePointer Uniform %v2uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %v2bool = OpTypeVector %bool 2 %v3bool = OpTypeVector %bool 3 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Image_uint = OpTypePointer Image %uint %CulledObjectBoxBounds = OpVariable %_ptr_Uniform_type_StructuredBuffer_v4float Uniform %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %RWShadowTileNumCulledObjects = OpVariable %_ptr_UniformConstant_type_buffer_image UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_uint Input %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %70 = OpUndef %v3float %71 = OpConstantNull %v3float %ShadowObjectCullPS = OpFunction %void None %58 %72 = OpLabel %73 = OpVariable %_ptr_Function__arr_v3float_uint_8 Function %74 = OpLoad %uint %in_var_TEXCOORD0 %75 = OpLoad %v4float %gl_FragCoord %76 = OpVectorShuffle %v2float %75 %75 0 1 %77 = OpConvertFToU %v2uint %76 %78 = OpCompositeExtract %uint %77 1 %79 = OpAccessChain %_ptr_Uniform_v2uint %_Globals %int_0 %80 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_0 %int_0 %81 = OpLoad %uint %80 %82 = OpIMul %uint %78 %81 %83 = OpCompositeExtract %uint %77 0 %84 = OpIAdd %uint %82 %83 %85 = OpConvertUToF %float %83 %86 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_0 %int_1 %87 = OpLoad %uint %86 %88 = OpISub %uint %87 %uint_1 %89 = OpISub %uint %88 %78 %90 = OpConvertUToF %float %89 %91 = OpCompositeConstruct %v2float %85 %90 %92 = OpLoad %v2uint %79 %93 = OpConvertUToF %v2float %92 %94 = OpFDiv %v2float %91 %93 %95 = OpFMul %v2float %94 %27 %96 = OpFSub %v2float %95 %29 %97 = OpFAdd %v2float %91 %29 %98 = OpFDiv %v2float %97 %93 %99 = OpFMul %v2float %98 %27 %100 = OpFSub %v2float %99 %29 %101 = OpVectorShuffle %v3float %70 %100 3 4 2 %102 = OpCompositeInsert %v3float %float_1 %101 2 %103 = OpIMul %uint %74 %uint_5 %104 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %103 %105 = OpLoad %v4float %104 %106 = OpVectorShuffle %v3float %105 %105 0 1 2 %107 = OpIAdd %uint %103 %uint_1 %108 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %107 %109 = OpLoad %v4float %108 %110 = OpVectorShuffle %v3float %109 %109 0 1 2 %111 = OpVectorShuffle %v2float %109 %71 0 1 %112 = OpVectorShuffle %v2float %96 %71 0 1 %113 = OpFOrdGreaterThan %v2bool %111 %112 %114 = OpAll %bool %113 %115 = OpFOrdLessThan %v3bool %106 %102 %116 = OpAll %bool %115 %117 = OpLogicalAnd %bool %114 %116 OpSelectionMerge %118 DontFlatten OpBranchConditional %117 %119 %118 %119 = OpLabel %120 = OpFAdd %v3float %106 %110 %121 = OpFMul %v3float %33 %120 %122 = OpCompositeExtract %float %96 0 %123 = OpCompositeExtract %float %96 1 %124 = OpCompositeConstruct %v3float %122 %123 %float_n1000 %125 = OpAccessChain %_ptr_Function_v3float %73 %int_0 OpStore %125 %124 %126 = OpCompositeExtract %float %100 0 %127 = OpCompositeConstruct %v3float %126 %123 %float_n1000 %128 = OpAccessChain %_ptr_Function_v3float %73 %int_1 OpStore %128 %127 %129 = OpCompositeExtract %float %100 1 %130 = OpCompositeConstruct %v3float %122 %129 %float_n1000 %131 = OpAccessChain %_ptr_Function_v3float %73 %int_2 OpStore %131 %130 %132 = OpCompositeConstruct %v3float %126 %129 %float_n1000 %133 = OpAccessChain %_ptr_Function_v3float %73 %int_3 OpStore %133 %132 %134 = OpCompositeConstruct %v3float %122 %123 %float_1 %135 = OpAccessChain %_ptr_Function_v3float %73 %int_4 OpStore %135 %134 %136 = OpCompositeConstruct %v3float %126 %123 %float_1 %137 = OpAccessChain %_ptr_Function_v3float %73 %int_5 OpStore %137 %136 %138 = OpCompositeConstruct %v3float %122 %129 %float_1 %139 = OpAccessChain %_ptr_Function_v3float %73 %int_6 OpStore %139 %138 %140 = OpCompositeConstruct %v3float %126 %129 %float_1 %141 = OpAccessChain %_ptr_Function_v3float %73 %int_7 OpStore %141 %140 %142 = OpIAdd %uint %103 %uint_2 %143 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %142 %144 = OpLoad %v4float %143 %145 = OpVectorShuffle %v3float %144 %144 0 1 2 %146 = OpIAdd %uint %103 %uint_3 %147 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %146 %148 = OpLoad %v4float %147 %149 = OpVectorShuffle %v3float %148 %148 0 1 2 %150 = OpIAdd %uint %103 %uint_4 %151 = OpAccessChain %_ptr_Uniform_v4float %CulledObjectBoxBounds %int_0 %150 %152 = OpLoad %v4float %151 %153 = OpVectorShuffle %v3float %152 %152 0 1 2 OpBranch %154 %154 = OpLabel %155 = OpPhi %v3float %37 %119 %156 %157 %158 = OpPhi %v3float %35 %119 %159 %157 %160 = OpPhi %int %int_0 %119 %161 %157 %162 = OpSLessThan %bool %160 %int_8 OpLoopMerge %163 %157 Unroll OpBranchConditional %162 %157 %163 %157 = OpLabel %164 = OpAccessChain %_ptr_Function_v3float %73 %160 %165 = OpLoad %v3float %164 %166 = OpFSub %v3float %165 %121 %167 = OpDot %float %166 %145 %168 = OpDot %float %166 %149 %169 = OpDot %float %166 %153 %170 = OpCompositeConstruct %v3float %167 %168 %169 %159 = OpExtInst %v3float %1 FMin %158 %170 %156 = OpExtInst %v3float %1 FMax %155 %170 %161 = OpIAdd %int %160 %int_1 OpBranch %154 %163 = OpLabel %171 = OpFOrdLessThan %v3bool %158 %44 %172 = OpAll %bool %171 %173 = OpFOrdGreaterThan %v3bool %155 %46 %174 = OpAll %bool %173 %175 = OpLogicalAnd %bool %172 %174 OpSelectionMerge %176 DontFlatten OpBranchConditional %175 %177 %176 %177 = OpLabel %178 = OpImageTexelPointer %_ptr_Image_uint %RWShadowTileNumCulledObjects %84 %uint_0 %179 = OpAtomicIAdd %uint %178 %uint_1 %uint_0 %uint_1 OpBranch %176 %176 = OpLabel OpBranch %118 %118 = OpLabel OpStore %out_var_SV_Target0 %22 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/tesc/000077500000000000000000000000001400026215700202345ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4/asm/tesc/hs-incorrect-base-type.asm.tesc000066400000000000000000002116051400026215700261670ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 598 ; Schema: 0 OpCapability Tessellation OpCapability SampledBuffer OpCapability StorageImageExtendedFormats OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %MainHull "main" %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_COLOR0 %in_var_TEXCOORD0 %in_var_TEXCOORD4 %in_var_PRIMITIVE_ID %in_var_LIGHTMAP_ID %in_var_VS_To_DS_Position %gl_InvocationID %out_var_TEXCOORD10_centroid %out_var_TEXCOORD11_centroid %out_var_COLOR0 %out_var_TEXCOORD0 %out_var_TEXCOORD4 %out_var_PRIMITIVE_ID %out_var_LIGHTMAP_ID %out_var_VS_To_DS_Position %out_var_PN_POSITION %out_var_PN_DisplacementScales %out_var_PN_TessellationMultiplier %out_var_PN_WorldDisplacementMultiplier %gl_TessLevelOuter %gl_TessLevelInner %out_var_PN_POSITION9 OpExecutionMode %MainHull Triangles OpExecutionMode %MainHull SpacingFractionalOdd OpExecutionMode %MainHull VertexOrderCw OpExecutionMode %MainHull OutputVertices 3 OpSource HLSL 600 OpName %FPNTessellationHSToDS "FPNTessellationHSToDS" OpMemberName %FPNTessellationHSToDS 0 "PassSpecificData" OpMemberName %FPNTessellationHSToDS 1 "WorldPosition" OpMemberName %FPNTessellationHSToDS 2 "DisplacementScale" OpMemberName %FPNTessellationHSToDS 3 "TessellationMultiplier" OpMemberName %FPNTessellationHSToDS 4 "WorldDisplacementMultiplier" OpName %FBasePassVSToDS "FBasePassVSToDS" OpMemberName %FBasePassVSToDS 0 "FactoryInterpolants" OpMemberName %FBasePassVSToDS 1 "BasePassInterpolants" OpMemberName %FBasePassVSToDS 2 "Position" OpName %FVertexFactoryInterpolantsVSToDS "FVertexFactoryInterpolantsVSToDS" OpMemberName %FVertexFactoryInterpolantsVSToDS 0 "InterpolantsVSToPS" OpName %FVertexFactoryInterpolantsVSToPS "FVertexFactoryInterpolantsVSToPS" OpMemberName %FVertexFactoryInterpolantsVSToPS 0 "TangentToWorld0" OpMemberName %FVertexFactoryInterpolantsVSToPS 1 "TangentToWorld2" OpMemberName %FVertexFactoryInterpolantsVSToPS 2 "Color" OpMemberName %FVertexFactoryInterpolantsVSToPS 3 "TexCoords" OpMemberName %FVertexFactoryInterpolantsVSToPS 4 "LightMapCoordinate" OpMemberName %FVertexFactoryInterpolantsVSToPS 5 "PrimitiveId" OpMemberName %FVertexFactoryInterpolantsVSToPS 6 "LightmapDataIndex" OpName %FBasePassInterpolantsVSToDS "FBasePassInterpolantsVSToDS" OpName %FSharedBasePassInterpolants "FSharedBasePassInterpolants" OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_TranslatedWorldToView" OpMemberName %type_View 3 "View_ViewToTranslatedWorld" OpMemberName %type_View 4 "View_TranslatedWorldToCameraView" OpMemberName %type_View 5 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 6 "View_ViewToClip" OpMemberName %type_View 7 "View_ViewToClipNoAA" OpMemberName %type_View 8 "View_ClipToView" OpMemberName %type_View 9 "View_ClipToTranslatedWorld" OpMemberName %type_View 10 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 11 "View_ScreenToWorld" OpMemberName %type_View 12 "View_ScreenToTranslatedWorld" OpMemberName %type_View 13 "View_ViewForward" OpMemberName %type_View 14 "PrePadding_View_844" OpMemberName %type_View 15 "View_ViewUp" OpMemberName %type_View 16 "PrePadding_View_860" OpMemberName %type_View 17 "View_ViewRight" OpMemberName %type_View 18 "PrePadding_View_876" OpMemberName %type_View 19 "View_HMDViewNoRollUp" OpMemberName %type_View 20 "PrePadding_View_892" OpMemberName %type_View 21 "View_HMDViewNoRollRight" OpMemberName %type_View 22 "PrePadding_View_908" OpMemberName %type_View 23 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 24 "View_ScreenPositionScaleBias" OpMemberName %type_View 25 "View_WorldCameraOrigin" OpMemberName %type_View 26 "PrePadding_View_956" OpMemberName %type_View 27 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 28 "PrePadding_View_972" OpMemberName %type_View 29 "View_WorldViewOrigin" OpMemberName %type_View 30 "PrePadding_View_988" OpMemberName %type_View 31 "View_PreViewTranslation" OpMemberName %type_View 32 "PrePadding_View_1004" OpMemberName %type_View 33 "View_PrevProjection" OpMemberName %type_View 34 "View_PrevViewProj" OpMemberName %type_View 35 "View_PrevViewRotationProj" OpMemberName %type_View 36 "View_PrevViewToClip" OpMemberName %type_View 37 "View_PrevClipToView" OpMemberName %type_View 38 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 39 "View_PrevTranslatedWorldToView" OpMemberName %type_View 40 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 41 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 42 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 43 "View_PrevWorldCameraOrigin" OpMemberName %type_View 44 "PrePadding_View_1660" OpMemberName %type_View 45 "View_PrevWorldViewOrigin" OpMemberName %type_View 46 "PrePadding_View_1676" OpMemberName %type_View 47 "View_PrevPreViewTranslation" OpMemberName %type_View 48 "PrePadding_View_1692" OpMemberName %type_View 49 "View_PrevInvViewProj" OpMemberName %type_View 50 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 51 "View_ClipToPrevClip" OpMemberName %type_View 52 "View_TemporalAAJitter" OpMemberName %type_View 53 "View_GlobalClippingPlane" OpMemberName %type_View 54 "View_FieldOfViewWideAngles" OpMemberName %type_View 55 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 56 "View_ViewRectMin" OpMemberName %type_View 57 "View_ViewSizeAndInvSize" OpMemberName %type_View 58 "View_BufferSizeAndInvSize" OpMemberName %type_View 59 "View_BufferBilinearUVMinMax" OpMemberName %type_View 60 "View_NumSceneColorMSAASamples" OpMemberName %type_View 61 "View_PreExposure" OpMemberName %type_View 62 "View_OneOverPreExposure" OpMemberName %type_View 63 "PrePadding_View_2012" OpMemberName %type_View 64 "View_DiffuseOverrideParameter" OpMemberName %type_View 65 "View_SpecularOverrideParameter" OpMemberName %type_View 66 "View_NormalOverrideParameter" OpMemberName %type_View 67 "View_RoughnessOverrideParameter" OpMemberName %type_View 68 "View_PrevFrameGameTime" OpMemberName %type_View 69 "View_PrevFrameRealTime" OpMemberName %type_View 70 "View_OutOfBoundsMask" OpMemberName %type_View 71 "PrePadding_View_2084" OpMemberName %type_View 72 "PrePadding_View_2088" OpMemberName %type_View 73 "PrePadding_View_2092" OpMemberName %type_View 74 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 75 "View_CullingSign" OpMemberName %type_View 76 "View_NearPlane" OpMemberName %type_View 77 "View_AdaptiveTessellationFactor" OpMemberName %type_View 78 "View_GameTime" OpMemberName %type_View 79 "View_RealTime" OpMemberName %type_View 80 "View_DeltaTime" OpMemberName %type_View 81 "View_MaterialTextureMipBias" OpMemberName %type_View 82 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 83 "View_Random" OpMemberName %type_View 84 "View_FrameNumber" OpMemberName %type_View 85 "View_StateFrameIndexMod8" OpMemberName %type_View 86 "View_StateFrameIndex" OpMemberName %type_View 87 "View_CameraCut" OpMemberName %type_View 88 "View_UnlitViewmodeMask" OpMemberName %type_View 89 "PrePadding_View_2164" OpMemberName %type_View 90 "PrePadding_View_2168" OpMemberName %type_View 91 "PrePadding_View_2172" OpMemberName %type_View 92 "View_DirectionalLightColor" OpMemberName %type_View 93 "View_DirectionalLightDirection" OpMemberName %type_View 94 "PrePadding_View_2204" OpMemberName %type_View 95 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 97 "View_TemporalAAParams" OpMemberName %type_View 98 "View_CircleDOFParams" OpMemberName %type_View 99 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 100 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 101 "View_DepthOfFieldScale" OpMemberName %type_View 102 "View_DepthOfFieldFocalLength" OpMemberName %type_View 103 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 104 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 105 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 106 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 107 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 108 "View_GeneralPurposeTweak" OpMemberName %type_View 109 "View_DemosaicVposOffset" OpMemberName %type_View 110 "PrePadding_View_2348" OpMemberName %type_View 111 "View_IndirectLightingColorScale" OpMemberName %type_View 112 "View_HDR32bppEncodingMode" OpMemberName %type_View 113 "View_AtmosphericFogSunDirection" OpMemberName %type_View 114 "View_AtmosphericFogSunPower" OpMemberName %type_View 115 "View_AtmosphericFogPower" OpMemberName %type_View 116 "View_AtmosphericFogDensityScale" OpMemberName %type_View 117 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 118 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 119 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 120 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 121 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 122 "View_AtmosphericFogStartDistance" OpMemberName %type_View 123 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 124 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 125 "View_AtmosphericFogRenderMask" OpMemberName %type_View 126 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 127 "View_AtmosphericFogSunColor" OpMemberName %type_View 128 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 129 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 130 "View_AmbientCubemapTint" OpMemberName %type_View 131 "View_AmbientCubemapIntensity" OpMemberName %type_View 132 "View_SkyLightParameters" OpMemberName %type_View 133 "PrePadding_View_2488" OpMemberName %type_View 134 "PrePadding_View_2492" OpMemberName %type_View 135 "View_SkyLightColor" OpMemberName %type_View 136 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 137 "View_MobilePreviewMode" OpMemberName %type_View 138 "View_HMDEyePaddingOffset" OpMemberName %type_View 139 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 140 "View_ShowDecalsMask" OpMemberName %type_View 141 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 142 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 143 "PrePadding_View_2648" OpMemberName %type_View 144 "PrePadding_View_2652" OpMemberName %type_View 145 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 146 "View_StereoPassIndex" OpMemberName %type_View 147 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 148 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 149 "View_GlobalVolumeDimension" OpMemberName %type_View 150 "View_GlobalVolumeTexelSize" OpMemberName %type_View 151 "View_MaxGlobalDistance" OpMemberName %type_View 152 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 153 "View_VolumetricFogInvGridSize" OpMemberName %type_View 154 "PrePadding_View_2828" OpMemberName %type_View 155 "View_VolumetricFogGridZParams" OpMemberName %type_View 156 "PrePadding_View_2844" OpMemberName %type_View 157 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 158 "View_VolumetricFogMaxDistance" OpMemberName %type_View 159 "PrePadding_View_2860" OpMemberName %type_View 160 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 161 "PrePadding_View_2876" OpMemberName %type_View 162 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 163 "PrePadding_View_2892" OpMemberName %type_View 164 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 165 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 166 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 167 "View_StereoIPD" OpMemberName %type_View 168 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 169 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_StructuredBuffer_v4float "type.StructuredBuffer.v4float" OpName %View_PrimitiveSceneData "View_PrimitiveSceneData" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_COLOR0 "in.var.COLOR0" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %in_var_TEXCOORD4 "in.var.TEXCOORD4" OpName %in_var_PRIMITIVE_ID "in.var.PRIMITIVE_ID" OpName %in_var_LIGHTMAP_ID "in.var.LIGHTMAP_ID" OpName %in_var_VS_To_DS_Position "in.var.VS_To_DS_Position" OpName %out_var_TEXCOORD10_centroid "out.var.TEXCOORD10_centroid" OpName %out_var_TEXCOORD11_centroid "out.var.TEXCOORD11_centroid" OpName %out_var_COLOR0 "out.var.COLOR0" OpName %out_var_TEXCOORD0 "out.var.TEXCOORD0" OpName %out_var_TEXCOORD4 "out.var.TEXCOORD4" OpName %out_var_PRIMITIVE_ID "out.var.PRIMITIVE_ID" OpName %out_var_LIGHTMAP_ID "out.var.LIGHTMAP_ID" OpName %out_var_VS_To_DS_Position "out.var.VS_To_DS_Position" OpName %out_var_PN_POSITION "out.var.PN_POSITION" OpName %out_var_PN_DisplacementScales "out.var.PN_DisplacementScales" OpName %out_var_PN_TessellationMultiplier "out.var.PN_TessellationMultiplier" OpName %out_var_PN_WorldDisplacementMultiplier "out.var.PN_WorldDisplacementMultiplier" OpName %out_var_PN_POSITION9 "out.var.PN_POSITION9" OpName %MainHull "MainHull" OpName %param_var_I "param.var.I" OpName %temp_var_hullMainRetVal "temp.var.hullMainRetVal" OpName %if_merge "if.merge" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_COLOR0 UserSemantic "COLOR0" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %in_var_TEXCOORD4 UserSemantic "TEXCOORD4" OpDecorateString %in_var_PRIMITIVE_ID UserSemantic "PRIMITIVE_ID" OpDecorateString %in_var_LIGHTMAP_ID UserSemantic "LIGHTMAP_ID" OpDecorateString %in_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorateString %gl_InvocationID UserSemantic "SV_OutputControlPointID" OpDecorateString %out_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %out_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %out_var_COLOR0 UserSemantic "COLOR0" OpDecorateString %out_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %out_var_TEXCOORD4 UserSemantic "TEXCOORD4" OpDecorateString %out_var_PRIMITIVE_ID UserSemantic "PRIMITIVE_ID" OpDecorateString %out_var_LIGHTMAP_ID UserSemantic "LIGHTMAP_ID" OpDecorateString %out_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorateString %out_var_PN_POSITION UserSemantic "PN_POSITION" OpDecorateString %out_var_PN_DisplacementScales UserSemantic "PN_DisplacementScales" OpDecorateString %out_var_PN_TessellationMultiplier UserSemantic "PN_TessellationMultiplier" OpDecorateString %out_var_PN_WorldDisplacementMultiplier UserSemantic "PN_WorldDisplacementMultiplier" OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter OpDecorateString %gl_TessLevelOuter UserSemantic "SV_TessFactor" OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorateString %gl_TessLevelInner UserSemantic "SV_InsideTessFactor" OpDecorate %gl_TessLevelInner Patch OpDecorateString %out_var_PN_POSITION9 UserSemantic "PN_POSITION9" OpDecorate %out_var_PN_POSITION9 Patch OpDecorate %in_var_TEXCOORD10_centroid Location 0 OpDecorate %in_var_TEXCOORD11_centroid Location 1 OpDecorate %in_var_COLOR0 Location 2 OpDecorate %in_var_TEXCOORD0 Location 3 OpDecorate %in_var_TEXCOORD4 Location 4 OpDecorate %in_var_PRIMITIVE_ID Location 5 OpDecorate %in_var_LIGHTMAP_ID Location 6 OpDecorate %in_var_VS_To_DS_Position Location 7 OpDecorate %out_var_COLOR0 Location 0 OpDecorate %out_var_LIGHTMAP_ID Location 1 OpDecorate %out_var_PN_DisplacementScales Location 2 OpDecorate %out_var_PN_POSITION Location 3 OpDecorate %out_var_PN_POSITION9 Location 6 OpDecorate %out_var_PN_TessellationMultiplier Location 7 OpDecorate %out_var_PN_WorldDisplacementMultiplier Location 8 OpDecorate %out_var_PRIMITIVE_ID Location 9 OpDecorate %out_var_TEXCOORD0 Location 10 OpDecorate %out_var_TEXCOORD10_centroid Location 11 OpDecorate %out_var_TEXCOORD11_centroid Location 12 OpDecorate %out_var_TEXCOORD4 Location 13 OpDecorate %out_var_VS_To_DS_Position Location 14 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 1 OpDecorate %View_PrimitiveSceneData DescriptorSet 0 OpDecorate %View_PrimitiveSceneData Binding 0 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 14 Offset 844 OpMemberDecorate %type_View 15 Offset 848 OpMemberDecorate %type_View 16 Offset 860 OpMemberDecorate %type_View 17 Offset 864 OpMemberDecorate %type_View 18 Offset 876 OpMemberDecorate %type_View 19 Offset 880 OpMemberDecorate %type_View 20 Offset 892 OpMemberDecorate %type_View 21 Offset 896 OpMemberDecorate %type_View 22 Offset 908 OpMemberDecorate %type_View 23 Offset 912 OpMemberDecorate %type_View 24 Offset 928 OpMemberDecorate %type_View 25 Offset 944 OpMemberDecorate %type_View 26 Offset 956 OpMemberDecorate %type_View 27 Offset 960 OpMemberDecorate %type_View 28 Offset 972 OpMemberDecorate %type_View 29 Offset 976 OpMemberDecorate %type_View 30 Offset 988 OpMemberDecorate %type_View 31 Offset 992 OpMemberDecorate %type_View 32 Offset 1004 OpMemberDecorate %type_View 33 Offset 1008 OpMemberDecorate %type_View 33 MatrixStride 16 OpMemberDecorate %type_View 33 ColMajor OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 44 Offset 1660 OpMemberDecorate %type_View 45 Offset 1664 OpMemberDecorate %type_View 46 Offset 1676 OpMemberDecorate %type_View 47 Offset 1680 OpMemberDecorate %type_View 48 Offset 1692 OpMemberDecorate %type_View 49 Offset 1696 OpMemberDecorate %type_View 49 MatrixStride 16 OpMemberDecorate %type_View 49 ColMajor OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 53 Offset 1904 OpMemberDecorate %type_View 54 Offset 1920 OpMemberDecorate %type_View 55 Offset 1928 OpMemberDecorate %type_View 56 Offset 1936 OpMemberDecorate %type_View 57 Offset 1952 OpMemberDecorate %type_View 58 Offset 1968 OpMemberDecorate %type_View 59 Offset 1984 OpMemberDecorate %type_View 60 Offset 2000 OpMemberDecorate %type_View 61 Offset 2004 OpMemberDecorate %type_View 62 Offset 2008 OpMemberDecorate %type_View 63 Offset 2012 OpMemberDecorate %type_View 64 Offset 2016 OpMemberDecorate %type_View 65 Offset 2032 OpMemberDecorate %type_View 66 Offset 2048 OpMemberDecorate %type_View 67 Offset 2064 OpMemberDecorate %type_View 68 Offset 2072 OpMemberDecorate %type_View 69 Offset 2076 OpMemberDecorate %type_View 70 Offset 2080 OpMemberDecorate %type_View 71 Offset 2084 OpMemberDecorate %type_View 72 Offset 2088 OpMemberDecorate %type_View 73 Offset 2092 OpMemberDecorate %type_View 74 Offset 2096 OpMemberDecorate %type_View 75 Offset 2108 OpMemberDecorate %type_View 76 Offset 2112 OpMemberDecorate %type_View 77 Offset 2116 OpMemberDecorate %type_View 78 Offset 2120 OpMemberDecorate %type_View 79 Offset 2124 OpMemberDecorate %type_View 80 Offset 2128 OpMemberDecorate %type_View 81 Offset 2132 OpMemberDecorate %type_View 82 Offset 2136 OpMemberDecorate %type_View 83 Offset 2140 OpMemberDecorate %type_View 84 Offset 2144 OpMemberDecorate %type_View 85 Offset 2148 OpMemberDecorate %type_View 86 Offset 2152 OpMemberDecorate %type_View 87 Offset 2156 OpMemberDecorate %type_View 88 Offset 2160 OpMemberDecorate %type_View 89 Offset 2164 OpMemberDecorate %type_View 90 Offset 2168 OpMemberDecorate %type_View 91 Offset 2172 OpMemberDecorate %type_View 92 Offset 2176 OpMemberDecorate %type_View 93 Offset 2192 OpMemberDecorate %type_View 94 Offset 2204 OpMemberDecorate %type_View 95 Offset 2208 OpMemberDecorate %type_View 96 Offset 2240 OpMemberDecorate %type_View 97 Offset 2272 OpMemberDecorate %type_View 98 Offset 2288 OpMemberDecorate %type_View 99 Offset 2304 OpMemberDecorate %type_View 100 Offset 2308 OpMemberDecorate %type_View 101 Offset 2312 OpMemberDecorate %type_View 102 Offset 2316 OpMemberDecorate %type_View 103 Offset 2320 OpMemberDecorate %type_View 104 Offset 2324 OpMemberDecorate %type_View 105 Offset 2328 OpMemberDecorate %type_View 106 Offset 2332 OpMemberDecorate %type_View 107 Offset 2336 OpMemberDecorate %type_View 108 Offset 2340 OpMemberDecorate %type_View 109 Offset 2344 OpMemberDecorate %type_View 110 Offset 2348 OpMemberDecorate %type_View 111 Offset 2352 OpMemberDecorate %type_View 112 Offset 2364 OpMemberDecorate %type_View 113 Offset 2368 OpMemberDecorate %type_View 114 Offset 2380 OpMemberDecorate %type_View 115 Offset 2384 OpMemberDecorate %type_View 116 Offset 2388 OpMemberDecorate %type_View 117 Offset 2392 OpMemberDecorate %type_View 118 Offset 2396 OpMemberDecorate %type_View 119 Offset 2400 OpMemberDecorate %type_View 120 Offset 2404 OpMemberDecorate %type_View 121 Offset 2408 OpMemberDecorate %type_View 122 Offset 2412 OpMemberDecorate %type_View 123 Offset 2416 OpMemberDecorate %type_View 124 Offset 2420 OpMemberDecorate %type_View 125 Offset 2424 OpMemberDecorate %type_View 126 Offset 2428 OpMemberDecorate %type_View 127 Offset 2432 OpMemberDecorate %type_View 128 Offset 2448 OpMemberDecorate %type_View 129 Offset 2460 OpMemberDecorate %type_View 130 Offset 2464 OpMemberDecorate %type_View 131 Offset 2480 OpMemberDecorate %type_View 132 Offset 2484 OpMemberDecorate %type_View 133 Offset 2488 OpMemberDecorate %type_View 134 Offset 2492 OpMemberDecorate %type_View 135 Offset 2496 OpMemberDecorate %type_View 136 Offset 2512 OpMemberDecorate %type_View 137 Offset 2624 OpMemberDecorate %type_View 138 Offset 2628 OpMemberDecorate %type_View 139 Offset 2632 OpMemberDecorate %type_View 140 Offset 2636 OpMemberDecorate %type_View 141 Offset 2640 OpMemberDecorate %type_View 142 Offset 2644 OpMemberDecorate %type_View 143 Offset 2648 OpMemberDecorate %type_View 144 Offset 2652 OpMemberDecorate %type_View 145 Offset 2656 OpMemberDecorate %type_View 146 Offset 2668 OpMemberDecorate %type_View 147 Offset 2672 OpMemberDecorate %type_View 148 Offset 2736 OpMemberDecorate %type_View 149 Offset 2800 OpMemberDecorate %type_View 150 Offset 2804 OpMemberDecorate %type_View 151 Offset 2808 OpMemberDecorate %type_View 152 Offset 2812 OpMemberDecorate %type_View 153 Offset 2816 OpMemberDecorate %type_View 154 Offset 2828 OpMemberDecorate %type_View 155 Offset 2832 OpMemberDecorate %type_View 156 Offset 2844 OpMemberDecorate %type_View 157 Offset 2848 OpMemberDecorate %type_View 158 Offset 2856 OpMemberDecorate %type_View 159 Offset 2860 OpMemberDecorate %type_View 160 Offset 2864 OpMemberDecorate %type_View 161 Offset 2876 OpMemberDecorate %type_View 162 Offset 2880 OpMemberDecorate %type_View 163 Offset 2892 OpMemberDecorate %type_View 164 Offset 2896 OpMemberDecorate %type_View 165 Offset 2908 OpMemberDecorate %type_View 166 Offset 2912 OpMemberDecorate %type_View 167 Offset 2924 OpMemberDecorate %type_View 168 Offset 2928 OpMemberDecorate %type_View 169 Offset 2932 OpDecorate %type_View Block OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %type_StructuredBuffer_v4float 0 Offset 0 OpMemberDecorate %type_StructuredBuffer_v4float 0 NonWritable OpDecorate %type_StructuredBuffer_v4float BufferBlock %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %float_2 = OpConstant %float 2 %62 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %float_0_5 = OpConstant %float 0.5 %int_3 = OpConstant %int 3 %float_0_333000004 = OpConstant %float 0.333000004 %float_1 = OpConstant %float 1 %67 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_15 = OpConstant %float 15 %69 = OpConstantComposite %v4float %float_15 %float_15 %float_15 %float_15 %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %FVertexFactoryInterpolantsVSToPS = OpTypeStruct %v4float %v4float %v4float %_arr_v4float_uint_1 %v4float %uint %uint %FVertexFactoryInterpolantsVSToDS = OpTypeStruct %FVertexFactoryInterpolantsVSToPS %FSharedBasePassInterpolants = OpTypeStruct %FBasePassInterpolantsVSToDS = OpTypeStruct %FSharedBasePassInterpolants %FBasePassVSToDS = OpTypeStruct %FVertexFactoryInterpolantsVSToDS %FBasePassInterpolantsVSToDS %v4float %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %FPNTessellationHSToDS = OpTypeStruct %FBasePassVSToDS %_arr_v4float_uint_3 %v3float %float %float %v3int = OpTypeVector %int 3 %73 = OpConstantComposite %v3int %int_0 %int_0 %int_0 %74 = OpConstantComposite %v3int %int_3 %int_3 %int_3 %float_0 = OpConstant %float 0 %76 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %77 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %int_77 = OpConstant %int 77 %int_6 = OpConstant %int 6 %int_27 = OpConstant %int 27 %81 = OpConstantComposite %v3int %int_1 %int_1 %int_1 %82 = OpConstantComposite %v3int %int_2 %int_2 %int_2 %uint_26 = OpConstant %uint 26 %uint_12 = OpConstant %uint 12 %uint_22 = OpConstant %uint 22 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %_runtimearr_v4float = OpTypeRuntimeArray %v4float %type_StructuredBuffer_v4float = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_type_StructuredBuffer_v4float = OpTypePointer Uniform %type_StructuredBuffer_v4float %_arr_v4float_uint_12 = OpTypeArray %v4float %uint_12 %_ptr_Input__arr_v4float_uint_12 = OpTypePointer Input %_arr_v4float_uint_12 %_arr__arr_v4float_uint_1_uint_12 = OpTypeArray %_arr_v4float_uint_1 %uint_12 %_ptr_Input__arr__arr_v4float_uint_1_uint_12 = OpTypePointer Input %_arr__arr_v4float_uint_1_uint_12 %_arr_uint_uint_12 = OpTypeArray %uint %uint_12 %_ptr_Input__arr_uint_uint_12 = OpTypePointer Input %_arr_uint_uint_12 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output__arr_v4float_uint_3 = OpTypePointer Output %_arr_v4float_uint_3 %_arr__arr_v4float_uint_1_uint_3 = OpTypeArray %_arr_v4float_uint_1 %uint_3 %_ptr_Output__arr__arr_v4float_uint_1_uint_3 = OpTypePointer Output %_arr__arr_v4float_uint_1_uint_3 %_arr_uint_uint_3 = OpTypeArray %uint %uint_3 %_ptr_Output__arr_uint_uint_3 = OpTypePointer Output %_arr_uint_uint_3 %_arr__arr_v4float_uint_3_uint_3 = OpTypeArray %_arr_v4float_uint_3 %uint_3 %_ptr_Output__arr__arr_v4float_uint_3_uint_3 = OpTypePointer Output %_arr__arr_v4float_uint_3_uint_3 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Output__arr_v3float_uint_3 = OpTypePointer Output %_arr_v3float_uint_3 %_ptr_Output__arr_float_uint_3 = OpTypePointer Output %_arr_float_uint_3 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %111 = OpTypeFunction %void %_arr_FBasePassVSToDS_uint_12 = OpTypeArray %FBasePassVSToDS %uint_12 %_ptr_Function__arr_FBasePassVSToDS_uint_12 = OpTypePointer Function %_arr_FBasePassVSToDS_uint_12 %_arr_FPNTessellationHSToDS_uint_3 = OpTypeArray %FPNTessellationHSToDS %uint_3 %_ptr_Workgroup__arr_FPNTessellationHSToDS_uint_3 = OpTypePointer Workgroup %_arr_FPNTessellationHSToDS_uint_3 %_ptr_Output__arr_v4float_uint_1 = OpTypePointer Output %_arr_v4float_uint_1 %_ptr_Output_uint = OpTypePointer Output %uint %_ptr_Output_v3float = OpTypePointer Output %v3float %_ptr_Output_float = OpTypePointer Output %float %_ptr_Workgroup_FPNTessellationHSToDS = OpTypePointer Workgroup %FPNTessellationHSToDS %bool = OpTypeBool %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Workgroup_v4float = OpTypePointer Workgroup %v4float %_ptr_Function_float = OpTypePointer Function %float %_ptr_Workgroup_float = OpTypePointer Workgroup %float %mat3v3float = OpTypeMatrix %v3float 3 %_ptr_Function_FVertexFactoryInterpolantsVSToDS = OpTypePointer Function %FVertexFactoryInterpolantsVSToDS %_ptr_Function_FVertexFactoryInterpolantsVSToPS = OpTypePointer Function %FVertexFactoryInterpolantsVSToPS %_ptr_Function_FBasePassVSToDS = OpTypePointer Function %FBasePassVSToDS %v3bool = OpTypeVector %bool 3 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %View = OpVariable %_ptr_Uniform_type_View Uniform %View_PrimitiveSceneData = OpVariable %_ptr_Uniform_type_StructuredBuffer_v4float Uniform %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_COLOR0 = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_TEXCOORD0 = OpVariable %_ptr_Input__arr__arr_v4float_uint_1_uint_12 Input %in_var_TEXCOORD4 = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_PRIMITIVE_ID = OpVariable %_ptr_Input__arr_uint_uint_12 Input %in_var_LIGHTMAP_ID = OpVariable %_ptr_Input__arr_uint_uint_12 Input %in_var_VS_To_DS_Position = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %gl_InvocationID = OpVariable %_ptr_Input_uint Input %out_var_TEXCOORD10_centroid = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_TEXCOORD11_centroid = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_COLOR0 = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_TEXCOORD0 = OpVariable %_ptr_Output__arr__arr_v4float_uint_1_uint_3 Output %out_var_TEXCOORD4 = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_PRIMITIVE_ID = OpVariable %_ptr_Output__arr_uint_uint_3 Output %out_var_LIGHTMAP_ID = OpVariable %_ptr_Output__arr_uint_uint_3 Output %out_var_VS_To_DS_Position = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_PN_POSITION = OpVariable %_ptr_Output__arr__arr_v4float_uint_3_uint_3 Output %out_var_PN_DisplacementScales = OpVariable %_ptr_Output__arr_v3float_uint_3 Output %out_var_PN_TessellationMultiplier = OpVariable %_ptr_Output__arr_float_uint_3 Output %out_var_PN_WorldDisplacementMultiplier = OpVariable %_ptr_Output__arr_float_uint_3 Output %gl_TessLevelOuter = OpVariable %_ptr_Output__arr_float_uint_4 Output %gl_TessLevelInner = OpVariable %_ptr_Output__arr_float_uint_2 Output %out_var_PN_POSITION9 = OpVariable %_ptr_Output_v4float Output %133 = OpConstantNull %FSharedBasePassInterpolants %134 = OpConstantComposite %FBasePassInterpolantsVSToDS %133 %float_0_333333343 = OpConstant %float 0.333333343 %136 = OpConstantComposite %v4float %float_0_333333343 %float_0_333333343 %float_0_333333343 %float_0_333333343 %137 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 %float_0_166666672 = OpConstant %float 0.166666672 %139 = OpConstantComposite %v4float %float_0_166666672 %float_0_166666672 %float_0_166666672 %float_0_166666672 %140 = OpUndef %v4float ; XXX: Original asm used Function here, which is wrong. ; This patches the SPIR-V to be correct. %temp_var_hullMainRetVal = OpVariable %_ptr_Workgroup__arr_FPNTessellationHSToDS_uint_3 Workgroup %MainHull = OpFunction %void None %111 %141 = OpLabel %param_var_I = OpVariable %_ptr_Function__arr_FBasePassVSToDS_uint_12 Function %142 = OpLoad %_arr_v4float_uint_12 %in_var_TEXCOORD10_centroid %143 = OpLoad %_arr_v4float_uint_12 %in_var_TEXCOORD11_centroid %144 = OpLoad %_arr_v4float_uint_12 %in_var_COLOR0 %145 = OpLoad %_arr__arr_v4float_uint_1_uint_12 %in_var_TEXCOORD0 %146 = OpLoad %_arr_v4float_uint_12 %in_var_TEXCOORD4 %147 = OpLoad %_arr_uint_uint_12 %in_var_PRIMITIVE_ID %148 = OpLoad %_arr_uint_uint_12 %in_var_LIGHTMAP_ID %149 = OpCompositeExtract %v4float %142 0 %150 = OpCompositeExtract %v4float %143 0 %151 = OpCompositeExtract %v4float %144 0 %152 = OpCompositeExtract %_arr_v4float_uint_1 %145 0 %153 = OpCompositeExtract %v4float %146 0 %154 = OpCompositeExtract %uint %147 0 %155 = OpCompositeExtract %uint %148 0 %156 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %149 %150 %151 %152 %153 %154 %155 %157 = OpCompositeExtract %v4float %142 1 %158 = OpCompositeExtract %v4float %143 1 %159 = OpCompositeExtract %v4float %144 1 %160 = OpCompositeExtract %_arr_v4float_uint_1 %145 1 %161 = OpCompositeExtract %v4float %146 1 %162 = OpCompositeExtract %uint %147 1 %163 = OpCompositeExtract %uint %148 1 %164 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %157 %158 %159 %160 %161 %162 %163 %165 = OpCompositeExtract %v4float %142 2 %166 = OpCompositeExtract %v4float %143 2 %167 = OpCompositeExtract %v4float %144 2 %168 = OpCompositeExtract %_arr_v4float_uint_1 %145 2 %169 = OpCompositeExtract %v4float %146 2 %170 = OpCompositeExtract %uint %147 2 %171 = OpCompositeExtract %uint %148 2 %172 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %165 %166 %167 %168 %169 %170 %171 %173 = OpCompositeExtract %v4float %142 3 %174 = OpCompositeExtract %v4float %143 3 %175 = OpCompositeExtract %v4float %144 3 %176 = OpCompositeExtract %_arr_v4float_uint_1 %145 3 %177 = OpCompositeExtract %v4float %146 3 %178 = OpCompositeExtract %uint %147 3 %179 = OpCompositeExtract %uint %148 3 %180 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %173 %174 %175 %176 %177 %178 %179 %181 = OpCompositeExtract %v4float %142 4 %182 = OpCompositeExtract %v4float %143 4 %183 = OpCompositeExtract %v4float %144 4 %184 = OpCompositeExtract %_arr_v4float_uint_1 %145 4 %185 = OpCompositeExtract %v4float %146 4 %186 = OpCompositeExtract %uint %147 4 %187 = OpCompositeExtract %uint %148 4 %188 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %181 %182 %183 %184 %185 %186 %187 %189 = OpCompositeExtract %v4float %142 5 %190 = OpCompositeExtract %v4float %143 5 %191 = OpCompositeExtract %v4float %144 5 %192 = OpCompositeExtract %_arr_v4float_uint_1 %145 5 %193 = OpCompositeExtract %v4float %146 5 %194 = OpCompositeExtract %uint %147 5 %195 = OpCompositeExtract %uint %148 5 %196 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %189 %190 %191 %192 %193 %194 %195 %197 = OpCompositeExtract %v4float %142 6 %198 = OpCompositeExtract %v4float %143 6 %199 = OpCompositeExtract %v4float %144 6 %200 = OpCompositeExtract %_arr_v4float_uint_1 %145 6 %201 = OpCompositeExtract %v4float %146 6 %202 = OpCompositeExtract %uint %147 6 %203 = OpCompositeExtract %uint %148 6 %204 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %197 %198 %199 %200 %201 %202 %203 %205 = OpCompositeExtract %v4float %142 7 %206 = OpCompositeExtract %v4float %143 7 %207 = OpCompositeExtract %v4float %144 7 %208 = OpCompositeExtract %_arr_v4float_uint_1 %145 7 %209 = OpCompositeExtract %v4float %146 7 %210 = OpCompositeExtract %uint %147 7 %211 = OpCompositeExtract %uint %148 7 %212 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %205 %206 %207 %208 %209 %210 %211 %213 = OpCompositeExtract %v4float %142 8 %214 = OpCompositeExtract %v4float %143 8 %215 = OpCompositeExtract %v4float %144 8 %216 = OpCompositeExtract %_arr_v4float_uint_1 %145 8 %217 = OpCompositeExtract %v4float %146 8 %218 = OpCompositeExtract %uint %147 8 %219 = OpCompositeExtract %uint %148 8 %220 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %213 %214 %215 %216 %217 %218 %219 %221 = OpCompositeExtract %v4float %142 9 %222 = OpCompositeExtract %v4float %143 9 %223 = OpCompositeExtract %v4float %144 9 %224 = OpCompositeExtract %_arr_v4float_uint_1 %145 9 %225 = OpCompositeExtract %v4float %146 9 %226 = OpCompositeExtract %uint %147 9 %227 = OpCompositeExtract %uint %148 9 %228 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %221 %222 %223 %224 %225 %226 %227 %229 = OpCompositeExtract %v4float %142 10 %230 = OpCompositeExtract %v4float %143 10 %231 = OpCompositeExtract %v4float %144 10 %232 = OpCompositeExtract %_arr_v4float_uint_1 %145 10 %233 = OpCompositeExtract %v4float %146 10 %234 = OpCompositeExtract %uint %147 10 %235 = OpCompositeExtract %uint %148 10 %236 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %229 %230 %231 %232 %233 %234 %235 %237 = OpCompositeExtract %v4float %142 11 %238 = OpCompositeExtract %v4float %143 11 %239 = OpCompositeExtract %v4float %144 11 %240 = OpCompositeExtract %_arr_v4float_uint_1 %145 11 %241 = OpCompositeExtract %v4float %146 11 %242 = OpCompositeExtract %uint %147 11 %243 = OpCompositeExtract %uint %148 11 %244 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %237 %238 %239 %240 %241 %242 %243 %245 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %156 %246 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %164 %247 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %172 %248 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %180 %249 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %188 %250 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %196 %251 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %204 %252 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %212 %253 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %220 %254 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %228 %255 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %236 %256 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %244 %257 = OpLoad %_arr_v4float_uint_12 %in_var_VS_To_DS_Position %258 = OpCompositeExtract %v4float %257 0 %259 = OpCompositeConstruct %FBasePassVSToDS %245 %134 %258 %260 = OpCompositeExtract %v4float %257 1 %261 = OpCompositeConstruct %FBasePassVSToDS %246 %134 %260 %262 = OpCompositeExtract %v4float %257 2 %263 = OpCompositeConstruct %FBasePassVSToDS %247 %134 %262 %264 = OpCompositeExtract %v4float %257 3 %265 = OpCompositeConstruct %FBasePassVSToDS %248 %134 %264 %266 = OpCompositeExtract %v4float %257 4 %267 = OpCompositeConstruct %FBasePassVSToDS %249 %134 %266 %268 = OpCompositeExtract %v4float %257 5 %269 = OpCompositeConstruct %FBasePassVSToDS %250 %134 %268 %270 = OpCompositeExtract %v4float %257 6 %271 = OpCompositeConstruct %FBasePassVSToDS %251 %134 %270 %272 = OpCompositeExtract %v4float %257 7 %273 = OpCompositeConstruct %FBasePassVSToDS %252 %134 %272 %274 = OpCompositeExtract %v4float %257 8 %275 = OpCompositeConstruct %FBasePassVSToDS %253 %134 %274 %276 = OpCompositeExtract %v4float %257 9 %277 = OpCompositeConstruct %FBasePassVSToDS %254 %134 %276 %278 = OpCompositeExtract %v4float %257 10 %279 = OpCompositeConstruct %FBasePassVSToDS %255 %134 %278 %280 = OpCompositeExtract %v4float %257 11 %281 = OpCompositeConstruct %FBasePassVSToDS %256 %134 %280 %282 = OpCompositeConstruct %_arr_FBasePassVSToDS_uint_12 %259 %261 %263 %265 %267 %269 %271 %273 %275 %277 %279 %281 OpStore %param_var_I %282 %283 = OpLoad %uint %gl_InvocationID %284 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %283 %int_0 %285 = OpLoad %FVertexFactoryInterpolantsVSToDS %284 %286 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %285 0 %287 = OpCompositeExtract %v4float %286 0 %288 = OpCompositeExtract %v4float %286 1 %289 = OpVectorShuffle %v3float %287 %287 0 1 2 %290 = OpVectorShuffle %v3float %288 %288 0 1 2 %291 = OpExtInst %v3float %1 Cross %290 %289 %292 = OpCompositeExtract %float %288 3 %293 = OpCompositeConstruct %v3float %292 %292 %292 %294 = OpFMul %v3float %291 %293 %295 = OpCompositeConstruct %mat3v3float %289 %294 %290 %296 = OpCompositeExtract %float %288 0 %297 = OpCompositeExtract %float %288 1 %298 = OpCompositeExtract %float %288 2 %299 = OpCompositeConstruct %v4float %296 %297 %298 %float_0 %300 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToPS %param_var_I %283 %int_0 %int_0 %301 = OpLoad %FVertexFactoryInterpolantsVSToPS %300 %302 = OpCompositeExtract %uint %301 5 %303 = OpIMul %uint %302 %uint_26 %304 = OpIAdd %uint %303 %uint_22 %305 = OpAccessChain %_ptr_Uniform_v4float %View_PrimitiveSceneData %int_0 %304 %306 = OpLoad %v4float %305 %307 = OpVectorShuffle %v3float %306 %306 0 1 2 %308 = OpVectorTimesMatrix %v3float %307 %295 %309 = OpULessThan %bool %283 %uint_2 %310 = OpIAdd %uint %283 %uint_1 %311 = OpSelect %uint %309 %310 %uint_0 %312 = OpIMul %uint %uint_2 %283 %313 = OpIAdd %uint %uint_3 %312 %314 = OpIAdd %uint %312 %uint_4 %315 = OpAccessChain %_ptr_Function_FBasePassVSToDS %param_var_I %283 %316 = OpLoad %FBasePassVSToDS %315 %317 = OpAccessChain %_ptr_Function_v4float %param_var_I %283 %int_2 %318 = OpLoad %v4float %317 %319 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %311 %int_0 %320 = OpLoad %FVertexFactoryInterpolantsVSToDS %319 %321 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %320 0 %322 = OpCompositeExtract %v4float %321 1 %323 = OpCompositeExtract %float %322 0 %324 = OpCompositeExtract %float %322 1 %325 = OpCompositeExtract %float %322 2 %326 = OpCompositeConstruct %v4float %323 %324 %325 %float_0 %327 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %313 %int_0 %328 = OpLoad %FVertexFactoryInterpolantsVSToDS %327 %329 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %328 0 %330 = OpCompositeExtract %v4float %329 1 %331 = OpCompositeExtract %float %330 0 %332 = OpCompositeExtract %float %330 1 %333 = OpCompositeExtract %float %330 2 %334 = OpCompositeConstruct %v4float %331 %332 %333 %float_0 %335 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %314 %int_0 %336 = OpLoad %FVertexFactoryInterpolantsVSToDS %335 %337 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %336 0 %338 = OpCompositeExtract %v4float %337 1 %339 = OpCompositeExtract %float %338 0 %340 = OpCompositeExtract %float %338 1 %341 = OpCompositeExtract %float %338 2 %342 = OpCompositeConstruct %v4float %339 %340 %341 %float_0 %343 = OpLoad %v4float %317 %344 = OpAccessChain %_ptr_Function_v4float %param_var_I %311 %int_2 %345 = OpLoad %v4float %344 %346 = OpFMul %v4float %62 %343 %347 = OpFAdd %v4float %346 %345 %348 = OpFSub %v4float %345 %343 %349 = OpDot %float %348 %299 %350 = OpCompositeConstruct %v4float %349 %349 %349 %349 %351 = OpFMul %v4float %350 %299 %352 = OpFSub %v4float %347 %351 %353 = OpFMul %v4float %352 %136 %354 = OpAccessChain %_ptr_Function_v4float %param_var_I %313 %int_2 %355 = OpLoad %v4float %354 %356 = OpAccessChain %_ptr_Function_v4float %param_var_I %314 %int_2 %357 = OpLoad %v4float %356 %358 = OpFMul %v4float %62 %355 %359 = OpFAdd %v4float %358 %357 %360 = OpFSub %v4float %357 %355 %361 = OpDot %float %360 %334 %362 = OpCompositeConstruct %v4float %361 %361 %361 %361 %363 = OpFMul %v4float %362 %334 %364 = OpFSub %v4float %359 %363 %365 = OpFMul %v4float %364 %136 %366 = OpFAdd %v4float %353 %365 %367 = OpFMul %v4float %366 %137 %368 = OpLoad %v4float %344 %369 = OpLoad %v4float %317 %370 = OpFMul %v4float %62 %368 %371 = OpFAdd %v4float %370 %369 %372 = OpFSub %v4float %369 %368 %373 = OpDot %float %372 %326 %374 = OpCompositeConstruct %v4float %373 %373 %373 %373 %375 = OpFMul %v4float %374 %326 %376 = OpFSub %v4float %371 %375 %377 = OpFMul %v4float %376 %136 %378 = OpLoad %v4float %356 %379 = OpLoad %v4float %354 %380 = OpFMul %v4float %62 %378 %381 = OpFAdd %v4float %380 %379 %382 = OpFSub %v4float %379 %378 %383 = OpDot %float %382 %342 %384 = OpCompositeConstruct %v4float %383 %383 %383 %383 %385 = OpFMul %v4float %384 %342 %386 = OpFSub %v4float %381 %385 %387 = OpFMul %v4float %386 %136 %388 = OpFAdd %v4float %377 %387 %389 = OpFMul %v4float %388 %137 %390 = OpCompositeConstruct %_arr_v4float_uint_3 %318 %367 %389 %391 = OpCompositeConstruct %FPNTessellationHSToDS %316 %390 %308 %float_1 %float_1 %392 = OpCompositeExtract %FVertexFactoryInterpolantsVSToDS %316 0 %393 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %392 0 %394 = OpCompositeExtract %v4float %393 0 %395 = OpAccessChain %_ptr_Output_v4float %out_var_TEXCOORD10_centroid %283 OpStore %395 %394 %396 = OpCompositeExtract %v4float %393 1 %397 = OpAccessChain %_ptr_Output_v4float %out_var_TEXCOORD11_centroid %283 OpStore %397 %396 %398 = OpCompositeExtract %v4float %393 2 %399 = OpAccessChain %_ptr_Output_v4float %out_var_COLOR0 %283 OpStore %399 %398 %400 = OpCompositeExtract %_arr_v4float_uint_1 %393 3 %401 = OpAccessChain %_ptr_Output__arr_v4float_uint_1 %out_var_TEXCOORD0 %283 OpStore %401 %400 %402 = OpCompositeExtract %v4float %393 4 %403 = OpAccessChain %_ptr_Output_v4float %out_var_TEXCOORD4 %283 OpStore %403 %402 %404 = OpCompositeExtract %uint %393 5 %405 = OpAccessChain %_ptr_Output_uint %out_var_PRIMITIVE_ID %283 OpStore %405 %404 %406 = OpCompositeExtract %uint %393 6 %407 = OpAccessChain %_ptr_Output_uint %out_var_LIGHTMAP_ID %283 OpStore %407 %406 %408 = OpCompositeExtract %v4float %316 2 %409 = OpAccessChain %_ptr_Output_v4float %out_var_VS_To_DS_Position %283 OpStore %409 %408 %410 = OpAccessChain %_ptr_Output__arr_v4float_uint_3 %out_var_PN_POSITION %283 OpStore %410 %390 %411 = OpAccessChain %_ptr_Output_v3float %out_var_PN_DisplacementScales %283 OpStore %411 %308 %412 = OpAccessChain %_ptr_Output_float %out_var_PN_TessellationMultiplier %283 OpStore %412 %float_1 %413 = OpAccessChain %_ptr_Output_float %out_var_PN_WorldDisplacementMultiplier %283 OpStore %413 %float_1 %414 = OpAccessChain %_ptr_Workgroup_FPNTessellationHSToDS %temp_var_hullMainRetVal %283 OpStore %414 %391 OpControlBarrier %uint_2 %uint_4 %uint_0 %415 = OpIEqual %bool %283 %uint_0 OpSelectionMerge %if_merge None OpBranchConditional %415 %416 %if_merge %416 = OpLabel %417 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_0 %418 = OpLoad %mat4v4float %417 %419 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_6 %420 = OpLoad %mat4v4float %419 %421 = OpAccessChain %_ptr_Uniform_v3float %View %int_27 %422 = OpLoad %v3float %421 %423 = OpAccessChain %_ptr_Uniform_float %View %int_77 %424 = OpLoad %float %423 %425 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_0 %int_1 %int_0 %426 = OpLoad %v4float %425 %427 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_0 %int_1 %int_1 %428 = OpLoad %v4float %427 %429 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_0 %int_1 %int_2 %430 = OpLoad %v4float %429 %431 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_1 %int_1 %int_0 %432 = OpLoad %v4float %431 %433 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_1 %int_1 %int_1 %434 = OpLoad %v4float %433 %435 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_1 %int_1 %int_2 %436 = OpLoad %v4float %435 %437 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_2 %int_1 %int_0 %438 = OpLoad %v4float %437 %439 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_2 %int_1 %int_1 %440 = OpLoad %v4float %439 %441 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_2 %int_1 %int_2 %442 = OpLoad %v4float %441 %443 = OpFAdd %v4float %428 %430 %444 = OpFAdd %v4float %443 %434 %445 = OpFAdd %v4float %444 %436 %446 = OpFAdd %v4float %445 %440 %447 = OpFAdd %v4float %446 %442 %448 = OpFMul %v4float %447 %139 %449 = OpFAdd %v4float %438 %432 %450 = OpFAdd %v4float %449 %426 %451 = OpFMul %v4float %450 %136 %452 = OpFSub %v4float %448 %451 %453 = OpFMul %v4float %452 %137 %454 = OpFAdd %v4float %448 %453 %455 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_1 %int_3 %456 = OpLoad %float %455 %457 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_2 %int_3 %458 = OpLoad %float %457 %459 = OpFAdd %float %456 %458 %460 = OpFMul %float %float_0_5 %459 %461 = OpCompositeInsert %v4float %460 %140 0 %462 = OpLoad %float %457 %463 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_0 %int_3 %464 = OpLoad %float %463 %465 = OpFAdd %float %462 %464 %466 = OpFMul %float %float_0_5 %465 %467 = OpCompositeInsert %v4float %466 %461 1 %468 = OpLoad %float %463 %469 = OpLoad %float %455 %470 = OpFAdd %float %468 %469 %471 = OpFMul %float %float_0_5 %470 %472 = OpCompositeInsert %v4float %471 %467 2 %473 = OpLoad %float %463 %474 = OpLoad %float %455 %475 = OpFAdd %float %473 %474 %476 = OpLoad %float %457 %477 = OpFAdd %float %475 %476 %478 = OpFMul %float %float_0_333000004 %477 %479 = OpCompositeInsert %v4float %478 %472 3 %480 = OpVectorShuffle %v3float %426 %426 0 1 2 %481 = OpVectorShuffle %v3float %432 %432 0 1 2 %482 = OpVectorShuffle %v3float %438 %438 0 1 2 OpBranch %483 %483 = OpLabel OpLoopMerge %484 %485 None OpBranch %486 %486 = OpLabel %487 = OpMatrixTimesVector %v4float %420 %76 %488 = OpCompositeExtract %float %426 0 %489 = OpCompositeExtract %float %426 1 %490 = OpCompositeExtract %float %426 2 %491 = OpCompositeConstruct %v4float %488 %489 %490 %float_1 %492 = OpMatrixTimesVector %v4float %418 %491 %493 = OpVectorShuffle %v3float %492 %492 0 1 2 %494 = OpVectorShuffle %v3float %487 %487 0 1 2 %495 = OpFSub %v3float %493 %494 %496 = OpCompositeExtract %float %492 3 %497 = OpCompositeExtract %float %487 3 %498 = OpFAdd %float %496 %497 %499 = OpCompositeConstruct %v3float %498 %498 %498 %500 = OpFOrdLessThan %v3bool %495 %499 %501 = OpSelect %v3int %500 %81 %73 %502 = OpFAdd %v3float %493 %494 %503 = OpFNegate %float %496 %504 = OpFSub %float %503 %497 %505 = OpCompositeConstruct %v3float %504 %504 %504 %506 = OpFOrdGreaterThan %v3bool %502 %505 %507 = OpSelect %v3int %506 %81 %73 %508 = OpIMul %v3int %82 %507 %509 = OpIAdd %v3int %501 %508 %510 = OpCompositeExtract %float %432 0 %511 = OpCompositeExtract %float %432 1 %512 = OpCompositeExtract %float %432 2 %513 = OpCompositeConstruct %v4float %510 %511 %512 %float_1 %514 = OpMatrixTimesVector %v4float %418 %513 %515 = OpVectorShuffle %v3float %514 %514 0 1 2 %516 = OpFSub %v3float %515 %494 %517 = OpCompositeExtract %float %514 3 %518 = OpFAdd %float %517 %497 %519 = OpCompositeConstruct %v3float %518 %518 %518 %520 = OpFOrdLessThan %v3bool %516 %519 %521 = OpSelect %v3int %520 %81 %73 %522 = OpFAdd %v3float %515 %494 %523 = OpFNegate %float %517 %524 = OpFSub %float %523 %497 %525 = OpCompositeConstruct %v3float %524 %524 %524 %526 = OpFOrdGreaterThan %v3bool %522 %525 %527 = OpSelect %v3int %526 %81 %73 %528 = OpIMul %v3int %82 %527 %529 = OpIAdd %v3int %521 %528 %530 = OpBitwiseOr %v3int %509 %529 %531 = OpCompositeExtract %float %438 0 %532 = OpCompositeExtract %float %438 1 %533 = OpCompositeExtract %float %438 2 %534 = OpCompositeConstruct %v4float %531 %532 %533 %float_1 %535 = OpMatrixTimesVector %v4float %418 %534 %536 = OpVectorShuffle %v3float %535 %535 0 1 2 %537 = OpFSub %v3float %536 %494 %538 = OpCompositeExtract %float %535 3 %539 = OpFAdd %float %538 %497 %540 = OpCompositeConstruct %v3float %539 %539 %539 %541 = OpFOrdLessThan %v3bool %537 %540 %542 = OpSelect %v3int %541 %81 %73 %543 = OpFAdd %v3float %536 %494 %544 = OpFNegate %float %538 %545 = OpFSub %float %544 %497 %546 = OpCompositeConstruct %v3float %545 %545 %545 %547 = OpFOrdGreaterThan %v3bool %543 %546 %548 = OpSelect %v3int %547 %81 %73 %549 = OpIMul %v3int %82 %548 %550 = OpIAdd %v3int %542 %549 %551 = OpBitwiseOr %v3int %530 %550 %552 = OpINotEqual %v3bool %551 %74 %553 = OpAny %bool %552 OpSelectionMerge %554 None OpBranchConditional %553 %555 %554 %555 = OpLabel OpBranch %484 %554 = OpLabel %556 = OpFSub %v3float %480 %481 %557 = OpFSub %v3float %481 %482 %558 = OpFSub %v3float %482 %480 %559 = OpFAdd %v3float %480 %481 %560 = OpFMul %v3float %77 %559 %561 = OpFSub %v3float %560 %422 %562 = OpFAdd %v3float %481 %482 %563 = OpFMul %v3float %77 %562 %564 = OpFSub %v3float %563 %422 %565 = OpFAdd %v3float %482 %480 %566 = OpFMul %v3float %77 %565 %567 = OpFSub %v3float %566 %422 %568 = OpDot %float %557 %557 %569 = OpDot %float %564 %564 %570 = OpFDiv %float %568 %569 %571 = OpExtInst %float %1 Sqrt %570 %572 = OpDot %float %558 %558 %573 = OpDot %float %567 %567 %574 = OpFDiv %float %572 %573 %575 = OpExtInst %float %1 Sqrt %574 %576 = OpDot %float %556 %556 %577 = OpDot %float %561 %561 %578 = OpFDiv %float %576 %577 %579 = OpExtInst %float %1 Sqrt %578 %580 = OpCompositeConstruct %v4float %571 %575 %579 %float_1 %581 = OpFAdd %float %571 %575 %582 = OpFAdd %float %581 %579 %583 = OpFMul %float %float_0_333000004 %582 %584 = OpCompositeInsert %v4float %583 %580 3 %585 = OpCompositeConstruct %v4float %424 %424 %424 %424 %586 = OpFMul %v4float %585 %584 OpBranch %484 %485 = OpLabel OpBranch %483 %484 = OpLabel %587 = OpPhi %v4float %76 %555 %586 %554 %588 = OpFMul %v4float %479 %587 %589 = OpExtInst %v4float %1 FClamp %588 %67 %69 %590 = OpCompositeExtract %float %589 0 %591 = OpCompositeExtract %float %589 1 %592 = OpCompositeExtract %float %589 2 %593 = OpCompositeExtract %float %589 3 %594 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_0 OpStore %594 %590 %595 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_1 OpStore %595 %591 %596 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_2 OpStore %596 %592 %597 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %uint_0 OpStore %597 %593 OpStore %out_var_PN_POSITION9 %454 OpBranch %if_merge %if_merge = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/tesc/hs-input-array-access.asm.tesc000066400000000000000000002301731400026215700260230ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 607 ; Schema: 0 OpCapability Tessellation OpCapability SampledBuffer OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %MainHull "main" %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_VS_To_DS_Position %in_var_VS_To_DS_VertexID %gl_InvocationID %out_var_TEXCOORD10_centroid %out_var_TEXCOORD11_centroid %out_var_VS_To_DS_Position %out_var_VS_To_DS_VertexID %out_var_PN_POSITION %out_var_PN_DisplacementScales %out_var_PN_TessellationMultiplier %out_var_PN_WorldDisplacementMultiplier %out_var_PN_DominantVertex %out_var_PN_DominantVertex1 %out_var_PN_DominantVertex2 %out_var_PN_DominantEdge %out_var_PN_DominantEdge1 %out_var_PN_DominantEdge2 %out_var_PN_DominantEdge3 %out_var_PN_DominantEdge4 %out_var_PN_DominantEdge5 %gl_TessLevelOuter %gl_TessLevelInner %out_var_PN_POSITION9 OpExecutionMode %MainHull Triangles OpExecutionMode %MainHull SpacingFractionalOdd OpExecutionMode %MainHull VertexOrderCw OpExecutionMode %MainHull OutputVertices 3 OpSource HLSL 600 OpName %FPNTessellationHSToDS "FPNTessellationHSToDS" OpMemberName %FPNTessellationHSToDS 0 "PassSpecificData" OpMemberName %FPNTessellationHSToDS 1 "WorldPosition" OpMemberName %FPNTessellationHSToDS 2 "DisplacementScale" OpMemberName %FPNTessellationHSToDS 3 "TessellationMultiplier" OpMemberName %FPNTessellationHSToDS 4 "WorldDisplacementMultiplier" OpMemberName %FPNTessellationHSToDS 5 "DominantVertex" OpMemberName %FPNTessellationHSToDS 6 "DominantEdge" OpName %FHitProxyVSToDS "FHitProxyVSToDS" OpMemberName %FHitProxyVSToDS 0 "FactoryInterpolants" OpMemberName %FHitProxyVSToDS 1 "Position" OpMemberName %FHitProxyVSToDS 2 "VertexID" OpName %FVertexFactoryInterpolantsVSToDS "FVertexFactoryInterpolantsVSToDS" OpMemberName %FVertexFactoryInterpolantsVSToDS 0 "InterpolantsVSToPS" OpName %FVertexFactoryInterpolantsVSToPS "FVertexFactoryInterpolantsVSToPS" OpMemberName %FVertexFactoryInterpolantsVSToPS 0 "TangentToWorld0" OpMemberName %FVertexFactoryInterpolantsVSToPS 1 "TangentToWorld2" OpName %FHullShaderConstantDominantVertexData "FHullShaderConstantDominantVertexData" OpMemberName %FHullShaderConstantDominantVertexData 0 "UV" OpMemberName %FHullShaderConstantDominantVertexData 1 "Normal" OpMemberName %FHullShaderConstantDominantVertexData 2 "Tangent" OpName %FHullShaderConstantDominantEdgeData "FHullShaderConstantDominantEdgeData" OpMemberName %FHullShaderConstantDominantEdgeData 0 "UV0" OpMemberName %FHullShaderConstantDominantEdgeData 1 "UV1" OpMemberName %FHullShaderConstantDominantEdgeData 2 "Normal0" OpMemberName %FHullShaderConstantDominantEdgeData 3 "Normal1" OpMemberName %FHullShaderConstantDominantEdgeData 4 "Tangent0" OpMemberName %FHullShaderConstantDominantEdgeData 5 "Tangent1" OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_ClipToWorld" OpMemberName %type_View 3 "View_TranslatedWorldToView" OpMemberName %type_View 4 "View_ViewToTranslatedWorld" OpMemberName %type_View 5 "View_TranslatedWorldToCameraView" OpMemberName %type_View 6 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 7 "View_ViewToClip" OpMemberName %type_View 8 "View_ViewToClipNoAA" OpMemberName %type_View 9 "View_ClipToView" OpMemberName %type_View 10 "View_ClipToTranslatedWorld" OpMemberName %type_View 11 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 12 "View_ScreenToWorld" OpMemberName %type_View 13 "View_ScreenToTranslatedWorld" OpMemberName %type_View 14 "View_ViewForward" OpMemberName %type_View 15 "PrePadding_View_908" OpMemberName %type_View 16 "View_ViewUp" OpMemberName %type_View 17 "PrePadding_View_924" OpMemberName %type_View 18 "View_ViewRight" OpMemberName %type_View 19 "PrePadding_View_940" OpMemberName %type_View 20 "View_HMDViewNoRollUp" OpMemberName %type_View 21 "PrePadding_View_956" OpMemberName %type_View 22 "View_HMDViewNoRollRight" OpMemberName %type_View 23 "PrePadding_View_972" OpMemberName %type_View 24 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 25 "View_ScreenPositionScaleBias" OpMemberName %type_View 26 "View_WorldCameraOrigin" OpMemberName %type_View 27 "PrePadding_View_1020" OpMemberName %type_View 28 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 29 "PrePadding_View_1036" OpMemberName %type_View 30 "View_WorldViewOrigin" OpMemberName %type_View 31 "PrePadding_View_1052" OpMemberName %type_View 32 "View_PreViewTranslation" OpMemberName %type_View 33 "PrePadding_View_1068" OpMemberName %type_View 34 "View_PrevProjection" OpMemberName %type_View 35 "View_PrevViewProj" OpMemberName %type_View 36 "View_PrevViewRotationProj" OpMemberName %type_View 37 "View_PrevViewToClip" OpMemberName %type_View 38 "View_PrevClipToView" OpMemberName %type_View 39 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 40 "View_PrevTranslatedWorldToView" OpMemberName %type_View 41 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 42 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 43 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 44 "View_PrevWorldCameraOrigin" OpMemberName %type_View 45 "PrePadding_View_1724" OpMemberName %type_View 46 "View_PrevWorldViewOrigin" OpMemberName %type_View 47 "PrePadding_View_1740" OpMemberName %type_View 48 "View_PrevPreViewTranslation" OpMemberName %type_View 49 "PrePadding_View_1756" OpMemberName %type_View 50 "View_PrevInvViewProj" OpMemberName %type_View 51 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 52 "View_ClipToPrevClip" OpMemberName %type_View 53 "View_TemporalAAJitter" OpMemberName %type_View 54 "View_GlobalClippingPlane" OpMemberName %type_View 55 "View_FieldOfViewWideAngles" OpMemberName %type_View 56 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 57 "View_ViewRectMin" OpMemberName %type_View 58 "View_ViewSizeAndInvSize" OpMemberName %type_View 59 "View_BufferSizeAndInvSize" OpMemberName %type_View 60 "View_BufferBilinearUVMinMax" OpMemberName %type_View 61 "View_NumSceneColorMSAASamples" OpMemberName %type_View 62 "View_PreExposure" OpMemberName %type_View 63 "View_OneOverPreExposure" OpMemberName %type_View 64 "PrePadding_View_2076" OpMemberName %type_View 65 "View_DiffuseOverrideParameter" OpMemberName %type_View 66 "View_SpecularOverrideParameter" OpMemberName %type_View 67 "View_NormalOverrideParameter" OpMemberName %type_View 68 "View_RoughnessOverrideParameter" OpMemberName %type_View 69 "View_PrevFrameGameTime" OpMemberName %type_View 70 "View_PrevFrameRealTime" OpMemberName %type_View 71 "View_OutOfBoundsMask" OpMemberName %type_View 72 "PrePadding_View_2148" OpMemberName %type_View 73 "PrePadding_View_2152" OpMemberName %type_View 74 "PrePadding_View_2156" OpMemberName %type_View 75 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 76 "View_CullingSign" OpMemberName %type_View 77 "View_NearPlane" OpMemberName %type_View 78 "View_AdaptiveTessellationFactor" OpMemberName %type_View 79 "View_GameTime" OpMemberName %type_View 80 "View_RealTime" OpMemberName %type_View 81 "View_DeltaTime" OpMemberName %type_View 82 "View_MaterialTextureMipBias" OpMemberName %type_View 83 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 84 "View_Random" OpMemberName %type_View 85 "View_FrameNumber" OpMemberName %type_View 86 "View_StateFrameIndexMod8" OpMemberName %type_View 87 "View_StateFrameIndex" OpMemberName %type_View 88 "View_CameraCut" OpMemberName %type_View 89 "View_UnlitViewmodeMask" OpMemberName %type_View 90 "PrePadding_View_2228" OpMemberName %type_View 91 "PrePadding_View_2232" OpMemberName %type_View 92 "PrePadding_View_2236" OpMemberName %type_View 93 "View_DirectionalLightColor" OpMemberName %type_View 94 "View_DirectionalLightDirection" OpMemberName %type_View 95 "PrePadding_View_2268" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 97 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 98 "View_TemporalAAParams" OpMemberName %type_View 99 "View_CircleDOFParams" OpMemberName %type_View 100 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 101 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 102 "View_DepthOfFieldScale" OpMemberName %type_View 103 "View_DepthOfFieldFocalLength" OpMemberName %type_View 104 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 105 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 106 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 107 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 108 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 109 "View_GeneralPurposeTweak" OpMemberName %type_View 110 "View_DemosaicVposOffset" OpMemberName %type_View 111 "PrePadding_View_2412" OpMemberName %type_View 112 "View_IndirectLightingColorScale" OpMemberName %type_View 113 "View_HDR32bppEncodingMode" OpMemberName %type_View 114 "View_AtmosphericFogSunDirection" OpMemberName %type_View 115 "View_AtmosphericFogSunPower" OpMemberName %type_View 116 "View_AtmosphericFogPower" OpMemberName %type_View 117 "View_AtmosphericFogDensityScale" OpMemberName %type_View 118 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 119 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 120 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 121 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 122 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 123 "View_AtmosphericFogStartDistance" OpMemberName %type_View 124 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 125 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 126 "View_AtmosphericFogSunDiscHalfApexAngleRadian" OpMemberName %type_View 127 "PrePadding_View_2492" OpMemberName %type_View 128 "View_AtmosphericFogSunDiscLuminance" OpMemberName %type_View 129 "View_AtmosphericFogRenderMask" OpMemberName %type_View 130 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 131 "PrePadding_View_2520" OpMemberName %type_View 132 "PrePadding_View_2524" OpMemberName %type_View 133 "View_AtmosphericFogSunColor" OpMemberName %type_View 134 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 135 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 136 "View_AmbientCubemapTint" OpMemberName %type_View 137 "View_AmbientCubemapIntensity" OpMemberName %type_View 138 "View_SkyLightParameters" OpMemberName %type_View 139 "PrePadding_View_2584" OpMemberName %type_View 140 "PrePadding_View_2588" OpMemberName %type_View 141 "View_SkyLightColor" OpMemberName %type_View 142 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 143 "View_MobilePreviewMode" OpMemberName %type_View 144 "View_HMDEyePaddingOffset" OpMemberName %type_View 145 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 146 "View_ShowDecalsMask" OpMemberName %type_View 147 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 148 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 149 "PrePadding_View_2744" OpMemberName %type_View 150 "PrePadding_View_2748" OpMemberName %type_View 151 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 152 "View_StereoPassIndex" OpMemberName %type_View 153 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 154 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 155 "View_GlobalVolumeDimension" OpMemberName %type_View 156 "View_GlobalVolumeTexelSize" OpMemberName %type_View 157 "View_MaxGlobalDistance" OpMemberName %type_View 158 "PrePadding_View_2908" OpMemberName %type_View 159 "View_CursorPosition" OpMemberName %type_View 160 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 161 "PrePadding_View_2924" OpMemberName %type_View 162 "View_VolumetricFogInvGridSize" OpMemberName %type_View 163 "PrePadding_View_2940" OpMemberName %type_View 164 "View_VolumetricFogGridZParams" OpMemberName %type_View 165 "PrePadding_View_2956" OpMemberName %type_View 166 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 167 "View_VolumetricFogMaxDistance" OpMemberName %type_View 168 "PrePadding_View_2972" OpMemberName %type_View 169 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 170 "PrePadding_View_2988" OpMemberName %type_View 171 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 172 "PrePadding_View_3004" OpMemberName %type_View 173 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 174 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 175 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 176 "View_StereoIPD" OpMemberName %type_View 177 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 178 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_Primitive "type.Primitive" OpMemberName %type_Primitive 0 "Primitive_LocalToWorld" OpMemberName %type_Primitive 1 "Primitive_InvNonUniformScaleAndDeterminantSign" OpMemberName %type_Primitive 2 "Primitive_ObjectWorldPositionAndRadius" OpMemberName %type_Primitive 3 "Primitive_WorldToLocal" OpMemberName %type_Primitive 4 "Primitive_PreviousLocalToWorld" OpMemberName %type_Primitive 5 "Primitive_PreviousWorldToLocal" OpMemberName %type_Primitive 6 "Primitive_ActorWorldPosition" OpMemberName %type_Primitive 7 "Primitive_UseSingleSampleShadowFromStationaryLights" OpMemberName %type_Primitive 8 "Primitive_ObjectBounds" OpMemberName %type_Primitive 9 "Primitive_LpvBiasMultiplier" OpMemberName %type_Primitive 10 "Primitive_DecalReceiverMask" OpMemberName %type_Primitive 11 "Primitive_PerObjectGBufferData" OpMemberName %type_Primitive 12 "Primitive_UseVolumetricLightmapShadowFromStationaryLights" OpMemberName %type_Primitive 13 "Primitive_DrawsVelocity" OpMemberName %type_Primitive 14 "Primitive_ObjectOrientation" OpMemberName %type_Primitive 15 "Primitive_NonUniformScale" OpMemberName %type_Primitive 16 "Primitive_LocalObjectBoundsMin" OpMemberName %type_Primitive 17 "Primitive_LightingChannelMask" OpMemberName %type_Primitive 18 "Primitive_LocalObjectBoundsMax" OpMemberName %type_Primitive 19 "Primitive_LightmapDataIndex" OpMemberName %type_Primitive 20 "Primitive_PreSkinnedLocalBounds" OpMemberName %type_Primitive 21 "Primitive_SingleCaptureIndex" OpMemberName %type_Primitive 22 "Primitive_OutputVelocity" OpMemberName %type_Primitive 23 "PrePadding_Primitive_420" OpMemberName %type_Primitive 24 "PrePadding_Primitive_424" OpMemberName %type_Primitive 25 "PrePadding_Primitive_428" OpMemberName %type_Primitive 26 "Primitive_CustomPrimitiveData" OpName %Primitive "Primitive" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_VS_To_DS_Position "in.var.VS_To_DS_Position" OpName %in_var_VS_To_DS_VertexID "in.var.VS_To_DS_VertexID" OpName %out_var_TEXCOORD10_centroid "out.var.TEXCOORD10_centroid" OpName %out_var_TEXCOORD11_centroid "out.var.TEXCOORD11_centroid" OpName %out_var_VS_To_DS_Position "out.var.VS_To_DS_Position" OpName %out_var_VS_To_DS_VertexID "out.var.VS_To_DS_VertexID" OpName %out_var_PN_POSITION "out.var.PN_POSITION" OpName %out_var_PN_DisplacementScales "out.var.PN_DisplacementScales" OpName %out_var_PN_TessellationMultiplier "out.var.PN_TessellationMultiplier" OpName %out_var_PN_WorldDisplacementMultiplier "out.var.PN_WorldDisplacementMultiplier" OpName %out_var_PN_DominantVertex "out.var.PN_DominantVertex" OpName %out_var_PN_DominantVertex1 "out.var.PN_DominantVertex1" OpName %out_var_PN_DominantVertex2 "out.var.PN_DominantVertex2" OpName %out_var_PN_DominantEdge "out.var.PN_DominantEdge" OpName %out_var_PN_DominantEdge1 "out.var.PN_DominantEdge1" OpName %out_var_PN_DominantEdge2 "out.var.PN_DominantEdge2" OpName %out_var_PN_DominantEdge3 "out.var.PN_DominantEdge3" OpName %out_var_PN_DominantEdge4 "out.var.PN_DominantEdge4" OpName %out_var_PN_DominantEdge5 "out.var.PN_DominantEdge5" OpName %out_var_PN_POSITION9 "out.var.PN_POSITION9" OpName %MainHull "MainHull" OpName %param_var_I "param.var.I" OpName %temp_var_hullMainRetVal "temp.var.hullMainRetVal" OpName %if_merge "if.merge" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorateString %in_var_VS_To_DS_VertexID UserSemantic "VS_To_DS_VertexID" OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorateString %gl_InvocationID UserSemantic "SV_OutputControlPointID" OpDecorateString %out_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %out_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %out_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorateString %out_var_VS_To_DS_VertexID UserSemantic "VS_To_DS_VertexID" OpDecorateString %out_var_PN_POSITION UserSemantic "PN_POSITION" OpDecorateString %out_var_PN_DisplacementScales UserSemantic "PN_DisplacementScales" OpDecorateString %out_var_PN_TessellationMultiplier UserSemantic "PN_TessellationMultiplier" OpDecorateString %out_var_PN_WorldDisplacementMultiplier UserSemantic "PN_WorldDisplacementMultiplier" OpDecorateString %out_var_PN_DominantVertex UserSemantic "PN_DominantVertex" OpDecorateString %out_var_PN_DominantVertex1 UserSemantic "PN_DominantVertex" OpDecorateString %out_var_PN_DominantVertex2 UserSemantic "PN_DominantVertex" OpDecorateString %out_var_PN_DominantEdge UserSemantic "PN_DominantEdge" OpDecorateString %out_var_PN_DominantEdge1 UserSemantic "PN_DominantEdge" OpDecorateString %out_var_PN_DominantEdge2 UserSemantic "PN_DominantEdge" OpDecorateString %out_var_PN_DominantEdge3 UserSemantic "PN_DominantEdge" OpDecorateString %out_var_PN_DominantEdge4 UserSemantic "PN_DominantEdge" OpDecorateString %out_var_PN_DominantEdge5 UserSemantic "PN_DominantEdge" OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter OpDecorateString %gl_TessLevelOuter UserSemantic "SV_TessFactor" OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorateString %gl_TessLevelInner UserSemantic "SV_InsideTessFactor" OpDecorate %gl_TessLevelInner Patch OpDecorateString %out_var_PN_POSITION9 UserSemantic "PN_POSITION9" OpDecorate %out_var_PN_POSITION9 Patch OpDecorate %in_var_TEXCOORD10_centroid Location 0 OpDecorate %in_var_TEXCOORD11_centroid Location 1 OpDecorate %in_var_VS_To_DS_Position Location 2 OpDecorate %in_var_VS_To_DS_VertexID Location 3 OpDecorate %out_var_PN_DisplacementScales Location 0 OpDecorate %out_var_PN_DominantEdge Location 1 OpDecorate %out_var_PN_DominantEdge1 Location 2 OpDecorate %out_var_PN_DominantEdge2 Location 3 OpDecorate %out_var_PN_DominantEdge3 Location 4 OpDecorate %out_var_PN_DominantEdge4 Location 5 OpDecorate %out_var_PN_DominantEdge5 Location 6 OpDecorate %out_var_PN_DominantVertex Location 7 OpDecorate %out_var_PN_DominantVertex1 Location 8 OpDecorate %out_var_PN_DominantVertex2 Location 9 OpDecorate %out_var_PN_POSITION Location 10 OpDecorate %out_var_PN_POSITION9 Location 13 OpDecorate %out_var_PN_TessellationMultiplier Location 14 OpDecorate %out_var_PN_WorldDisplacementMultiplier Location 15 OpDecorate %out_var_TEXCOORD10_centroid Location 16 OpDecorate %out_var_TEXCOORD11_centroid Location 17 OpDecorate %out_var_VS_To_DS_Position Location 18 OpDecorate %out_var_VS_To_DS_VertexID Location 19 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %Primitive DescriptorSet 0 OpDecorate %Primitive Binding 1 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 13 MatrixStride 16 OpMemberDecorate %type_View 13 ColMajor OpMemberDecorate %type_View 14 Offset 896 OpMemberDecorate %type_View 15 Offset 908 OpMemberDecorate %type_View 16 Offset 912 OpMemberDecorate %type_View 17 Offset 924 OpMemberDecorate %type_View 18 Offset 928 OpMemberDecorate %type_View 19 Offset 940 OpMemberDecorate %type_View 20 Offset 944 OpMemberDecorate %type_View 21 Offset 956 OpMemberDecorate %type_View 22 Offset 960 OpMemberDecorate %type_View 23 Offset 972 OpMemberDecorate %type_View 24 Offset 976 OpMemberDecorate %type_View 25 Offset 992 OpMemberDecorate %type_View 26 Offset 1008 OpMemberDecorate %type_View 27 Offset 1020 OpMemberDecorate %type_View 28 Offset 1024 OpMemberDecorate %type_View 29 Offset 1036 OpMemberDecorate %type_View 30 Offset 1040 OpMemberDecorate %type_View 31 Offset 1052 OpMemberDecorate %type_View 32 Offset 1056 OpMemberDecorate %type_View 33 Offset 1068 OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 43 MatrixStride 16 OpMemberDecorate %type_View 43 ColMajor OpMemberDecorate %type_View 44 Offset 1712 OpMemberDecorate %type_View 45 Offset 1724 OpMemberDecorate %type_View 46 Offset 1728 OpMemberDecorate %type_View 47 Offset 1740 OpMemberDecorate %type_View 48 Offset 1744 OpMemberDecorate %type_View 49 Offset 1756 OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 52 MatrixStride 16 OpMemberDecorate %type_View 52 ColMajor OpMemberDecorate %type_View 53 Offset 1952 OpMemberDecorate %type_View 54 Offset 1968 OpMemberDecorate %type_View 55 Offset 1984 OpMemberDecorate %type_View 56 Offset 1992 OpMemberDecorate %type_View 57 Offset 2000 OpMemberDecorate %type_View 58 Offset 2016 OpMemberDecorate %type_View 59 Offset 2032 OpMemberDecorate %type_View 60 Offset 2048 OpMemberDecorate %type_View 61 Offset 2064 OpMemberDecorate %type_View 62 Offset 2068 OpMemberDecorate %type_View 63 Offset 2072 OpMemberDecorate %type_View 64 Offset 2076 OpMemberDecorate %type_View 65 Offset 2080 OpMemberDecorate %type_View 66 Offset 2096 OpMemberDecorate %type_View 67 Offset 2112 OpMemberDecorate %type_View 68 Offset 2128 OpMemberDecorate %type_View 69 Offset 2136 OpMemberDecorate %type_View 70 Offset 2140 OpMemberDecorate %type_View 71 Offset 2144 OpMemberDecorate %type_View 72 Offset 2148 OpMemberDecorate %type_View 73 Offset 2152 OpMemberDecorate %type_View 74 Offset 2156 OpMemberDecorate %type_View 75 Offset 2160 OpMemberDecorate %type_View 76 Offset 2172 OpMemberDecorate %type_View 77 Offset 2176 OpMemberDecorate %type_View 78 Offset 2180 OpMemberDecorate %type_View 79 Offset 2184 OpMemberDecorate %type_View 80 Offset 2188 OpMemberDecorate %type_View 81 Offset 2192 OpMemberDecorate %type_View 82 Offset 2196 OpMemberDecorate %type_View 83 Offset 2200 OpMemberDecorate %type_View 84 Offset 2204 OpMemberDecorate %type_View 85 Offset 2208 OpMemberDecorate %type_View 86 Offset 2212 OpMemberDecorate %type_View 87 Offset 2216 OpMemberDecorate %type_View 88 Offset 2220 OpMemberDecorate %type_View 89 Offset 2224 OpMemberDecorate %type_View 90 Offset 2228 OpMemberDecorate %type_View 91 Offset 2232 OpMemberDecorate %type_View 92 Offset 2236 OpMemberDecorate %type_View 93 Offset 2240 OpMemberDecorate %type_View 94 Offset 2256 OpMemberDecorate %type_View 95 Offset 2268 OpMemberDecorate %type_View 96 Offset 2272 OpMemberDecorate %type_View 97 Offset 2304 OpMemberDecorate %type_View 98 Offset 2336 OpMemberDecorate %type_View 99 Offset 2352 OpMemberDecorate %type_View 100 Offset 2368 OpMemberDecorate %type_View 101 Offset 2372 OpMemberDecorate %type_View 102 Offset 2376 OpMemberDecorate %type_View 103 Offset 2380 OpMemberDecorate %type_View 104 Offset 2384 OpMemberDecorate %type_View 105 Offset 2388 OpMemberDecorate %type_View 106 Offset 2392 OpMemberDecorate %type_View 107 Offset 2396 OpMemberDecorate %type_View 108 Offset 2400 OpMemberDecorate %type_View 109 Offset 2404 OpMemberDecorate %type_View 110 Offset 2408 OpMemberDecorate %type_View 111 Offset 2412 OpMemberDecorate %type_View 112 Offset 2416 OpMemberDecorate %type_View 113 Offset 2428 OpMemberDecorate %type_View 114 Offset 2432 OpMemberDecorate %type_View 115 Offset 2444 OpMemberDecorate %type_View 116 Offset 2448 OpMemberDecorate %type_View 117 Offset 2452 OpMemberDecorate %type_View 118 Offset 2456 OpMemberDecorate %type_View 119 Offset 2460 OpMemberDecorate %type_View 120 Offset 2464 OpMemberDecorate %type_View 121 Offset 2468 OpMemberDecorate %type_View 122 Offset 2472 OpMemberDecorate %type_View 123 Offset 2476 OpMemberDecorate %type_View 124 Offset 2480 OpMemberDecorate %type_View 125 Offset 2484 OpMemberDecorate %type_View 126 Offset 2488 OpMemberDecorate %type_View 127 Offset 2492 OpMemberDecorate %type_View 128 Offset 2496 OpMemberDecorate %type_View 129 Offset 2512 OpMemberDecorate %type_View 130 Offset 2516 OpMemberDecorate %type_View 131 Offset 2520 OpMemberDecorate %type_View 132 Offset 2524 OpMemberDecorate %type_View 133 Offset 2528 OpMemberDecorate %type_View 134 Offset 2544 OpMemberDecorate %type_View 135 Offset 2556 OpMemberDecorate %type_View 136 Offset 2560 OpMemberDecorate %type_View 137 Offset 2576 OpMemberDecorate %type_View 138 Offset 2580 OpMemberDecorate %type_View 139 Offset 2584 OpMemberDecorate %type_View 140 Offset 2588 OpMemberDecorate %type_View 141 Offset 2592 OpMemberDecorate %type_View 142 Offset 2608 OpMemberDecorate %type_View 143 Offset 2720 OpMemberDecorate %type_View 144 Offset 2724 OpMemberDecorate %type_View 145 Offset 2728 OpMemberDecorate %type_View 146 Offset 2732 OpMemberDecorate %type_View 147 Offset 2736 OpMemberDecorate %type_View 148 Offset 2740 OpMemberDecorate %type_View 149 Offset 2744 OpMemberDecorate %type_View 150 Offset 2748 OpMemberDecorate %type_View 151 Offset 2752 OpMemberDecorate %type_View 152 Offset 2764 OpMemberDecorate %type_View 153 Offset 2768 OpMemberDecorate %type_View 154 Offset 2832 OpMemberDecorate %type_View 155 Offset 2896 OpMemberDecorate %type_View 156 Offset 2900 OpMemberDecorate %type_View 157 Offset 2904 OpMemberDecorate %type_View 158 Offset 2908 OpMemberDecorate %type_View 159 Offset 2912 OpMemberDecorate %type_View 160 Offset 2920 OpMemberDecorate %type_View 161 Offset 2924 OpMemberDecorate %type_View 162 Offset 2928 OpMemberDecorate %type_View 163 Offset 2940 OpMemberDecorate %type_View 164 Offset 2944 OpMemberDecorate %type_View 165 Offset 2956 OpMemberDecorate %type_View 166 Offset 2960 OpMemberDecorate %type_View 167 Offset 2968 OpMemberDecorate %type_View 168 Offset 2972 OpMemberDecorate %type_View 169 Offset 2976 OpMemberDecorate %type_View 170 Offset 2988 OpMemberDecorate %type_View 171 Offset 2992 OpMemberDecorate %type_View 172 Offset 3004 OpMemberDecorate %type_View 173 Offset 3008 OpMemberDecorate %type_View 174 Offset 3020 OpMemberDecorate %type_View 175 Offset 3024 OpMemberDecorate %type_View 176 Offset 3036 OpMemberDecorate %type_View 177 Offset 3040 OpMemberDecorate %type_View 178 Offset 3044 OpDecorate %type_View Block OpMemberDecorate %type_Primitive 0 Offset 0 OpMemberDecorate %type_Primitive 0 MatrixStride 16 OpMemberDecorate %type_Primitive 0 ColMajor OpMemberDecorate %type_Primitive 1 Offset 64 OpMemberDecorate %type_Primitive 2 Offset 80 OpMemberDecorate %type_Primitive 3 Offset 96 OpMemberDecorate %type_Primitive 3 MatrixStride 16 OpMemberDecorate %type_Primitive 3 ColMajor OpMemberDecorate %type_Primitive 4 Offset 160 OpMemberDecorate %type_Primitive 4 MatrixStride 16 OpMemberDecorate %type_Primitive 4 ColMajor OpMemberDecorate %type_Primitive 5 Offset 224 OpMemberDecorate %type_Primitive 5 MatrixStride 16 OpMemberDecorate %type_Primitive 5 ColMajor OpMemberDecorate %type_Primitive 6 Offset 288 OpMemberDecorate %type_Primitive 7 Offset 300 OpMemberDecorate %type_Primitive 8 Offset 304 OpMemberDecorate %type_Primitive 9 Offset 316 OpMemberDecorate %type_Primitive 10 Offset 320 OpMemberDecorate %type_Primitive 11 Offset 324 OpMemberDecorate %type_Primitive 12 Offset 328 OpMemberDecorate %type_Primitive 13 Offset 332 OpMemberDecorate %type_Primitive 14 Offset 336 OpMemberDecorate %type_Primitive 15 Offset 352 OpMemberDecorate %type_Primitive 16 Offset 368 OpMemberDecorate %type_Primitive 17 Offset 380 OpMemberDecorate %type_Primitive 18 Offset 384 OpMemberDecorate %type_Primitive 19 Offset 396 OpMemberDecorate %type_Primitive 20 Offset 400 OpMemberDecorate %type_Primitive 21 Offset 412 OpMemberDecorate %type_Primitive 22 Offset 416 OpMemberDecorate %type_Primitive 23 Offset 420 OpMemberDecorate %type_Primitive 24 Offset 424 OpMemberDecorate %type_Primitive 25 Offset 428 OpMemberDecorate %type_Primitive 26 Offset 432 OpDecorate %type_Primitive Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %v2int = OpTypeVector %int 2 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %float_2 = OpConstant %float 2 %63 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %float_0_5 = OpConstant %float 0.5 %int_3 = OpConstant %int 3 %float_0_333000004 = OpConstant %float 0.333000004 %float_1 = OpConstant %float 1 %68 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_15 = OpConstant %float 15 %70 = OpConstantComposite %v4float %float_15 %float_15 %float_15 %float_15 %FVertexFactoryInterpolantsVSToPS = OpTypeStruct %v4float %v4float %FVertexFactoryInterpolantsVSToDS = OpTypeStruct %FVertexFactoryInterpolantsVSToPS %FHitProxyVSToDS = OpTypeStruct %FVertexFactoryInterpolantsVSToDS %v4float %uint %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %FHullShaderConstantDominantVertexData = OpTypeStruct %v2float %v4float %v3float %FHullShaderConstantDominantEdgeData = OpTypeStruct %v2float %v2float %v4float %v4float %v3float %v3float %FPNTessellationHSToDS = OpTypeStruct %FHitProxyVSToDS %_arr_v4float_uint_3 %v3float %float %float %FHullShaderConstantDominantVertexData %FHullShaderConstantDominantEdgeData %uint_9 = OpConstant %uint 9 %v3int = OpTypeVector %int 3 %74 = OpConstantComposite %v3int %int_0 %int_0 %int_0 %75 = OpConstantComposite %v3int %int_3 %int_3 %int_3 %float_0 = OpConstant %float 0 %77 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %78 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %int_78 = OpConstant %int 78 %int_15 = OpConstant %int 15 %int_7 = OpConstant %int 7 %int_28 = OpConstant %int 28 %83 = OpConstantComposite %v3int %int_1 %int_1 %int_1 %84 = OpConstantComposite %v3int %int_2 %int_2 %int_2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %uint %uint %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v2int %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_Primitive = OpTypeStruct %mat4v4float %v4float %v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %float %float %float %float %v4float %v4float %v3float %uint %v3float %uint %v3float %int %uint %uint %uint %uint %_arr_v4float_uint_4 %_ptr_Uniform_type_Primitive = OpTypePointer Uniform %type_Primitive %uint_12 = OpConstant %uint 12 %_arr_v4float_uint_12 = OpTypeArray %v4float %uint_12 %_ptr_Input__arr_v4float_uint_12 = OpTypePointer Input %_arr_v4float_uint_12 %_arr_uint_uint_12 = OpTypeArray %uint %uint_12 %_ptr_Input__arr_uint_uint_12 = OpTypePointer Input %_arr_uint_uint_12 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output__arr_v4float_uint_3 = OpTypePointer Output %_arr_v4float_uint_3 %_arr_uint_uint_3 = OpTypeArray %uint %uint_3 %_ptr_Output__arr_uint_uint_3 = OpTypePointer Output %_arr_uint_uint_3 %_arr__arr_v4float_uint_3_uint_3 = OpTypeArray %_arr_v4float_uint_3 %uint_3 %_ptr_Output__arr__arr_v4float_uint_3_uint_3 = OpTypePointer Output %_arr__arr_v4float_uint_3_uint_3 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Output__arr_v3float_uint_3 = OpTypePointer Output %_arr_v3float_uint_3 %_ptr_Output__arr_float_uint_3 = OpTypePointer Output %_arr_float_uint_3 %_arr_v2float_uint_3 = OpTypeArray %v2float %uint_3 %_ptr_Output__arr_v2float_uint_3 = OpTypePointer Output %_arr_v2float_uint_3 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %109 = OpTypeFunction %void %_arr_FHitProxyVSToDS_uint_12 = OpTypeArray %FHitProxyVSToDS %uint_12 %_ptr_Function__arr_FHitProxyVSToDS_uint_12 = OpTypePointer Function %_arr_FHitProxyVSToDS_uint_12 %_arr_FPNTessellationHSToDS_uint_3 = OpTypeArray %FPNTessellationHSToDS %uint_3 %_ptr_Function__arr_FPNTessellationHSToDS_uint_3 = OpTypePointer Function %_arr_FPNTessellationHSToDS_uint_3 %_ptr_Workgroup__arr_FPNTessellationHSToDS_uint_3 = OpTypePointer Workgroup %_arr_FPNTessellationHSToDS_uint_3 %_ptr_Output_uint = OpTypePointer Output %uint %_ptr_Output_v3float = OpTypePointer Output %v3float %_ptr_Output_float = OpTypePointer Output %float %_ptr_Output_v2float = OpTypePointer Output %v2float %_ptr_Function_FPNTessellationHSToDS = OpTypePointer Function %FPNTessellationHSToDS %_ptr_Workgroup_FPNTessellationHSToDS = OpTypePointer Workgroup %FPNTessellationHSToDS %bool = OpTypeBool %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_float = OpTypePointer Function %float %_ptr_Workgroup_v4float = OpTypePointer Workgroup %v4float %_ptr_Workgroup_float = OpTypePointer Workgroup %float %mat3v3float = OpTypeMatrix %v3float 3 %_ptr_Function_FVertexFactoryInterpolantsVSToDS = OpTypePointer Function %FVertexFactoryInterpolantsVSToDS %_ptr_Function_FHitProxyVSToDS = OpTypePointer Function %FHitProxyVSToDS %v3bool = OpTypeVector %bool 3 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %View = OpVariable %_ptr_Uniform_type_View Uniform %Primitive = OpVariable %_ptr_Uniform_type_Primitive Uniform %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_VS_To_DS_Position = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_VS_To_DS_VertexID = OpVariable %_ptr_Input__arr_uint_uint_12 Input %gl_InvocationID = OpVariable %_ptr_Input_uint Input %out_var_TEXCOORD10_centroid = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_TEXCOORD11_centroid = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_VS_To_DS_Position = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_VS_To_DS_VertexID = OpVariable %_ptr_Output__arr_uint_uint_3 Output %out_var_PN_POSITION = OpVariable %_ptr_Output__arr__arr_v4float_uint_3_uint_3 Output %out_var_PN_DisplacementScales = OpVariable %_ptr_Output__arr_v3float_uint_3 Output %out_var_PN_TessellationMultiplier = OpVariable %_ptr_Output__arr_float_uint_3 Output %out_var_PN_WorldDisplacementMultiplier = OpVariable %_ptr_Output__arr_float_uint_3 Output %out_var_PN_DominantVertex = OpVariable %_ptr_Output__arr_v2float_uint_3 Output %out_var_PN_DominantVertex1 = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_PN_DominantVertex2 = OpVariable %_ptr_Output__arr_v3float_uint_3 Output %out_var_PN_DominantEdge = OpVariable %_ptr_Output__arr_v2float_uint_3 Output %out_var_PN_DominantEdge1 = OpVariable %_ptr_Output__arr_v2float_uint_3 Output %out_var_PN_DominantEdge2 = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_PN_DominantEdge3 = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_PN_DominantEdge4 = OpVariable %_ptr_Output__arr_v3float_uint_3 Output %out_var_PN_DominantEdge5 = OpVariable %_ptr_Output__arr_v3float_uint_3 Output %gl_TessLevelOuter = OpVariable %_ptr_Output__arr_float_uint_4 Output %gl_TessLevelInner = OpVariable %_ptr_Output__arr_float_uint_2 Output %out_var_PN_POSITION9 = OpVariable %_ptr_Output_v4float Output %130 = OpConstantNull %v2float %float_0_333333343 = OpConstant %float 0.333333343 %132 = OpConstantComposite %v4float %float_0_333333343 %float_0_333333343 %float_0_333333343 %float_0_333333343 %133 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 %float_0_166666672 = OpConstant %float 0.166666672 %135 = OpConstantComposite %v4float %float_0_166666672 %float_0_166666672 %float_0_166666672 %float_0_166666672 %136 = OpUndef %v4float ; XXX: Original asm used Function here, which is wrong. ; This patches the SPIR-V to be correct. %temp_var_hullMainRetVal = OpVariable %_ptr_Workgroup__arr_FPNTessellationHSToDS_uint_3 Workgroup %MainHull = OpFunction %void None %109 %137 = OpLabel %param_var_I = OpVariable %_ptr_Function__arr_FHitProxyVSToDS_uint_12 Function %138 = OpLoad %_arr_v4float_uint_12 %in_var_TEXCOORD10_centroid %139 = OpLoad %_arr_v4float_uint_12 %in_var_TEXCOORD11_centroid %140 = OpCompositeExtract %v4float %138 0 %141 = OpCompositeExtract %v4float %139 0 %142 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %140 %141 %143 = OpCompositeExtract %v4float %138 1 %144 = OpCompositeExtract %v4float %139 1 %145 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %143 %144 %146 = OpCompositeExtract %v4float %138 2 %147 = OpCompositeExtract %v4float %139 2 %148 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %146 %147 %149 = OpCompositeExtract %v4float %138 3 %150 = OpCompositeExtract %v4float %139 3 %151 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %149 %150 %152 = OpCompositeExtract %v4float %138 4 %153 = OpCompositeExtract %v4float %139 4 %154 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %152 %153 %155 = OpCompositeExtract %v4float %138 5 %156 = OpCompositeExtract %v4float %139 5 %157 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %155 %156 %158 = OpCompositeExtract %v4float %138 6 %159 = OpCompositeExtract %v4float %139 6 %160 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %158 %159 %161 = OpCompositeExtract %v4float %138 7 %162 = OpCompositeExtract %v4float %139 7 %163 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %161 %162 %164 = OpCompositeExtract %v4float %138 8 %165 = OpCompositeExtract %v4float %139 8 %166 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %164 %165 %167 = OpCompositeExtract %v4float %138 9 %168 = OpCompositeExtract %v4float %139 9 %169 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %167 %168 %170 = OpCompositeExtract %v4float %138 10 %171 = OpCompositeExtract %v4float %139 10 %172 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %170 %171 %173 = OpCompositeExtract %v4float %138 11 %174 = OpCompositeExtract %v4float %139 11 %175 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %173 %174 %176 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %142 %177 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %145 %178 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %148 %179 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %151 %180 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %154 %181 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %157 %182 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %160 %183 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %163 %184 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %166 %185 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %169 %186 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %172 %187 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %175 %188 = OpLoad %_arr_v4float_uint_12 %in_var_VS_To_DS_Position %189 = OpLoad %_arr_uint_uint_12 %in_var_VS_To_DS_VertexID %190 = OpCompositeExtract %v4float %188 0 %191 = OpCompositeExtract %uint %189 0 %192 = OpCompositeConstruct %FHitProxyVSToDS %176 %190 %191 %193 = OpCompositeExtract %v4float %188 1 %194 = OpCompositeExtract %uint %189 1 %195 = OpCompositeConstruct %FHitProxyVSToDS %177 %193 %194 %196 = OpCompositeExtract %v4float %188 2 %197 = OpCompositeExtract %uint %189 2 %198 = OpCompositeConstruct %FHitProxyVSToDS %178 %196 %197 %199 = OpCompositeExtract %v4float %188 3 %200 = OpCompositeExtract %uint %189 3 %201 = OpCompositeConstruct %FHitProxyVSToDS %179 %199 %200 %202 = OpCompositeExtract %v4float %188 4 %203 = OpCompositeExtract %uint %189 4 %204 = OpCompositeConstruct %FHitProxyVSToDS %180 %202 %203 %205 = OpCompositeExtract %v4float %188 5 %206 = OpCompositeExtract %uint %189 5 %207 = OpCompositeConstruct %FHitProxyVSToDS %181 %205 %206 %208 = OpCompositeExtract %v4float %188 6 %209 = OpCompositeExtract %uint %189 6 %210 = OpCompositeConstruct %FHitProxyVSToDS %182 %208 %209 %211 = OpCompositeExtract %v4float %188 7 %212 = OpCompositeExtract %uint %189 7 %213 = OpCompositeConstruct %FHitProxyVSToDS %183 %211 %212 %214 = OpCompositeExtract %v4float %188 8 %215 = OpCompositeExtract %uint %189 8 %216 = OpCompositeConstruct %FHitProxyVSToDS %184 %214 %215 %217 = OpCompositeExtract %v4float %188 9 %218 = OpCompositeExtract %uint %189 9 %219 = OpCompositeConstruct %FHitProxyVSToDS %185 %217 %218 %220 = OpCompositeExtract %v4float %188 10 %221 = OpCompositeExtract %uint %189 10 %222 = OpCompositeConstruct %FHitProxyVSToDS %186 %220 %221 %223 = OpCompositeExtract %v4float %188 11 %224 = OpCompositeExtract %uint %189 11 %225 = OpCompositeConstruct %FHitProxyVSToDS %187 %223 %224 %226 = OpCompositeConstruct %_arr_FHitProxyVSToDS_uint_12 %192 %195 %198 %201 %204 %207 %210 %213 %216 %219 %222 %225 OpStore %param_var_I %226 %227 = OpLoad %uint %gl_InvocationID %228 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %227 %int_0 %229 = OpLoad %FVertexFactoryInterpolantsVSToDS %228 %230 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %229 0 %231 = OpCompositeExtract %v4float %230 0 %232 = OpCompositeExtract %v4float %230 1 %233 = OpVectorShuffle %v3float %231 %231 0 1 2 %234 = OpVectorShuffle %v3float %232 %232 0 1 2 %235 = OpExtInst %v3float %1 Cross %234 %233 %236 = OpCompositeExtract %float %232 3 %237 = OpCompositeConstruct %v3float %236 %236 %236 %238 = OpFMul %v3float %235 %237 %239 = OpCompositeConstruct %mat3v3float %233 %238 %234 %240 = OpCompositeExtract %float %232 0 %241 = OpCompositeExtract %float %232 1 %242 = OpCompositeExtract %float %232 2 %243 = OpCompositeConstruct %v4float %240 %241 %242 %float_0 %244 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_15 %245 = OpLoad %v4float %244 %246 = OpVectorShuffle %v3float %245 %245 0 1 2 %247 = OpVectorTimesMatrix %v3float %246 %239 %248 = OpULessThan %bool %227 %uint_2 %249 = OpIAdd %uint %227 %uint_1 %250 = OpSelect %uint %248 %249 %uint_0 %251 = OpIMul %uint %uint_2 %227 %252 = OpIAdd %uint %uint_3 %251 %253 = OpIAdd %uint %251 %uint_4 %254 = OpAccessChain %_ptr_Function_FHitProxyVSToDS %param_var_I %227 %255 = OpLoad %FHitProxyVSToDS %254 %256 = OpAccessChain %_ptr_Function_v4float %param_var_I %227 %int_1 %257 = OpLoad %v4float %256 %258 = OpULessThan %bool %250 %uint_2 %259 = OpIAdd %uint %250 %uint_1 %260 = OpSelect %uint %258 %259 %uint_0 %261 = OpIMul %uint %uint_2 %250 %262 = OpIAdd %uint %uint_3 %261 %263 = OpIAdd %uint %261 %uint_4 %264 = OpIAdd %uint %uint_9 %227 %265 = OpAccessChain %_ptr_Function_FHitProxyVSToDS %param_var_I %264 %266 = OpLoad %FHitProxyVSToDS %265 %267 = OpCompositeExtract %FVertexFactoryInterpolantsVSToDS %266 0 %268 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %267 0 %269 = OpCompositeExtract %v4float %268 0 %270 = OpCompositeExtract %v4float %268 1 %271 = OpVectorShuffle %v3float %269 %269 0 1 2 %272 = OpCompositeExtract %float %270 0 %273 = OpCompositeExtract %float %270 1 %274 = OpCompositeExtract %float %270 2 %275 = OpCompositeConstruct %v4float %272 %273 %274 %float_0 %276 = OpAccessChain %_ptr_Function_FHitProxyVSToDS %param_var_I %250 %277 = OpLoad %FHitProxyVSToDS %276 %278 = OpCompositeExtract %uint %277 2 %279 = OpAccessChain %_ptr_Function_FHitProxyVSToDS %param_var_I %260 %280 = OpLoad %FHitProxyVSToDS %279 %281 = OpCompositeExtract %uint %280 2 %282 = OpAccessChain %_ptr_Function_FHitProxyVSToDS %param_var_I %262 %283 = OpLoad %FHitProxyVSToDS %282 %284 = OpCompositeExtract %uint %283 2 %285 = OpAccessChain %_ptr_Function_FHitProxyVSToDS %param_var_I %263 %286 = OpLoad %FHitProxyVSToDS %285 %287 = OpCompositeExtract %uint %286 2 %288 = OpCompositeExtract %FVertexFactoryInterpolantsVSToDS %277 0 %289 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %288 0 %290 = OpCompositeExtract %v4float %289 0 %291 = OpCompositeExtract %v4float %289 1 %292 = OpCompositeExtract %FVertexFactoryInterpolantsVSToDS %280 0 %293 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %292 0 %294 = OpCompositeExtract %v4float %293 0 %295 = OpCompositeExtract %v4float %293 1 %296 = OpULessThan %bool %284 %278 %297 = OpIEqual %bool %284 %278 %298 = OpULessThan %bool %287 %281 %299 = OpLogicalAnd %bool %297 %298 %300 = OpLogicalOr %bool %296 %299 OpSelectionMerge %301 None OpBranchConditional %300 %302 %301 %302 = OpLabel %303 = OpCompositeExtract %FVertexFactoryInterpolantsVSToDS %283 0 %304 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %303 0 %305 = OpCompositeExtract %v4float %304 0 %306 = OpCompositeExtract %v4float %304 1 %307 = OpCompositeExtract %FVertexFactoryInterpolantsVSToDS %286 0 %308 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %307 0 %309 = OpCompositeExtract %v4float %308 0 %310 = OpCompositeExtract %v4float %308 1 OpBranch %301 %301 = OpLabel %311 = OpPhi %v4float %294 %137 %309 %302 %312 = OpPhi %v4float %295 %137 %310 %302 %313 = OpPhi %v4float %290 %137 %305 %302 %314 = OpPhi %v4float %291 %137 %306 %302 %315 = OpVectorShuffle %v3float %313 %313 0 1 2 %316 = OpVectorShuffle %v3float %311 %311 0 1 2 %317 = OpCompositeExtract %float %314 0 %318 = OpCompositeExtract %float %314 1 %319 = OpCompositeExtract %float %314 2 %320 = OpCompositeConstruct %v4float %317 %318 %319 %float_0 %321 = OpCompositeExtract %float %312 0 %322 = OpCompositeExtract %float %312 1 %323 = OpCompositeExtract %float %312 2 %324 = OpCompositeConstruct %v4float %321 %322 %323 %float_0 %325 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %250 %int_0 %326 = OpLoad %FVertexFactoryInterpolantsVSToDS %325 %327 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %326 0 %328 = OpCompositeExtract %v4float %327 1 %329 = OpCompositeExtract %float %328 0 %330 = OpCompositeExtract %float %328 1 %331 = OpCompositeExtract %float %328 2 %332 = OpCompositeConstruct %v4float %329 %330 %331 %float_0 %333 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %252 %int_0 %334 = OpLoad %FVertexFactoryInterpolantsVSToDS %333 %335 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %334 0 %336 = OpCompositeExtract %v4float %335 1 %337 = OpCompositeExtract %float %336 0 %338 = OpCompositeExtract %float %336 1 %339 = OpCompositeExtract %float %336 2 %340 = OpCompositeConstruct %v4float %337 %338 %339 %float_0 %341 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %253 %int_0 %342 = OpLoad %FVertexFactoryInterpolantsVSToDS %341 %343 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %342 0 %344 = OpCompositeExtract %v4float %343 1 %345 = OpCompositeExtract %float %344 0 %346 = OpCompositeExtract %float %344 1 %347 = OpCompositeExtract %float %344 2 %348 = OpCompositeConstruct %v4float %345 %346 %347 %float_0 %349 = OpLoad %v4float %256 %350 = OpAccessChain %_ptr_Function_v4float %param_var_I %250 %int_1 %351 = OpLoad %v4float %350 %352 = OpFMul %v4float %63 %349 %353 = OpFAdd %v4float %352 %351 %354 = OpFSub %v4float %351 %349 %355 = OpDot %float %354 %243 %356 = OpCompositeConstruct %v4float %355 %355 %355 %355 %357 = OpFMul %v4float %356 %243 %358 = OpFSub %v4float %353 %357 %359 = OpFMul %v4float %358 %132 %360 = OpAccessChain %_ptr_Function_v4float %param_var_I %252 %int_1 %361 = OpLoad %v4float %360 %362 = OpAccessChain %_ptr_Function_v4float %param_var_I %253 %int_1 %363 = OpLoad %v4float %362 %364 = OpFMul %v4float %63 %361 %365 = OpFAdd %v4float %364 %363 %366 = OpFSub %v4float %363 %361 %367 = OpDot %float %366 %340 %368 = OpCompositeConstruct %v4float %367 %367 %367 %367 %369 = OpFMul %v4float %368 %340 %370 = OpFSub %v4float %365 %369 %371 = OpFMul %v4float %370 %132 %372 = OpFAdd %v4float %359 %371 %373 = OpFMul %v4float %372 %133 %374 = OpLoad %v4float %350 %375 = OpLoad %v4float %256 %376 = OpFMul %v4float %63 %374 %377 = OpFAdd %v4float %376 %375 %378 = OpFSub %v4float %375 %374 %379 = OpDot %float %378 %332 %380 = OpCompositeConstruct %v4float %379 %379 %379 %379 %381 = OpFMul %v4float %380 %332 %382 = OpFSub %v4float %377 %381 %383 = OpFMul %v4float %382 %132 %384 = OpLoad %v4float %362 %385 = OpLoad %v4float %360 %386 = OpFMul %v4float %63 %384 %387 = OpFAdd %v4float %386 %385 %388 = OpFSub %v4float %385 %384 %389 = OpDot %float %388 %348 %390 = OpCompositeConstruct %v4float %389 %389 %389 %389 %391 = OpFMul %v4float %390 %348 %392 = OpFSub %v4float %387 %391 %393 = OpFMul %v4float %392 %132 %394 = OpFAdd %v4float %383 %393 %395 = OpFMul %v4float %394 %133 %396 = OpCompositeConstruct %FHullShaderConstantDominantEdgeData %130 %130 %320 %324 %315 %316 %397 = OpCompositeConstruct %FHullShaderConstantDominantVertexData %130 %275 %271 %398 = OpCompositeConstruct %_arr_v4float_uint_3 %257 %373 %395 %399 = OpCompositeConstruct %FPNTessellationHSToDS %255 %398 %247 %float_1 %float_1 %397 %396 %400 = OpCompositeExtract %FVertexFactoryInterpolantsVSToDS %255 0 %401 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %400 0 %402 = OpCompositeExtract %v4float %401 0 %403 = OpAccessChain %_ptr_Output_v4float %out_var_TEXCOORD10_centroid %227 OpStore %403 %402 %404 = OpCompositeExtract %v4float %401 1 %405 = OpAccessChain %_ptr_Output_v4float %out_var_TEXCOORD11_centroid %227 OpStore %405 %404 %406 = OpCompositeExtract %v4float %255 1 %407 = OpAccessChain %_ptr_Output_v4float %out_var_VS_To_DS_Position %227 OpStore %407 %406 %408 = OpCompositeExtract %uint %255 2 %409 = OpAccessChain %_ptr_Output_uint %out_var_VS_To_DS_VertexID %227 OpStore %409 %408 %410 = OpAccessChain %_ptr_Output__arr_v4float_uint_3 %out_var_PN_POSITION %227 OpStore %410 %398 %411 = OpAccessChain %_ptr_Output_v3float %out_var_PN_DisplacementScales %227 OpStore %411 %247 %412 = OpAccessChain %_ptr_Output_float %out_var_PN_TessellationMultiplier %227 OpStore %412 %float_1 %413 = OpAccessChain %_ptr_Output_float %out_var_PN_WorldDisplacementMultiplier %227 OpStore %413 %float_1 %414 = OpAccessChain %_ptr_Output_v2float %out_var_PN_DominantVertex %227 OpStore %414 %130 %415 = OpAccessChain %_ptr_Output_v4float %out_var_PN_DominantVertex1 %227 OpStore %415 %275 %416 = OpAccessChain %_ptr_Output_v3float %out_var_PN_DominantVertex2 %227 OpStore %416 %271 %417 = OpAccessChain %_ptr_Output_v2float %out_var_PN_DominantEdge %227 OpStore %417 %130 %418 = OpAccessChain %_ptr_Output_v2float %out_var_PN_DominantEdge1 %227 OpStore %418 %130 %419 = OpAccessChain %_ptr_Output_v4float %out_var_PN_DominantEdge2 %227 OpStore %419 %320 %420 = OpAccessChain %_ptr_Output_v4float %out_var_PN_DominantEdge3 %227 OpStore %420 %324 %421 = OpAccessChain %_ptr_Output_v3float %out_var_PN_DominantEdge4 %227 OpStore %421 %315 %422 = OpAccessChain %_ptr_Output_v3float %out_var_PN_DominantEdge5 %227 OpStore %422 %316 %423 = OpAccessChain %_ptr_Workgroup_FPNTessellationHSToDS %temp_var_hullMainRetVal %227 OpStore %423 %399 OpControlBarrier %uint_2 %uint_4 %uint_0 %424 = OpIEqual %bool %227 %uint_0 OpSelectionMerge %if_merge None OpBranchConditional %424 %425 %if_merge %425 = OpLabel %426 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_0 %427 = OpLoad %mat4v4float %426 %428 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_7 %429 = OpLoad %mat4v4float %428 %430 = OpAccessChain %_ptr_Uniform_v3float %View %int_28 %431 = OpLoad %v3float %430 %432 = OpAccessChain %_ptr_Uniform_float %View %int_78 %433 = OpLoad %float %432 %434 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_0 %int_1 %int_0 %435 = OpLoad %v4float %434 %436 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_0 %int_1 %int_1 %437 = OpLoad %v4float %436 %438 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_0 %int_1 %int_2 %439 = OpLoad %v4float %438 %440 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_1 %int_1 %int_0 %441 = OpLoad %v4float %440 %442 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_1 %int_1 %int_1 %443 = OpLoad %v4float %442 %444 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_1 %int_1 %int_2 %445 = OpLoad %v4float %444 %446 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_2 %int_1 %int_0 %447 = OpLoad %v4float %446 %448 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_2 %int_1 %int_1 %449 = OpLoad %v4float %448 %450 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_2 %int_1 %int_2 %451 = OpLoad %v4float %450 %452 = OpFAdd %v4float %437 %439 %453 = OpFAdd %v4float %452 %443 %454 = OpFAdd %v4float %453 %445 %455 = OpFAdd %v4float %454 %449 %456 = OpFAdd %v4float %455 %451 %457 = OpFMul %v4float %456 %135 %458 = OpFAdd %v4float %447 %441 %459 = OpFAdd %v4float %458 %435 %460 = OpFMul %v4float %459 %132 %461 = OpFSub %v4float %457 %460 %462 = OpFMul %v4float %461 %133 %463 = OpFAdd %v4float %457 %462 %464 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_1 %int_3 %465 = OpLoad %float %464 %466 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_2 %int_3 %467 = OpLoad %float %466 %468 = OpFAdd %float %465 %467 %469 = OpFMul %float %float_0_5 %468 %470 = OpCompositeInsert %v4float %469 %136 0 %471 = OpLoad %float %466 %472 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_0 %int_3 %473 = OpLoad %float %472 %474 = OpFAdd %float %471 %473 %475 = OpFMul %float %float_0_5 %474 %476 = OpCompositeInsert %v4float %475 %470 1 %477 = OpLoad %float %472 %478 = OpLoad %float %464 %479 = OpFAdd %float %477 %478 %480 = OpFMul %float %float_0_5 %479 %481 = OpCompositeInsert %v4float %480 %476 2 %482 = OpLoad %float %472 %483 = OpLoad %float %464 %484 = OpFAdd %float %482 %483 %485 = OpLoad %float %466 %486 = OpFAdd %float %484 %485 %487 = OpFMul %float %float_0_333000004 %486 %488 = OpCompositeInsert %v4float %487 %481 3 %489 = OpVectorShuffle %v3float %435 %435 0 1 2 %490 = OpVectorShuffle %v3float %441 %441 0 1 2 %491 = OpVectorShuffle %v3float %447 %447 0 1 2 OpBranch %492 %492 = OpLabel OpLoopMerge %493 %494 None OpBranch %495 %495 = OpLabel %496 = OpMatrixTimesVector %v4float %429 %77 %497 = OpCompositeExtract %float %435 0 %498 = OpCompositeExtract %float %435 1 %499 = OpCompositeExtract %float %435 2 %500 = OpCompositeConstruct %v4float %497 %498 %499 %float_1 %501 = OpMatrixTimesVector %v4float %427 %500 %502 = OpVectorShuffle %v3float %501 %501 0 1 2 %503 = OpVectorShuffle %v3float %496 %496 0 1 2 %504 = OpFSub %v3float %502 %503 %505 = OpCompositeExtract %float %501 3 %506 = OpCompositeExtract %float %496 3 %507 = OpFAdd %float %505 %506 %508 = OpCompositeConstruct %v3float %507 %507 %507 %509 = OpFOrdLessThan %v3bool %504 %508 %510 = OpSelect %v3int %509 %83 %74 %511 = OpFAdd %v3float %502 %503 %512 = OpFNegate %float %505 %513 = OpFSub %float %512 %506 %514 = OpCompositeConstruct %v3float %513 %513 %513 %515 = OpFOrdGreaterThan %v3bool %511 %514 %516 = OpSelect %v3int %515 %83 %74 %517 = OpIMul %v3int %84 %516 %518 = OpIAdd %v3int %510 %517 %519 = OpCompositeExtract %float %441 0 %520 = OpCompositeExtract %float %441 1 %521 = OpCompositeExtract %float %441 2 %522 = OpCompositeConstruct %v4float %519 %520 %521 %float_1 %523 = OpMatrixTimesVector %v4float %427 %522 %524 = OpVectorShuffle %v3float %523 %523 0 1 2 %525 = OpFSub %v3float %524 %503 %526 = OpCompositeExtract %float %523 3 %527 = OpFAdd %float %526 %506 %528 = OpCompositeConstruct %v3float %527 %527 %527 %529 = OpFOrdLessThan %v3bool %525 %528 %530 = OpSelect %v3int %529 %83 %74 %531 = OpFAdd %v3float %524 %503 %532 = OpFNegate %float %526 %533 = OpFSub %float %532 %506 %534 = OpCompositeConstruct %v3float %533 %533 %533 %535 = OpFOrdGreaterThan %v3bool %531 %534 %536 = OpSelect %v3int %535 %83 %74 %537 = OpIMul %v3int %84 %536 %538 = OpIAdd %v3int %530 %537 %539 = OpBitwiseOr %v3int %518 %538 %540 = OpCompositeExtract %float %447 0 %541 = OpCompositeExtract %float %447 1 %542 = OpCompositeExtract %float %447 2 %543 = OpCompositeConstruct %v4float %540 %541 %542 %float_1 %544 = OpMatrixTimesVector %v4float %427 %543 %545 = OpVectorShuffle %v3float %544 %544 0 1 2 %546 = OpFSub %v3float %545 %503 %547 = OpCompositeExtract %float %544 3 %548 = OpFAdd %float %547 %506 %549 = OpCompositeConstruct %v3float %548 %548 %548 %550 = OpFOrdLessThan %v3bool %546 %549 %551 = OpSelect %v3int %550 %83 %74 %552 = OpFAdd %v3float %545 %503 %553 = OpFNegate %float %547 %554 = OpFSub %float %553 %506 %555 = OpCompositeConstruct %v3float %554 %554 %554 %556 = OpFOrdGreaterThan %v3bool %552 %555 %557 = OpSelect %v3int %556 %83 %74 %558 = OpIMul %v3int %84 %557 %559 = OpIAdd %v3int %551 %558 %560 = OpBitwiseOr %v3int %539 %559 %561 = OpINotEqual %v3bool %560 %75 %562 = OpAny %bool %561 OpSelectionMerge %563 None OpBranchConditional %562 %564 %563 %564 = OpLabel OpBranch %493 %563 = OpLabel %565 = OpFSub %v3float %489 %490 %566 = OpFSub %v3float %490 %491 %567 = OpFSub %v3float %491 %489 %568 = OpFAdd %v3float %489 %490 %569 = OpFMul %v3float %78 %568 %570 = OpFSub %v3float %569 %431 %571 = OpFAdd %v3float %490 %491 %572 = OpFMul %v3float %78 %571 %573 = OpFSub %v3float %572 %431 %574 = OpFAdd %v3float %491 %489 %575 = OpFMul %v3float %78 %574 %576 = OpFSub %v3float %575 %431 %577 = OpDot %float %566 %566 %578 = OpDot %float %573 %573 %579 = OpFDiv %float %577 %578 %580 = OpExtInst %float %1 Sqrt %579 %581 = OpDot %float %567 %567 %582 = OpDot %float %576 %576 %583 = OpFDiv %float %581 %582 %584 = OpExtInst %float %1 Sqrt %583 %585 = OpDot %float %565 %565 %586 = OpDot %float %570 %570 %587 = OpFDiv %float %585 %586 %588 = OpExtInst %float %1 Sqrt %587 %589 = OpCompositeConstruct %v4float %580 %584 %588 %float_1 %590 = OpFAdd %float %580 %584 %591 = OpFAdd %float %590 %588 %592 = OpFMul %float %float_0_333000004 %591 %593 = OpCompositeInsert %v4float %592 %589 3 %594 = OpCompositeConstruct %v4float %433 %433 %433 %433 %595 = OpFMul %v4float %594 %593 OpBranch %493 %494 = OpLabel OpBranch %492 %493 = OpLabel %596 = OpPhi %v4float %77 %564 %595 %563 %597 = OpFMul %v4float %488 %596 %598 = OpExtInst %v4float %1 FClamp %597 %68 %70 %599 = OpCompositeExtract %float %598 0 %600 = OpCompositeExtract %float %598 1 %601 = OpCompositeExtract %float %598 2 %602 = OpCompositeExtract %float %598 3 %603 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_0 OpStore %603 %599 %604 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_1 OpStore %604 %600 %605 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_2 OpStore %605 %601 %606 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %uint_0 OpStore %606 %602 OpStore %out_var_PN_POSITION9 %463 OpBranch %if_merge %if_merge = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/tesc/hs-texcoord-array.asm.tesc000066400000000000000000002111541400026215700252520ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 531 ; Schema: 0 OpCapability Tessellation OpCapability SampledBuffer OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %MainHull "main" %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_COLOR0 %in_var_TEXCOORD0 %in_var_VS_To_DS_Position %gl_InvocationID %out_var_TEXCOORD10_centroid %out_var_TEXCOORD11_centroid %out_var_COLOR0 %out_var_TEXCOORD0 %out_var_VS_To_DS_Position %out_var_PN_POSITION %out_var_PN_DisplacementScales %out_var_PN_TessellationMultiplier %out_var_PN_WorldDisplacementMultiplier %gl_TessLevelOuter %gl_TessLevelInner %out_var_PN_POSITION9 OpExecutionMode %MainHull Triangles OpExecutionMode %MainHull SpacingFractionalOdd OpExecutionMode %MainHull VertexOrderCw OpExecutionMode %MainHull OutputVertices 3 OpSource HLSL 600 OpName %FPNTessellationHSToDS "FPNTessellationHSToDS" OpMemberName %FPNTessellationHSToDS 0 "PassSpecificData" OpMemberName %FPNTessellationHSToDS 1 "WorldPosition" OpMemberName %FPNTessellationHSToDS 2 "DisplacementScale" OpMemberName %FPNTessellationHSToDS 3 "TessellationMultiplier" OpMemberName %FPNTessellationHSToDS 4 "WorldDisplacementMultiplier" OpName %FHitProxyVSToDS "FHitProxyVSToDS" OpMemberName %FHitProxyVSToDS 0 "FactoryInterpolants" OpMemberName %FHitProxyVSToDS 1 "Position" OpName %FVertexFactoryInterpolantsVSToDS "FVertexFactoryInterpolantsVSToDS" OpMemberName %FVertexFactoryInterpolantsVSToDS 0 "InterpolantsVSToPS" OpName %FVertexFactoryInterpolantsVSToPS "FVertexFactoryInterpolantsVSToPS" OpMemberName %FVertexFactoryInterpolantsVSToPS 0 "TangentToWorld0" OpMemberName %FVertexFactoryInterpolantsVSToPS 1 "TangentToWorld2" OpMemberName %FVertexFactoryInterpolantsVSToPS 2 "Color" OpMemberName %FVertexFactoryInterpolantsVSToPS 3 "TexCoords" OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_ClipToWorld" OpMemberName %type_View 3 "View_TranslatedWorldToView" OpMemberName %type_View 4 "View_ViewToTranslatedWorld" OpMemberName %type_View 5 "View_TranslatedWorldToCameraView" OpMemberName %type_View 6 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 7 "View_ViewToClip" OpMemberName %type_View 8 "View_ViewToClipNoAA" OpMemberName %type_View 9 "View_ClipToView" OpMemberName %type_View 10 "View_ClipToTranslatedWorld" OpMemberName %type_View 11 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 12 "View_ScreenToWorld" OpMemberName %type_View 13 "View_ScreenToTranslatedWorld" OpMemberName %type_View 14 "View_ViewForward" OpMemberName %type_View 15 "PrePadding_View_908" OpMemberName %type_View 16 "View_ViewUp" OpMemberName %type_View 17 "PrePadding_View_924" OpMemberName %type_View 18 "View_ViewRight" OpMemberName %type_View 19 "PrePadding_View_940" OpMemberName %type_View 20 "View_HMDViewNoRollUp" OpMemberName %type_View 21 "PrePadding_View_956" OpMemberName %type_View 22 "View_HMDViewNoRollRight" OpMemberName %type_View 23 "PrePadding_View_972" OpMemberName %type_View 24 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 25 "View_ScreenPositionScaleBias" OpMemberName %type_View 26 "View_WorldCameraOrigin" OpMemberName %type_View 27 "PrePadding_View_1020" OpMemberName %type_View 28 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 29 "PrePadding_View_1036" OpMemberName %type_View 30 "View_WorldViewOrigin" OpMemberName %type_View 31 "PrePadding_View_1052" OpMemberName %type_View 32 "View_PreViewTranslation" OpMemberName %type_View 33 "PrePadding_View_1068" OpMemberName %type_View 34 "View_PrevProjection" OpMemberName %type_View 35 "View_PrevViewProj" OpMemberName %type_View 36 "View_PrevViewRotationProj" OpMemberName %type_View 37 "View_PrevViewToClip" OpMemberName %type_View 38 "View_PrevClipToView" OpMemberName %type_View 39 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 40 "View_PrevTranslatedWorldToView" OpMemberName %type_View 41 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 42 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 43 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 44 "View_PrevWorldCameraOrigin" OpMemberName %type_View 45 "PrePadding_View_1724" OpMemberName %type_View 46 "View_PrevWorldViewOrigin" OpMemberName %type_View 47 "PrePadding_View_1740" OpMemberName %type_View 48 "View_PrevPreViewTranslation" OpMemberName %type_View 49 "PrePadding_View_1756" OpMemberName %type_View 50 "View_PrevInvViewProj" OpMemberName %type_View 51 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 52 "View_ClipToPrevClip" OpMemberName %type_View 53 "View_TemporalAAJitter" OpMemberName %type_View 54 "View_GlobalClippingPlane" OpMemberName %type_View 55 "View_FieldOfViewWideAngles" OpMemberName %type_View 56 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 57 "View_ViewRectMin" OpMemberName %type_View 58 "View_ViewSizeAndInvSize" OpMemberName %type_View 59 "View_BufferSizeAndInvSize" OpMemberName %type_View 60 "View_BufferBilinearUVMinMax" OpMemberName %type_View 61 "View_NumSceneColorMSAASamples" OpMemberName %type_View 62 "View_PreExposure" OpMemberName %type_View 63 "View_OneOverPreExposure" OpMemberName %type_View 64 "PrePadding_View_2076" OpMemberName %type_View 65 "View_DiffuseOverrideParameter" OpMemberName %type_View 66 "View_SpecularOverrideParameter" OpMemberName %type_View 67 "View_NormalOverrideParameter" OpMemberName %type_View 68 "View_RoughnessOverrideParameter" OpMemberName %type_View 69 "View_PrevFrameGameTime" OpMemberName %type_View 70 "View_PrevFrameRealTime" OpMemberName %type_View 71 "View_OutOfBoundsMask" OpMemberName %type_View 72 "PrePadding_View_2148" OpMemberName %type_View 73 "PrePadding_View_2152" OpMemberName %type_View 74 "PrePadding_View_2156" OpMemberName %type_View 75 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 76 "View_CullingSign" OpMemberName %type_View 77 "View_NearPlane" OpMemberName %type_View 78 "View_AdaptiveTessellationFactor" OpMemberName %type_View 79 "View_GameTime" OpMemberName %type_View 80 "View_RealTime" OpMemberName %type_View 81 "View_DeltaTime" OpMemberName %type_View 82 "View_MaterialTextureMipBias" OpMemberName %type_View 83 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 84 "View_Random" OpMemberName %type_View 85 "View_FrameNumber" OpMemberName %type_View 86 "View_StateFrameIndexMod8" OpMemberName %type_View 87 "View_StateFrameIndex" OpMemberName %type_View 88 "View_CameraCut" OpMemberName %type_View 89 "View_UnlitViewmodeMask" OpMemberName %type_View 90 "PrePadding_View_2228" OpMemberName %type_View 91 "PrePadding_View_2232" OpMemberName %type_View 92 "PrePadding_View_2236" OpMemberName %type_View 93 "View_DirectionalLightColor" OpMemberName %type_View 94 "View_DirectionalLightDirection" OpMemberName %type_View 95 "PrePadding_View_2268" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 97 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 98 "View_TemporalAAParams" OpMemberName %type_View 99 "View_CircleDOFParams" OpMemberName %type_View 100 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 101 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 102 "View_DepthOfFieldScale" OpMemberName %type_View 103 "View_DepthOfFieldFocalLength" OpMemberName %type_View 104 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 105 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 106 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 107 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 108 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 109 "View_GeneralPurposeTweak" OpMemberName %type_View 110 "View_DemosaicVposOffset" OpMemberName %type_View 111 "PrePadding_View_2412" OpMemberName %type_View 112 "View_IndirectLightingColorScale" OpMemberName %type_View 113 "View_HDR32bppEncodingMode" OpMemberName %type_View 114 "View_AtmosphericFogSunDirection" OpMemberName %type_View 115 "View_AtmosphericFogSunPower" OpMemberName %type_View 116 "View_AtmosphericFogPower" OpMemberName %type_View 117 "View_AtmosphericFogDensityScale" OpMemberName %type_View 118 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 119 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 120 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 121 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 122 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 123 "View_AtmosphericFogStartDistance" OpMemberName %type_View 124 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 125 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 126 "View_AtmosphericFogSunDiscHalfApexAngleRadian" OpMemberName %type_View 127 "PrePadding_View_2492" OpMemberName %type_View 128 "View_AtmosphericFogSunDiscLuminance" OpMemberName %type_View 129 "View_AtmosphericFogRenderMask" OpMemberName %type_View 130 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 131 "PrePadding_View_2520" OpMemberName %type_View 132 "PrePadding_View_2524" OpMemberName %type_View 133 "View_AtmosphericFogSunColor" OpMemberName %type_View 134 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 135 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 136 "View_AmbientCubemapTint" OpMemberName %type_View 137 "View_AmbientCubemapIntensity" OpMemberName %type_View 138 "View_SkyLightParameters" OpMemberName %type_View 139 "PrePadding_View_2584" OpMemberName %type_View 140 "PrePadding_View_2588" OpMemberName %type_View 141 "View_SkyLightColor" OpMemberName %type_View 142 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 143 "View_MobilePreviewMode" OpMemberName %type_View 144 "View_HMDEyePaddingOffset" OpMemberName %type_View 145 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 146 "View_ShowDecalsMask" OpMemberName %type_View 147 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 148 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 149 "PrePadding_View_2744" OpMemberName %type_View 150 "PrePadding_View_2748" OpMemberName %type_View 151 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 152 "View_StereoPassIndex" OpMemberName %type_View 153 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 154 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 155 "View_GlobalVolumeDimension" OpMemberName %type_View 156 "View_GlobalVolumeTexelSize" OpMemberName %type_View 157 "View_MaxGlobalDistance" OpMemberName %type_View 158 "PrePadding_View_2908" OpMemberName %type_View 159 "View_CursorPosition" OpMemberName %type_View 160 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 161 "PrePadding_View_2924" OpMemberName %type_View 162 "View_VolumetricFogInvGridSize" OpMemberName %type_View 163 "PrePadding_View_2940" OpMemberName %type_View 164 "View_VolumetricFogGridZParams" OpMemberName %type_View 165 "PrePadding_View_2956" OpMemberName %type_View 166 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 167 "View_VolumetricFogMaxDistance" OpMemberName %type_View 168 "PrePadding_View_2972" OpMemberName %type_View 169 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 170 "PrePadding_View_2988" OpMemberName %type_View 171 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 172 "PrePadding_View_3004" OpMemberName %type_View 173 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 174 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 175 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 176 "View_StereoIPD" OpMemberName %type_View 177 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 178 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_Primitive "type.Primitive" OpMemberName %type_Primitive 0 "Primitive_LocalToWorld" OpMemberName %type_Primitive 1 "Primitive_InvNonUniformScaleAndDeterminantSign" OpMemberName %type_Primitive 2 "Primitive_ObjectWorldPositionAndRadius" OpMemberName %type_Primitive 3 "Primitive_WorldToLocal" OpMemberName %type_Primitive 4 "Primitive_PreviousLocalToWorld" OpMemberName %type_Primitive 5 "Primitive_PreviousWorldToLocal" OpMemberName %type_Primitive 6 "Primitive_ActorWorldPosition" OpMemberName %type_Primitive 7 "Primitive_UseSingleSampleShadowFromStationaryLights" OpMemberName %type_Primitive 8 "Primitive_ObjectBounds" OpMemberName %type_Primitive 9 "Primitive_LpvBiasMultiplier" OpMemberName %type_Primitive 10 "Primitive_DecalReceiverMask" OpMemberName %type_Primitive 11 "Primitive_PerObjectGBufferData" OpMemberName %type_Primitive 12 "Primitive_UseVolumetricLightmapShadowFromStationaryLights" OpMemberName %type_Primitive 13 "Primitive_DrawsVelocity" OpMemberName %type_Primitive 14 "Primitive_ObjectOrientation" OpMemberName %type_Primitive 15 "Primitive_NonUniformScale" OpMemberName %type_Primitive 16 "Primitive_LocalObjectBoundsMin" OpMemberName %type_Primitive 17 "Primitive_LightingChannelMask" OpMemberName %type_Primitive 18 "Primitive_LocalObjectBoundsMax" OpMemberName %type_Primitive 19 "Primitive_LightmapDataIndex" OpMemberName %type_Primitive 20 "Primitive_PreSkinnedLocalBounds" OpMemberName %type_Primitive 21 "Primitive_SingleCaptureIndex" OpMemberName %type_Primitive 22 "Primitive_OutputVelocity" OpMemberName %type_Primitive 23 "PrePadding_Primitive_420" OpMemberName %type_Primitive 24 "PrePadding_Primitive_424" OpMemberName %type_Primitive 25 "PrePadding_Primitive_428" OpMemberName %type_Primitive 26 "Primitive_CustomPrimitiveData" OpName %Primitive "Primitive" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_COLOR0 "in.var.COLOR0" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %in_var_VS_To_DS_Position "in.var.VS_To_DS_Position" OpName %out_var_TEXCOORD10_centroid "out.var.TEXCOORD10_centroid" OpName %out_var_TEXCOORD11_centroid "out.var.TEXCOORD11_centroid" OpName %out_var_COLOR0 "out.var.COLOR0" OpName %out_var_TEXCOORD0 "out.var.TEXCOORD0" OpName %out_var_VS_To_DS_Position "out.var.VS_To_DS_Position" OpName %out_var_PN_POSITION "out.var.PN_POSITION" OpName %out_var_PN_DisplacementScales "out.var.PN_DisplacementScales" OpName %out_var_PN_TessellationMultiplier "out.var.PN_TessellationMultiplier" OpName %out_var_PN_WorldDisplacementMultiplier "out.var.PN_WorldDisplacementMultiplier" OpName %out_var_PN_POSITION9 "out.var.PN_POSITION9" OpName %MainHull "MainHull" OpName %param_var_I "param.var.I" OpName %temp_var_hullMainRetVal "temp.var.hullMainRetVal" OpName %if_merge "if.merge" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_COLOR0 UserSemantic "COLOR0" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %in_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorateString %gl_InvocationID UserSemantic "SV_OutputControlPointID" OpDecorateString %out_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %out_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %out_var_COLOR0 UserSemantic "COLOR0" OpDecorateString %out_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %out_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorateString %out_var_PN_POSITION UserSemantic "PN_POSITION" OpDecorateString %out_var_PN_DisplacementScales UserSemantic "PN_DisplacementScales" OpDecorateString %out_var_PN_TessellationMultiplier UserSemantic "PN_TessellationMultiplier" OpDecorateString %out_var_PN_WorldDisplacementMultiplier UserSemantic "PN_WorldDisplacementMultiplier" OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter OpDecorateString %gl_TessLevelOuter UserSemantic "SV_TessFactor" OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorateString %gl_TessLevelInner UserSemantic "SV_InsideTessFactor" OpDecorate %gl_TessLevelInner Patch OpDecorateString %out_var_PN_POSITION9 UserSemantic "PN_POSITION9" OpDecorate %out_var_PN_POSITION9 Patch OpDecorate %in_var_TEXCOORD10_centroid Location 0 OpDecorate %in_var_TEXCOORD11_centroid Location 1 OpDecorate %in_var_COLOR0 Location 2 OpDecorate %in_var_TEXCOORD0 Location 3 OpDecorate %in_var_VS_To_DS_Position Location 5 OpDecorate %out_var_COLOR0 Location 0 OpDecorate %out_var_PN_DisplacementScales Location 1 OpDecorate %out_var_PN_POSITION Location 2 OpDecorate %out_var_PN_POSITION9 Location 5 OpDecorate %out_var_PN_TessellationMultiplier Location 6 OpDecorate %out_var_PN_WorldDisplacementMultiplier Location 7 OpDecorate %out_var_TEXCOORD0 Location 8 OpDecorate %out_var_TEXCOORD10_centroid Location 10 OpDecorate %out_var_TEXCOORD11_centroid Location 11 OpDecorate %out_var_VS_To_DS_Position Location 12 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %Primitive DescriptorSet 0 OpDecorate %Primitive Binding 1 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 13 MatrixStride 16 OpMemberDecorate %type_View 13 ColMajor OpMemberDecorate %type_View 14 Offset 896 OpMemberDecorate %type_View 15 Offset 908 OpMemberDecorate %type_View 16 Offset 912 OpMemberDecorate %type_View 17 Offset 924 OpMemberDecorate %type_View 18 Offset 928 OpMemberDecorate %type_View 19 Offset 940 OpMemberDecorate %type_View 20 Offset 944 OpMemberDecorate %type_View 21 Offset 956 OpMemberDecorate %type_View 22 Offset 960 OpMemberDecorate %type_View 23 Offset 972 OpMemberDecorate %type_View 24 Offset 976 OpMemberDecorate %type_View 25 Offset 992 OpMemberDecorate %type_View 26 Offset 1008 OpMemberDecorate %type_View 27 Offset 1020 OpMemberDecorate %type_View 28 Offset 1024 OpMemberDecorate %type_View 29 Offset 1036 OpMemberDecorate %type_View 30 Offset 1040 OpMemberDecorate %type_View 31 Offset 1052 OpMemberDecorate %type_View 32 Offset 1056 OpMemberDecorate %type_View 33 Offset 1068 OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 43 MatrixStride 16 OpMemberDecorate %type_View 43 ColMajor OpMemberDecorate %type_View 44 Offset 1712 OpMemberDecorate %type_View 45 Offset 1724 OpMemberDecorate %type_View 46 Offset 1728 OpMemberDecorate %type_View 47 Offset 1740 OpMemberDecorate %type_View 48 Offset 1744 OpMemberDecorate %type_View 49 Offset 1756 OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 52 MatrixStride 16 OpMemberDecorate %type_View 52 ColMajor OpMemberDecorate %type_View 53 Offset 1952 OpMemberDecorate %type_View 54 Offset 1968 OpMemberDecorate %type_View 55 Offset 1984 OpMemberDecorate %type_View 56 Offset 1992 OpMemberDecorate %type_View 57 Offset 2000 OpMemberDecorate %type_View 58 Offset 2016 OpMemberDecorate %type_View 59 Offset 2032 OpMemberDecorate %type_View 60 Offset 2048 OpMemberDecorate %type_View 61 Offset 2064 OpMemberDecorate %type_View 62 Offset 2068 OpMemberDecorate %type_View 63 Offset 2072 OpMemberDecorate %type_View 64 Offset 2076 OpMemberDecorate %type_View 65 Offset 2080 OpMemberDecorate %type_View 66 Offset 2096 OpMemberDecorate %type_View 67 Offset 2112 OpMemberDecorate %type_View 68 Offset 2128 OpMemberDecorate %type_View 69 Offset 2136 OpMemberDecorate %type_View 70 Offset 2140 OpMemberDecorate %type_View 71 Offset 2144 OpMemberDecorate %type_View 72 Offset 2148 OpMemberDecorate %type_View 73 Offset 2152 OpMemberDecorate %type_View 74 Offset 2156 OpMemberDecorate %type_View 75 Offset 2160 OpMemberDecorate %type_View 76 Offset 2172 OpMemberDecorate %type_View 77 Offset 2176 OpMemberDecorate %type_View 78 Offset 2180 OpMemberDecorate %type_View 79 Offset 2184 OpMemberDecorate %type_View 80 Offset 2188 OpMemberDecorate %type_View 81 Offset 2192 OpMemberDecorate %type_View 82 Offset 2196 OpMemberDecorate %type_View 83 Offset 2200 OpMemberDecorate %type_View 84 Offset 2204 OpMemberDecorate %type_View 85 Offset 2208 OpMemberDecorate %type_View 86 Offset 2212 OpMemberDecorate %type_View 87 Offset 2216 OpMemberDecorate %type_View 88 Offset 2220 OpMemberDecorate %type_View 89 Offset 2224 OpMemberDecorate %type_View 90 Offset 2228 OpMemberDecorate %type_View 91 Offset 2232 OpMemberDecorate %type_View 92 Offset 2236 OpMemberDecorate %type_View 93 Offset 2240 OpMemberDecorate %type_View 94 Offset 2256 OpMemberDecorate %type_View 95 Offset 2268 OpMemberDecorate %type_View 96 Offset 2272 OpMemberDecorate %type_View 97 Offset 2304 OpMemberDecorate %type_View 98 Offset 2336 OpMemberDecorate %type_View 99 Offset 2352 OpMemberDecorate %type_View 100 Offset 2368 OpMemberDecorate %type_View 101 Offset 2372 OpMemberDecorate %type_View 102 Offset 2376 OpMemberDecorate %type_View 103 Offset 2380 OpMemberDecorate %type_View 104 Offset 2384 OpMemberDecorate %type_View 105 Offset 2388 OpMemberDecorate %type_View 106 Offset 2392 OpMemberDecorate %type_View 107 Offset 2396 OpMemberDecorate %type_View 108 Offset 2400 OpMemberDecorate %type_View 109 Offset 2404 OpMemberDecorate %type_View 110 Offset 2408 OpMemberDecorate %type_View 111 Offset 2412 OpMemberDecorate %type_View 112 Offset 2416 OpMemberDecorate %type_View 113 Offset 2428 OpMemberDecorate %type_View 114 Offset 2432 OpMemberDecorate %type_View 115 Offset 2444 OpMemberDecorate %type_View 116 Offset 2448 OpMemberDecorate %type_View 117 Offset 2452 OpMemberDecorate %type_View 118 Offset 2456 OpMemberDecorate %type_View 119 Offset 2460 OpMemberDecorate %type_View 120 Offset 2464 OpMemberDecorate %type_View 121 Offset 2468 OpMemberDecorate %type_View 122 Offset 2472 OpMemberDecorate %type_View 123 Offset 2476 OpMemberDecorate %type_View 124 Offset 2480 OpMemberDecorate %type_View 125 Offset 2484 OpMemberDecorate %type_View 126 Offset 2488 OpMemberDecorate %type_View 127 Offset 2492 OpMemberDecorate %type_View 128 Offset 2496 OpMemberDecorate %type_View 129 Offset 2512 OpMemberDecorate %type_View 130 Offset 2516 OpMemberDecorate %type_View 131 Offset 2520 OpMemberDecorate %type_View 132 Offset 2524 OpMemberDecorate %type_View 133 Offset 2528 OpMemberDecorate %type_View 134 Offset 2544 OpMemberDecorate %type_View 135 Offset 2556 OpMemberDecorate %type_View 136 Offset 2560 OpMemberDecorate %type_View 137 Offset 2576 OpMemberDecorate %type_View 138 Offset 2580 OpMemberDecorate %type_View 139 Offset 2584 OpMemberDecorate %type_View 140 Offset 2588 OpMemberDecorate %type_View 141 Offset 2592 OpMemberDecorate %type_View 142 Offset 2608 OpMemberDecorate %type_View 143 Offset 2720 OpMemberDecorate %type_View 144 Offset 2724 OpMemberDecorate %type_View 145 Offset 2728 OpMemberDecorate %type_View 146 Offset 2732 OpMemberDecorate %type_View 147 Offset 2736 OpMemberDecorate %type_View 148 Offset 2740 OpMemberDecorate %type_View 149 Offset 2744 OpMemberDecorate %type_View 150 Offset 2748 OpMemberDecorate %type_View 151 Offset 2752 OpMemberDecorate %type_View 152 Offset 2764 OpMemberDecorate %type_View 153 Offset 2768 OpMemberDecorate %type_View 154 Offset 2832 OpMemberDecorate %type_View 155 Offset 2896 OpMemberDecorate %type_View 156 Offset 2900 OpMemberDecorate %type_View 157 Offset 2904 OpMemberDecorate %type_View 158 Offset 2908 OpMemberDecorate %type_View 159 Offset 2912 OpMemberDecorate %type_View 160 Offset 2920 OpMemberDecorate %type_View 161 Offset 2924 OpMemberDecorate %type_View 162 Offset 2928 OpMemberDecorate %type_View 163 Offset 2940 OpMemberDecorate %type_View 164 Offset 2944 OpMemberDecorate %type_View 165 Offset 2956 OpMemberDecorate %type_View 166 Offset 2960 OpMemberDecorate %type_View 167 Offset 2968 OpMemberDecorate %type_View 168 Offset 2972 OpMemberDecorate %type_View 169 Offset 2976 OpMemberDecorate %type_View 170 Offset 2988 OpMemberDecorate %type_View 171 Offset 2992 OpMemberDecorate %type_View 172 Offset 3004 OpMemberDecorate %type_View 173 Offset 3008 OpMemberDecorate %type_View 174 Offset 3020 OpMemberDecorate %type_View 175 Offset 3024 OpMemberDecorate %type_View 176 Offset 3036 OpMemberDecorate %type_View 177 Offset 3040 OpMemberDecorate %type_View 178 Offset 3044 OpDecorate %type_View Block OpMemberDecorate %type_Primitive 0 Offset 0 OpMemberDecorate %type_Primitive 0 MatrixStride 16 OpMemberDecorate %type_Primitive 0 ColMajor OpMemberDecorate %type_Primitive 1 Offset 64 OpMemberDecorate %type_Primitive 2 Offset 80 OpMemberDecorate %type_Primitive 3 Offset 96 OpMemberDecorate %type_Primitive 3 MatrixStride 16 OpMemberDecorate %type_Primitive 3 ColMajor OpMemberDecorate %type_Primitive 4 Offset 160 OpMemberDecorate %type_Primitive 4 MatrixStride 16 OpMemberDecorate %type_Primitive 4 ColMajor OpMemberDecorate %type_Primitive 5 Offset 224 OpMemberDecorate %type_Primitive 5 MatrixStride 16 OpMemberDecorate %type_Primitive 5 ColMajor OpMemberDecorate %type_Primitive 6 Offset 288 OpMemberDecorate %type_Primitive 7 Offset 300 OpMemberDecorate %type_Primitive 8 Offset 304 OpMemberDecorate %type_Primitive 9 Offset 316 OpMemberDecorate %type_Primitive 10 Offset 320 OpMemberDecorate %type_Primitive 11 Offset 324 OpMemberDecorate %type_Primitive 12 Offset 328 OpMemberDecorate %type_Primitive 13 Offset 332 OpMemberDecorate %type_Primitive 14 Offset 336 OpMemberDecorate %type_Primitive 15 Offset 352 OpMemberDecorate %type_Primitive 16 Offset 368 OpMemberDecorate %type_Primitive 17 Offset 380 OpMemberDecorate %type_Primitive 18 Offset 384 OpMemberDecorate %type_Primitive 19 Offset 396 OpMemberDecorate %type_Primitive 20 Offset 400 OpMemberDecorate %type_Primitive 21 Offset 412 OpMemberDecorate %type_Primitive 22 Offset 416 OpMemberDecorate %type_Primitive 23 Offset 420 OpMemberDecorate %type_Primitive 24 Offset 424 OpMemberDecorate %type_Primitive 25 Offset 428 OpMemberDecorate %type_Primitive 26 Offset 432 OpDecorate %type_Primitive Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %v2int = OpTypeVector %int 2 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %float_2 = OpConstant %float 2 %54 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %float_0_5 = OpConstant %float 0.5 %int_3 = OpConstant %int 3 %float_0_333000004 = OpConstant %float 0.333000004 %float_1 = OpConstant %float 1 %59 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_15 = OpConstant %float 15 %61 = OpConstantComposite %v4float %float_15 %float_15 %float_15 %float_15 %_arr_v2float_uint_2 = OpTypeArray %v2float %uint_2 %FVertexFactoryInterpolantsVSToPS = OpTypeStruct %v4float %v4float %v4float %_arr_v2float_uint_2 %FVertexFactoryInterpolantsVSToDS = OpTypeStruct %FVertexFactoryInterpolantsVSToPS %FHitProxyVSToDS = OpTypeStruct %FVertexFactoryInterpolantsVSToDS %v4float %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %FPNTessellationHSToDS = OpTypeStruct %FHitProxyVSToDS %_arr_v4float_uint_3 %v3float %float %float %v3int = OpTypeVector %int 3 %65 = OpConstantComposite %v3int %int_0 %int_0 %int_0 %66 = OpConstantComposite %v3int %int_3 %int_3 %int_3 %float_0 = OpConstant %float 0 %68 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %69 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %int_78 = OpConstant %int 78 %int_15 = OpConstant %int 15 %int_7 = OpConstant %int 7 %int_28 = OpConstant %int 28 %74 = OpConstantComposite %v3int %int_1 %int_1 %int_1 %75 = OpConstantComposite %v3int %int_2 %int_2 %int_2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %uint %uint %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v2int %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_Primitive = OpTypeStruct %mat4v4float %v4float %v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %float %float %float %float %v4float %v4float %v3float %uint %v3float %uint %v3float %int %uint %uint %uint %uint %_arr_v4float_uint_4 %_ptr_Uniform_type_Primitive = OpTypePointer Uniform %type_Primitive %uint_12 = OpConstant %uint 12 %_arr_v4float_uint_12 = OpTypeArray %v4float %uint_12 %_ptr_Input__arr_v4float_uint_12 = OpTypePointer Input %_arr_v4float_uint_12 %_arr__arr_v2float_uint_2_uint_12 = OpTypeArray %_arr_v2float_uint_2 %uint_12 %_ptr_Input__arr__arr_v2float_uint_2_uint_12 = OpTypePointer Input %_arr__arr_v2float_uint_2_uint_12 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output__arr_v4float_uint_3 = OpTypePointer Output %_arr_v4float_uint_3 %_arr__arr_v2float_uint_2_uint_3 = OpTypeArray %_arr_v2float_uint_2 %uint_3 %_ptr_Output__arr__arr_v2float_uint_2_uint_3 = OpTypePointer Output %_arr__arr_v2float_uint_2_uint_3 %_arr__arr_v4float_uint_3_uint_3 = OpTypeArray %_arr_v4float_uint_3 %uint_3 %_ptr_Output__arr__arr_v4float_uint_3_uint_3 = OpTypePointer Output %_arr__arr_v4float_uint_3_uint_3 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Output__arr_v3float_uint_3 = OpTypePointer Output %_arr_v3float_uint_3 %_ptr_Output__arr_float_uint_3 = OpTypePointer Output %_arr_float_uint_3 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %98 = OpTypeFunction %void %_arr_FHitProxyVSToDS_uint_12 = OpTypeArray %FHitProxyVSToDS %uint_12 %_ptr_Function__arr_FHitProxyVSToDS_uint_12 = OpTypePointer Function %_arr_FHitProxyVSToDS_uint_12 %_arr_FPNTessellationHSToDS_uint_3 = OpTypeArray %FPNTessellationHSToDS %uint_3 %_ptr_Function__arr_FPNTessellationHSToDS_uint_3 = OpTypePointer Function %_arr_FPNTessellationHSToDS_uint_3 %_ptr_Workgroup__arr_FPNTessellationHSToDS_uint_3 = OpTypePointer Workgroup %_arr_FPNTessellationHSToDS_uint_3 %_ptr_Output__arr_v2float_uint_2 = OpTypePointer Output %_arr_v2float_uint_2 %_ptr_Output_v3float = OpTypePointer Output %v3float %_ptr_Output_float = OpTypePointer Output %float %_ptr_Function_FPNTessellationHSToDS = OpTypePointer Function %FPNTessellationHSToDS %_ptr_Workgroup_FPNTessellationHSToDS = OpTypePointer Workgroup %FPNTessellationHSToDS %bool = OpTypeBool %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_float = OpTypePointer Function %float %_ptr_Workgroup_v4float = OpTypePointer Workgroup %v4float %_ptr_Workgroup_float = OpTypePointer Workgroup %float %mat3v3float = OpTypeMatrix %v3float 3 %_ptr_Function_FVertexFactoryInterpolantsVSToDS = OpTypePointer Function %FVertexFactoryInterpolantsVSToDS %_ptr_Function_FHitProxyVSToDS = OpTypePointer Function %FHitProxyVSToDS %v3bool = OpTypeVector %bool 3 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %View = OpVariable %_ptr_Uniform_type_View Uniform %Primitive = OpVariable %_ptr_Uniform_type_Primitive Uniform %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_COLOR0 = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %in_var_TEXCOORD0 = OpVariable %_ptr_Input__arr__arr_v2float_uint_2_uint_12 Input %in_var_VS_To_DS_Position = OpVariable %_ptr_Input__arr_v4float_uint_12 Input %gl_InvocationID = OpVariable %_ptr_Input_uint Input %out_var_TEXCOORD10_centroid = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_TEXCOORD11_centroid = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_COLOR0 = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_TEXCOORD0 = OpVariable %_ptr_Output__arr__arr_v2float_uint_2_uint_3 Output %out_var_VS_To_DS_Position = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %out_var_PN_POSITION = OpVariable %_ptr_Output__arr__arr_v4float_uint_3_uint_3 Output %out_var_PN_DisplacementScales = OpVariable %_ptr_Output__arr_v3float_uint_3 Output %out_var_PN_TessellationMultiplier = OpVariable %_ptr_Output__arr_float_uint_3 Output %out_var_PN_WorldDisplacementMultiplier = OpVariable %_ptr_Output__arr_float_uint_3 Output %gl_TessLevelOuter = OpVariable %_ptr_Output__arr_float_uint_4 Output %gl_TessLevelInner = OpVariable %_ptr_Output__arr_float_uint_2 Output %out_var_PN_POSITION9 = OpVariable %_ptr_Output_v4float Output %float_0_333333343 = OpConstant %float 0.333333343 %119 = OpConstantComposite %v4float %float_0_333333343 %float_0_333333343 %float_0_333333343 %float_0_333333343 %120 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 %float_0_166666672 = OpConstant %float 0.166666672 %122 = OpConstantComposite %v4float %float_0_166666672 %float_0_166666672 %float_0_166666672 %float_0_166666672 %123 = OpUndef %v4float ; XXX: Original asm used Function here, which is wrong. ; This patches the SPIR-V to be correct. %temp_var_hullMainRetVal = OpVariable %_ptr_Workgroup__arr_FPNTessellationHSToDS_uint_3 Workgroup %MainHull = OpFunction %void None %98 %124 = OpLabel %param_var_I = OpVariable %_ptr_Function__arr_FHitProxyVSToDS_uint_12 Function %125 = OpLoad %_arr_v4float_uint_12 %in_var_TEXCOORD10_centroid %126 = OpLoad %_arr_v4float_uint_12 %in_var_TEXCOORD11_centroid %127 = OpLoad %_arr_v4float_uint_12 %in_var_COLOR0 %128 = OpLoad %_arr__arr_v2float_uint_2_uint_12 %in_var_TEXCOORD0 %129 = OpCompositeExtract %v4float %125 0 %130 = OpCompositeExtract %v4float %126 0 %131 = OpCompositeExtract %v4float %127 0 %132 = OpCompositeExtract %_arr_v2float_uint_2 %128 0 %133 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %129 %130 %131 %132 %134 = OpCompositeExtract %v4float %125 1 %135 = OpCompositeExtract %v4float %126 1 %136 = OpCompositeExtract %v4float %127 1 %137 = OpCompositeExtract %_arr_v2float_uint_2 %128 1 %138 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %134 %135 %136 %137 %139 = OpCompositeExtract %v4float %125 2 %140 = OpCompositeExtract %v4float %126 2 %141 = OpCompositeExtract %v4float %127 2 %142 = OpCompositeExtract %_arr_v2float_uint_2 %128 2 %143 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %139 %140 %141 %142 %144 = OpCompositeExtract %v4float %125 3 %145 = OpCompositeExtract %v4float %126 3 %146 = OpCompositeExtract %v4float %127 3 %147 = OpCompositeExtract %_arr_v2float_uint_2 %128 3 %148 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %144 %145 %146 %147 %149 = OpCompositeExtract %v4float %125 4 %150 = OpCompositeExtract %v4float %126 4 %151 = OpCompositeExtract %v4float %127 4 %152 = OpCompositeExtract %_arr_v2float_uint_2 %128 4 %153 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %149 %150 %151 %152 %154 = OpCompositeExtract %v4float %125 5 %155 = OpCompositeExtract %v4float %126 5 %156 = OpCompositeExtract %v4float %127 5 %157 = OpCompositeExtract %_arr_v2float_uint_2 %128 5 %158 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %154 %155 %156 %157 %159 = OpCompositeExtract %v4float %125 6 %160 = OpCompositeExtract %v4float %126 6 %161 = OpCompositeExtract %v4float %127 6 %162 = OpCompositeExtract %_arr_v2float_uint_2 %128 6 %163 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %159 %160 %161 %162 %164 = OpCompositeExtract %v4float %125 7 %165 = OpCompositeExtract %v4float %126 7 %166 = OpCompositeExtract %v4float %127 7 %167 = OpCompositeExtract %_arr_v2float_uint_2 %128 7 %168 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %164 %165 %166 %167 %169 = OpCompositeExtract %v4float %125 8 %170 = OpCompositeExtract %v4float %126 8 %171 = OpCompositeExtract %v4float %127 8 %172 = OpCompositeExtract %_arr_v2float_uint_2 %128 8 %173 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %169 %170 %171 %172 %174 = OpCompositeExtract %v4float %125 9 %175 = OpCompositeExtract %v4float %126 9 %176 = OpCompositeExtract %v4float %127 9 %177 = OpCompositeExtract %_arr_v2float_uint_2 %128 9 %178 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %174 %175 %176 %177 %179 = OpCompositeExtract %v4float %125 10 %180 = OpCompositeExtract %v4float %126 10 %181 = OpCompositeExtract %v4float %127 10 %182 = OpCompositeExtract %_arr_v2float_uint_2 %128 10 %183 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %179 %180 %181 %182 %184 = OpCompositeExtract %v4float %125 11 %185 = OpCompositeExtract %v4float %126 11 %186 = OpCompositeExtract %v4float %127 11 %187 = OpCompositeExtract %_arr_v2float_uint_2 %128 11 %188 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %184 %185 %186 %187 %189 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %133 %190 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %138 %191 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %143 %192 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %148 %193 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %153 %194 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %158 %195 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %163 %196 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %168 %197 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %173 %198 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %178 %199 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %183 %200 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %188 %201 = OpLoad %_arr_v4float_uint_12 %in_var_VS_To_DS_Position %202 = OpCompositeExtract %v4float %201 0 %203 = OpCompositeConstruct %FHitProxyVSToDS %189 %202 %204 = OpCompositeExtract %v4float %201 1 %205 = OpCompositeConstruct %FHitProxyVSToDS %190 %204 %206 = OpCompositeExtract %v4float %201 2 %207 = OpCompositeConstruct %FHitProxyVSToDS %191 %206 %208 = OpCompositeExtract %v4float %201 3 %209 = OpCompositeConstruct %FHitProxyVSToDS %192 %208 %210 = OpCompositeExtract %v4float %201 4 %211 = OpCompositeConstruct %FHitProxyVSToDS %193 %210 %212 = OpCompositeExtract %v4float %201 5 %213 = OpCompositeConstruct %FHitProxyVSToDS %194 %212 %214 = OpCompositeExtract %v4float %201 6 %215 = OpCompositeConstruct %FHitProxyVSToDS %195 %214 %216 = OpCompositeExtract %v4float %201 7 %217 = OpCompositeConstruct %FHitProxyVSToDS %196 %216 %218 = OpCompositeExtract %v4float %201 8 %219 = OpCompositeConstruct %FHitProxyVSToDS %197 %218 %220 = OpCompositeExtract %v4float %201 9 %221 = OpCompositeConstruct %FHitProxyVSToDS %198 %220 %222 = OpCompositeExtract %v4float %201 10 %223 = OpCompositeConstruct %FHitProxyVSToDS %199 %222 %224 = OpCompositeExtract %v4float %201 11 %225 = OpCompositeConstruct %FHitProxyVSToDS %200 %224 %226 = OpCompositeConstruct %_arr_FHitProxyVSToDS_uint_12 %203 %205 %207 %209 %211 %213 %215 %217 %219 %221 %223 %225 OpStore %param_var_I %226 %227 = OpLoad %uint %gl_InvocationID %228 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %227 %int_0 %229 = OpLoad %FVertexFactoryInterpolantsVSToDS %228 %230 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %229 0 %231 = OpCompositeExtract %v4float %230 0 %232 = OpCompositeExtract %v4float %230 1 %233 = OpVectorShuffle %v3float %231 %231 0 1 2 %234 = OpVectorShuffle %v3float %232 %232 0 1 2 %235 = OpExtInst %v3float %1 Cross %234 %233 %236 = OpCompositeExtract %float %232 3 %237 = OpCompositeConstruct %v3float %236 %236 %236 %238 = OpFMul %v3float %235 %237 %239 = OpCompositeConstruct %mat3v3float %233 %238 %234 %240 = OpCompositeExtract %float %232 0 %241 = OpCompositeExtract %float %232 1 %242 = OpCompositeExtract %float %232 2 %243 = OpCompositeConstruct %v4float %240 %241 %242 %float_0 %244 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_15 %245 = OpLoad %v4float %244 %246 = OpVectorShuffle %v3float %245 %245 0 1 2 %247 = OpVectorTimesMatrix %v3float %246 %239 %248 = OpULessThan %bool %227 %uint_2 %249 = OpIAdd %uint %227 %uint_1 %250 = OpSelect %uint %248 %249 %uint_0 %251 = OpIMul %uint %uint_2 %227 %252 = OpIAdd %uint %uint_3 %251 %253 = OpIAdd %uint %251 %uint_4 %254 = OpAccessChain %_ptr_Function_FHitProxyVSToDS %param_var_I %227 %255 = OpLoad %FHitProxyVSToDS %254 %256 = OpAccessChain %_ptr_Function_v4float %param_var_I %227 %int_1 %257 = OpLoad %v4float %256 %258 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %250 %int_0 %259 = OpLoad %FVertexFactoryInterpolantsVSToDS %258 %260 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %259 0 %261 = OpCompositeExtract %v4float %260 1 %262 = OpCompositeExtract %float %261 0 %263 = OpCompositeExtract %float %261 1 %264 = OpCompositeExtract %float %261 2 %265 = OpCompositeConstruct %v4float %262 %263 %264 %float_0 %266 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %252 %int_0 %267 = OpLoad %FVertexFactoryInterpolantsVSToDS %266 %268 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %267 0 %269 = OpCompositeExtract %v4float %268 1 %270 = OpCompositeExtract %float %269 0 %271 = OpCompositeExtract %float %269 1 %272 = OpCompositeExtract %float %269 2 %273 = OpCompositeConstruct %v4float %270 %271 %272 %float_0 %274 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %253 %int_0 %275 = OpLoad %FVertexFactoryInterpolantsVSToDS %274 %276 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %275 0 %277 = OpCompositeExtract %v4float %276 1 %278 = OpCompositeExtract %float %277 0 %279 = OpCompositeExtract %float %277 1 %280 = OpCompositeExtract %float %277 2 %281 = OpCompositeConstruct %v4float %278 %279 %280 %float_0 %282 = OpLoad %v4float %256 %283 = OpAccessChain %_ptr_Function_v4float %param_var_I %250 %int_1 %284 = OpLoad %v4float %283 %285 = OpFMul %v4float %54 %282 %286 = OpFAdd %v4float %285 %284 %287 = OpFSub %v4float %284 %282 %288 = OpDot %float %287 %243 %289 = OpCompositeConstruct %v4float %288 %288 %288 %288 %290 = OpFMul %v4float %289 %243 %291 = OpFSub %v4float %286 %290 %292 = OpFMul %v4float %291 %119 %293 = OpAccessChain %_ptr_Function_v4float %param_var_I %252 %int_1 %294 = OpLoad %v4float %293 %295 = OpAccessChain %_ptr_Function_v4float %param_var_I %253 %int_1 %296 = OpLoad %v4float %295 %297 = OpFMul %v4float %54 %294 %298 = OpFAdd %v4float %297 %296 %299 = OpFSub %v4float %296 %294 %300 = OpDot %float %299 %273 %301 = OpCompositeConstruct %v4float %300 %300 %300 %300 %302 = OpFMul %v4float %301 %273 %303 = OpFSub %v4float %298 %302 %304 = OpFMul %v4float %303 %119 %305 = OpFAdd %v4float %292 %304 %306 = OpFMul %v4float %305 %120 %307 = OpLoad %v4float %283 %308 = OpLoad %v4float %256 %309 = OpFMul %v4float %54 %307 %310 = OpFAdd %v4float %309 %308 %311 = OpFSub %v4float %308 %307 %312 = OpDot %float %311 %265 %313 = OpCompositeConstruct %v4float %312 %312 %312 %312 %314 = OpFMul %v4float %313 %265 %315 = OpFSub %v4float %310 %314 %316 = OpFMul %v4float %315 %119 %317 = OpLoad %v4float %295 %318 = OpLoad %v4float %293 %319 = OpFMul %v4float %54 %317 %320 = OpFAdd %v4float %319 %318 %321 = OpFSub %v4float %318 %317 %322 = OpDot %float %321 %281 %323 = OpCompositeConstruct %v4float %322 %322 %322 %322 %324 = OpFMul %v4float %323 %281 %325 = OpFSub %v4float %320 %324 %326 = OpFMul %v4float %325 %119 %327 = OpFAdd %v4float %316 %326 %328 = OpFMul %v4float %327 %120 %329 = OpCompositeConstruct %_arr_v4float_uint_3 %257 %306 %328 %330 = OpCompositeConstruct %FPNTessellationHSToDS %255 %329 %247 %float_1 %float_1 %331 = OpCompositeExtract %FVertexFactoryInterpolantsVSToDS %255 0 %332 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %331 0 %333 = OpCompositeExtract %v4float %332 0 %334 = OpAccessChain %_ptr_Output_v4float %out_var_TEXCOORD10_centroid %227 OpStore %334 %333 %335 = OpCompositeExtract %v4float %332 1 %336 = OpAccessChain %_ptr_Output_v4float %out_var_TEXCOORD11_centroid %227 OpStore %336 %335 %337 = OpCompositeExtract %v4float %332 2 %338 = OpAccessChain %_ptr_Output_v4float %out_var_COLOR0 %227 OpStore %338 %337 %339 = OpCompositeExtract %_arr_v2float_uint_2 %332 3 %340 = OpAccessChain %_ptr_Output__arr_v2float_uint_2 %out_var_TEXCOORD0 %227 OpStore %340 %339 %341 = OpCompositeExtract %v4float %255 1 %342 = OpAccessChain %_ptr_Output_v4float %out_var_VS_To_DS_Position %227 OpStore %342 %341 %343 = OpAccessChain %_ptr_Output__arr_v4float_uint_3 %out_var_PN_POSITION %227 OpStore %343 %329 %344 = OpAccessChain %_ptr_Output_v3float %out_var_PN_DisplacementScales %227 OpStore %344 %247 %345 = OpAccessChain %_ptr_Output_float %out_var_PN_TessellationMultiplier %227 OpStore %345 %float_1 %346 = OpAccessChain %_ptr_Output_float %out_var_PN_WorldDisplacementMultiplier %227 OpStore %346 %float_1 %347 = OpAccessChain %_ptr_Workgroup_FPNTessellationHSToDS %temp_var_hullMainRetVal %227 OpStore %347 %330 OpControlBarrier %uint_2 %uint_4 %uint_0 %348 = OpIEqual %bool %227 %uint_0 OpSelectionMerge %if_merge None OpBranchConditional %348 %349 %if_merge %349 = OpLabel %350 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_0 %351 = OpLoad %mat4v4float %350 %352 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_7 %353 = OpLoad %mat4v4float %352 %354 = OpAccessChain %_ptr_Uniform_v3float %View %int_28 %355 = OpLoad %v3float %354 %356 = OpAccessChain %_ptr_Uniform_float %View %int_78 %357 = OpLoad %float %356 %358 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_0 %int_1 %int_0 %359 = OpLoad %v4float %358 %360 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_0 %int_1 %int_1 %361 = OpLoad %v4float %360 %362 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_0 %int_1 %int_2 %363 = OpLoad %v4float %362 %364 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_1 %int_1 %int_0 %365 = OpLoad %v4float %364 %366 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_1 %int_1 %int_1 %367 = OpLoad %v4float %366 %368 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_1 %int_1 %int_2 %369 = OpLoad %v4float %368 %370 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_2 %int_1 %int_0 %371 = OpLoad %v4float %370 %372 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_2 %int_1 %int_1 %373 = OpLoad %v4float %372 %374 = OpAccessChain %_ptr_Workgroup_v4float %temp_var_hullMainRetVal %uint_2 %int_1 %int_2 %375 = OpLoad %v4float %374 %376 = OpFAdd %v4float %361 %363 %377 = OpFAdd %v4float %376 %367 %378 = OpFAdd %v4float %377 %369 %379 = OpFAdd %v4float %378 %373 %380 = OpFAdd %v4float %379 %375 %381 = OpFMul %v4float %380 %122 %382 = OpFAdd %v4float %371 %365 %383 = OpFAdd %v4float %382 %359 %384 = OpFMul %v4float %383 %119 %385 = OpFSub %v4float %381 %384 %386 = OpFMul %v4float %385 %120 %387 = OpFAdd %v4float %381 %386 %388 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_1 %int_3 %389 = OpLoad %float %388 %390 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_2 %int_3 %391 = OpLoad %float %390 %392 = OpFAdd %float %389 %391 %393 = OpFMul %float %float_0_5 %392 %394 = OpCompositeInsert %v4float %393 %123 0 %395 = OpLoad %float %390 %396 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_0 %int_3 %397 = OpLoad %float %396 %398 = OpFAdd %float %395 %397 %399 = OpFMul %float %float_0_5 %398 %400 = OpCompositeInsert %v4float %399 %394 1 %401 = OpLoad %float %396 %402 = OpLoad %float %388 %403 = OpFAdd %float %401 %402 %404 = OpFMul %float %float_0_5 %403 %405 = OpCompositeInsert %v4float %404 %400 2 %406 = OpLoad %float %396 %407 = OpLoad %float %388 %408 = OpFAdd %float %406 %407 %409 = OpLoad %float %390 %410 = OpFAdd %float %408 %409 %411 = OpFMul %float %float_0_333000004 %410 %412 = OpCompositeInsert %v4float %411 %405 3 %413 = OpVectorShuffle %v3float %359 %359 0 1 2 %414 = OpVectorShuffle %v3float %365 %365 0 1 2 %415 = OpVectorShuffle %v3float %371 %371 0 1 2 OpBranch %416 %416 = OpLabel OpLoopMerge %417 %418 None OpBranch %419 %419 = OpLabel %420 = OpMatrixTimesVector %v4float %353 %68 %421 = OpCompositeExtract %float %359 0 %422 = OpCompositeExtract %float %359 1 %423 = OpCompositeExtract %float %359 2 %424 = OpCompositeConstruct %v4float %421 %422 %423 %float_1 %425 = OpMatrixTimesVector %v4float %351 %424 %426 = OpVectorShuffle %v3float %425 %425 0 1 2 %427 = OpVectorShuffle %v3float %420 %420 0 1 2 %428 = OpFSub %v3float %426 %427 %429 = OpCompositeExtract %float %425 3 %430 = OpCompositeExtract %float %420 3 %431 = OpFAdd %float %429 %430 %432 = OpCompositeConstruct %v3float %431 %431 %431 %433 = OpFOrdLessThan %v3bool %428 %432 %434 = OpSelect %v3int %433 %74 %65 %435 = OpFAdd %v3float %426 %427 %436 = OpFNegate %float %429 %437 = OpFSub %float %436 %430 %438 = OpCompositeConstruct %v3float %437 %437 %437 %439 = OpFOrdGreaterThan %v3bool %435 %438 %440 = OpSelect %v3int %439 %74 %65 %441 = OpIMul %v3int %75 %440 %442 = OpIAdd %v3int %434 %441 %443 = OpCompositeExtract %float %365 0 %444 = OpCompositeExtract %float %365 1 %445 = OpCompositeExtract %float %365 2 %446 = OpCompositeConstruct %v4float %443 %444 %445 %float_1 %447 = OpMatrixTimesVector %v4float %351 %446 %448 = OpVectorShuffle %v3float %447 %447 0 1 2 %449 = OpFSub %v3float %448 %427 %450 = OpCompositeExtract %float %447 3 %451 = OpFAdd %float %450 %430 %452 = OpCompositeConstruct %v3float %451 %451 %451 %453 = OpFOrdLessThan %v3bool %449 %452 %454 = OpSelect %v3int %453 %74 %65 %455 = OpFAdd %v3float %448 %427 %456 = OpFNegate %float %450 %457 = OpFSub %float %456 %430 %458 = OpCompositeConstruct %v3float %457 %457 %457 %459 = OpFOrdGreaterThan %v3bool %455 %458 %460 = OpSelect %v3int %459 %74 %65 %461 = OpIMul %v3int %75 %460 %462 = OpIAdd %v3int %454 %461 %463 = OpBitwiseOr %v3int %442 %462 %464 = OpCompositeExtract %float %371 0 %465 = OpCompositeExtract %float %371 1 %466 = OpCompositeExtract %float %371 2 %467 = OpCompositeConstruct %v4float %464 %465 %466 %float_1 %468 = OpMatrixTimesVector %v4float %351 %467 %469 = OpVectorShuffle %v3float %468 %468 0 1 2 %470 = OpFSub %v3float %469 %427 %471 = OpCompositeExtract %float %468 3 %472 = OpFAdd %float %471 %430 %473 = OpCompositeConstruct %v3float %472 %472 %472 %474 = OpFOrdLessThan %v3bool %470 %473 %475 = OpSelect %v3int %474 %74 %65 %476 = OpFAdd %v3float %469 %427 %477 = OpFNegate %float %471 %478 = OpFSub %float %477 %430 %479 = OpCompositeConstruct %v3float %478 %478 %478 %480 = OpFOrdGreaterThan %v3bool %476 %479 %481 = OpSelect %v3int %480 %74 %65 %482 = OpIMul %v3int %75 %481 %483 = OpIAdd %v3int %475 %482 %484 = OpBitwiseOr %v3int %463 %483 %485 = OpINotEqual %v3bool %484 %66 %486 = OpAny %bool %485 OpSelectionMerge %487 None OpBranchConditional %486 %488 %487 %488 = OpLabel OpBranch %417 %487 = OpLabel %489 = OpFSub %v3float %413 %414 %490 = OpFSub %v3float %414 %415 %491 = OpFSub %v3float %415 %413 %492 = OpFAdd %v3float %413 %414 %493 = OpFMul %v3float %69 %492 %494 = OpFSub %v3float %493 %355 %495 = OpFAdd %v3float %414 %415 %496 = OpFMul %v3float %69 %495 %497 = OpFSub %v3float %496 %355 %498 = OpFAdd %v3float %415 %413 %499 = OpFMul %v3float %69 %498 %500 = OpFSub %v3float %499 %355 %501 = OpDot %float %490 %490 %502 = OpDot %float %497 %497 %503 = OpFDiv %float %501 %502 %504 = OpExtInst %float %1 Sqrt %503 %505 = OpDot %float %491 %491 %506 = OpDot %float %500 %500 %507 = OpFDiv %float %505 %506 %508 = OpExtInst %float %1 Sqrt %507 %509 = OpDot %float %489 %489 %510 = OpDot %float %494 %494 %511 = OpFDiv %float %509 %510 %512 = OpExtInst %float %1 Sqrt %511 %513 = OpCompositeConstruct %v4float %504 %508 %512 %float_1 %514 = OpFAdd %float %504 %508 %515 = OpFAdd %float %514 %512 %516 = OpFMul %float %float_0_333000004 %515 %517 = OpCompositeInsert %v4float %516 %513 3 %518 = OpCompositeConstruct %v4float %357 %357 %357 %357 %519 = OpFMul %v4float %518 %517 OpBranch %417 %418 = OpLabel OpBranch %416 %417 = OpLabel %520 = OpPhi %v4float %68 %488 %519 %487 %521 = OpFMul %v4float %412 %520 %522 = OpExtInst %v4float %1 FClamp %521 %59 %61 %523 = OpCompositeExtract %float %522 0 %524 = OpCompositeExtract %float %522 1 %525 = OpCompositeExtract %float %522 2 %526 = OpCompositeExtract %float %522 3 %527 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_0 OpStore %527 %523 %528 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_1 OpStore %528 %524 %529 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_2 OpStore %529 %525 %530 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %uint_0 OpStore %530 %526 OpStore %out_var_PN_POSITION9 %387 OpBranch %if_merge %if_merge = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/tesc/tess-factor-must-be-threadgroup.asm.tesc000066400000000000000000000532061400026215700300270ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 179 ; Schema: 0 OpCapability Tessellation OpCapability SampledBuffer OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %MainHull "main" %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_VS_To_DS_Position %gl_InvocationID %out_var_TEXCOORD10_centroid %out_var_TEXCOORD11_centroid %out_var_VS_To_DS_Position %out_var_Flat_DisplacementScales %out_var_Flat_TessellationMultiplier %out_var_Flat_WorldDisplacementMultiplier %gl_TessLevelOuter %gl_TessLevelInner OpExecutionMode %MainHull Triangles OpExecutionMode %MainHull SpacingFractionalOdd OpExecutionMode %MainHull VertexOrderCw OpExecutionMode %MainHull OutputVertices 3 OpSource HLSL 600 OpName %FFlatTessellationHSToDS "FFlatTessellationHSToDS" OpMemberName %FFlatTessellationHSToDS 0 "PassSpecificData" OpMemberName %FFlatTessellationHSToDS 1 "DisplacementScale" OpMemberName %FFlatTessellationHSToDS 2 "TessellationMultiplier" OpMemberName %FFlatTessellationHSToDS 3 "WorldDisplacementMultiplier" OpName %FBasePassVSToDS "FBasePassVSToDS" OpMemberName %FBasePassVSToDS 0 "FactoryInterpolants" OpMemberName %FBasePassVSToDS 1 "BasePassInterpolants" OpMemberName %FBasePassVSToDS 2 "Position" OpName %FVertexFactoryInterpolantsVSToDS "FVertexFactoryInterpolantsVSToDS" OpMemberName %FVertexFactoryInterpolantsVSToDS 0 "InterpolantsVSToPS" OpName %FVertexFactoryInterpolantsVSToPS "FVertexFactoryInterpolantsVSToPS" OpMemberName %FVertexFactoryInterpolantsVSToPS 0 "TangentToWorld0" OpMemberName %FVertexFactoryInterpolantsVSToPS 1 "TangentToWorld2" OpName %FBasePassInterpolantsVSToDS "FBasePassInterpolantsVSToDS" OpName %FSharedBasePassInterpolants "FSharedBasePassInterpolants" OpName %type_Primitive "type.Primitive" OpMemberName %type_Primitive 0 "Primitive_LocalToWorld" OpMemberName %type_Primitive 1 "Primitive_InvNonUniformScaleAndDeterminantSign" OpMemberName %type_Primitive 2 "Primitive_ObjectWorldPositionAndRadius" OpMemberName %type_Primitive 3 "Primitive_WorldToLocal" OpMemberName %type_Primitive 4 "Primitive_PreviousLocalToWorld" OpMemberName %type_Primitive 5 "Primitive_PreviousWorldToLocal" OpMemberName %type_Primitive 6 "Primitive_ActorWorldPosition" OpMemberName %type_Primitive 7 "Primitive_UseSingleSampleShadowFromStationaryLights" OpMemberName %type_Primitive 8 "Primitive_ObjectBounds" OpMemberName %type_Primitive 9 "Primitive_LpvBiasMultiplier" OpMemberName %type_Primitive 10 "Primitive_DecalReceiverMask" OpMemberName %type_Primitive 11 "Primitive_PerObjectGBufferData" OpMemberName %type_Primitive 12 "Primitive_UseVolumetricLightmapShadowFromStationaryLights" OpMemberName %type_Primitive 13 "Primitive_DrawsVelocity" OpMemberName %type_Primitive 14 "Primitive_ObjectOrientation" OpMemberName %type_Primitive 15 "Primitive_NonUniformScale" OpMemberName %type_Primitive 16 "Primitive_LocalObjectBoundsMin" OpMemberName %type_Primitive 17 "Primitive_LightingChannelMask" OpMemberName %type_Primitive 18 "Primitive_LocalObjectBoundsMax" OpMemberName %type_Primitive 19 "Primitive_LightmapDataIndex" OpMemberName %type_Primitive 20 "Primitive_PreSkinnedLocalBounds" OpMemberName %type_Primitive 21 "Primitive_SingleCaptureIndex" OpMemberName %type_Primitive 22 "Primitive_OutputVelocity" OpMemberName %type_Primitive 23 "PrePadding_Primitive_420" OpMemberName %type_Primitive 24 "PrePadding_Primitive_424" OpMemberName %type_Primitive 25 "PrePadding_Primitive_428" OpMemberName %type_Primitive 26 "Primitive_CustomPrimitiveData" OpName %Primitive "Primitive" OpName %type_Material "type.Material" OpMemberName %type_Material 0 "Material_VectorExpressions" OpMemberName %type_Material 1 "Material_ScalarExpressions" OpName %Material "Material" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_VS_To_DS_Position "in.var.VS_To_DS_Position" OpName %out_var_TEXCOORD10_centroid "out.var.TEXCOORD10_centroid" OpName %out_var_TEXCOORD11_centroid "out.var.TEXCOORD11_centroid" OpName %out_var_VS_To_DS_Position "out.var.VS_To_DS_Position" OpName %out_var_Flat_DisplacementScales "out.var.Flat_DisplacementScales" OpName %out_var_Flat_TessellationMultiplier "out.var.Flat_TessellationMultiplier" OpName %out_var_Flat_WorldDisplacementMultiplier "out.var.Flat_WorldDisplacementMultiplier" OpName %MainHull "MainHull" OpName %param_var_I "param.var.I" OpName %temp_var_hullMainRetVal "temp.var.hullMainRetVal" OpName %if_merge "if.merge" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorateString %gl_InvocationID UserSemantic "SV_OutputControlPointID" OpDecorateString %out_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %out_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %out_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorateString %out_var_Flat_DisplacementScales UserSemantic "Flat_DisplacementScales" OpDecorateString %out_var_Flat_TessellationMultiplier UserSemantic "Flat_TessellationMultiplier" OpDecorateString %out_var_Flat_WorldDisplacementMultiplier UserSemantic "Flat_WorldDisplacementMultiplier" OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter OpDecorateString %gl_TessLevelOuter UserSemantic "SV_TessFactor" OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorateString %gl_TessLevelInner UserSemantic "SV_InsideTessFactor" OpDecorate %gl_TessLevelInner Patch OpDecorate %in_var_TEXCOORD10_centroid Location 0 OpDecorate %in_var_TEXCOORD11_centroid Location 1 OpDecorate %in_var_VS_To_DS_Position Location 2 OpDecorate %out_var_Flat_DisplacementScales Location 0 OpDecorate %out_var_Flat_TessellationMultiplier Location 1 OpDecorate %out_var_Flat_WorldDisplacementMultiplier Location 2 OpDecorate %out_var_TEXCOORD10_centroid Location 3 OpDecorate %out_var_TEXCOORD11_centroid Location 4 OpDecorate %out_var_VS_To_DS_Position Location 5 OpDecorate %Primitive DescriptorSet 0 OpDecorate %Primitive Binding 0 OpDecorate %Material DescriptorSet 0 OpDecorate %Material Binding 1 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_Primitive 0 Offset 0 OpMemberDecorate %type_Primitive 0 MatrixStride 16 OpMemberDecorate %type_Primitive 0 ColMajor OpMemberDecorate %type_Primitive 1 Offset 64 OpMemberDecorate %type_Primitive 2 Offset 80 OpMemberDecorate %type_Primitive 3 Offset 96 OpMemberDecorate %type_Primitive 3 MatrixStride 16 OpMemberDecorate %type_Primitive 3 ColMajor OpMemberDecorate %type_Primitive 4 Offset 160 OpMemberDecorate %type_Primitive 4 MatrixStride 16 OpMemberDecorate %type_Primitive 4 ColMajor OpMemberDecorate %type_Primitive 5 Offset 224 OpMemberDecorate %type_Primitive 5 MatrixStride 16 OpMemberDecorate %type_Primitive 5 ColMajor OpMemberDecorate %type_Primitive 6 Offset 288 OpMemberDecorate %type_Primitive 7 Offset 300 OpMemberDecorate %type_Primitive 8 Offset 304 OpMemberDecorate %type_Primitive 9 Offset 316 OpMemberDecorate %type_Primitive 10 Offset 320 OpMemberDecorate %type_Primitive 11 Offset 324 OpMemberDecorate %type_Primitive 12 Offset 328 OpMemberDecorate %type_Primitive 13 Offset 332 OpMemberDecorate %type_Primitive 14 Offset 336 OpMemberDecorate %type_Primitive 15 Offset 352 OpMemberDecorate %type_Primitive 16 Offset 368 OpMemberDecorate %type_Primitive 17 Offset 380 OpMemberDecorate %type_Primitive 18 Offset 384 OpMemberDecorate %type_Primitive 19 Offset 396 OpMemberDecorate %type_Primitive 20 Offset 400 OpMemberDecorate %type_Primitive 21 Offset 412 OpMemberDecorate %type_Primitive 22 Offset 416 OpMemberDecorate %type_Primitive 23 Offset 420 OpMemberDecorate %type_Primitive 24 Offset 424 OpMemberDecorate %type_Primitive 25 Offset 428 OpMemberDecorate %type_Primitive 26 Offset 432 OpDecorate %type_Primitive Block OpDecorate %_arr_v4float_uint_3 ArrayStride 16 OpDecorate %_arr_v4float_uint_1 ArrayStride 16 OpMemberDecorate %type_Material 0 Offset 0 OpMemberDecorate %type_Material 1 Offset 48 OpDecorate %type_Material Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_4 = OpConstant %uint 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %float_0_5 = OpConstant %float 0.5 %int_1 = OpConstant %int 1 %float_0_333000004 = OpConstant %float 0.333000004 %float_1 = OpConstant %float 1 %49 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_15 = OpConstant %float 15 %51 = OpConstantComposite %v4float %float_15 %float_15 %float_15 %float_15 %FVertexFactoryInterpolantsVSToPS = OpTypeStruct %v4float %v4float %FVertexFactoryInterpolantsVSToDS = OpTypeStruct %FVertexFactoryInterpolantsVSToPS %FSharedBasePassInterpolants = OpTypeStruct %FBasePassInterpolantsVSToDS = OpTypeStruct %FSharedBasePassInterpolants %FBasePassVSToDS = OpTypeStruct %FVertexFactoryInterpolantsVSToDS %FBasePassInterpolantsVSToDS %v4float %FFlatTessellationHSToDS = OpTypeStruct %FBasePassVSToDS %v3float %float %float %int_15 = OpConstant %int 15 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_Primitive = OpTypeStruct %mat4v4float %v4float %v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %float %float %float %float %v4float %v4float %v3float %uint %v3float %uint %v3float %int %uint %uint %uint %uint %_arr_v4float_uint_4 %_ptr_Uniform_type_Primitive = OpTypePointer Uniform %type_Primitive %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %type_Material = OpTypeStruct %_arr_v4float_uint_3 %_arr_v4float_uint_1 %_ptr_Uniform_type_Material = OpTypePointer Uniform %type_Material %_arr_v4float_uint_3_0 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3_0 = OpTypePointer Input %_arr_v4float_uint_3_0 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output__arr_v4float_uint_3_0 = OpTypePointer Output %_arr_v4float_uint_3_0 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Output__arr_v3float_uint_3 = OpTypePointer Output %_arr_v3float_uint_3 %_ptr_Output__arr_float_uint_3 = OpTypePointer Output %_arr_float_uint_3 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %void = OpTypeVoid %67 = OpTypeFunction %void %_arr_FBasePassVSToDS_uint_3 = OpTypeArray %FBasePassVSToDS %uint_3 %_ptr_Function__arr_FBasePassVSToDS_uint_3 = OpTypePointer Function %_arr_FBasePassVSToDS_uint_3 %_arr_FFlatTessellationHSToDS_uint_3 = OpTypeArray %FFlatTessellationHSToDS %uint_3 %_ptr_Function__arr_FFlatTessellationHSToDS_uint_3 = OpTypePointer Function %_arr_FFlatTessellationHSToDS_uint_3 %_ptr_Workgroup__arr_FFlatTessellationHSToDS_uint_3 = OpTypePointer Workgroup %_arr_FFlatTessellationHSToDS_uint_3 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Output_v3float = OpTypePointer Output %v3float %_ptr_Output_float = OpTypePointer Output %float %_ptr_Function_FFlatTessellationHSToDS = OpTypePointer Function %FFlatTessellationHSToDS %_ptr_Workgroup_FFlatTessellationHSToDS = OpTypePointer Workgroup %FFlatTessellationHSToDS %bool = OpTypeBool %_ptr_Function_float = OpTypePointer Function %float %_ptr_Workgroup_float = OpTypePointer Workgroup %float %mat3v3float = OpTypeMatrix %v3float 3 %_ptr_Function_FVertexFactoryInterpolantsVSToDS = OpTypePointer Function %FVertexFactoryInterpolantsVSToDS %_ptr_Function_FBasePassVSToDS = OpTypePointer Function %FBasePassVSToDS %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %Primitive = OpVariable %_ptr_Uniform_type_Primitive Uniform %Material = OpVariable %_ptr_Uniform_type_Material Uniform %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3_0 Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3_0 Input %in_var_VS_To_DS_Position = OpVariable %_ptr_Input__arr_v4float_uint_3_0 Input %gl_InvocationID = OpVariable %_ptr_Input_uint Input %out_var_TEXCOORD10_centroid = OpVariable %_ptr_Output__arr_v4float_uint_3_0 Output %out_var_TEXCOORD11_centroid = OpVariable %_ptr_Output__arr_v4float_uint_3_0 Output %out_var_VS_To_DS_Position = OpVariable %_ptr_Output__arr_v4float_uint_3_0 Output %out_var_Flat_DisplacementScales = OpVariable %_ptr_Output__arr_v3float_uint_3 Output %out_var_Flat_TessellationMultiplier = OpVariable %_ptr_Output__arr_float_uint_3 Output %out_var_Flat_WorldDisplacementMultiplier = OpVariable %_ptr_Output__arr_float_uint_3 Output %gl_TessLevelOuter = OpVariable %_ptr_Output__arr_float_uint_4 Output %gl_TessLevelInner = OpVariable %_ptr_Output__arr_float_uint_2 Output %83 = OpConstantNull %FSharedBasePassInterpolants %84 = OpConstantComposite %FBasePassInterpolantsVSToDS %83 %85 = OpUndef %v4float ; XXX: Original asm used Function here, which is wrong. ; This patches the SPIR-V to be correct. %temp_var_hullMainRetVal = OpVariable %_ptr_Workgroup__arr_FFlatTessellationHSToDS_uint_3 Workgroup %MainHull = OpFunction %void None %67 %86 = OpLabel %param_var_I = OpVariable %_ptr_Function__arr_FBasePassVSToDS_uint_3 Function %87 = OpLoad %_arr_v4float_uint_3_0 %in_var_TEXCOORD10_centroid %88 = OpLoad %_arr_v4float_uint_3_0 %in_var_TEXCOORD11_centroid %89 = OpCompositeExtract %v4float %87 0 %90 = OpCompositeExtract %v4float %88 0 %91 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %89 %90 %92 = OpCompositeExtract %v4float %87 1 %93 = OpCompositeExtract %v4float %88 1 %94 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %92 %93 %95 = OpCompositeExtract %v4float %87 2 %96 = OpCompositeExtract %v4float %88 2 %97 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToPS %95 %96 %98 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %91 %99 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %94 %100 = OpCompositeConstruct %FVertexFactoryInterpolantsVSToDS %97 %101 = OpLoad %_arr_v4float_uint_3_0 %in_var_VS_To_DS_Position %102 = OpCompositeExtract %v4float %101 0 %103 = OpCompositeConstruct %FBasePassVSToDS %98 %84 %102 %104 = OpCompositeExtract %v4float %101 1 %105 = OpCompositeConstruct %FBasePassVSToDS %99 %84 %104 %106 = OpCompositeExtract %v4float %101 2 %107 = OpCompositeConstruct %FBasePassVSToDS %100 %84 %106 %108 = OpCompositeConstruct %_arr_FBasePassVSToDS_uint_3 %103 %105 %107 OpStore %param_var_I %108 %109 = OpLoad %uint %gl_InvocationID %110 = OpAccessChain %_ptr_Function_FVertexFactoryInterpolantsVSToDS %param_var_I %109 %int_0 %111 = OpLoad %FVertexFactoryInterpolantsVSToDS %110 %112 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %111 0 %113 = OpCompositeExtract %v4float %112 0 %114 = OpCompositeExtract %v4float %112 1 %115 = OpVectorShuffle %v3float %113 %113 0 1 2 %116 = OpVectorShuffle %v3float %114 %114 0 1 2 %117 = OpExtInst %v3float %1 Cross %116 %115 %118 = OpCompositeExtract %float %114 3 %119 = OpCompositeConstruct %v3float %118 %118 %118 %120 = OpFMul %v3float %117 %119 %121 = OpCompositeConstruct %mat3v3float %115 %120 %116 %122 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_15 %123 = OpLoad %v4float %122 %124 = OpVectorShuffle %v3float %123 %123 0 1 2 %125 = OpVectorTimesMatrix %v3float %124 %121 %126 = OpAccessChain %_ptr_Function_FBasePassVSToDS %param_var_I %109 %127 = OpLoad %FBasePassVSToDS %126 %128 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_0 %int_0 %129 = OpLoad %float %128 %130 = OpCompositeConstruct %FFlatTessellationHSToDS %127 %125 %129 %float_1 %131 = OpCompositeExtract %FVertexFactoryInterpolantsVSToDS %127 0 %132 = OpCompositeExtract %FVertexFactoryInterpolantsVSToPS %131 0 %133 = OpCompositeExtract %v4float %132 0 %134 = OpAccessChain %_ptr_Output_v4float %out_var_TEXCOORD10_centroid %109 OpStore %134 %133 %135 = OpCompositeExtract %v4float %132 1 %136 = OpAccessChain %_ptr_Output_v4float %out_var_TEXCOORD11_centroid %109 OpStore %136 %135 %137 = OpCompositeExtract %v4float %127 2 %138 = OpAccessChain %_ptr_Output_v4float %out_var_VS_To_DS_Position %109 OpStore %138 %137 %139 = OpAccessChain %_ptr_Output_v3float %out_var_Flat_DisplacementScales %109 OpStore %139 %125 %140 = OpAccessChain %_ptr_Output_float %out_var_Flat_TessellationMultiplier %109 OpStore %140 %129 %141 = OpAccessChain %_ptr_Output_float %out_var_Flat_WorldDisplacementMultiplier %109 OpStore %141 %float_1 %142 = OpAccessChain %_ptr_Workgroup_FFlatTessellationHSToDS %temp_var_hullMainRetVal %109 OpStore %142 %130 OpControlBarrier %uint_2 %uint_4 %uint_0 %143 = OpIEqual %bool %109 %uint_0 OpSelectionMerge %if_merge None OpBranchConditional %143 %144 %if_merge %144 = OpLabel %145 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_1 %int_2 %146 = OpLoad %float %145 %147 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_2 %int_2 %148 = OpLoad %float %147 %149 = OpFAdd %float %146 %148 %150 = OpFMul %float %float_0_5 %149 %151 = OpCompositeInsert %v4float %150 %85 0 %152 = OpLoad %float %147 %153 = OpAccessChain %_ptr_Workgroup_float %temp_var_hullMainRetVal %uint_0 %int_2 %154 = OpLoad %float %153 %155 = OpFAdd %float %152 %154 %156 = OpFMul %float %float_0_5 %155 %157 = OpCompositeInsert %v4float %156 %151 1 %158 = OpLoad %float %153 %159 = OpLoad %float %145 %160 = OpFAdd %float %158 %159 %161 = OpFMul %float %float_0_5 %160 %162 = OpCompositeInsert %v4float %161 %157 2 %163 = OpLoad %float %153 %164 = OpLoad %float %145 %165 = OpFAdd %float %163 %164 %166 = OpLoad %float %147 %167 = OpFAdd %float %165 %166 %168 = OpFMul %float %float_0_333000004 %167 %169 = OpCompositeInsert %v4float %168 %162 3 %170 = OpExtInst %v4float %1 FClamp %169 %49 %51 %171 = OpCompositeExtract %float %170 0 %172 = OpCompositeExtract %float %170 1 %173 = OpCompositeExtract %float %170 2 %174 = OpCompositeExtract %float %170 3 %175 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_0 OpStore %175 %171 %176 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_1 OpStore %176 %172 %177 = OpAccessChain %_ptr_Output_float %gl_TessLevelOuter %uint_2 OpStore %177 %173 %178 = OpAccessChain %_ptr_Output_float %gl_TessLevelInner %uint_0 OpStore %178 %174 OpBranch %if_merge %if_merge = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/tese/000077500000000000000000000000001400026215700202365ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4/asm/tese/ds-double-gl-in-deref.asm.tese000066400000000000000000002053051400026215700256510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 310 ; Schema: 0 OpCapability Tessellation OpCapability SampledBuffer OpCapability StorageImageExtendedFormats OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %MainDomain "main" %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_COLOR0 %in_var_TEXCOORD0 %in_var_PRIMITIVE_ID %in_var_VS_to_DS_Position %in_var_PN_POSITION %in_var_PN_DisplacementScales %in_var_PN_TessellationMultiplier %in_var_PN_WorldDisplacementMultiplier %gl_TessLevelOuter %gl_TessLevelInner %in_var_PN_POSITION9 %gl_TessCoord %out_var_TEXCOORD10_centroid %out_var_TEXCOORD11_centroid %out_var_COLOR0 %out_var_TEXCOORD0 %out_var_PRIMITIVE_ID %out_var_TEXCOORD6 %out_var_TEXCOORD8 %out_var_TEXCOORD7 %gl_Position OpExecutionMode %MainDomain Triangles OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_ClipToWorld" OpMemberName %type_View 3 "View_TranslatedWorldToView" OpMemberName %type_View 4 "View_ViewToTranslatedWorld" OpMemberName %type_View 5 "View_TranslatedWorldToCameraView" OpMemberName %type_View 6 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 7 "View_ViewToClip" OpMemberName %type_View 8 "View_ViewToClipNoAA" OpMemberName %type_View 9 "View_ClipToView" OpMemberName %type_View 10 "View_ClipToTranslatedWorld" OpMemberName %type_View 11 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 12 "View_ScreenToWorld" OpMemberName %type_View 13 "View_ScreenToTranslatedWorld" OpMemberName %type_View 14 "View_ViewForward" OpMemberName %type_View 15 "PrePadding_View_908" OpMemberName %type_View 16 "View_ViewUp" OpMemberName %type_View 17 "PrePadding_View_924" OpMemberName %type_View 18 "View_ViewRight" OpMemberName %type_View 19 "PrePadding_View_940" OpMemberName %type_View 20 "View_HMDViewNoRollUp" OpMemberName %type_View 21 "PrePadding_View_956" OpMemberName %type_View 22 "View_HMDViewNoRollRight" OpMemberName %type_View 23 "PrePadding_View_972" OpMemberName %type_View 24 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 25 "View_ScreenPositionScaleBias" OpMemberName %type_View 26 "View_WorldCameraOrigin" OpMemberName %type_View 27 "PrePadding_View_1020" OpMemberName %type_View 28 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 29 "PrePadding_View_1036" OpMemberName %type_View 30 "View_WorldViewOrigin" OpMemberName %type_View 31 "PrePadding_View_1052" OpMemberName %type_View 32 "View_PreViewTranslation" OpMemberName %type_View 33 "PrePadding_View_1068" OpMemberName %type_View 34 "View_PrevProjection" OpMemberName %type_View 35 "View_PrevViewProj" OpMemberName %type_View 36 "View_PrevViewRotationProj" OpMemberName %type_View 37 "View_PrevViewToClip" OpMemberName %type_View 38 "View_PrevClipToView" OpMemberName %type_View 39 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 40 "View_PrevTranslatedWorldToView" OpMemberName %type_View 41 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 42 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 43 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 44 "View_PrevWorldCameraOrigin" OpMemberName %type_View 45 "PrePadding_View_1724" OpMemberName %type_View 46 "View_PrevWorldViewOrigin" OpMemberName %type_View 47 "PrePadding_View_1740" OpMemberName %type_View 48 "View_PrevPreViewTranslation" OpMemberName %type_View 49 "PrePadding_View_1756" OpMemberName %type_View 50 "View_PrevInvViewProj" OpMemberName %type_View 51 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 52 "View_ClipToPrevClip" OpMemberName %type_View 53 "View_TemporalAAJitter" OpMemberName %type_View 54 "View_GlobalClippingPlane" OpMemberName %type_View 55 "View_FieldOfViewWideAngles" OpMemberName %type_View 56 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 57 "View_ViewRectMin" OpMemberName %type_View 58 "View_ViewSizeAndInvSize" OpMemberName %type_View 59 "View_BufferSizeAndInvSize" OpMemberName %type_View 60 "View_BufferBilinearUVMinMax" OpMemberName %type_View 61 "View_NumSceneColorMSAASamples" OpMemberName %type_View 62 "View_PreExposure" OpMemberName %type_View 63 "View_OneOverPreExposure" OpMemberName %type_View 64 "PrePadding_View_2076" OpMemberName %type_View 65 "View_DiffuseOverrideParameter" OpMemberName %type_View 66 "View_SpecularOverrideParameter" OpMemberName %type_View 67 "View_NormalOverrideParameter" OpMemberName %type_View 68 "View_RoughnessOverrideParameter" OpMemberName %type_View 69 "View_PrevFrameGameTime" OpMemberName %type_View 70 "View_PrevFrameRealTime" OpMemberName %type_View 71 "View_OutOfBoundsMask" OpMemberName %type_View 72 "PrePadding_View_2148" OpMemberName %type_View 73 "PrePadding_View_2152" OpMemberName %type_View 74 "PrePadding_View_2156" OpMemberName %type_View 75 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 76 "View_CullingSign" OpMemberName %type_View 77 "View_NearPlane" OpMemberName %type_View 78 "View_AdaptiveTessellationFactor" OpMemberName %type_View 79 "View_GameTime" OpMemberName %type_View 80 "View_RealTime" OpMemberName %type_View 81 "View_DeltaTime" OpMemberName %type_View 82 "View_MaterialTextureMipBias" OpMemberName %type_View 83 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 84 "View_Random" OpMemberName %type_View 85 "View_FrameNumber" OpMemberName %type_View 86 "View_StateFrameIndexMod8" OpMemberName %type_View 87 "View_StateFrameIndex" OpMemberName %type_View 88 "View_CameraCut" OpMemberName %type_View 89 "View_UnlitViewmodeMask" OpMemberName %type_View 90 "PrePadding_View_2228" OpMemberName %type_View 91 "PrePadding_View_2232" OpMemberName %type_View 92 "PrePadding_View_2236" OpMemberName %type_View 93 "View_DirectionalLightColor" OpMemberName %type_View 94 "View_DirectionalLightDirection" OpMemberName %type_View 95 "PrePadding_View_2268" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 97 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 98 "View_TemporalAAParams" OpMemberName %type_View 99 "View_CircleDOFParams" OpMemberName %type_View 100 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 101 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 102 "View_DepthOfFieldScale" OpMemberName %type_View 103 "View_DepthOfFieldFocalLength" OpMemberName %type_View 104 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 105 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 106 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 107 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 108 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 109 "View_GeneralPurposeTweak" OpMemberName %type_View 110 "View_DemosaicVposOffset" OpMemberName %type_View 111 "PrePadding_View_2412" OpMemberName %type_View 112 "View_IndirectLightingColorScale" OpMemberName %type_View 113 "View_HDR32bppEncodingMode" OpMemberName %type_View 114 "View_AtmosphericFogSunDirection" OpMemberName %type_View 115 "View_AtmosphericFogSunPower" OpMemberName %type_View 116 "View_AtmosphericFogPower" OpMemberName %type_View 117 "View_AtmosphericFogDensityScale" OpMemberName %type_View 118 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 119 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 120 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 121 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 122 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 123 "View_AtmosphericFogStartDistance" OpMemberName %type_View 124 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 125 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 126 "View_AtmosphericFogSunDiscHalfApexAngleRadian" OpMemberName %type_View 127 "PrePadding_View_2492" OpMemberName %type_View 128 "View_AtmosphericFogSunDiscLuminance" OpMemberName %type_View 129 "View_AtmosphericFogRenderMask" OpMemberName %type_View 130 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 131 "PrePadding_View_2520" OpMemberName %type_View 132 "PrePadding_View_2524" OpMemberName %type_View 133 "View_AtmosphericFogSunColor" OpMemberName %type_View 134 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 135 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 136 "View_AmbientCubemapTint" OpMemberName %type_View 137 "View_AmbientCubemapIntensity" OpMemberName %type_View 138 "View_SkyLightParameters" OpMemberName %type_View 139 "PrePadding_View_2584" OpMemberName %type_View 140 "PrePadding_View_2588" OpMemberName %type_View 141 "View_SkyLightColor" OpMemberName %type_View 142 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 143 "View_MobilePreviewMode" OpMemberName %type_View 144 "View_HMDEyePaddingOffset" OpMemberName %type_View 145 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 146 "View_ShowDecalsMask" OpMemberName %type_View 147 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 148 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 149 "PrePadding_View_2744" OpMemberName %type_View 150 "PrePadding_View_2748" OpMemberName %type_View 151 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 152 "View_StereoPassIndex" OpMemberName %type_View 153 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 154 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 155 "View_GlobalVolumeDimension" OpMemberName %type_View 156 "View_GlobalVolumeTexelSize" OpMemberName %type_View 157 "View_MaxGlobalDistance" OpMemberName %type_View 158 "PrePadding_View_2908" OpMemberName %type_View 159 "View_CursorPosition" OpMemberName %type_View 160 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 161 "PrePadding_View_2924" OpMemberName %type_View 162 "View_VolumetricFogInvGridSize" OpMemberName %type_View 163 "PrePadding_View_2940" OpMemberName %type_View 164 "View_VolumetricFogGridZParams" OpMemberName %type_View 165 "PrePadding_View_2956" OpMemberName %type_View 166 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 167 "View_VolumetricFogMaxDistance" OpMemberName %type_View 168 "PrePadding_View_2972" OpMemberName %type_View 169 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 170 "PrePadding_View_2988" OpMemberName %type_View 171 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 172 "PrePadding_View_3004" OpMemberName %type_View 173 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 174 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 175 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 176 "View_StereoIPD" OpMemberName %type_View 177 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 178 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_sampler "type.sampler" OpName %type_2d_image "type.2d.image" OpName %type_ShadowDepthPass "type.ShadowDepthPass" OpMemberName %type_ShadowDepthPass 0 "PrePadding_ShadowDepthPass_LPV_0" OpMemberName %type_ShadowDepthPass 1 "PrePadding_ShadowDepthPass_LPV_4" OpMemberName %type_ShadowDepthPass 2 "PrePadding_ShadowDepthPass_LPV_8" OpMemberName %type_ShadowDepthPass 3 "PrePadding_ShadowDepthPass_LPV_12" OpMemberName %type_ShadowDepthPass 4 "PrePadding_ShadowDepthPass_LPV_16" OpMemberName %type_ShadowDepthPass 5 "PrePadding_ShadowDepthPass_LPV_20" OpMemberName %type_ShadowDepthPass 6 "PrePadding_ShadowDepthPass_LPV_24" OpMemberName %type_ShadowDepthPass 7 "PrePadding_ShadowDepthPass_LPV_28" OpMemberName %type_ShadowDepthPass 8 "PrePadding_ShadowDepthPass_LPV_32" OpMemberName %type_ShadowDepthPass 9 "PrePadding_ShadowDepthPass_LPV_36" OpMemberName %type_ShadowDepthPass 10 "PrePadding_ShadowDepthPass_LPV_40" OpMemberName %type_ShadowDepthPass 11 "PrePadding_ShadowDepthPass_LPV_44" OpMemberName %type_ShadowDepthPass 12 "PrePadding_ShadowDepthPass_LPV_48" OpMemberName %type_ShadowDepthPass 13 "PrePadding_ShadowDepthPass_LPV_52" OpMemberName %type_ShadowDepthPass 14 "PrePadding_ShadowDepthPass_LPV_56" OpMemberName %type_ShadowDepthPass 15 "PrePadding_ShadowDepthPass_LPV_60" OpMemberName %type_ShadowDepthPass 16 "PrePadding_ShadowDepthPass_LPV_64" OpMemberName %type_ShadowDepthPass 17 "PrePadding_ShadowDepthPass_LPV_68" OpMemberName %type_ShadowDepthPass 18 "PrePadding_ShadowDepthPass_LPV_72" OpMemberName %type_ShadowDepthPass 19 "PrePadding_ShadowDepthPass_LPV_76" OpMemberName %type_ShadowDepthPass 20 "PrePadding_ShadowDepthPass_LPV_80" OpMemberName %type_ShadowDepthPass 21 "PrePadding_ShadowDepthPass_LPV_84" OpMemberName %type_ShadowDepthPass 22 "PrePadding_ShadowDepthPass_LPV_88" OpMemberName %type_ShadowDepthPass 23 "PrePadding_ShadowDepthPass_LPV_92" OpMemberName %type_ShadowDepthPass 24 "PrePadding_ShadowDepthPass_LPV_96" OpMemberName %type_ShadowDepthPass 25 "PrePadding_ShadowDepthPass_LPV_100" OpMemberName %type_ShadowDepthPass 26 "PrePadding_ShadowDepthPass_LPV_104" OpMemberName %type_ShadowDepthPass 27 "PrePadding_ShadowDepthPass_LPV_108" OpMemberName %type_ShadowDepthPass 28 "PrePadding_ShadowDepthPass_LPV_112" OpMemberName %type_ShadowDepthPass 29 "PrePadding_ShadowDepthPass_LPV_116" OpMemberName %type_ShadowDepthPass 30 "PrePadding_ShadowDepthPass_LPV_120" OpMemberName %type_ShadowDepthPass 31 "PrePadding_ShadowDepthPass_LPV_124" OpMemberName %type_ShadowDepthPass 32 "PrePadding_ShadowDepthPass_LPV_128" OpMemberName %type_ShadowDepthPass 33 "PrePadding_ShadowDepthPass_LPV_132" OpMemberName %type_ShadowDepthPass 34 "PrePadding_ShadowDepthPass_LPV_136" OpMemberName %type_ShadowDepthPass 35 "PrePadding_ShadowDepthPass_LPV_140" OpMemberName %type_ShadowDepthPass 36 "PrePadding_ShadowDepthPass_LPV_144" OpMemberName %type_ShadowDepthPass 37 "PrePadding_ShadowDepthPass_LPV_148" OpMemberName %type_ShadowDepthPass 38 "PrePadding_ShadowDepthPass_LPV_152" OpMemberName %type_ShadowDepthPass 39 "PrePadding_ShadowDepthPass_LPV_156" OpMemberName %type_ShadowDepthPass 40 "PrePadding_ShadowDepthPass_LPV_160" OpMemberName %type_ShadowDepthPass 41 "PrePadding_ShadowDepthPass_LPV_164" OpMemberName %type_ShadowDepthPass 42 "PrePadding_ShadowDepthPass_LPV_168" OpMemberName %type_ShadowDepthPass 43 "PrePadding_ShadowDepthPass_LPV_172" OpMemberName %type_ShadowDepthPass 44 "PrePadding_ShadowDepthPass_LPV_176" OpMemberName %type_ShadowDepthPass 45 "PrePadding_ShadowDepthPass_LPV_180" OpMemberName %type_ShadowDepthPass 46 "PrePadding_ShadowDepthPass_LPV_184" OpMemberName %type_ShadowDepthPass 47 "PrePadding_ShadowDepthPass_LPV_188" OpMemberName %type_ShadowDepthPass 48 "PrePadding_ShadowDepthPass_LPV_192" OpMemberName %type_ShadowDepthPass 49 "PrePadding_ShadowDepthPass_LPV_196" OpMemberName %type_ShadowDepthPass 50 "PrePadding_ShadowDepthPass_LPV_200" OpMemberName %type_ShadowDepthPass 51 "PrePadding_ShadowDepthPass_LPV_204" OpMemberName %type_ShadowDepthPass 52 "PrePadding_ShadowDepthPass_LPV_208" OpMemberName %type_ShadowDepthPass 53 "PrePadding_ShadowDepthPass_LPV_212" OpMemberName %type_ShadowDepthPass 54 "PrePadding_ShadowDepthPass_LPV_216" OpMemberName %type_ShadowDepthPass 55 "PrePadding_ShadowDepthPass_LPV_220" OpMemberName %type_ShadowDepthPass 56 "PrePadding_ShadowDepthPass_LPV_224" OpMemberName %type_ShadowDepthPass 57 "PrePadding_ShadowDepthPass_LPV_228" OpMemberName %type_ShadowDepthPass 58 "PrePadding_ShadowDepthPass_LPV_232" OpMemberName %type_ShadowDepthPass 59 "PrePadding_ShadowDepthPass_LPV_236" OpMemberName %type_ShadowDepthPass 60 "PrePadding_ShadowDepthPass_LPV_240" OpMemberName %type_ShadowDepthPass 61 "PrePadding_ShadowDepthPass_LPV_244" OpMemberName %type_ShadowDepthPass 62 "PrePadding_ShadowDepthPass_LPV_248" OpMemberName %type_ShadowDepthPass 63 "PrePadding_ShadowDepthPass_LPV_252" OpMemberName %type_ShadowDepthPass 64 "PrePadding_ShadowDepthPass_LPV_256" OpMemberName %type_ShadowDepthPass 65 "PrePadding_ShadowDepthPass_LPV_260" OpMemberName %type_ShadowDepthPass 66 "PrePadding_ShadowDepthPass_LPV_264" OpMemberName %type_ShadowDepthPass 67 "PrePadding_ShadowDepthPass_LPV_268" OpMemberName %type_ShadowDepthPass 68 "ShadowDepthPass_LPV_mRsmToWorld" OpMemberName %type_ShadowDepthPass 69 "ShadowDepthPass_LPV_mLightColour" OpMemberName %type_ShadowDepthPass 70 "ShadowDepthPass_LPV_GeometryVolumeCaptureLightDirection" OpMemberName %type_ShadowDepthPass 71 "ShadowDepthPass_LPV_mEyePos" OpMemberName %type_ShadowDepthPass 72 "ShadowDepthPass_LPV_mOldGridOffset" OpMemberName %type_ShadowDepthPass 73 "PrePadding_ShadowDepthPass_LPV_396" OpMemberName %type_ShadowDepthPass 74 "ShadowDepthPass_LPV_mLpvGridOffset" OpMemberName %type_ShadowDepthPass 75 "ShadowDepthPass_LPV_ClearMultiplier" OpMemberName %type_ShadowDepthPass 76 "ShadowDepthPass_LPV_LpvScale" OpMemberName %type_ShadowDepthPass 77 "ShadowDepthPass_LPV_OneOverLpvScale" OpMemberName %type_ShadowDepthPass 78 "ShadowDepthPass_LPV_DirectionalOcclusionIntensity" OpMemberName %type_ShadowDepthPass 79 "ShadowDepthPass_LPV_DirectionalOcclusionRadius" OpMemberName %type_ShadowDepthPass 80 "ShadowDepthPass_LPV_RsmAreaIntensityMultiplier" OpMemberName %type_ShadowDepthPass 81 "ShadowDepthPass_LPV_RsmPixelToTexcoordMultiplier" OpMemberName %type_ShadowDepthPass 82 "ShadowDepthPass_LPV_SecondaryOcclusionStrength" OpMemberName %type_ShadowDepthPass 83 "ShadowDepthPass_LPV_SecondaryBounceStrength" OpMemberName %type_ShadowDepthPass 84 "ShadowDepthPass_LPV_VplInjectionBias" OpMemberName %type_ShadowDepthPass 85 "ShadowDepthPass_LPV_GeometryVolumeInjectionBias" OpMemberName %type_ShadowDepthPass 86 "ShadowDepthPass_LPV_EmissiveInjectionMultiplier" OpMemberName %type_ShadowDepthPass 87 "ShadowDepthPass_LPV_PropagationIndex" OpMemberName %type_ShadowDepthPass 88 "ShadowDepthPass_ProjectionMatrix" OpMemberName %type_ShadowDepthPass 89 "ShadowDepthPass_ViewMatrix" OpMemberName %type_ShadowDepthPass 90 "ShadowDepthPass_ShadowParams" OpMemberName %type_ShadowDepthPass 91 "ShadowDepthPass_bClampToNearPlane" OpMemberName %type_ShadowDepthPass 92 "PrePadding_ShadowDepthPass_612" OpMemberName %type_ShadowDepthPass 93 "PrePadding_ShadowDepthPass_616" OpMemberName %type_ShadowDepthPass 94 "PrePadding_ShadowDepthPass_620" OpMemberName %type_ShadowDepthPass 95 "ShadowDepthPass_ShadowViewProjectionMatrices" OpMemberName %type_ShadowDepthPass 96 "ShadowDepthPass_ShadowViewMatrices" OpName %ShadowDepthPass "ShadowDepthPass" OpName %Material_Texture2D_3 "Material_Texture2D_3" OpName %Material_Texture2D_3Sampler "Material_Texture2D_3Sampler" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_COLOR0 "in.var.COLOR0" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %in_var_PRIMITIVE_ID "in.var.PRIMITIVE_ID" OpName %in_var_VS_to_DS_Position "in.var.VS_to_DS_Position" OpName %in_var_PN_POSITION "in.var.PN_POSITION" OpName %in_var_PN_DisplacementScales "in.var.PN_DisplacementScales" OpName %in_var_PN_TessellationMultiplier "in.var.PN_TessellationMultiplier" OpName %in_var_PN_WorldDisplacementMultiplier "in.var.PN_WorldDisplacementMultiplier" OpName %in_var_PN_POSITION9 "in.var.PN_POSITION9" OpName %out_var_TEXCOORD10_centroid "out.var.TEXCOORD10_centroid" OpName %out_var_TEXCOORD11_centroid "out.var.TEXCOORD11_centroid" OpName %out_var_COLOR0 "out.var.COLOR0" OpName %out_var_TEXCOORD0 "out.var.TEXCOORD0" OpName %out_var_PRIMITIVE_ID "out.var.PRIMITIVE_ID" OpName %out_var_TEXCOORD6 "out.var.TEXCOORD6" OpName %out_var_TEXCOORD8 "out.var.TEXCOORD8" OpName %out_var_TEXCOORD7 "out.var.TEXCOORD7" OpName %MainDomain "MainDomain" OpName %type_sampled_image "type.sampled.image" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_COLOR0 UserSemantic "COLOR0" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %in_var_PRIMITIVE_ID UserSemantic "PRIMITIVE_ID" OpDecorateString %in_var_VS_to_DS_Position UserSemantic "VS_to_DS_Position" OpDecorateString %in_var_PN_POSITION UserSemantic "PN_POSITION" OpDecorateString %in_var_PN_DisplacementScales UserSemantic "PN_DisplacementScales" OpDecorateString %in_var_PN_TessellationMultiplier UserSemantic "PN_TessellationMultiplier" OpDecorateString %in_var_PN_WorldDisplacementMultiplier UserSemantic "PN_WorldDisplacementMultiplier" OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter OpDecorateString %gl_TessLevelOuter UserSemantic "SV_TessFactor" OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorateString %gl_TessLevelInner UserSemantic "SV_InsideTessFactor" OpDecorate %gl_TessLevelInner Patch OpDecorateString %in_var_PN_POSITION9 UserSemantic "PN_POSITION9" OpDecorate %in_var_PN_POSITION9 Patch OpDecorate %gl_TessCoord BuiltIn TessCoord OpDecorateString %gl_TessCoord UserSemantic "SV_DomainLocation" OpDecorate %gl_TessCoord Patch OpDecorateString %out_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %out_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %out_var_COLOR0 UserSemantic "COLOR0" OpDecorateString %out_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %out_var_PRIMITIVE_ID UserSemantic "PRIMITIVE_ID" OpDecorateString %out_var_TEXCOORD6 UserSemantic "TEXCOORD6" OpDecorateString %out_var_TEXCOORD8 UserSemantic "TEXCOORD8" OpDecorateString %out_var_TEXCOORD7 UserSemantic "TEXCOORD7" OpDecorate %gl_Position BuiltIn Position OpDecorateString %gl_Position UserSemantic "SV_POSITION" OpDecorate %in_var_COLOR0 Location 0 OpDecorate %in_var_PN_DisplacementScales Location 1 OpDecorate %in_var_PN_POSITION Location 2 OpDecorate %in_var_PN_POSITION9 Location 5 OpDecorate %in_var_PN_TessellationMultiplier Location 6 OpDecorate %in_var_PN_WorldDisplacementMultiplier Location 7 OpDecorate %in_var_PRIMITIVE_ID Location 8 OpDecorate %in_var_TEXCOORD0 Location 9 OpDecorate %in_var_TEXCOORD10_centroid Location 10 OpDecorate %in_var_TEXCOORD11_centroid Location 11 OpDecorate %in_var_VS_to_DS_Position Location 12 OpDecorate %out_var_TEXCOORD10_centroid Location 0 OpDecorate %out_var_TEXCOORD11_centroid Location 1 OpDecorate %out_var_COLOR0 Location 2 OpDecorate %out_var_TEXCOORD0 Location 3 OpDecorate %out_var_PRIMITIVE_ID Location 4 OpDecorate %out_var_TEXCOORD6 Location 5 OpDecorate %out_var_TEXCOORD8 Location 6 OpDecorate %out_var_TEXCOORD7 Location 7 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %ShadowDepthPass DescriptorSet 0 OpDecorate %ShadowDepthPass Binding 1 OpDecorate %Material_Texture2D_3 DescriptorSet 0 OpDecorate %Material_Texture2D_3 Binding 0 OpDecorate %Material_Texture2D_3Sampler DescriptorSet 0 OpDecorate %Material_Texture2D_3Sampler Binding 0 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 13 MatrixStride 16 OpMemberDecorate %type_View 13 ColMajor OpMemberDecorate %type_View 14 Offset 896 OpMemberDecorate %type_View 15 Offset 908 OpMemberDecorate %type_View 16 Offset 912 OpMemberDecorate %type_View 17 Offset 924 OpMemberDecorate %type_View 18 Offset 928 OpMemberDecorate %type_View 19 Offset 940 OpMemberDecorate %type_View 20 Offset 944 OpMemberDecorate %type_View 21 Offset 956 OpMemberDecorate %type_View 22 Offset 960 OpMemberDecorate %type_View 23 Offset 972 OpMemberDecorate %type_View 24 Offset 976 OpMemberDecorate %type_View 25 Offset 992 OpMemberDecorate %type_View 26 Offset 1008 OpMemberDecorate %type_View 27 Offset 1020 OpMemberDecorate %type_View 28 Offset 1024 OpMemberDecorate %type_View 29 Offset 1036 OpMemberDecorate %type_View 30 Offset 1040 OpMemberDecorate %type_View 31 Offset 1052 OpMemberDecorate %type_View 32 Offset 1056 OpMemberDecorate %type_View 33 Offset 1068 OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 43 MatrixStride 16 OpMemberDecorate %type_View 43 ColMajor OpMemberDecorate %type_View 44 Offset 1712 OpMemberDecorate %type_View 45 Offset 1724 OpMemberDecorate %type_View 46 Offset 1728 OpMemberDecorate %type_View 47 Offset 1740 OpMemberDecorate %type_View 48 Offset 1744 OpMemberDecorate %type_View 49 Offset 1756 OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 52 MatrixStride 16 OpMemberDecorate %type_View 52 ColMajor OpMemberDecorate %type_View 53 Offset 1952 OpMemberDecorate %type_View 54 Offset 1968 OpMemberDecorate %type_View 55 Offset 1984 OpMemberDecorate %type_View 56 Offset 1992 OpMemberDecorate %type_View 57 Offset 2000 OpMemberDecorate %type_View 58 Offset 2016 OpMemberDecorate %type_View 59 Offset 2032 OpMemberDecorate %type_View 60 Offset 2048 OpMemberDecorate %type_View 61 Offset 2064 OpMemberDecorate %type_View 62 Offset 2068 OpMemberDecorate %type_View 63 Offset 2072 OpMemberDecorate %type_View 64 Offset 2076 OpMemberDecorate %type_View 65 Offset 2080 OpMemberDecorate %type_View 66 Offset 2096 OpMemberDecorate %type_View 67 Offset 2112 OpMemberDecorate %type_View 68 Offset 2128 OpMemberDecorate %type_View 69 Offset 2136 OpMemberDecorate %type_View 70 Offset 2140 OpMemberDecorate %type_View 71 Offset 2144 OpMemberDecorate %type_View 72 Offset 2148 OpMemberDecorate %type_View 73 Offset 2152 OpMemberDecorate %type_View 74 Offset 2156 OpMemberDecorate %type_View 75 Offset 2160 OpMemberDecorate %type_View 76 Offset 2172 OpMemberDecorate %type_View 77 Offset 2176 OpMemberDecorate %type_View 78 Offset 2180 OpMemberDecorate %type_View 79 Offset 2184 OpMemberDecorate %type_View 80 Offset 2188 OpMemberDecorate %type_View 81 Offset 2192 OpMemberDecorate %type_View 82 Offset 2196 OpMemberDecorate %type_View 83 Offset 2200 OpMemberDecorate %type_View 84 Offset 2204 OpMemberDecorate %type_View 85 Offset 2208 OpMemberDecorate %type_View 86 Offset 2212 OpMemberDecorate %type_View 87 Offset 2216 OpMemberDecorate %type_View 88 Offset 2220 OpMemberDecorate %type_View 89 Offset 2224 OpMemberDecorate %type_View 90 Offset 2228 OpMemberDecorate %type_View 91 Offset 2232 OpMemberDecorate %type_View 92 Offset 2236 OpMemberDecorate %type_View 93 Offset 2240 OpMemberDecorate %type_View 94 Offset 2256 OpMemberDecorate %type_View 95 Offset 2268 OpMemberDecorate %type_View 96 Offset 2272 OpMemberDecorate %type_View 97 Offset 2304 OpMemberDecorate %type_View 98 Offset 2336 OpMemberDecorate %type_View 99 Offset 2352 OpMemberDecorate %type_View 100 Offset 2368 OpMemberDecorate %type_View 101 Offset 2372 OpMemberDecorate %type_View 102 Offset 2376 OpMemberDecorate %type_View 103 Offset 2380 OpMemberDecorate %type_View 104 Offset 2384 OpMemberDecorate %type_View 105 Offset 2388 OpMemberDecorate %type_View 106 Offset 2392 OpMemberDecorate %type_View 107 Offset 2396 OpMemberDecorate %type_View 108 Offset 2400 OpMemberDecorate %type_View 109 Offset 2404 OpMemberDecorate %type_View 110 Offset 2408 OpMemberDecorate %type_View 111 Offset 2412 OpMemberDecorate %type_View 112 Offset 2416 OpMemberDecorate %type_View 113 Offset 2428 OpMemberDecorate %type_View 114 Offset 2432 OpMemberDecorate %type_View 115 Offset 2444 OpMemberDecorate %type_View 116 Offset 2448 OpMemberDecorate %type_View 117 Offset 2452 OpMemberDecorate %type_View 118 Offset 2456 OpMemberDecorate %type_View 119 Offset 2460 OpMemberDecorate %type_View 120 Offset 2464 OpMemberDecorate %type_View 121 Offset 2468 OpMemberDecorate %type_View 122 Offset 2472 OpMemberDecorate %type_View 123 Offset 2476 OpMemberDecorate %type_View 124 Offset 2480 OpMemberDecorate %type_View 125 Offset 2484 OpMemberDecorate %type_View 126 Offset 2488 OpMemberDecorate %type_View 127 Offset 2492 OpMemberDecorate %type_View 128 Offset 2496 OpMemberDecorate %type_View 129 Offset 2512 OpMemberDecorate %type_View 130 Offset 2516 OpMemberDecorate %type_View 131 Offset 2520 OpMemberDecorate %type_View 132 Offset 2524 OpMemberDecorate %type_View 133 Offset 2528 OpMemberDecorate %type_View 134 Offset 2544 OpMemberDecorate %type_View 135 Offset 2556 OpMemberDecorate %type_View 136 Offset 2560 OpMemberDecorate %type_View 137 Offset 2576 OpMemberDecorate %type_View 138 Offset 2580 OpMemberDecorate %type_View 139 Offset 2584 OpMemberDecorate %type_View 140 Offset 2588 OpMemberDecorate %type_View 141 Offset 2592 OpMemberDecorate %type_View 142 Offset 2608 OpMemberDecorate %type_View 143 Offset 2720 OpMemberDecorate %type_View 144 Offset 2724 OpMemberDecorate %type_View 145 Offset 2728 OpMemberDecorate %type_View 146 Offset 2732 OpMemberDecorate %type_View 147 Offset 2736 OpMemberDecorate %type_View 148 Offset 2740 OpMemberDecorate %type_View 149 Offset 2744 OpMemberDecorate %type_View 150 Offset 2748 OpMemberDecorate %type_View 151 Offset 2752 OpMemberDecorate %type_View 152 Offset 2764 OpMemberDecorate %type_View 153 Offset 2768 OpMemberDecorate %type_View 154 Offset 2832 OpMemberDecorate %type_View 155 Offset 2896 OpMemberDecorate %type_View 156 Offset 2900 OpMemberDecorate %type_View 157 Offset 2904 OpMemberDecorate %type_View 158 Offset 2908 OpMemberDecorate %type_View 159 Offset 2912 OpMemberDecorate %type_View 160 Offset 2920 OpMemberDecorate %type_View 161 Offset 2924 OpMemberDecorate %type_View 162 Offset 2928 OpMemberDecorate %type_View 163 Offset 2940 OpMemberDecorate %type_View 164 Offset 2944 OpMemberDecorate %type_View 165 Offset 2956 OpMemberDecorate %type_View 166 Offset 2960 OpMemberDecorate %type_View 167 Offset 2968 OpMemberDecorate %type_View 168 Offset 2972 OpMemberDecorate %type_View 169 Offset 2976 OpMemberDecorate %type_View 170 Offset 2988 OpMemberDecorate %type_View 171 Offset 2992 OpMemberDecorate %type_View 172 Offset 3004 OpMemberDecorate %type_View 173 Offset 3008 OpMemberDecorate %type_View 174 Offset 3020 OpMemberDecorate %type_View 175 Offset 3024 OpMemberDecorate %type_View 176 Offset 3036 OpMemberDecorate %type_View 177 Offset 3040 OpMemberDecorate %type_View 178 Offset 3044 OpDecorate %type_View Block OpDecorate %_arr_mat4v4float_uint_6 ArrayStride 64 OpMemberDecorate %type_ShadowDepthPass 0 Offset 0 OpMemberDecorate %type_ShadowDepthPass 1 Offset 4 OpMemberDecorate %type_ShadowDepthPass 2 Offset 8 OpMemberDecorate %type_ShadowDepthPass 3 Offset 12 OpMemberDecorate %type_ShadowDepthPass 4 Offset 16 OpMemberDecorate %type_ShadowDepthPass 5 Offset 20 OpMemberDecorate %type_ShadowDepthPass 6 Offset 24 OpMemberDecorate %type_ShadowDepthPass 7 Offset 28 OpMemberDecorate %type_ShadowDepthPass 8 Offset 32 OpMemberDecorate %type_ShadowDepthPass 9 Offset 36 OpMemberDecorate %type_ShadowDepthPass 10 Offset 40 OpMemberDecorate %type_ShadowDepthPass 11 Offset 44 OpMemberDecorate %type_ShadowDepthPass 12 Offset 48 OpMemberDecorate %type_ShadowDepthPass 13 Offset 52 OpMemberDecorate %type_ShadowDepthPass 14 Offset 56 OpMemberDecorate %type_ShadowDepthPass 15 Offset 60 OpMemberDecorate %type_ShadowDepthPass 16 Offset 64 OpMemberDecorate %type_ShadowDepthPass 17 Offset 68 OpMemberDecorate %type_ShadowDepthPass 18 Offset 72 OpMemberDecorate %type_ShadowDepthPass 19 Offset 76 OpMemberDecorate %type_ShadowDepthPass 20 Offset 80 OpMemberDecorate %type_ShadowDepthPass 21 Offset 84 OpMemberDecorate %type_ShadowDepthPass 22 Offset 88 OpMemberDecorate %type_ShadowDepthPass 23 Offset 92 OpMemberDecorate %type_ShadowDepthPass 24 Offset 96 OpMemberDecorate %type_ShadowDepthPass 25 Offset 100 OpMemberDecorate %type_ShadowDepthPass 26 Offset 104 OpMemberDecorate %type_ShadowDepthPass 27 Offset 108 OpMemberDecorate %type_ShadowDepthPass 28 Offset 112 OpMemberDecorate %type_ShadowDepthPass 29 Offset 116 OpMemberDecorate %type_ShadowDepthPass 30 Offset 120 OpMemberDecorate %type_ShadowDepthPass 31 Offset 124 OpMemberDecorate %type_ShadowDepthPass 32 Offset 128 OpMemberDecorate %type_ShadowDepthPass 33 Offset 132 OpMemberDecorate %type_ShadowDepthPass 34 Offset 136 OpMemberDecorate %type_ShadowDepthPass 35 Offset 140 OpMemberDecorate %type_ShadowDepthPass 36 Offset 144 OpMemberDecorate %type_ShadowDepthPass 37 Offset 148 OpMemberDecorate %type_ShadowDepthPass 38 Offset 152 OpMemberDecorate %type_ShadowDepthPass 39 Offset 156 OpMemberDecorate %type_ShadowDepthPass 40 Offset 160 OpMemberDecorate %type_ShadowDepthPass 41 Offset 164 OpMemberDecorate %type_ShadowDepthPass 42 Offset 168 OpMemberDecorate %type_ShadowDepthPass 43 Offset 172 OpMemberDecorate %type_ShadowDepthPass 44 Offset 176 OpMemberDecorate %type_ShadowDepthPass 45 Offset 180 OpMemberDecorate %type_ShadowDepthPass 46 Offset 184 OpMemberDecorate %type_ShadowDepthPass 47 Offset 188 OpMemberDecorate %type_ShadowDepthPass 48 Offset 192 OpMemberDecorate %type_ShadowDepthPass 49 Offset 196 OpMemberDecorate %type_ShadowDepthPass 50 Offset 200 OpMemberDecorate %type_ShadowDepthPass 51 Offset 204 OpMemberDecorate %type_ShadowDepthPass 52 Offset 208 OpMemberDecorate %type_ShadowDepthPass 53 Offset 212 OpMemberDecorate %type_ShadowDepthPass 54 Offset 216 OpMemberDecorate %type_ShadowDepthPass 55 Offset 220 OpMemberDecorate %type_ShadowDepthPass 56 Offset 224 OpMemberDecorate %type_ShadowDepthPass 57 Offset 228 OpMemberDecorate %type_ShadowDepthPass 58 Offset 232 OpMemberDecorate %type_ShadowDepthPass 59 Offset 236 OpMemberDecorate %type_ShadowDepthPass 60 Offset 240 OpMemberDecorate %type_ShadowDepthPass 61 Offset 244 OpMemberDecorate %type_ShadowDepthPass 62 Offset 248 OpMemberDecorate %type_ShadowDepthPass 63 Offset 252 OpMemberDecorate %type_ShadowDepthPass 64 Offset 256 OpMemberDecorate %type_ShadowDepthPass 65 Offset 260 OpMemberDecorate %type_ShadowDepthPass 66 Offset 264 OpMemberDecorate %type_ShadowDepthPass 67 Offset 268 OpMemberDecorate %type_ShadowDepthPass 68 Offset 272 OpMemberDecorate %type_ShadowDepthPass 68 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 68 ColMajor OpMemberDecorate %type_ShadowDepthPass 69 Offset 336 OpMemberDecorate %type_ShadowDepthPass 70 Offset 352 OpMemberDecorate %type_ShadowDepthPass 71 Offset 368 OpMemberDecorate %type_ShadowDepthPass 72 Offset 384 OpMemberDecorate %type_ShadowDepthPass 73 Offset 396 OpMemberDecorate %type_ShadowDepthPass 74 Offset 400 OpMemberDecorate %type_ShadowDepthPass 75 Offset 412 OpMemberDecorate %type_ShadowDepthPass 76 Offset 416 OpMemberDecorate %type_ShadowDepthPass 77 Offset 420 OpMemberDecorate %type_ShadowDepthPass 78 Offset 424 OpMemberDecorate %type_ShadowDepthPass 79 Offset 428 OpMemberDecorate %type_ShadowDepthPass 80 Offset 432 OpMemberDecorate %type_ShadowDepthPass 81 Offset 436 OpMemberDecorate %type_ShadowDepthPass 82 Offset 440 OpMemberDecorate %type_ShadowDepthPass 83 Offset 444 OpMemberDecorate %type_ShadowDepthPass 84 Offset 448 OpMemberDecorate %type_ShadowDepthPass 85 Offset 452 OpMemberDecorate %type_ShadowDepthPass 86 Offset 456 OpMemberDecorate %type_ShadowDepthPass 87 Offset 460 OpMemberDecorate %type_ShadowDepthPass 88 Offset 464 OpMemberDecorate %type_ShadowDepthPass 88 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 88 ColMajor OpMemberDecorate %type_ShadowDepthPass 89 Offset 528 OpMemberDecorate %type_ShadowDepthPass 89 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 89 ColMajor OpMemberDecorate %type_ShadowDepthPass 90 Offset 592 OpMemberDecorate %type_ShadowDepthPass 91 Offset 608 OpMemberDecorate %type_ShadowDepthPass 92 Offset 612 OpMemberDecorate %type_ShadowDepthPass 93 Offset 616 OpMemberDecorate %type_ShadowDepthPass 94 Offset 620 OpMemberDecorate %type_ShadowDepthPass 95 Offset 624 OpMemberDecorate %type_ShadowDepthPass 95 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 95 ColMajor OpMemberDecorate %type_ShadowDepthPass 96 Offset 1008 OpMemberDecorate %type_ShadowDepthPass 96 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 96 ColMajor OpDecorate %type_ShadowDepthPass Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %v2int = OpTypeVector %int 2 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %float_3 = OpConstant %float 3 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %float_6 = OpConstant %float 6 %57 = OpConstantComposite %v4float %float_6 %float_6 %float_6 %float_6 %float_1 = OpConstant %float 1 %int_79 = OpConstant %int 79 %float_0_200000003 = OpConstant %float 0.200000003 %float_n0_699999988 = OpConstant %float -0.699999988 %float_2 = OpConstant %float 2 %63 = OpConstantComposite %v2float %float_1 %float_2 %float_n1 = OpConstant %float -1 %float_10 = OpConstant %float 10 %float_0_5 = OpConstant %float 0.5 %67 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %int_88 = OpConstant %int 88 %int_89 = OpConstant %int 89 %int_90 = OpConstant %int 90 %int_91 = OpConstant %int 91 %float_0 = OpConstant %float 0 %float_9_99999997en07 = OpConstant %float 9.99999997e-07 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %uint %uint %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v2int %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %uint_6 = OpConstant %uint 6 %_arr_mat4v4float_uint_6 = OpTypeArray %mat4v4float %uint_6 %v3int = OpTypeVector %int 3 %type_ShadowDepthPass = OpTypeStruct %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %mat4v4float %v4float %v4float %v4float %v3int %int %v3int %float %float %float %float %float %float %float %float %float %float %float %float %int %mat4v4float %mat4v4float %v4float %float %float %float %float %_arr_mat4v4float_uint_6 %_arr_mat4v4float_uint_6 %_ptr_Uniform_type_ShadowDepthPass = OpTypePointer Uniform %type_ShadowDepthPass %uint_3 = OpConstant %uint 3 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %_arr__arr_v4float_uint_1_uint_3 = OpTypeArray %_arr_v4float_uint_1 %uint_3 %_ptr_Input__arr__arr_v4float_uint_1_uint_3 = OpTypePointer Input %_arr__arr_v4float_uint_1_uint_3 %_arr_uint_uint_3 = OpTypeArray %uint %uint_3 %_ptr_Input__arr_uint_uint_3 = OpTypePointer Input %_arr_uint_uint_3 %_arr__arr_v4float_uint_3_uint_3 = OpTypeArray %_arr_v4float_uint_3 %uint_3 %_ptr_Input__arr__arr_v4float_uint_3_uint_3 = OpTypePointer Input %_arr__arr_v4float_uint_3_uint_3 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Input__arr_v3float_uint_3 = OpTypePointer Input %_arr_v3float_uint_3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %_ptr_Input__arr_float_uint_3 = OpTypePointer Input %_arr_float_uint_3 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Input__arr_float_uint_4 = OpTypePointer Input %_arr_float_uint_4 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Input__arr_float_uint_2 = OpTypePointer Input %_arr_float_uint_2 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_v3float = OpTypePointer Input %v3float %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Output__arr_v4float_uint_1 = OpTypePointer Output %_arr_v4float_uint_1 %_ptr_Output_uint = OpTypePointer Output %uint %_ptr_Output_float = OpTypePointer Output %float %_ptr_Output_v3float = OpTypePointer Output %v3float %void = OpTypeVoid %106 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %bool = OpTypeBool %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Function_mat4v4float = OpTypePointer Function %mat4v4float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %type_sampled_image = OpTypeSampledImage %type_2d_image %View = OpVariable %_ptr_Uniform_type_View Uniform %ShadowDepthPass = OpVariable %_ptr_Uniform_type_ShadowDepthPass Uniform %Material_Texture2D_3 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %Material_Texture2D_3Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_COLOR0 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_TEXCOORD0 = OpVariable %_ptr_Input__arr__arr_v4float_uint_1_uint_3 Input %in_var_PRIMITIVE_ID = OpVariable %_ptr_Input__arr_uint_uint_3 Input %in_var_VS_to_DS_Position = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_PN_POSITION = OpVariable %_ptr_Input__arr__arr_v4float_uint_3_uint_3 Input %in_var_PN_DisplacementScales = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %in_var_PN_TessellationMultiplier = OpVariable %_ptr_Input__arr_float_uint_3 Input %in_var_PN_WorldDisplacementMultiplier = OpVariable %_ptr_Input__arr_float_uint_3 Input %gl_TessLevelOuter = OpVariable %_ptr_Input__arr_float_uint_4 Input %gl_TessLevelInner = OpVariable %_ptr_Input__arr_float_uint_2 Input %in_var_PN_POSITION9 = OpVariable %_ptr_Input_v4float Input %gl_TessCoord = OpVariable %_ptr_Input_v3float Input %out_var_TEXCOORD10_centroid = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD11_centroid = OpVariable %_ptr_Output_v4float Output %out_var_COLOR0 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD0 = OpVariable %_ptr_Output__arr_v4float_uint_1 Output %out_var_PRIMITIVE_ID = OpVariable %_ptr_Output_uint Output %out_var_TEXCOORD6 = OpVariable %_ptr_Output_float Output %out_var_TEXCOORD8 = OpVariable %_ptr_Output_float Output %out_var_TEXCOORD7 = OpVariable %_ptr_Output_v3float Output %gl_Position = OpVariable %_ptr_Output_v4float Output %112 = OpConstantNull %v4float %113 = OpUndef %v4float %_ptr_Input_uint = OpTypePointer Input %uint %MainDomain = OpFunction %void None %106 %115 = OpLabel %116 = OpVariable %_ptr_Function_mat4v4float Function %117 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD10_centroid %118 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD11_centroid %119 = OpLoad %_arr_v4float_uint_3 %in_var_COLOR0 %120 = OpLoad %_arr__arr_v4float_uint_1_uint_3 %in_var_TEXCOORD0 %121 = OpAccessChain %_ptr_Input_uint %in_var_PRIMITIVE_ID %uint_0 %122 = OpLoad %uint %121 %123 = OpCompositeExtract %v4float %117 0 %124 = OpCompositeExtract %v4float %118 0 %125 = OpCompositeExtract %v4float %119 0 %126 = OpCompositeExtract %_arr_v4float_uint_1 %120 0 %127 = OpCompositeExtract %v4float %117 1 %128 = OpCompositeExtract %v4float %118 1 %129 = OpCompositeExtract %v4float %119 1 %130 = OpCompositeExtract %_arr_v4float_uint_1 %120 1 %131 = OpCompositeExtract %v4float %117 2 %132 = OpCompositeExtract %v4float %118 2 %133 = OpCompositeExtract %v4float %119 2 %134 = OpCompositeExtract %_arr_v4float_uint_1 %120 2 %135 = OpLoad %_arr__arr_v4float_uint_3_uint_3 %in_var_PN_POSITION %136 = OpLoad %_arr_float_uint_3 %in_var_PN_WorldDisplacementMultiplier %137 = OpCompositeExtract %_arr_v4float_uint_3 %135 0 %138 = OpCompositeExtract %float %136 0 %139 = OpCompositeExtract %_arr_v4float_uint_3 %135 1 %140 = OpCompositeExtract %float %136 1 %141 = OpCompositeExtract %_arr_v4float_uint_3 %135 2 %142 = OpCompositeExtract %float %136 2 %143 = OpCompositeExtract %v4float %137 0 %144 = OpCompositeExtract %v4float %137 1 %145 = OpCompositeExtract %v4float %137 2 %146 = OpCompositeExtract %v4float %139 0 %147 = OpCompositeExtract %v4float %139 1 %148 = OpCompositeExtract %v4float %139 2 %149 = OpCompositeExtract %v4float %141 0 %150 = OpCompositeExtract %v4float %141 1 %151 = OpCompositeExtract %v4float %141 2 %152 = OpLoad %v4float %in_var_PN_POSITION9 %153 = OpLoad %v3float %gl_TessCoord %154 = OpCompositeExtract %float %153 0 %155 = OpCompositeExtract %float %153 1 %156 = OpCompositeExtract %float %153 2 %157 = OpFMul %float %154 %154 %158 = OpFMul %float %155 %155 %159 = OpFMul %float %156 %156 %160 = OpFMul %float %157 %float_3 %161 = OpFMul %float %158 %float_3 %162 = OpFMul %float %159 %float_3 %163 = OpCompositeConstruct %v4float %157 %157 %157 %157 %164 = OpFMul %v4float %143 %163 %165 = OpCompositeConstruct %v4float %154 %154 %154 %154 %166 = OpFMul %v4float %164 %165 %167 = OpCompositeConstruct %v4float %158 %158 %158 %158 %168 = OpFMul %v4float %146 %167 %169 = OpCompositeConstruct %v4float %155 %155 %155 %155 %170 = OpFMul %v4float %168 %169 %171 = OpFAdd %v4float %166 %170 %172 = OpCompositeConstruct %v4float %159 %159 %159 %159 %173 = OpFMul %v4float %149 %172 %174 = OpCompositeConstruct %v4float %156 %156 %156 %156 %175 = OpFMul %v4float %173 %174 %176 = OpFAdd %v4float %171 %175 %177 = OpCompositeConstruct %v4float %160 %160 %160 %160 %178 = OpFMul %v4float %144 %177 %179 = OpFMul %v4float %178 %169 %180 = OpFAdd %v4float %176 %179 %181 = OpCompositeConstruct %v4float %161 %161 %161 %161 %182 = OpFMul %v4float %145 %181 %183 = OpFMul %v4float %182 %165 %184 = OpFAdd %v4float %180 %183 %185 = OpFMul %v4float %147 %181 %186 = OpFMul %v4float %185 %174 %187 = OpFAdd %v4float %184 %186 %188 = OpCompositeConstruct %v4float %162 %162 %162 %162 %189 = OpFMul %v4float %148 %188 %190 = OpFMul %v4float %189 %169 %191 = OpFAdd %v4float %187 %190 %192 = OpFMul %v4float %150 %188 %193 = OpFMul %v4float %192 %165 %194 = OpFAdd %v4float %191 %193 %195 = OpFMul %v4float %151 %177 %196 = OpFMul %v4float %195 %174 %197 = OpFAdd %v4float %194 %196 %198 = OpFMul %v4float %152 %57 %199 = OpFMul %v4float %198 %174 %200 = OpFMul %v4float %199 %165 %201 = OpFMul %v4float %200 %169 %202 = OpFAdd %v4float %197 %201 %203 = OpCompositeExtract %v4float %126 0 %204 = OpCompositeExtract %v4float %130 0 %205 = OpVectorShuffle %v3float %123 %123 0 1 2 %206 = OpCompositeConstruct %v3float %154 %154 %154 %207 = OpFMul %v3float %205 %206 %208 = OpVectorShuffle %v3float %127 %127 0 1 2 %209 = OpCompositeConstruct %v3float %155 %155 %155 %210 = OpFMul %v3float %208 %209 %211 = OpFAdd %v3float %207 %210 %212 = OpFMul %v4float %124 %165 %213 = OpFMul %v4float %128 %169 %214 = OpFAdd %v4float %212 %213 %215 = OpFMul %v4float %125 %165 %216 = OpFMul %v4float %129 %169 %217 = OpFAdd %v4float %215 %216 %218 = OpFMul %v4float %203 %165 %219 = OpFMul %v4float %204 %169 %220 = OpFAdd %v4float %218 %219 %221 = OpCompositeExtract %v4float %134 0 %222 = OpVectorShuffle %v3float %211 %112 0 1 2 %223 = OpVectorShuffle %v3float %131 %131 0 1 2 %224 = OpCompositeConstruct %v3float %156 %156 %156 %225 = OpFMul %v3float %223 %224 %226 = OpFAdd %v3float %222 %225 %227 = OpVectorShuffle %v4float %113 %226 4 5 6 3 %228 = OpFMul %v4float %132 %174 %229 = OpFAdd %v4float %214 %228 %230 = OpFMul %v4float %133 %174 %231 = OpFAdd %v4float %217 %230 %232 = OpFMul %v4float %221 %174 %233 = OpFAdd %v4float %220 %232 %234 = OpCompositeConstruct %_arr_v4float_uint_1 %233 %235 = OpVectorShuffle %v2float %233 %233 2 3 %236 = OpVectorShuffle %v3float %229 %229 0 1 2 %237 = OpAccessChain %_ptr_Uniform_float %View %int_79 %238 = OpLoad %float %237 %239 = OpFMul %float %238 %float_0_200000003 %240 = OpFMul %float %238 %float_n0_699999988 %241 = OpFMul %v2float %235 %63 %242 = OpCompositeConstruct %v2float %239 %240 %243 = OpFAdd %v2float %242 %241 %244 = OpLoad %type_2d_image %Material_Texture2D_3 %245 = OpLoad %type_sampler %Material_Texture2D_3Sampler %246 = OpSampledImage %type_sampled_image %244 %245 %247 = OpImageSampleExplicitLod %v4float %246 %243 Lod %float_n1 %248 = OpCompositeExtract %float %247 0 %249 = OpFMul %float %248 %float_10 %250 = OpCompositeExtract %float %231 0 %251 = OpFSub %float %float_1 %250 %252 = OpFMul %float %249 %251 %253 = OpCompositeConstruct %v3float %252 %252 %252 %254 = OpFMul %v3float %253 %236 %255 = OpFMul %v3float %254 %67 %256 = OpFMul %float %138 %154 %257 = OpFMul %float %140 %155 %258 = OpFAdd %float %256 %257 %259 = OpFMul %float %142 %156 %260 = OpFAdd %float %258 %259 %261 = OpCompositeConstruct %v3float %260 %260 %260 %262 = OpFMul %v3float %255 %261 %263 = OpVectorShuffle %v3float %202 %202 0 1 2 %264 = OpFAdd %v3float %263 %262 %265 = OpVectorShuffle %v4float %202 %264 4 5 6 3 %266 = OpAccessChain %_ptr_Uniform_mat4v4float %ShadowDepthPass %int_88 %267 = OpLoad %mat4v4float %266 %268 = OpAccessChain %_ptr_Uniform_mat4v4float %ShadowDepthPass %int_89 %269 = OpLoad %mat4v4float %268 OpStore %116 %269 %270 = OpMatrixTimesVector %v4float %267 %265 %271 = OpAccessChain %_ptr_Uniform_float %ShadowDepthPass %int_91 %272 = OpLoad %float %271 %273 = OpFOrdGreaterThan %bool %272 %float_0 %274 = OpCompositeExtract %float %270 2 %275 = OpFOrdLessThan %bool %274 %float_0 %276 = OpLogicalAnd %bool %273 %275 OpSelectionMerge %277 None OpBranchConditional %276 %278 %277 %278 = OpLabel %279 = OpCompositeInsert %v4float %float_9_99999997en07 %270 2 %280 = OpCompositeInsert %v4float %float_1 %279 3 OpBranch %277 %277 = OpLabel %281 = OpPhi %v4float %270 %115 %280 %278 %282 = OpAccessChain %_ptr_Function_float %116 %uint_0 %int_2 %283 = OpLoad %float %282 %284 = OpAccessChain %_ptr_Function_float %116 %uint_1 %int_2 %285 = OpLoad %float %284 %286 = OpAccessChain %_ptr_Function_float %116 %uint_2 %int_2 %287 = OpLoad %float %286 %288 = OpCompositeConstruct %v3float %283 %285 %287 %289 = OpDot %float %288 %236 %290 = OpExtInst %float %1 FAbs %289 %291 = OpAccessChain %_ptr_Uniform_float %ShadowDepthPass %int_90 %int_2 %292 = OpLoad %float %291 %293 = OpExtInst %float %1 FAbs %290 %294 = OpFOrdGreaterThan %bool %293 %float_0 %295 = OpFMul %float %290 %290 %296 = OpFSub %float %float_1 %295 %297 = OpExtInst %float %1 FClamp %296 %float_0 %float_1 %298 = OpExtInst %float %1 Sqrt %297 %299 = OpFDiv %float %298 %290 %300 = OpSelect %float %294 %299 %292 %301 = OpExtInst %float %1 FClamp %300 %float_0 %292 %302 = OpAccessChain %_ptr_Uniform_float %ShadowDepthPass %int_90 %int_1 %303 = OpLoad %float %302 %304 = OpFMul %float %303 %301 %305 = OpAccessChain %_ptr_Uniform_float %ShadowDepthPass %int_90 %int_0 %306 = OpLoad %float %305 %307 = OpFAdd %float %304 %306 %308 = OpCompositeExtract %float %281 2 %309 = OpVectorShuffle %v3float %264 %112 0 1 2 OpStore %out_var_TEXCOORD10_centroid %227 OpStore %out_var_TEXCOORD11_centroid %229 OpStore %out_var_COLOR0 %231 OpStore %out_var_TEXCOORD0 %234 OpStore %out_var_PRIMITIVE_ID %122 OpStore %out_var_TEXCOORD6 %308 OpStore %out_var_TEXCOORD8 %307 OpStore %out_var_TEXCOORD7 %309 OpStore %gl_Position %281 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/tese/ds-patch-input-fixes.asm.tese000066400000000000000000002063461400026215700256660ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 581 ; Schema: 0 OpCapability Tessellation OpCapability ClipDistance OpCapability SampledBuffer OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %MainDomain "main" %gl_ClipDistance %in_var_TEXCOORD6 %in_var_TEXCOORD8 %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_VS_To_DS_Position %in_var_VS_To_DS_VertexID %in_var_PN_POSITION %in_var_PN_DisplacementScales %in_var_PN_TessellationMultiplier %in_var_PN_WorldDisplacementMultiplier %in_var_PN_DominantVertex %in_var_PN_DominantVertex1 %in_var_PN_DominantVertex2 %in_var_PN_DominantEdge %in_var_PN_DominantEdge1 %in_var_PN_DominantEdge2 %in_var_PN_DominantEdge3 %in_var_PN_DominantEdge4 %in_var_PN_DominantEdge5 %gl_TessLevelOuter %gl_TessLevelInner %in_var_PN_POSITION9 %gl_TessCoord %gl_Position %out_var_TEXCOORD6 %out_var_TEXCOORD7 %out_var_TEXCOORD10_centroid %out_var_TEXCOORD11_centroid OpExecutionMode %MainDomain Triangles OpExecutionMode %MainDomain SpacingFractionalOdd OpExecutionMode %MainDomain VertexOrderCw OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_ClipToWorld" OpMemberName %type_View 3 "View_TranslatedWorldToView" OpMemberName %type_View 4 "View_ViewToTranslatedWorld" OpMemberName %type_View 5 "View_TranslatedWorldToCameraView" OpMemberName %type_View 6 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 7 "View_ViewToClip" OpMemberName %type_View 8 "View_ViewToClipNoAA" OpMemberName %type_View 9 "View_ClipToView" OpMemberName %type_View 10 "View_ClipToTranslatedWorld" OpMemberName %type_View 11 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 12 "View_ScreenToWorld" OpMemberName %type_View 13 "View_ScreenToTranslatedWorld" OpMemberName %type_View 14 "View_ViewForward" OpMemberName %type_View 15 "PrePadding_View_908" OpMemberName %type_View 16 "View_ViewUp" OpMemberName %type_View 17 "PrePadding_View_924" OpMemberName %type_View 18 "View_ViewRight" OpMemberName %type_View 19 "PrePadding_View_940" OpMemberName %type_View 20 "View_HMDViewNoRollUp" OpMemberName %type_View 21 "PrePadding_View_956" OpMemberName %type_View 22 "View_HMDViewNoRollRight" OpMemberName %type_View 23 "PrePadding_View_972" OpMemberName %type_View 24 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 25 "View_ScreenPositionScaleBias" OpMemberName %type_View 26 "View_WorldCameraOrigin" OpMemberName %type_View 27 "PrePadding_View_1020" OpMemberName %type_View 28 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 29 "PrePadding_View_1036" OpMemberName %type_View 30 "View_WorldViewOrigin" OpMemberName %type_View 31 "PrePadding_View_1052" OpMemberName %type_View 32 "View_PreViewTranslation" OpMemberName %type_View 33 "PrePadding_View_1068" OpMemberName %type_View 34 "View_PrevProjection" OpMemberName %type_View 35 "View_PrevViewProj" OpMemberName %type_View 36 "View_PrevViewRotationProj" OpMemberName %type_View 37 "View_PrevViewToClip" OpMemberName %type_View 38 "View_PrevClipToView" OpMemberName %type_View 39 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 40 "View_PrevTranslatedWorldToView" OpMemberName %type_View 41 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 42 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 43 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 44 "View_PrevWorldCameraOrigin" OpMemberName %type_View 45 "PrePadding_View_1724" OpMemberName %type_View 46 "View_PrevWorldViewOrigin" OpMemberName %type_View 47 "PrePadding_View_1740" OpMemberName %type_View 48 "View_PrevPreViewTranslation" OpMemberName %type_View 49 "PrePadding_View_1756" OpMemberName %type_View 50 "View_PrevInvViewProj" OpMemberName %type_View 51 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 52 "View_ClipToPrevClip" OpMemberName %type_View 53 "View_TemporalAAJitter" OpMemberName %type_View 54 "View_GlobalClippingPlane" OpMemberName %type_View 55 "View_FieldOfViewWideAngles" OpMemberName %type_View 56 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 57 "View_ViewRectMin" OpMemberName %type_View 58 "View_ViewSizeAndInvSize" OpMemberName %type_View 59 "View_BufferSizeAndInvSize" OpMemberName %type_View 60 "View_BufferBilinearUVMinMax" OpMemberName %type_View 61 "View_NumSceneColorMSAASamples" OpMemberName %type_View 62 "View_PreExposure" OpMemberName %type_View 63 "View_OneOverPreExposure" OpMemberName %type_View 64 "PrePadding_View_2076" OpMemberName %type_View 65 "View_DiffuseOverrideParameter" OpMemberName %type_View 66 "View_SpecularOverrideParameter" OpMemberName %type_View 67 "View_NormalOverrideParameter" OpMemberName %type_View 68 "View_RoughnessOverrideParameter" OpMemberName %type_View 69 "View_PrevFrameGameTime" OpMemberName %type_View 70 "View_PrevFrameRealTime" OpMemberName %type_View 71 "View_OutOfBoundsMask" OpMemberName %type_View 72 "PrePadding_View_2148" OpMemberName %type_View 73 "PrePadding_View_2152" OpMemberName %type_View 74 "PrePadding_View_2156" OpMemberName %type_View 75 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 76 "View_CullingSign" OpMemberName %type_View 77 "View_NearPlane" OpMemberName %type_View 78 "View_AdaptiveTessellationFactor" OpMemberName %type_View 79 "View_GameTime" OpMemberName %type_View 80 "View_RealTime" OpMemberName %type_View 81 "View_DeltaTime" OpMemberName %type_View 82 "View_MaterialTextureMipBias" OpMemberName %type_View 83 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 84 "View_Random" OpMemberName %type_View 85 "View_FrameNumber" OpMemberName %type_View 86 "View_StateFrameIndexMod8" OpMemberName %type_View 87 "View_StateFrameIndex" OpMemberName %type_View 88 "View_CameraCut" OpMemberName %type_View 89 "View_UnlitViewmodeMask" OpMemberName %type_View 90 "PrePadding_View_2228" OpMemberName %type_View 91 "PrePadding_View_2232" OpMemberName %type_View 92 "PrePadding_View_2236" OpMemberName %type_View 93 "View_DirectionalLightColor" OpMemberName %type_View 94 "View_DirectionalLightDirection" OpMemberName %type_View 95 "PrePadding_View_2268" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 97 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 98 "View_TemporalAAParams" OpMemberName %type_View 99 "View_CircleDOFParams" OpMemberName %type_View 100 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 101 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 102 "View_DepthOfFieldScale" OpMemberName %type_View 103 "View_DepthOfFieldFocalLength" OpMemberName %type_View 104 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 105 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 106 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 107 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 108 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 109 "View_GeneralPurposeTweak" OpMemberName %type_View 110 "View_DemosaicVposOffset" OpMemberName %type_View 111 "PrePadding_View_2412" OpMemberName %type_View 112 "View_IndirectLightingColorScale" OpMemberName %type_View 113 "View_HDR32bppEncodingMode" OpMemberName %type_View 114 "View_AtmosphericFogSunDirection" OpMemberName %type_View 115 "View_AtmosphericFogSunPower" OpMemberName %type_View 116 "View_AtmosphericFogPower" OpMemberName %type_View 117 "View_AtmosphericFogDensityScale" OpMemberName %type_View 118 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 119 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 120 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 121 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 122 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 123 "View_AtmosphericFogStartDistance" OpMemberName %type_View 124 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 125 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 126 "View_AtmosphericFogSunDiscHalfApexAngleRadian" OpMemberName %type_View 127 "PrePadding_View_2492" OpMemberName %type_View 128 "View_AtmosphericFogSunDiscLuminance" OpMemberName %type_View 129 "View_AtmosphericFogRenderMask" OpMemberName %type_View 130 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 131 "PrePadding_View_2520" OpMemberName %type_View 132 "PrePadding_View_2524" OpMemberName %type_View 133 "View_AtmosphericFogSunColor" OpMemberName %type_View 134 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 135 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 136 "View_AmbientCubemapTint" OpMemberName %type_View 137 "View_AmbientCubemapIntensity" OpMemberName %type_View 138 "View_SkyLightParameters" OpMemberName %type_View 139 "PrePadding_View_2584" OpMemberName %type_View 140 "PrePadding_View_2588" OpMemberName %type_View 141 "View_SkyLightColor" OpMemberName %type_View 142 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 143 "View_MobilePreviewMode" OpMemberName %type_View 144 "View_HMDEyePaddingOffset" OpMemberName %type_View 145 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 146 "View_ShowDecalsMask" OpMemberName %type_View 147 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 148 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 149 "PrePadding_View_2744" OpMemberName %type_View 150 "PrePadding_View_2748" OpMemberName %type_View 151 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 152 "View_StereoPassIndex" OpMemberName %type_View 153 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 154 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 155 "View_GlobalVolumeDimension" OpMemberName %type_View 156 "View_GlobalVolumeTexelSize" OpMemberName %type_View 157 "View_MaxGlobalDistance" OpMemberName %type_View 158 "PrePadding_View_2908" OpMemberName %type_View 159 "View_CursorPosition" OpMemberName %type_View 160 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 161 "PrePadding_View_2924" OpMemberName %type_View 162 "View_VolumetricFogInvGridSize" OpMemberName %type_View 163 "PrePadding_View_2940" OpMemberName %type_View 164 "View_VolumetricFogGridZParams" OpMemberName %type_View 165 "PrePadding_View_2956" OpMemberName %type_View 166 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 167 "View_VolumetricFogMaxDistance" OpMemberName %type_View 168 "PrePadding_View_2972" OpMemberName %type_View 169 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 170 "PrePadding_View_2988" OpMemberName %type_View 171 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 172 "PrePadding_View_3004" OpMemberName %type_View 173 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 174 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 175 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 176 "View_StereoIPD" OpMemberName %type_View 177 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 178 "View_EyeToPixelSpreadAngle" OpMemberName %type_View 179 "PrePadding_View_3048" OpMemberName %type_View 180 "PrePadding_View_3052" OpMemberName %type_View 181 "View_WorldToVirtualTexture" OpMemberName %type_View 182 "View_VirtualTextureParams" OpMemberName %type_View 183 "View_XRPassthroughCameraUVs" OpName %View "View" OpName %type_sampler "type.sampler" OpName %type_3d_image "type.3d.image" OpName %View_GlobalDistanceFieldTexture0 "View_GlobalDistanceFieldTexture0" OpName %View_GlobalDistanceFieldSampler0 "View_GlobalDistanceFieldSampler0" OpName %View_GlobalDistanceFieldTexture1 "View_GlobalDistanceFieldTexture1" OpName %View_GlobalDistanceFieldTexture2 "View_GlobalDistanceFieldTexture2" OpName %View_GlobalDistanceFieldTexture3 "View_GlobalDistanceFieldTexture3" OpName %type_Material "type.Material" OpMemberName %type_Material 0 "Material_VectorExpressions" OpMemberName %type_Material 1 "Material_ScalarExpressions" OpName %Material "Material" OpName %in_var_TEXCOORD6 "in.var.TEXCOORD6" OpName %in_var_TEXCOORD8 "in.var.TEXCOORD8" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_VS_To_DS_Position "in.var.VS_To_DS_Position" OpName %in_var_VS_To_DS_VertexID "in.var.VS_To_DS_VertexID" OpName %in_var_PN_POSITION "in.var.PN_POSITION" OpName %in_var_PN_DisplacementScales "in.var.PN_DisplacementScales" OpName %in_var_PN_TessellationMultiplier "in.var.PN_TessellationMultiplier" OpName %in_var_PN_WorldDisplacementMultiplier "in.var.PN_WorldDisplacementMultiplier" OpName %in_var_PN_DominantVertex "in.var.PN_DominantVertex" OpName %in_var_PN_DominantVertex1 "in.var.PN_DominantVertex1" OpName %in_var_PN_DominantVertex2 "in.var.PN_DominantVertex2" OpName %in_var_PN_DominantEdge "in.var.PN_DominantEdge" OpName %in_var_PN_DominantEdge1 "in.var.PN_DominantEdge1" OpName %in_var_PN_DominantEdge2 "in.var.PN_DominantEdge2" OpName %in_var_PN_DominantEdge3 "in.var.PN_DominantEdge3" OpName %in_var_PN_DominantEdge4 "in.var.PN_DominantEdge4" OpName %in_var_PN_DominantEdge5 "in.var.PN_DominantEdge5" OpName %in_var_PN_POSITION9 "in.var.PN_POSITION9" OpName %out_var_TEXCOORD6 "out.var.TEXCOORD6" OpName %out_var_TEXCOORD7 "out.var.TEXCOORD7" OpName %out_var_TEXCOORD10_centroid "out.var.TEXCOORD10_centroid" OpName %out_var_TEXCOORD11_centroid "out.var.TEXCOORD11_centroid" OpName %MainDomain "MainDomain" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_ClipDistance BuiltIn ClipDistance OpDecorateString %gl_ClipDistance UserSemantic "SV_ClipDistance" OpDecorateString %in_var_TEXCOORD6 UserSemantic "TEXCOORD6" OpDecorateString %in_var_TEXCOORD8 UserSemantic "TEXCOORD8" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorateString %in_var_VS_To_DS_VertexID UserSemantic "VS_To_DS_VertexID" OpDecorateString %in_var_PN_POSITION UserSemantic "PN_POSITION" OpDecorateString %in_var_PN_DisplacementScales UserSemantic "PN_DisplacementScales" OpDecorateString %in_var_PN_TessellationMultiplier UserSemantic "PN_TessellationMultiplier" OpDecorateString %in_var_PN_WorldDisplacementMultiplier UserSemantic "PN_WorldDisplacementMultiplier" OpDecorateString %in_var_PN_DominantVertex UserSemantic "PN_DominantVertex" OpDecorateString %in_var_PN_DominantVertex1 UserSemantic "PN_DominantVertex" OpDecorateString %in_var_PN_DominantVertex2 UserSemantic "PN_DominantVertex" OpDecorateString %in_var_PN_DominantEdge UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge1 UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge2 UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge3 UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge4 UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge5 UserSemantic "PN_DominantEdge" OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter OpDecorateString %gl_TessLevelOuter UserSemantic "SV_TessFactor" OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorateString %gl_TessLevelInner UserSemantic "SV_InsideTessFactor" OpDecorate %gl_TessLevelInner Patch OpDecorateString %in_var_PN_POSITION9 UserSemantic "PN_POSITION9" OpDecorate %in_var_PN_POSITION9 Patch OpDecorate %gl_TessCoord BuiltIn TessCoord OpDecorateString %gl_TessCoord UserSemantic "SV_DomainLocation" OpDecorate %gl_TessCoord Patch OpDecorate %gl_Position BuiltIn Position OpDecorateString %gl_Position UserSemantic "SV_POSITION" OpDecorateString %out_var_TEXCOORD6 UserSemantic "TEXCOORD6" OpDecorateString %out_var_TEXCOORD7 UserSemantic "TEXCOORD7" OpDecorateString %out_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %out_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorate %in_var_PN_DisplacementScales Location 0 OpDecorate %in_var_PN_DominantEdge Location 1 OpDecorate %in_var_PN_DominantEdge1 Location 2 OpDecorate %in_var_PN_DominantEdge2 Location 3 OpDecorate %in_var_PN_DominantEdge3 Location 4 OpDecorate %in_var_PN_DominantEdge4 Location 5 OpDecorate %in_var_PN_DominantEdge5 Location 6 OpDecorate %in_var_PN_DominantVertex Location 7 OpDecorate %in_var_PN_DominantVertex1 Location 8 OpDecorate %in_var_PN_DominantVertex2 Location 9 OpDecorate %in_var_PN_POSITION Location 10 OpDecorate %in_var_PN_POSITION9 Location 13 OpDecorate %in_var_PN_TessellationMultiplier Location 14 OpDecorate %in_var_PN_WorldDisplacementMultiplier Location 15 OpDecorate %in_var_TEXCOORD10_centroid Location 16 OpDecorate %in_var_TEXCOORD11_centroid Location 17 OpDecorate %in_var_TEXCOORD6 Location 18 OpDecorate %in_var_TEXCOORD8 Location 19 OpDecorate %in_var_VS_To_DS_Position Location 20 OpDecorate %in_var_VS_To_DS_VertexID Location 21 OpDecorate %out_var_TEXCOORD6 Location 0 OpDecorate %out_var_TEXCOORD7 Location 1 OpDecorate %out_var_TEXCOORD10_centroid Location 2 OpDecorate %out_var_TEXCOORD11_centroid Location 3 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %View_GlobalDistanceFieldTexture0 DescriptorSet 0 OpDecorate %View_GlobalDistanceFieldTexture0 Binding 0 OpDecorate %View_GlobalDistanceFieldSampler0 DescriptorSet 0 OpDecorate %View_GlobalDistanceFieldSampler0 Binding 0 OpDecorate %View_GlobalDistanceFieldTexture1 DescriptorSet 0 OpDecorate %View_GlobalDistanceFieldTexture1 Binding 1 OpDecorate %View_GlobalDistanceFieldTexture2 DescriptorSet 0 OpDecorate %View_GlobalDistanceFieldTexture2 Binding 2 OpDecorate %View_GlobalDistanceFieldTexture3 DescriptorSet 0 OpDecorate %View_GlobalDistanceFieldTexture3 Binding 3 OpDecorate %Material DescriptorSet 0 OpDecorate %Material Binding 1 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 13 MatrixStride 16 OpMemberDecorate %type_View 13 ColMajor OpMemberDecorate %type_View 14 Offset 896 OpMemberDecorate %type_View 15 Offset 908 OpMemberDecorate %type_View 16 Offset 912 OpMemberDecorate %type_View 17 Offset 924 OpMemberDecorate %type_View 18 Offset 928 OpMemberDecorate %type_View 19 Offset 940 OpMemberDecorate %type_View 20 Offset 944 OpMemberDecorate %type_View 21 Offset 956 OpMemberDecorate %type_View 22 Offset 960 OpMemberDecorate %type_View 23 Offset 972 OpMemberDecorate %type_View 24 Offset 976 OpMemberDecorate %type_View 25 Offset 992 OpMemberDecorate %type_View 26 Offset 1008 OpMemberDecorate %type_View 27 Offset 1020 OpMemberDecorate %type_View 28 Offset 1024 OpMemberDecorate %type_View 29 Offset 1036 OpMemberDecorate %type_View 30 Offset 1040 OpMemberDecorate %type_View 31 Offset 1052 OpMemberDecorate %type_View 32 Offset 1056 OpMemberDecorate %type_View 33 Offset 1068 OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 43 MatrixStride 16 OpMemberDecorate %type_View 43 ColMajor OpMemberDecorate %type_View 44 Offset 1712 OpMemberDecorate %type_View 45 Offset 1724 OpMemberDecorate %type_View 46 Offset 1728 OpMemberDecorate %type_View 47 Offset 1740 OpMemberDecorate %type_View 48 Offset 1744 OpMemberDecorate %type_View 49 Offset 1756 OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 52 MatrixStride 16 OpMemberDecorate %type_View 52 ColMajor OpMemberDecorate %type_View 53 Offset 1952 OpMemberDecorate %type_View 54 Offset 1968 OpMemberDecorate %type_View 55 Offset 1984 OpMemberDecorate %type_View 56 Offset 1992 OpMemberDecorate %type_View 57 Offset 2000 OpMemberDecorate %type_View 58 Offset 2016 OpMemberDecorate %type_View 59 Offset 2032 OpMemberDecorate %type_View 60 Offset 2048 OpMemberDecorate %type_View 61 Offset 2064 OpMemberDecorate %type_View 62 Offset 2068 OpMemberDecorate %type_View 63 Offset 2072 OpMemberDecorate %type_View 64 Offset 2076 OpMemberDecorate %type_View 65 Offset 2080 OpMemberDecorate %type_View 66 Offset 2096 OpMemberDecorate %type_View 67 Offset 2112 OpMemberDecorate %type_View 68 Offset 2128 OpMemberDecorate %type_View 69 Offset 2136 OpMemberDecorate %type_View 70 Offset 2140 OpMemberDecorate %type_View 71 Offset 2144 OpMemberDecorate %type_View 72 Offset 2148 OpMemberDecorate %type_View 73 Offset 2152 OpMemberDecorate %type_View 74 Offset 2156 OpMemberDecorate %type_View 75 Offset 2160 OpMemberDecorate %type_View 76 Offset 2172 OpMemberDecorate %type_View 77 Offset 2176 OpMemberDecorate %type_View 78 Offset 2180 OpMemberDecorate %type_View 79 Offset 2184 OpMemberDecorate %type_View 80 Offset 2188 OpMemberDecorate %type_View 81 Offset 2192 OpMemberDecorate %type_View 82 Offset 2196 OpMemberDecorate %type_View 83 Offset 2200 OpMemberDecorate %type_View 84 Offset 2204 OpMemberDecorate %type_View 85 Offset 2208 OpMemberDecorate %type_View 86 Offset 2212 OpMemberDecorate %type_View 87 Offset 2216 OpMemberDecorate %type_View 88 Offset 2220 OpMemberDecorate %type_View 89 Offset 2224 OpMemberDecorate %type_View 90 Offset 2228 OpMemberDecorate %type_View 91 Offset 2232 OpMemberDecorate %type_View 92 Offset 2236 OpMemberDecorate %type_View 93 Offset 2240 OpMemberDecorate %type_View 94 Offset 2256 OpMemberDecorate %type_View 95 Offset 2268 OpMemberDecorate %type_View 96 Offset 2272 OpMemberDecorate %type_View 97 Offset 2304 OpMemberDecorate %type_View 98 Offset 2336 OpMemberDecorate %type_View 99 Offset 2352 OpMemberDecorate %type_View 100 Offset 2368 OpMemberDecorate %type_View 101 Offset 2372 OpMemberDecorate %type_View 102 Offset 2376 OpMemberDecorate %type_View 103 Offset 2380 OpMemberDecorate %type_View 104 Offset 2384 OpMemberDecorate %type_View 105 Offset 2388 OpMemberDecorate %type_View 106 Offset 2392 OpMemberDecorate %type_View 107 Offset 2396 OpMemberDecorate %type_View 108 Offset 2400 OpMemberDecorate %type_View 109 Offset 2404 OpMemberDecorate %type_View 110 Offset 2408 OpMemberDecorate %type_View 111 Offset 2412 OpMemberDecorate %type_View 112 Offset 2416 OpMemberDecorate %type_View 113 Offset 2428 OpMemberDecorate %type_View 114 Offset 2432 OpMemberDecorate %type_View 115 Offset 2444 OpMemberDecorate %type_View 116 Offset 2448 OpMemberDecorate %type_View 117 Offset 2452 OpMemberDecorate %type_View 118 Offset 2456 OpMemberDecorate %type_View 119 Offset 2460 OpMemberDecorate %type_View 120 Offset 2464 OpMemberDecorate %type_View 121 Offset 2468 OpMemberDecorate %type_View 122 Offset 2472 OpMemberDecorate %type_View 123 Offset 2476 OpMemberDecorate %type_View 124 Offset 2480 OpMemberDecorate %type_View 125 Offset 2484 OpMemberDecorate %type_View 126 Offset 2488 OpMemberDecorate %type_View 127 Offset 2492 OpMemberDecorate %type_View 128 Offset 2496 OpMemberDecorate %type_View 129 Offset 2512 OpMemberDecorate %type_View 130 Offset 2516 OpMemberDecorate %type_View 131 Offset 2520 OpMemberDecorate %type_View 132 Offset 2524 OpMemberDecorate %type_View 133 Offset 2528 OpMemberDecorate %type_View 134 Offset 2544 OpMemberDecorate %type_View 135 Offset 2556 OpMemberDecorate %type_View 136 Offset 2560 OpMemberDecorate %type_View 137 Offset 2576 OpMemberDecorate %type_View 138 Offset 2580 OpMemberDecorate %type_View 139 Offset 2584 OpMemberDecorate %type_View 140 Offset 2588 OpMemberDecorate %type_View 141 Offset 2592 OpMemberDecorate %type_View 142 Offset 2608 OpMemberDecorate %type_View 143 Offset 2720 OpMemberDecorate %type_View 144 Offset 2724 OpMemberDecorate %type_View 145 Offset 2728 OpMemberDecorate %type_View 146 Offset 2732 OpMemberDecorate %type_View 147 Offset 2736 OpMemberDecorate %type_View 148 Offset 2740 OpMemberDecorate %type_View 149 Offset 2744 OpMemberDecorate %type_View 150 Offset 2748 OpMemberDecorate %type_View 151 Offset 2752 OpMemberDecorate %type_View 152 Offset 2764 OpMemberDecorate %type_View 153 Offset 2768 OpMemberDecorate %type_View 154 Offset 2832 OpMemberDecorate %type_View 155 Offset 2896 OpMemberDecorate %type_View 156 Offset 2900 OpMemberDecorate %type_View 157 Offset 2904 OpMemberDecorate %type_View 158 Offset 2908 OpMemberDecorate %type_View 159 Offset 2912 OpMemberDecorate %type_View 160 Offset 2920 OpMemberDecorate %type_View 161 Offset 2924 OpMemberDecorate %type_View 162 Offset 2928 OpMemberDecorate %type_View 163 Offset 2940 OpMemberDecorate %type_View 164 Offset 2944 OpMemberDecorate %type_View 165 Offset 2956 OpMemberDecorate %type_View 166 Offset 2960 OpMemberDecorate %type_View 167 Offset 2968 OpMemberDecorate %type_View 168 Offset 2972 OpMemberDecorate %type_View 169 Offset 2976 OpMemberDecorate %type_View 170 Offset 2988 OpMemberDecorate %type_View 171 Offset 2992 OpMemberDecorate %type_View 172 Offset 3004 OpMemberDecorate %type_View 173 Offset 3008 OpMemberDecorate %type_View 174 Offset 3020 OpMemberDecorate %type_View 175 Offset 3024 OpMemberDecorate %type_View 176 Offset 3036 OpMemberDecorate %type_View 177 Offset 3040 OpMemberDecorate %type_View 178 Offset 3044 OpMemberDecorate %type_View 179 Offset 3048 OpMemberDecorate %type_View 180 Offset 3052 OpMemberDecorate %type_View 181 Offset 3056 OpMemberDecorate %type_View 181 MatrixStride 16 OpMemberDecorate %type_View 181 ColMajor OpMemberDecorate %type_View 182 Offset 3120 OpMemberDecorate %type_View 183 Offset 3136 OpDecorate %type_View Block OpDecorate %_arr_v4float_uint_5 ArrayStride 16 OpMemberDecorate %type_Material 0 Offset 0 OpMemberDecorate %type_Material 1 Offset 80 OpDecorate %type_Material Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %v2int = OpTypeVector %int 2 %float_0_00100000005 = OpConstant %float 0.00100000005 %uint_0 = OpConstant %uint 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %float_3 = OpConstant %float 3 %uint_1 = OpConstant %uint 1 %float_6 = OpConstant %float 6 %67 = OpConstantComposite %v4float %float_6 %float_6 %float_6 %float_6 %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %int_3 = OpConstant %int 3 %float_2 = OpConstant %float 2 %int_26 = OpConstant %int 26 %int_32 = OpConstant %int 32 %int_54 = OpConstant %int 54 %int_153 = OpConstant %int 153 %int_154 = OpConstant %int 154 %int_156 = OpConstant %int 156 %int_157 = OpConstant %int 157 %float_10 = OpConstant %float 10 %uint_3 = OpConstant %uint 3 %81 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %uint %uint %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v2int %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %float %float %mat4v4float %v4float %_arr_v4float_uint_2 %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %type_3d_image = OpTypeImage %float 3D 2 0 0 1 Unknown %_ptr_UniformConstant_type_3d_image = OpTypePointer UniformConstant %type_3d_image %uint_5 = OpConstant %uint 5 %_arr_v4float_uint_5 = OpTypeArray %v4float %uint_5 %type_Material = OpTypeStruct %_arr_v4float_uint_5 %_arr_v4float_uint_2 %_ptr_Uniform_type_Material = OpTypePointer Uniform %type_Material %_arr_float_uint_1 = OpTypeArray %float %uint_1 %_ptr_Output__arr_float_uint_1 = OpTypePointer Output %_arr_float_uint_1 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %_arr_uint_uint_3 = OpTypeArray %uint %uint_3 %_ptr_Input__arr_uint_uint_3 = OpTypePointer Input %_arr_uint_uint_3 %_arr__arr_v4float_uint_3_uint_3 = OpTypeArray %_arr_v4float_uint_3 %uint_3 %_ptr_Input__arr__arr_v4float_uint_3_uint_3 = OpTypePointer Input %_arr__arr_v4float_uint_3_uint_3 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Input__arr_v3float_uint_3 = OpTypePointer Input %_arr_v3float_uint_3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %_ptr_Input__arr_float_uint_3 = OpTypePointer Input %_arr_float_uint_3 %_arr_v2float_uint_3 = OpTypeArray %v2float %uint_3 %_ptr_Input__arr_v2float_uint_3 = OpTypePointer Input %_arr_v2float_uint_3 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Input__arr_float_uint_4 = OpTypePointer Input %_arr_float_uint_4 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Input__arr_float_uint_2 = OpTypePointer Input %_arr_float_uint_2 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_v3float = OpTypePointer Input %v3float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %109 = OpTypeFunction %void %_ptr_Output_float = OpTypePointer Output %float %mat3v3float = OpTypeMatrix %v3float 3 %bool = OpTypeBool %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %type_sampled_image = OpTypeSampledImage %type_3d_image %View = OpVariable %_ptr_Uniform_type_View Uniform %View_GlobalDistanceFieldTexture0 = OpVariable %_ptr_UniformConstant_type_3d_image UniformConstant %View_GlobalDistanceFieldSampler0 = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %View_GlobalDistanceFieldTexture1 = OpVariable %_ptr_UniformConstant_type_3d_image UniformConstant %View_GlobalDistanceFieldTexture2 = OpVariable %_ptr_UniformConstant_type_3d_image UniformConstant %View_GlobalDistanceFieldTexture3 = OpVariable %_ptr_UniformConstant_type_3d_image UniformConstant %Material = OpVariable %_ptr_Uniform_type_Material Uniform %gl_ClipDistance = OpVariable %_ptr_Output__arr_float_uint_1 Output %in_var_TEXCOORD6 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_TEXCOORD8 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_VS_To_DS_Position = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_VS_To_DS_VertexID = OpVariable %_ptr_Input__arr_uint_uint_3 Input %in_var_PN_POSITION = OpVariable %_ptr_Input__arr__arr_v4float_uint_3_uint_3 Input %in_var_PN_DisplacementScales = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %in_var_PN_TessellationMultiplier = OpVariable %_ptr_Input__arr_float_uint_3 Input %in_var_PN_WorldDisplacementMultiplier = OpVariable %_ptr_Input__arr_float_uint_3 Input %in_var_PN_DominantVertex = OpVariable %_ptr_Input__arr_v2float_uint_3 Input %in_var_PN_DominantVertex1 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_PN_DominantVertex2 = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %in_var_PN_DominantEdge = OpVariable %_ptr_Input__arr_v2float_uint_3 Input %in_var_PN_DominantEdge1 = OpVariable %_ptr_Input__arr_v2float_uint_3 Input %in_var_PN_DominantEdge2 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_PN_DominantEdge3 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_PN_DominantEdge4 = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %in_var_PN_DominantEdge5 = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %gl_TessLevelOuter = OpVariable %_ptr_Input__arr_float_uint_4 Input %gl_TessLevelInner = OpVariable %_ptr_Input__arr_float_uint_2 Input %in_var_PN_POSITION9 = OpVariable %_ptr_Input_v4float Input %gl_TessCoord = OpVariable %_ptr_Input_v3float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD6 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD7 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD10_centroid = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD11_centroid = OpVariable %_ptr_Output_v4float Output %117 = OpConstantNull %v4float %118 = OpUndef %v4float %MainDomain = OpFunction %void None %109 %119 = OpLabel %120 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD6 %121 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD8 %122 = OpCompositeExtract %v4float %120 0 %123 = OpCompositeExtract %v4float %121 0 %124 = OpCompositeExtract %v4float %120 1 %125 = OpCompositeExtract %v4float %121 1 %126 = OpCompositeExtract %v4float %120 2 %127 = OpCompositeExtract %v4float %121 2 %128 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD10_centroid %129 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD11_centroid %130 = OpCompositeExtract %v4float %128 0 %131 = OpCompositeExtract %v4float %129 0 %132 = OpCompositeExtract %v4float %128 1 %133 = OpCompositeExtract %v4float %129 1 %134 = OpCompositeExtract %v4float %128 2 %135 = OpCompositeExtract %v4float %129 2 %136 = OpLoad %_arr__arr_v4float_uint_3_uint_3 %in_var_PN_POSITION %137 = OpLoad %_arr_float_uint_3 %in_var_PN_WorldDisplacementMultiplier %138 = OpLoad %_arr_v4float_uint_3 %in_var_PN_DominantVertex1 %139 = OpLoad %_arr_v3float_uint_3 %in_var_PN_DominantVertex2 %140 = OpCompositeExtract %v4float %138 0 %141 = OpCompositeExtract %v3float %139 0 %142 = OpCompositeExtract %v4float %138 1 %143 = OpCompositeExtract %v3float %139 1 %144 = OpCompositeExtract %v4float %138 2 %145 = OpCompositeExtract %v3float %139 2 %146 = OpLoad %_arr_v4float_uint_3 %in_var_PN_DominantEdge2 %147 = OpLoad %_arr_v4float_uint_3 %in_var_PN_DominantEdge3 %148 = OpLoad %_arr_v3float_uint_3 %in_var_PN_DominantEdge4 %149 = OpLoad %_arr_v3float_uint_3 %in_var_PN_DominantEdge5 %150 = OpCompositeExtract %v4float %146 0 %151 = OpCompositeExtract %v4float %147 0 %152 = OpCompositeExtract %v3float %148 0 %153 = OpCompositeExtract %v3float %149 0 %154 = OpCompositeExtract %v4float %146 1 %155 = OpCompositeExtract %v4float %147 1 %156 = OpCompositeExtract %v3float %148 1 %157 = OpCompositeExtract %v3float %149 1 %158 = OpCompositeExtract %v4float %146 2 %159 = OpCompositeExtract %v4float %147 2 %160 = OpCompositeExtract %v3float %148 2 %161 = OpCompositeExtract %v3float %149 2 %162 = OpCompositeExtract %_arr_v4float_uint_3 %136 0 %163 = OpCompositeExtract %float %137 0 %164 = OpCompositeExtract %_arr_v4float_uint_3 %136 1 %165 = OpCompositeExtract %float %137 1 %166 = OpCompositeExtract %_arr_v4float_uint_3 %136 2 %167 = OpCompositeExtract %float %137 2 %168 = OpCompositeExtract %v4float %162 0 %169 = OpCompositeExtract %v4float %162 1 %170 = OpCompositeExtract %v4float %162 2 %171 = OpCompositeExtract %v4float %164 0 %172 = OpCompositeExtract %v4float %164 1 %173 = OpCompositeExtract %v4float %164 2 %174 = OpCompositeExtract %v4float %166 0 %175 = OpCompositeExtract %v4float %166 1 %176 = OpCompositeExtract %v4float %166 2 %177 = OpLoad %v4float %in_var_PN_POSITION9 %178 = OpLoad %v3float %gl_TessCoord %179 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_0 %180 = OpLoad %mat4v4float %179 %181 = OpAccessChain %_ptr_Uniform_v3float %View %int_26 %182 = OpLoad %v3float %181 %183 = OpAccessChain %_ptr_Uniform_v3float %View %int_32 %184 = OpLoad %v3float %183 %185 = OpAccessChain %_ptr_Uniform_v4float %View %int_54 %186 = OpLoad %v4float %185 %187 = OpCompositeExtract %float %178 0 %188 = OpCompositeExtract %float %178 1 %189 = OpCompositeExtract %float %178 2 %190 = OpFMul %float %187 %187 %191 = OpFMul %float %188 %188 %192 = OpFMul %float %189 %189 %193 = OpFMul %float %190 %float_3 %194 = OpFMul %float %191 %float_3 %195 = OpFMul %float %192 %float_3 %196 = OpCompositeConstruct %v4float %190 %190 %190 %190 %197 = OpFMul %v4float %168 %196 %198 = OpCompositeConstruct %v4float %187 %187 %187 %187 %199 = OpFMul %v4float %197 %198 %200 = OpCompositeConstruct %v4float %191 %191 %191 %191 %201 = OpFMul %v4float %171 %200 %202 = OpCompositeConstruct %v4float %188 %188 %188 %188 %203 = OpFMul %v4float %201 %202 %204 = OpFAdd %v4float %199 %203 %205 = OpCompositeConstruct %v4float %192 %192 %192 %192 %206 = OpFMul %v4float %174 %205 %207 = OpCompositeConstruct %v4float %189 %189 %189 %189 %208 = OpFMul %v4float %206 %207 %209 = OpFAdd %v4float %204 %208 %210 = OpCompositeConstruct %v4float %193 %193 %193 %193 %211 = OpFMul %v4float %169 %210 %212 = OpFMul %v4float %211 %202 %213 = OpFAdd %v4float %209 %212 %214 = OpCompositeConstruct %v4float %194 %194 %194 %194 %215 = OpFMul %v4float %170 %214 %216 = OpFMul %v4float %215 %198 %217 = OpFAdd %v4float %213 %216 %218 = OpFMul %v4float %172 %214 %219 = OpFMul %v4float %218 %207 %220 = OpFAdd %v4float %217 %219 %221 = OpCompositeConstruct %v4float %195 %195 %195 %195 %222 = OpFMul %v4float %173 %221 %223 = OpFMul %v4float %222 %202 %224 = OpFAdd %v4float %220 %223 %225 = OpFMul %v4float %175 %221 %226 = OpFMul %v4float %225 %198 %227 = OpFAdd %v4float %224 %226 %228 = OpFMul %v4float %176 %210 %229 = OpFMul %v4float %228 %207 %230 = OpFAdd %v4float %227 %229 %231 = OpFMul %v4float %177 %67 %232 = OpFMul %v4float %231 %207 %233 = OpFMul %v4float %232 %198 %234 = OpFMul %v4float %233 %202 %235 = OpFAdd %v4float %230 %234 %236 = OpVectorShuffle %v3float %130 %130 0 1 2 %237 = OpCompositeConstruct %v3float %187 %187 %187 %238 = OpFMul %v3float %236 %237 %239 = OpVectorShuffle %v3float %132 %132 0 1 2 %240 = OpCompositeConstruct %v3float %188 %188 %188 %241 = OpFMul %v3float %239 %240 %242 = OpFAdd %v3float %238 %241 %243 = OpFMul %v4float %131 %198 %244 = OpFMul %v4float %133 %202 %245 = OpFAdd %v4float %243 %244 %246 = OpFMul %v4float %122 %198 %247 = OpFMul %v4float %124 %202 %248 = OpFAdd %v4float %246 %247 %249 = OpFMul %v4float %123 %198 %250 = OpFMul %v4float %125 %202 %251 = OpFAdd %v4float %249 %250 %252 = OpVectorShuffle %v3float %242 %117 0 1 2 %253 = OpVectorShuffle %v3float %134 %134 0 1 2 %254 = OpCompositeConstruct %v3float %189 %189 %189 %255 = OpFMul %v3float %253 %254 %256 = OpFAdd %v3float %252 %255 %257 = OpVectorShuffle %v4float %118 %256 4 5 6 3 %258 = OpFMul %v4float %135 %207 %259 = OpFAdd %v4float %245 %258 %260 = OpFMul %v4float %126 %207 %261 = OpFAdd %v4float %248 %260 %262 = OpFMul %v4float %127 %207 %263 = OpFAdd %v4float %251 %262 %264 = OpVectorShuffle %v3float %235 %235 0 1 2 %265 = OpVectorShuffle %v3float %256 %117 0 1 2 %266 = OpVectorShuffle %v3float %259 %259 0 1 2 %267 = OpExtInst %v3float %1 Cross %266 %265 %268 = OpCompositeExtract %float %259 3 %269 = OpCompositeConstruct %v3float %268 %268 %268 %270 = OpFMul %v3float %267 %269 %271 = OpCompositeConstruct %mat3v3float %265 %270 %266 %272 = OpFAdd %v3float %264 %182 %273 = OpCompositeExtract %float %259 0 %274 = OpCompositeExtract %float %259 1 %275 = OpCompositeExtract %float %259 2 %276 = OpCompositeConstruct %v4float %273 %274 %275 %float_0 %277 = OpFOrdEqual %bool %187 %float_0 %278 = OpSelect %int %277 %int_1 %int_0 %279 = OpConvertSToF %float %278 %280 = OpFOrdEqual %bool %188 %float_0 %281 = OpSelect %int %280 %int_1 %int_0 %282 = OpConvertSToF %float %281 %283 = OpFOrdEqual %bool %189 %float_0 %284 = OpSelect %int %283 %int_1 %int_0 %285 = OpConvertSToF %float %284 %286 = OpFAdd %float %279 %282 %287 = OpFAdd %float %286 %285 %288 = OpFOrdEqual %bool %287 %float_2 %289 = OpSelect %int %288 %int_1 %int_0 %290 = OpConvertSToF %float %289 %291 = OpFOrdEqual %bool %287 %float_1 %292 = OpSelect %int %291 %int_1 %int_0 %293 = OpConvertSToF %float %292 %294 = OpFOrdEqual %bool %287 %float_0 %295 = OpSelect %int %294 %int_1 %int_0 %296 = OpConvertSToF %float %295 %297 = OpFOrdEqual %bool %290 %float_1 OpSelectionMerge %298 None OpBranchConditional %297 %299 %300 %300 = OpLabel %301 = OpFOrdNotEqual %bool %293 %float_0 OpSelectionMerge %302 None OpBranchConditional %301 %303 %302 %303 = OpLabel %304 = OpCompositeConstruct %v4float %279 %279 %279 %279 %305 = OpFMul %v4float %304 %150 %306 = OpCompositeConstruct %v4float %282 %282 %282 %282 %307 = OpFMul %v4float %306 %154 %308 = OpFAdd %v4float %305 %307 %309 = OpCompositeConstruct %v4float %285 %285 %285 %285 %310 = OpFMul %v4float %309 %158 %311 = OpFAdd %v4float %308 %310 %312 = OpFMul %v4float %304 %151 %313 = OpFMul %v4float %306 %155 %314 = OpFAdd %v4float %312 %313 %315 = OpFMul %v4float %309 %159 %316 = OpFAdd %v4float %314 %315 %317 = OpFMul %v4float %202 %311 %318 = OpFMul %v4float %207 %316 %319 = OpFAdd %v4float %317 %318 %320 = OpFMul %v4float %304 %319 %321 = OpFMul %v4float %207 %311 %322 = OpFMul %v4float %198 %316 %323 = OpFAdd %v4float %321 %322 %324 = OpFMul %v4float %306 %323 %325 = OpFAdd %v4float %320 %324 %326 = OpFMul %v4float %198 %311 %327 = OpFMul %v4float %202 %316 %328 = OpFAdd %v4float %326 %327 %329 = OpFMul %v4float %309 %328 %330 = OpFAdd %v4float %325 %329 %331 = OpCompositeConstruct %v3float %279 %279 %279 %332 = OpFMul %v3float %331 %152 %333 = OpCompositeConstruct %v3float %282 %282 %282 %334 = OpFMul %v3float %333 %156 %335 = OpFAdd %v3float %332 %334 %336 = OpCompositeConstruct %v3float %285 %285 %285 %337 = OpFMul %v3float %336 %160 %338 = OpFAdd %v3float %335 %337 %339 = OpFMul %v3float %331 %153 %340 = OpFMul %v3float %333 %157 %341 = OpFAdd %v3float %339 %340 %342 = OpFMul %v3float %336 %161 %343 = OpFAdd %v3float %341 %342 %344 = OpFMul %v3float %240 %338 %345 = OpFMul %v3float %254 %343 %346 = OpFAdd %v3float %344 %345 %347 = OpFMul %v3float %331 %346 %348 = OpFMul %v3float %254 %338 %349 = OpFMul %v3float %237 %343 %350 = OpFAdd %v3float %348 %349 %351 = OpFMul %v3float %333 %350 %352 = OpFAdd %v3float %347 %351 %353 = OpFMul %v3float %237 %338 %354 = OpFMul %v3float %240 %343 %355 = OpFAdd %v3float %353 %354 %356 = OpFMul %v3float %336 %355 %357 = OpFAdd %v3float %352 %356 OpBranch %302 %302 = OpLabel %358 = OpPhi %v4float %276 %300 %330 %303 %359 = OpPhi %v3float %265 %300 %357 %303 OpBranch %298 %299 = OpLabel %360 = OpFAdd %float %282 %285 %361 = OpFOrdEqual %bool %360 %float_2 %362 = OpSelect %int %361 %int_1 %int_0 %363 = OpConvertSToF %float %362 %364 = OpFAdd %float %285 %279 %365 = OpFOrdEqual %bool %364 %float_2 %366 = OpSelect %int %365 %int_1 %int_0 %367 = OpConvertSToF %float %366 %368 = OpFOrdEqual %bool %286 %float_2 %369 = OpSelect %int %368 %int_1 %int_0 %370 = OpConvertSToF %float %369 %371 = OpCompositeConstruct %v4float %363 %363 %363 %363 %372 = OpFMul %v4float %371 %140 %373 = OpCompositeConstruct %v4float %367 %367 %367 %367 %374 = OpFMul %v4float %373 %142 %375 = OpFAdd %v4float %372 %374 %376 = OpCompositeConstruct %v4float %370 %370 %370 %370 %377 = OpFMul %v4float %376 %144 %378 = OpFAdd %v4float %375 %377 %379 = OpCompositeConstruct %v3float %363 %363 %363 %380 = OpFMul %v3float %379 %141 %381 = OpCompositeConstruct %v3float %367 %367 %367 %382 = OpFMul %v3float %381 %143 %383 = OpFAdd %v3float %380 %382 %384 = OpCompositeConstruct %v3float %370 %370 %370 %385 = OpFMul %v3float %384 %145 %386 = OpFAdd %v3float %383 %385 OpBranch %298 %298 = OpLabel %387 = OpPhi %v4float %378 %299 %358 %302 %388 = OpPhi %v3float %386 %299 %359 %302 %389 = OpFOrdEqual %bool %296 %float_0 OpSelectionMerge %390 None OpBranchConditional %389 %391 %390 %391 = OpLabel %392 = OpVectorShuffle %v3float %387 %387 0 1 2 %393 = OpExtInst %v3float %1 Cross %392 %388 %394 = OpCompositeExtract %float %387 3 %395 = OpCompositeConstruct %v3float %394 %394 %394 %396 = OpFMul %v3float %393 %395 %397 = OpCompositeConstruct %mat3v3float %388 %396 %392 OpBranch %390 %390 = OpLabel %398 = OpPhi %mat3v3float %271 %298 %397 %391 %399 = OpAccessChain %_ptr_Uniform_float %View %int_157 %400 = OpLoad %float %399 %401 = OpAccessChain %_ptr_Uniform_v4float %View %int_153 %int_0 %402 = OpLoad %v4float %401 %403 = OpVectorShuffle %v3float %402 %402 0 1 2 %404 = OpVectorShuffle %v3float %402 %402 3 3 3 %405 = OpFSub %v3float %272 %403 %406 = OpFAdd %v3float %405 %404 %407 = OpExtInst %v3float %1 FMax %406 %81 %408 = OpFAdd %v3float %403 %404 %409 = OpFSub %v3float %408 %272 %410 = OpExtInst %v3float %1 FMax %409 %81 %411 = OpExtInst %v3float %1 FMin %407 %410 %412 = OpCompositeExtract %float %411 0 %413 = OpCompositeExtract %float %411 1 %414 = OpCompositeExtract %float %411 2 %415 = OpExtInst %float %1 FMin %413 %414 %416 = OpExtInst %float %1 FMin %412 %415 %417 = OpAccessChain %_ptr_Uniform_float %View %int_153 %int_0 %int_3 %418 = OpLoad %float %417 %419 = OpAccessChain %_ptr_Uniform_float %View %int_156 %420 = OpLoad %float %419 %421 = OpFMul %float %418 %420 %422 = OpFOrdGreaterThan %bool %416 %421 OpSelectionMerge %423 DontFlatten OpBranchConditional %422 %424 %425 %425 = OpLabel %426 = OpAccessChain %_ptr_Uniform_v4float %View %int_153 %int_1 %427 = OpLoad %v4float %426 %428 = OpVectorShuffle %v3float %427 %427 0 1 2 %429 = OpVectorShuffle %v3float %427 %427 3 3 3 %430 = OpFSub %v3float %272 %428 %431 = OpFAdd %v3float %430 %429 %432 = OpExtInst %v3float %1 FMax %431 %81 %433 = OpFAdd %v3float %428 %429 %434 = OpFSub %v3float %433 %272 %435 = OpExtInst %v3float %1 FMax %434 %81 %436 = OpExtInst %v3float %1 FMin %432 %435 %437 = OpCompositeExtract %float %436 0 %438 = OpCompositeExtract %float %436 1 %439 = OpCompositeExtract %float %436 2 %440 = OpExtInst %float %1 FMin %438 %439 %441 = OpExtInst %float %1 FMin %437 %440 %442 = OpAccessChain %_ptr_Uniform_float %View %int_153 %int_1 %int_3 %443 = OpLoad %float %442 %444 = OpFMul %float %443 %420 %445 = OpFOrdGreaterThan %bool %441 %444 OpSelectionMerge %446 DontFlatten OpBranchConditional %445 %447 %448 %448 = OpLabel %449 = OpAccessChain %_ptr_Uniform_v4float %View %int_153 %int_2 %450 = OpLoad %v4float %449 %451 = OpVectorShuffle %v3float %450 %450 0 1 2 %452 = OpVectorShuffle %v3float %450 %450 3 3 3 %453 = OpFSub %v3float %272 %451 %454 = OpFAdd %v3float %453 %452 %455 = OpExtInst %v3float %1 FMax %454 %81 %456 = OpFAdd %v3float %451 %452 %457 = OpFSub %v3float %456 %272 %458 = OpExtInst %v3float %1 FMax %457 %81 %459 = OpExtInst %v3float %1 FMin %455 %458 %460 = OpCompositeExtract %float %459 0 %461 = OpCompositeExtract %float %459 1 %462 = OpCompositeExtract %float %459 2 %463 = OpExtInst %float %1 FMin %461 %462 %464 = OpExtInst %float %1 FMin %460 %463 %465 = OpAccessChain %_ptr_Uniform_v4float %View %int_153 %int_3 %466 = OpLoad %v4float %465 %467 = OpVectorShuffle %v3float %466 %466 0 1 2 %468 = OpVectorShuffle %v3float %466 %466 3 3 3 %469 = OpFSub %v3float %272 %467 %470 = OpFAdd %v3float %469 %468 %471 = OpExtInst %v3float %1 FMax %470 %81 %472 = OpFAdd %v3float %467 %468 %473 = OpFSub %v3float %472 %272 %474 = OpExtInst %v3float %1 FMax %473 %81 %475 = OpExtInst %v3float %1 FMin %471 %474 %476 = OpCompositeExtract %float %475 0 %477 = OpCompositeExtract %float %475 1 %478 = OpCompositeExtract %float %475 2 %479 = OpExtInst %float %1 FMin %477 %478 %480 = OpExtInst %float %1 FMin %476 %479 %481 = OpAccessChain %_ptr_Uniform_float %View %int_153 %int_2 %int_3 %482 = OpLoad %float %481 %483 = OpFMul %float %482 %420 %484 = OpFOrdGreaterThan %bool %464 %483 OpSelectionMerge %485 DontFlatten OpBranchConditional %484 %486 %487 %487 = OpLabel %488 = OpAccessChain %_ptr_Uniform_float %View %int_153 %int_3 %int_3 %489 = OpLoad %float %488 %490 = OpFMul %float %489 %420 %491 = OpFOrdGreaterThan %bool %480 %490 OpSelectionMerge %492 None OpBranchConditional %491 %493 %492 %493 = OpLabel %494 = OpFMul %float %480 %float_10 %495 = OpAccessChain %_ptr_Uniform_float %View %int_154 %int_3 %int_3 %496 = OpLoad %float %495 %497 = OpFMul %float %494 %496 %498 = OpExtInst %float %1 FClamp %497 %float_0 %float_1 %499 = OpAccessChain %_ptr_Uniform_v4float %View %int_154 %uint_3 %500 = OpLoad %v4float %499 %501 = OpVectorShuffle %v3float %500 %500 3 3 3 %502 = OpFMul %v3float %272 %501 %503 = OpVectorShuffle %v3float %500 %500 0 1 2 %504 = OpFAdd %v3float %502 %503 %505 = OpLoad %type_3d_image %View_GlobalDistanceFieldTexture3 %506 = OpLoad %type_sampler %View_GlobalDistanceFieldSampler0 %507 = OpSampledImage %type_sampled_image %505 %506 %508 = OpImageSampleExplicitLod %v4float %507 %504 Lod %float_0 %509 = OpCompositeExtract %float %508 0 %510 = OpExtInst %float %1 FMix %400 %509 %498 OpBranch %492 %492 = OpLabel %511 = OpPhi %float %400 %487 %510 %493 OpBranch %485 %486 = OpLabel %512 = OpAccessChain %_ptr_Uniform_v4float %View %int_154 %uint_2 %513 = OpLoad %v4float %512 %514 = OpVectorShuffle %v3float %513 %513 3 3 3 %515 = OpFMul %v3float %272 %514 %516 = OpVectorShuffle %v3float %513 %513 0 1 2 %517 = OpFAdd %v3float %515 %516 %518 = OpLoad %type_3d_image %View_GlobalDistanceFieldTexture2 %519 = OpLoad %type_sampler %View_GlobalDistanceFieldSampler0 %520 = OpSampledImage %type_sampled_image %518 %519 %521 = OpImageSampleExplicitLod %v4float %520 %517 Lod %float_0 %522 = OpCompositeExtract %float %521 0 OpBranch %485 %485 = OpLabel %523 = OpPhi %float %522 %486 %511 %492 OpBranch %446 %447 = OpLabel %524 = OpAccessChain %_ptr_Uniform_v4float %View %int_154 %uint_1 %525 = OpLoad %v4float %524 %526 = OpVectorShuffle %v3float %525 %525 3 3 3 %527 = OpFMul %v3float %272 %526 %528 = OpVectorShuffle %v3float %525 %525 0 1 2 %529 = OpFAdd %v3float %527 %528 %530 = OpLoad %type_3d_image %View_GlobalDistanceFieldTexture1 %531 = OpLoad %type_sampler %View_GlobalDistanceFieldSampler0 %532 = OpSampledImage %type_sampled_image %530 %531 %533 = OpImageSampleExplicitLod %v4float %532 %529 Lod %float_0 %534 = OpCompositeExtract %float %533 0 OpBranch %446 %446 = OpLabel %535 = OpPhi %float %534 %447 %523 %485 OpBranch %423 %424 = OpLabel %536 = OpAccessChain %_ptr_Uniform_v4float %View %int_154 %uint_0 %537 = OpLoad %v4float %536 %538 = OpVectorShuffle %v3float %537 %537 3 3 3 %539 = OpFMul %v3float %272 %538 %540 = OpVectorShuffle %v3float %537 %537 0 1 2 %541 = OpFAdd %v3float %539 %540 %542 = OpLoad %type_3d_image %View_GlobalDistanceFieldTexture0 %543 = OpLoad %type_sampler %View_GlobalDistanceFieldSampler0 %544 = OpSampledImage %type_sampled_image %542 %543 %545 = OpImageSampleExplicitLod %v4float %544 %541 Lod %float_0 %546 = OpCompositeExtract %float %545 0 OpBranch %423 %423 = OpLabel %547 = OpPhi %float %546 %424 %535 %446 %548 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_0 %int_2 %549 = OpLoad %float %548 %550 = OpFAdd %float %547 %549 %551 = OpExtInst %float %1 FMin %550 %float_0 %552 = OpAccessChain %_ptr_Uniform_float %Material %int_1 %int_0 %int_3 %553 = OpLoad %float %552 %554 = OpFMul %float %551 %553 %555 = OpCompositeExtract %v3float %398 2 %556 = OpCompositeConstruct %v3float %554 %554 %554 %557 = OpFMul %v3float %555 %556 %558 = OpFMul %float %163 %187 %559 = OpFMul %float %165 %188 %560 = OpFAdd %float %558 %559 %561 = OpFMul %float %167 %189 %562 = OpFAdd %float %560 %561 %563 = OpCompositeConstruct %v3float %562 %562 %562 %564 = OpFMul %v3float %557 %563 %565 = OpFAdd %v3float %264 %564 %566 = OpVectorShuffle %v4float %235 %565 4 5 6 3 %567 = OpVectorShuffle %v3float %565 %117 0 1 2 %568 = OpFSub %v3float %567 %184 %569 = OpCompositeExtract %float %568 0 %570 = OpCompositeExtract %float %568 1 %571 = OpCompositeExtract %float %568 2 %572 = OpCompositeConstruct %v4float %569 %570 %571 %float_1 %573 = OpDot %float %186 %572 %574 = OpMatrixTimesVector %v4float %180 %566 %575 = OpCompositeExtract %float %574 3 %576 = OpFMul %float %float_0_00100000005 %575 %577 = OpCompositeExtract %float %574 2 %578 = OpFAdd %float %577 %576 %579 = OpCompositeInsert %v4float %578 %574 2 OpStore %gl_Position %579 OpStore %out_var_TEXCOORD6 %261 OpStore %out_var_TEXCOORD7 %263 OpStore %out_var_TEXCOORD10_centroid %257 OpStore %out_var_TEXCOORD11_centroid %259 %580 = OpAccessChain %_ptr_Output_float %gl_ClipDistance %uint_0 OpStore %580 %573 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/tese/ds-patch-inputs.asm.tese000066400000000000000000001073431400026215700247320ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 236 ; Schema: 0 OpCapability Tessellation OpCapability SampledBuffer OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %MainDomain "main" %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_VS_to_DS_Position %in_var_VS_To_DS_VertexID %in_var_PN_POSITION %in_var_PN_DisplacementScales %in_var_PN_TessellationMultiplier %in_var_PN_WorldDisplacementMultiplier %in_var_PN_DominantVertex %in_var_PN_DominantVertex1 %in_var_PN_DominantVertex2 %in_var_PN_DominantEdge %in_var_PN_DominantEdge1 %in_var_PN_DominantEdge2 %in_var_PN_DominantEdge3 %in_var_PN_DominantEdge4 %in_var_PN_DominantEdge5 %gl_TessLevelOuter %gl_TessLevelInner %in_var_PN_POSITION9 %gl_TessCoord %out_var_TEXCOORD10_centroid %out_var_TEXCOORD11_centroid %out_var_TEXCOORD6 %out_var_TEXCOORD7 %gl_Position OpExecutionMode %MainDomain Triangles OpSource HLSL 600 OpName %type_ShadowDepthPass "type.ShadowDepthPass" OpMemberName %type_ShadowDepthPass 0 "PrePadding_ShadowDepthPass_LPV_0" OpMemberName %type_ShadowDepthPass 1 "PrePadding_ShadowDepthPass_LPV_4" OpMemberName %type_ShadowDepthPass 2 "PrePadding_ShadowDepthPass_LPV_8" OpMemberName %type_ShadowDepthPass 3 "PrePadding_ShadowDepthPass_LPV_12" OpMemberName %type_ShadowDepthPass 4 "PrePadding_ShadowDepthPass_LPV_16" OpMemberName %type_ShadowDepthPass 5 "PrePadding_ShadowDepthPass_LPV_20" OpMemberName %type_ShadowDepthPass 6 "PrePadding_ShadowDepthPass_LPV_24" OpMemberName %type_ShadowDepthPass 7 "PrePadding_ShadowDepthPass_LPV_28" OpMemberName %type_ShadowDepthPass 8 "PrePadding_ShadowDepthPass_LPV_32" OpMemberName %type_ShadowDepthPass 9 "PrePadding_ShadowDepthPass_LPV_36" OpMemberName %type_ShadowDepthPass 10 "PrePadding_ShadowDepthPass_LPV_40" OpMemberName %type_ShadowDepthPass 11 "PrePadding_ShadowDepthPass_LPV_44" OpMemberName %type_ShadowDepthPass 12 "PrePadding_ShadowDepthPass_LPV_48" OpMemberName %type_ShadowDepthPass 13 "PrePadding_ShadowDepthPass_LPV_52" OpMemberName %type_ShadowDepthPass 14 "PrePadding_ShadowDepthPass_LPV_56" OpMemberName %type_ShadowDepthPass 15 "PrePadding_ShadowDepthPass_LPV_60" OpMemberName %type_ShadowDepthPass 16 "PrePadding_ShadowDepthPass_LPV_64" OpMemberName %type_ShadowDepthPass 17 "PrePadding_ShadowDepthPass_LPV_68" OpMemberName %type_ShadowDepthPass 18 "PrePadding_ShadowDepthPass_LPV_72" OpMemberName %type_ShadowDepthPass 19 "PrePadding_ShadowDepthPass_LPV_76" OpMemberName %type_ShadowDepthPass 20 "PrePadding_ShadowDepthPass_LPV_80" OpMemberName %type_ShadowDepthPass 21 "PrePadding_ShadowDepthPass_LPV_84" OpMemberName %type_ShadowDepthPass 22 "PrePadding_ShadowDepthPass_LPV_88" OpMemberName %type_ShadowDepthPass 23 "PrePadding_ShadowDepthPass_LPV_92" OpMemberName %type_ShadowDepthPass 24 "PrePadding_ShadowDepthPass_LPV_96" OpMemberName %type_ShadowDepthPass 25 "PrePadding_ShadowDepthPass_LPV_100" OpMemberName %type_ShadowDepthPass 26 "PrePadding_ShadowDepthPass_LPV_104" OpMemberName %type_ShadowDepthPass 27 "PrePadding_ShadowDepthPass_LPV_108" OpMemberName %type_ShadowDepthPass 28 "PrePadding_ShadowDepthPass_LPV_112" OpMemberName %type_ShadowDepthPass 29 "PrePadding_ShadowDepthPass_LPV_116" OpMemberName %type_ShadowDepthPass 30 "PrePadding_ShadowDepthPass_LPV_120" OpMemberName %type_ShadowDepthPass 31 "PrePadding_ShadowDepthPass_LPV_124" OpMemberName %type_ShadowDepthPass 32 "PrePadding_ShadowDepthPass_LPV_128" OpMemberName %type_ShadowDepthPass 33 "PrePadding_ShadowDepthPass_LPV_132" OpMemberName %type_ShadowDepthPass 34 "PrePadding_ShadowDepthPass_LPV_136" OpMemberName %type_ShadowDepthPass 35 "PrePadding_ShadowDepthPass_LPV_140" OpMemberName %type_ShadowDepthPass 36 "PrePadding_ShadowDepthPass_LPV_144" OpMemberName %type_ShadowDepthPass 37 "PrePadding_ShadowDepthPass_LPV_148" OpMemberName %type_ShadowDepthPass 38 "PrePadding_ShadowDepthPass_LPV_152" OpMemberName %type_ShadowDepthPass 39 "PrePadding_ShadowDepthPass_LPV_156" OpMemberName %type_ShadowDepthPass 40 "PrePadding_ShadowDepthPass_LPV_160" OpMemberName %type_ShadowDepthPass 41 "PrePadding_ShadowDepthPass_LPV_164" OpMemberName %type_ShadowDepthPass 42 "PrePadding_ShadowDepthPass_LPV_168" OpMemberName %type_ShadowDepthPass 43 "PrePadding_ShadowDepthPass_LPV_172" OpMemberName %type_ShadowDepthPass 44 "PrePadding_ShadowDepthPass_LPV_176" OpMemberName %type_ShadowDepthPass 45 "PrePadding_ShadowDepthPass_LPV_180" OpMemberName %type_ShadowDepthPass 46 "PrePadding_ShadowDepthPass_LPV_184" OpMemberName %type_ShadowDepthPass 47 "PrePadding_ShadowDepthPass_LPV_188" OpMemberName %type_ShadowDepthPass 48 "PrePadding_ShadowDepthPass_LPV_192" OpMemberName %type_ShadowDepthPass 49 "PrePadding_ShadowDepthPass_LPV_196" OpMemberName %type_ShadowDepthPass 50 "PrePadding_ShadowDepthPass_LPV_200" OpMemberName %type_ShadowDepthPass 51 "PrePadding_ShadowDepthPass_LPV_204" OpMemberName %type_ShadowDepthPass 52 "PrePadding_ShadowDepthPass_LPV_208" OpMemberName %type_ShadowDepthPass 53 "PrePadding_ShadowDepthPass_LPV_212" OpMemberName %type_ShadowDepthPass 54 "PrePadding_ShadowDepthPass_LPV_216" OpMemberName %type_ShadowDepthPass 55 "PrePadding_ShadowDepthPass_LPV_220" OpMemberName %type_ShadowDepthPass 56 "PrePadding_ShadowDepthPass_LPV_224" OpMemberName %type_ShadowDepthPass 57 "PrePadding_ShadowDepthPass_LPV_228" OpMemberName %type_ShadowDepthPass 58 "PrePadding_ShadowDepthPass_LPV_232" OpMemberName %type_ShadowDepthPass 59 "PrePadding_ShadowDepthPass_LPV_236" OpMemberName %type_ShadowDepthPass 60 "PrePadding_ShadowDepthPass_LPV_240" OpMemberName %type_ShadowDepthPass 61 "PrePadding_ShadowDepthPass_LPV_244" OpMemberName %type_ShadowDepthPass 62 "PrePadding_ShadowDepthPass_LPV_248" OpMemberName %type_ShadowDepthPass 63 "PrePadding_ShadowDepthPass_LPV_252" OpMemberName %type_ShadowDepthPass 64 "PrePadding_ShadowDepthPass_LPV_256" OpMemberName %type_ShadowDepthPass 65 "PrePadding_ShadowDepthPass_LPV_260" OpMemberName %type_ShadowDepthPass 66 "PrePadding_ShadowDepthPass_LPV_264" OpMemberName %type_ShadowDepthPass 67 "PrePadding_ShadowDepthPass_LPV_268" OpMemberName %type_ShadowDepthPass 68 "ShadowDepthPass_LPV_mRsmToWorld" OpMemberName %type_ShadowDepthPass 69 "ShadowDepthPass_LPV_mLightColour" OpMemberName %type_ShadowDepthPass 70 "ShadowDepthPass_LPV_GeometryVolumeCaptureLightDirection" OpMemberName %type_ShadowDepthPass 71 "ShadowDepthPass_LPV_mEyePos" OpMemberName %type_ShadowDepthPass 72 "ShadowDepthPass_LPV_mOldGridOffset" OpMemberName %type_ShadowDepthPass 73 "PrePadding_ShadowDepthPass_LPV_396" OpMemberName %type_ShadowDepthPass 74 "ShadowDepthPass_LPV_mLpvGridOffset" OpMemberName %type_ShadowDepthPass 75 "ShadowDepthPass_LPV_ClearMultiplier" OpMemberName %type_ShadowDepthPass 76 "ShadowDepthPass_LPV_LpvScale" OpMemberName %type_ShadowDepthPass 77 "ShadowDepthPass_LPV_OneOverLpvScale" OpMemberName %type_ShadowDepthPass 78 "ShadowDepthPass_LPV_DirectionalOcclusionIntensity" OpMemberName %type_ShadowDepthPass 79 "ShadowDepthPass_LPV_DirectionalOcclusionRadius" OpMemberName %type_ShadowDepthPass 80 "ShadowDepthPass_LPV_RsmAreaIntensityMultiplier" OpMemberName %type_ShadowDepthPass 81 "ShadowDepthPass_LPV_RsmPixelToTexcoordMultiplier" OpMemberName %type_ShadowDepthPass 82 "ShadowDepthPass_LPV_SecondaryOcclusionStrength" OpMemberName %type_ShadowDepthPass 83 "ShadowDepthPass_LPV_SecondaryBounceStrength" OpMemberName %type_ShadowDepthPass 84 "ShadowDepthPass_LPV_VplInjectionBias" OpMemberName %type_ShadowDepthPass 85 "ShadowDepthPass_LPV_GeometryVolumeInjectionBias" OpMemberName %type_ShadowDepthPass 86 "ShadowDepthPass_LPV_EmissiveInjectionMultiplier" OpMemberName %type_ShadowDepthPass 87 "ShadowDepthPass_LPV_PropagationIndex" OpMemberName %type_ShadowDepthPass 88 "ShadowDepthPass_ProjectionMatrix" OpMemberName %type_ShadowDepthPass 89 "ShadowDepthPass_ViewMatrix" OpMemberName %type_ShadowDepthPass 90 "ShadowDepthPass_ShadowParams" OpMemberName %type_ShadowDepthPass 91 "ShadowDepthPass_bClampToNearPlane" OpMemberName %type_ShadowDepthPass 92 "PrePadding_ShadowDepthPass_612" OpMemberName %type_ShadowDepthPass 93 "PrePadding_ShadowDepthPass_616" OpMemberName %type_ShadowDepthPass 94 "PrePadding_ShadowDepthPass_620" OpMemberName %type_ShadowDepthPass 95 "ShadowDepthPass_ShadowViewProjectionMatrices" OpMemberName %type_ShadowDepthPass 96 "ShadowDepthPass_ShadowViewMatrices" OpName %ShadowDepthPass "ShadowDepthPass" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_VS_to_DS_Position "in.var.VS_to_DS_Position" OpName %in_var_VS_To_DS_VertexID "in.var.VS_To_DS_VertexID" OpName %in_var_PN_POSITION "in.var.PN_POSITION" OpName %in_var_PN_DisplacementScales "in.var.PN_DisplacementScales" OpName %in_var_PN_TessellationMultiplier "in.var.PN_TessellationMultiplier" OpName %in_var_PN_WorldDisplacementMultiplier "in.var.PN_WorldDisplacementMultiplier" OpName %in_var_PN_DominantVertex "in.var.PN_DominantVertex" OpName %in_var_PN_DominantVertex1 "in.var.PN_DominantVertex1" OpName %in_var_PN_DominantVertex2 "in.var.PN_DominantVertex2" OpName %in_var_PN_DominantEdge "in.var.PN_DominantEdge" OpName %in_var_PN_DominantEdge1 "in.var.PN_DominantEdge1" OpName %in_var_PN_DominantEdge2 "in.var.PN_DominantEdge2" OpName %in_var_PN_DominantEdge3 "in.var.PN_DominantEdge3" OpName %in_var_PN_DominantEdge4 "in.var.PN_DominantEdge4" OpName %in_var_PN_DominantEdge5 "in.var.PN_DominantEdge5" OpName %in_var_PN_POSITION9 "in.var.PN_POSITION9" OpName %out_var_TEXCOORD10_centroid "out.var.TEXCOORD10_centroid" OpName %out_var_TEXCOORD11_centroid "out.var.TEXCOORD11_centroid" OpName %out_var_TEXCOORD6 "out.var.TEXCOORD6" OpName %out_var_TEXCOORD7 "out.var.TEXCOORD7" OpName %MainDomain "MainDomain" OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_VS_to_DS_Position UserSemantic "VS_to_DS_Position" OpDecorateString %in_var_VS_To_DS_VertexID UserSemantic "VS_To_DS_VertexID" OpDecorateString %in_var_PN_POSITION UserSemantic "PN_POSITION" OpDecorateString %in_var_PN_DisplacementScales UserSemantic "PN_DisplacementScales" OpDecorateString %in_var_PN_TessellationMultiplier UserSemantic "PN_TessellationMultiplier" OpDecorateString %in_var_PN_WorldDisplacementMultiplier UserSemantic "PN_WorldDisplacementMultiplier" OpDecorateString %in_var_PN_DominantVertex UserSemantic "PN_DominantVertex" OpDecorateString %in_var_PN_DominantVertex1 UserSemantic "PN_DominantVertex" OpDecorateString %in_var_PN_DominantVertex2 UserSemantic "PN_DominantVertex" OpDecorateString %in_var_PN_DominantEdge UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge1 UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge2 UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge3 UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge4 UserSemantic "PN_DominantEdge" OpDecorateString %in_var_PN_DominantEdge5 UserSemantic "PN_DominantEdge" OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter OpDecorateString %gl_TessLevelOuter UserSemantic "SV_TessFactor" OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorateString %gl_TessLevelInner UserSemantic "SV_InsideTessFactor" OpDecorate %gl_TessLevelInner Patch OpDecorateString %in_var_PN_POSITION9 UserSemantic "PN_POSITION9" OpDecorate %in_var_PN_POSITION9 Patch OpDecorate %gl_TessCoord BuiltIn TessCoord OpDecorateString %gl_TessCoord UserSemantic "SV_DomainLocation" OpDecorate %gl_TessCoord Patch OpDecorateString %out_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %out_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %out_var_TEXCOORD6 UserSemantic "TEXCOORD6" OpDecorateString %out_var_TEXCOORD7 UserSemantic "TEXCOORD7" OpDecorate %gl_Position BuiltIn Position OpDecorateString %gl_Position UserSemantic "SV_POSITION" OpDecorate %in_var_PN_DisplacementScales Location 0 OpDecorate %in_var_PN_DominantEdge Location 1 OpDecorate %in_var_PN_DominantEdge1 Location 2 OpDecorate %in_var_PN_DominantEdge2 Location 3 OpDecorate %in_var_PN_DominantEdge3 Location 4 OpDecorate %in_var_PN_DominantEdge4 Location 5 OpDecorate %in_var_PN_DominantEdge5 Location 6 OpDecorate %in_var_PN_DominantVertex Location 7 OpDecorate %in_var_PN_DominantVertex1 Location 8 OpDecorate %in_var_PN_DominantVertex2 Location 9 OpDecorate %in_var_PN_POSITION Location 10 OpDecorate %in_var_PN_POSITION9 Location 13 OpDecorate %in_var_PN_TessellationMultiplier Location 14 OpDecorate %in_var_PN_WorldDisplacementMultiplier Location 15 OpDecorate %in_var_TEXCOORD10_centroid Location 16 OpDecorate %in_var_TEXCOORD11_centroid Location 17 OpDecorate %in_var_VS_To_DS_VertexID Location 18 OpDecorate %in_var_VS_to_DS_Position Location 19 OpDecorate %out_var_TEXCOORD10_centroid Location 0 OpDecorate %out_var_TEXCOORD11_centroid Location 1 OpDecorate %out_var_TEXCOORD6 Location 2 OpDecorate %out_var_TEXCOORD7 Location 3 OpDecorate %ShadowDepthPass DescriptorSet 0 OpDecorate %ShadowDepthPass Binding 0 OpDecorate %_arr_mat4v4float_uint_6 ArrayStride 64 OpMemberDecorate %type_ShadowDepthPass 0 Offset 0 OpMemberDecorate %type_ShadowDepthPass 1 Offset 4 OpMemberDecorate %type_ShadowDepthPass 2 Offset 8 OpMemberDecorate %type_ShadowDepthPass 3 Offset 12 OpMemberDecorate %type_ShadowDepthPass 4 Offset 16 OpMemberDecorate %type_ShadowDepthPass 5 Offset 20 OpMemberDecorate %type_ShadowDepthPass 6 Offset 24 OpMemberDecorate %type_ShadowDepthPass 7 Offset 28 OpMemberDecorate %type_ShadowDepthPass 8 Offset 32 OpMemberDecorate %type_ShadowDepthPass 9 Offset 36 OpMemberDecorate %type_ShadowDepthPass 10 Offset 40 OpMemberDecorate %type_ShadowDepthPass 11 Offset 44 OpMemberDecorate %type_ShadowDepthPass 12 Offset 48 OpMemberDecorate %type_ShadowDepthPass 13 Offset 52 OpMemberDecorate %type_ShadowDepthPass 14 Offset 56 OpMemberDecorate %type_ShadowDepthPass 15 Offset 60 OpMemberDecorate %type_ShadowDepthPass 16 Offset 64 OpMemberDecorate %type_ShadowDepthPass 17 Offset 68 OpMemberDecorate %type_ShadowDepthPass 18 Offset 72 OpMemberDecorate %type_ShadowDepthPass 19 Offset 76 OpMemberDecorate %type_ShadowDepthPass 20 Offset 80 OpMemberDecorate %type_ShadowDepthPass 21 Offset 84 OpMemberDecorate %type_ShadowDepthPass 22 Offset 88 OpMemberDecorate %type_ShadowDepthPass 23 Offset 92 OpMemberDecorate %type_ShadowDepthPass 24 Offset 96 OpMemberDecorate %type_ShadowDepthPass 25 Offset 100 OpMemberDecorate %type_ShadowDepthPass 26 Offset 104 OpMemberDecorate %type_ShadowDepthPass 27 Offset 108 OpMemberDecorate %type_ShadowDepthPass 28 Offset 112 OpMemberDecorate %type_ShadowDepthPass 29 Offset 116 OpMemberDecorate %type_ShadowDepthPass 30 Offset 120 OpMemberDecorate %type_ShadowDepthPass 31 Offset 124 OpMemberDecorate %type_ShadowDepthPass 32 Offset 128 OpMemberDecorate %type_ShadowDepthPass 33 Offset 132 OpMemberDecorate %type_ShadowDepthPass 34 Offset 136 OpMemberDecorate %type_ShadowDepthPass 35 Offset 140 OpMemberDecorate %type_ShadowDepthPass 36 Offset 144 OpMemberDecorate %type_ShadowDepthPass 37 Offset 148 OpMemberDecorate %type_ShadowDepthPass 38 Offset 152 OpMemberDecorate %type_ShadowDepthPass 39 Offset 156 OpMemberDecorate %type_ShadowDepthPass 40 Offset 160 OpMemberDecorate %type_ShadowDepthPass 41 Offset 164 OpMemberDecorate %type_ShadowDepthPass 42 Offset 168 OpMemberDecorate %type_ShadowDepthPass 43 Offset 172 OpMemberDecorate %type_ShadowDepthPass 44 Offset 176 OpMemberDecorate %type_ShadowDepthPass 45 Offset 180 OpMemberDecorate %type_ShadowDepthPass 46 Offset 184 OpMemberDecorate %type_ShadowDepthPass 47 Offset 188 OpMemberDecorate %type_ShadowDepthPass 48 Offset 192 OpMemberDecorate %type_ShadowDepthPass 49 Offset 196 OpMemberDecorate %type_ShadowDepthPass 50 Offset 200 OpMemberDecorate %type_ShadowDepthPass 51 Offset 204 OpMemberDecorate %type_ShadowDepthPass 52 Offset 208 OpMemberDecorate %type_ShadowDepthPass 53 Offset 212 OpMemberDecorate %type_ShadowDepthPass 54 Offset 216 OpMemberDecorate %type_ShadowDepthPass 55 Offset 220 OpMemberDecorate %type_ShadowDepthPass 56 Offset 224 OpMemberDecorate %type_ShadowDepthPass 57 Offset 228 OpMemberDecorate %type_ShadowDepthPass 58 Offset 232 OpMemberDecorate %type_ShadowDepthPass 59 Offset 236 OpMemberDecorate %type_ShadowDepthPass 60 Offset 240 OpMemberDecorate %type_ShadowDepthPass 61 Offset 244 OpMemberDecorate %type_ShadowDepthPass 62 Offset 248 OpMemberDecorate %type_ShadowDepthPass 63 Offset 252 OpMemberDecorate %type_ShadowDepthPass 64 Offset 256 OpMemberDecorate %type_ShadowDepthPass 65 Offset 260 OpMemberDecorate %type_ShadowDepthPass 66 Offset 264 OpMemberDecorate %type_ShadowDepthPass 67 Offset 268 OpMemberDecorate %type_ShadowDepthPass 68 Offset 272 OpMemberDecorate %type_ShadowDepthPass 68 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 68 ColMajor OpMemberDecorate %type_ShadowDepthPass 69 Offset 336 OpMemberDecorate %type_ShadowDepthPass 70 Offset 352 OpMemberDecorate %type_ShadowDepthPass 71 Offset 368 OpMemberDecorate %type_ShadowDepthPass 72 Offset 384 OpMemberDecorate %type_ShadowDepthPass 73 Offset 396 OpMemberDecorate %type_ShadowDepthPass 74 Offset 400 OpMemberDecorate %type_ShadowDepthPass 75 Offset 412 OpMemberDecorate %type_ShadowDepthPass 76 Offset 416 OpMemberDecorate %type_ShadowDepthPass 77 Offset 420 OpMemberDecorate %type_ShadowDepthPass 78 Offset 424 OpMemberDecorate %type_ShadowDepthPass 79 Offset 428 OpMemberDecorate %type_ShadowDepthPass 80 Offset 432 OpMemberDecorate %type_ShadowDepthPass 81 Offset 436 OpMemberDecorate %type_ShadowDepthPass 82 Offset 440 OpMemberDecorate %type_ShadowDepthPass 83 Offset 444 OpMemberDecorate %type_ShadowDepthPass 84 Offset 448 OpMemberDecorate %type_ShadowDepthPass 85 Offset 452 OpMemberDecorate %type_ShadowDepthPass 86 Offset 456 OpMemberDecorate %type_ShadowDepthPass 87 Offset 460 OpMemberDecorate %type_ShadowDepthPass 88 Offset 464 OpMemberDecorate %type_ShadowDepthPass 88 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 88 ColMajor OpMemberDecorate %type_ShadowDepthPass 89 Offset 528 OpMemberDecorate %type_ShadowDepthPass 89 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 89 ColMajor OpMemberDecorate %type_ShadowDepthPass 90 Offset 592 OpMemberDecorate %type_ShadowDepthPass 91 Offset 608 OpMemberDecorate %type_ShadowDepthPass 92 Offset 612 OpMemberDecorate %type_ShadowDepthPass 93 Offset 616 OpMemberDecorate %type_ShadowDepthPass 94 Offset 620 OpMemberDecorate %type_ShadowDepthPass 95 Offset 624 OpMemberDecorate %type_ShadowDepthPass 95 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 95 ColMajor OpMemberDecorate %type_ShadowDepthPass 96 Offset 1008 OpMemberDecorate %type_ShadowDepthPass 96 MatrixStride 16 OpMemberDecorate %type_ShadowDepthPass 96 ColMajor OpDecorate %type_ShadowDepthPass Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_4 = OpConstant %uint 4 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %float_3 = OpConstant %float 3 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %float_6 = OpConstant %float 6 %48 = OpConstantComposite %v4float %float_6 %float_6 %float_6 %float_6 %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %int_3 = OpConstant %int 3 %int_88 = OpConstant %int 88 %int_89 = OpConstant %int 89 %int_90 = OpConstant %int 90 %int_91 = OpConstant %int 91 %float_9_99999997en07 = OpConstant %float 9.99999997e-07 %uint_6 = OpConstant %uint 6 %_arr_mat4v4float_uint_6 = OpTypeArray %mat4v4float %uint_6 %v3int = OpTypeVector %int 3 %type_ShadowDepthPass = OpTypeStruct %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %mat4v4float %v4float %v4float %v4float %v3int %int %v3int %float %float %float %float %float %float %float %float %float %float %float %float %int %mat4v4float %mat4v4float %v4float %float %float %float %float %_arr_mat4v4float_uint_6 %_arr_mat4v4float_uint_6 %_ptr_Uniform_type_ShadowDepthPass = OpTypePointer Uniform %type_ShadowDepthPass %uint_3 = OpConstant %uint 3 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %_arr_uint_uint_3 = OpTypeArray %uint %uint_3 %_ptr_Input__arr_uint_uint_3 = OpTypePointer Input %_arr_uint_uint_3 %_arr__arr_v4float_uint_3_uint_3 = OpTypeArray %_arr_v4float_uint_3 %uint_3 %_ptr_Input__arr__arr_v4float_uint_3_uint_3 = OpTypePointer Input %_arr__arr_v4float_uint_3_uint_3 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Input__arr_v3float_uint_3 = OpTypePointer Input %_arr_v3float_uint_3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %_ptr_Input__arr_float_uint_3 = OpTypePointer Input %_arr_float_uint_3 %_arr_v2float_uint_3 = OpTypeArray %v2float %uint_3 %_ptr_Input__arr_v2float_uint_3 = OpTypePointer Input %_arr_v2float_uint_3 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Input__arr_float_uint_4 = OpTypePointer Input %_arr_float_uint_4 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Input__arr_float_uint_2 = OpTypePointer Input %_arr_float_uint_2 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_v3float = OpTypePointer Input %v3float %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Output_float = OpTypePointer Output %float %_ptr_Output_v3float = OpTypePointer Output %v3float %void = OpTypeVoid %83 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %bool = OpTypeBool %_ptr_Function_mat4v4float = OpTypePointer Function %mat4v4float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %ShadowDepthPass = OpVariable %_ptr_Uniform_type_ShadowDepthPass Uniform %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_VS_to_DS_Position = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_VS_To_DS_VertexID = OpVariable %_ptr_Input__arr_uint_uint_3 Input %in_var_PN_POSITION = OpVariable %_ptr_Input__arr__arr_v4float_uint_3_uint_3 Input %in_var_PN_DisplacementScales = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %in_var_PN_TessellationMultiplier = OpVariable %_ptr_Input__arr_float_uint_3 Input %in_var_PN_WorldDisplacementMultiplier = OpVariable %_ptr_Input__arr_float_uint_3 Input %in_var_PN_DominantVertex = OpVariable %_ptr_Input__arr_v2float_uint_3 Input %in_var_PN_DominantVertex1 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_PN_DominantVertex2 = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %in_var_PN_DominantEdge = OpVariable %_ptr_Input__arr_v2float_uint_3 Input %in_var_PN_DominantEdge1 = OpVariable %_ptr_Input__arr_v2float_uint_3 Input %in_var_PN_DominantEdge2 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_PN_DominantEdge3 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_PN_DominantEdge4 = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %in_var_PN_DominantEdge5 = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %gl_TessLevelOuter = OpVariable %_ptr_Input__arr_float_uint_4 Input %gl_TessLevelInner = OpVariable %_ptr_Input__arr_float_uint_2 Input %in_var_PN_POSITION9 = OpVariable %_ptr_Input_v4float Input %gl_TessCoord = OpVariable %_ptr_Input_v3float Input %out_var_TEXCOORD10_centroid = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD11_centroid = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD6 = OpVariable %_ptr_Output_float Output %out_var_TEXCOORD7 = OpVariable %_ptr_Output_v3float Output %gl_Position = OpVariable %_ptr_Output_v4float Output %89 = OpConstantNull %v4float %90 = OpUndef %v4float %MainDomain = OpFunction %void None %83 %91 = OpLabel %92 = OpVariable %_ptr_Function_mat4v4float Function %93 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD10_centroid %94 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD11_centroid %95 = OpCompositeExtract %v4float %93 0 %96 = OpCompositeExtract %v4float %94 0 %97 = OpCompositeExtract %v4float %93 1 %98 = OpCompositeExtract %v4float %94 1 %99 = OpCompositeExtract %v4float %93 2 %100 = OpCompositeExtract %v4float %94 2 %101 = OpLoad %_arr__arr_v4float_uint_3_uint_3 %in_var_PN_POSITION %102 = OpCompositeExtract %_arr_v4float_uint_3 %101 0 %103 = OpCompositeExtract %_arr_v4float_uint_3 %101 1 %104 = OpCompositeExtract %_arr_v4float_uint_3 %101 2 %105 = OpCompositeExtract %v4float %102 0 %106 = OpCompositeExtract %v4float %102 1 %107 = OpCompositeExtract %v4float %102 2 %108 = OpCompositeExtract %v4float %103 0 %109 = OpCompositeExtract %v4float %103 1 %110 = OpCompositeExtract %v4float %103 2 %111 = OpCompositeExtract %v4float %104 0 %112 = OpCompositeExtract %v4float %104 1 %113 = OpCompositeExtract %v4float %104 2 %114 = OpLoad %v4float %in_var_PN_POSITION9 %115 = OpLoad %v3float %gl_TessCoord %116 = OpCompositeExtract %float %115 0 %117 = OpCompositeExtract %float %115 1 %118 = OpCompositeExtract %float %115 2 %119 = OpFMul %float %116 %116 %120 = OpFMul %float %117 %117 %121 = OpFMul %float %118 %118 %122 = OpFMul %float %119 %float_3 %123 = OpFMul %float %120 %float_3 %124 = OpFMul %float %121 %float_3 %125 = OpCompositeConstruct %v4float %119 %119 %119 %119 %126 = OpFMul %v4float %105 %125 %127 = OpCompositeConstruct %v4float %116 %116 %116 %116 %128 = OpFMul %v4float %126 %127 %129 = OpCompositeConstruct %v4float %120 %120 %120 %120 %130 = OpFMul %v4float %108 %129 %131 = OpCompositeConstruct %v4float %117 %117 %117 %117 %132 = OpFMul %v4float %130 %131 %133 = OpFAdd %v4float %128 %132 %134 = OpCompositeConstruct %v4float %121 %121 %121 %121 %135 = OpFMul %v4float %111 %134 %136 = OpCompositeConstruct %v4float %118 %118 %118 %118 %137 = OpFMul %v4float %135 %136 %138 = OpFAdd %v4float %133 %137 %139 = OpCompositeConstruct %v4float %122 %122 %122 %122 %140 = OpFMul %v4float %106 %139 %141 = OpFMul %v4float %140 %131 %142 = OpFAdd %v4float %138 %141 %143 = OpCompositeConstruct %v4float %123 %123 %123 %123 %144 = OpFMul %v4float %107 %143 %145 = OpFMul %v4float %144 %127 %146 = OpFAdd %v4float %142 %145 %147 = OpFMul %v4float %109 %143 %148 = OpFMul %v4float %147 %136 %149 = OpFAdd %v4float %146 %148 %150 = OpCompositeConstruct %v4float %124 %124 %124 %124 %151 = OpFMul %v4float %110 %150 %152 = OpFMul %v4float %151 %131 %153 = OpFAdd %v4float %149 %152 %154 = OpFMul %v4float %112 %150 %155 = OpFMul %v4float %154 %127 %156 = OpFAdd %v4float %153 %155 %157 = OpFMul %v4float %113 %139 %158 = OpFMul %v4float %157 %136 %159 = OpFAdd %v4float %156 %158 %160 = OpFMul %v4float %114 %48 %161 = OpFMul %v4float %160 %136 %162 = OpFMul %v4float %161 %127 %163 = OpFMul %v4float %162 %131 %164 = OpFAdd %v4float %159 %163 %165 = OpVectorShuffle %v3float %95 %95 0 1 2 %166 = OpCompositeConstruct %v3float %116 %116 %116 %167 = OpFMul %v3float %165 %166 %168 = OpVectorShuffle %v3float %97 %97 0 1 2 %169 = OpCompositeConstruct %v3float %117 %117 %117 %170 = OpFMul %v3float %168 %169 %171 = OpFAdd %v3float %167 %170 %172 = OpFMul %v4float %96 %127 %173 = OpFMul %v4float %98 %131 %174 = OpFAdd %v4float %172 %173 %175 = OpVectorShuffle %v3float %171 %89 0 1 2 %176 = OpVectorShuffle %v3float %99 %99 0 1 2 %177 = OpCompositeConstruct %v3float %118 %118 %118 %178 = OpFMul %v3float %176 %177 %179 = OpFAdd %v3float %175 %178 %180 = OpVectorShuffle %v4float %90 %179 4 5 6 3 %181 = OpFMul %v4float %100 %136 %182 = OpFAdd %v4float %174 %181 %183 = OpVectorShuffle %v3float %182 %182 0 1 2 %184 = OpVectorShuffle %v4float %164 %164 4 5 6 3 %185 = OpAccessChain %_ptr_Uniform_mat4v4float %ShadowDepthPass %int_88 %186 = OpLoad %mat4v4float %185 %187 = OpAccessChain %_ptr_Uniform_mat4v4float %ShadowDepthPass %int_89 %188 = OpLoad %mat4v4float %187 OpStore %92 %188 %189 = OpMatrixTimesVector %v4float %186 %184 %190 = OpAccessChain %_ptr_Uniform_float %ShadowDepthPass %int_91 %191 = OpLoad %float %190 %192 = OpFOrdGreaterThan %bool %191 %float_0 %193 = OpCompositeExtract %float %189 2 %194 = OpFOrdLessThan %bool %193 %float_0 %195 = OpLogicalAnd %bool %192 %194 OpSelectionMerge %196 None OpBranchConditional %195 %197 %196 %197 = OpLabel %198 = OpCompositeInsert %v4float %float_9_99999997en07 %189 2 %199 = OpCompositeInsert %v4float %float_1 %198 3 OpBranch %196 %196 = OpLabel %200 = OpPhi %v4float %189 %91 %199 %197 %201 = OpAccessChain %_ptr_Function_float %92 %uint_0 %int_2 %202 = OpLoad %float %201 %203 = OpAccessChain %_ptr_Function_float %92 %uint_1 %int_2 %204 = OpLoad %float %203 %205 = OpAccessChain %_ptr_Function_float %92 %uint_2 %int_2 %206 = OpLoad %float %205 %207 = OpCompositeConstruct %v3float %202 %204 %206 %208 = OpDot %float %207 %183 %209 = OpExtInst %float %1 FAbs %208 %210 = OpAccessChain %_ptr_Uniform_float %ShadowDepthPass %int_90 %int_2 %211 = OpLoad %float %210 %212 = OpExtInst %float %1 FAbs %209 %213 = OpFOrdGreaterThan %bool %212 %float_0 %214 = OpFMul %float %209 %209 %215 = OpFSub %float %float_1 %214 %216 = OpExtInst %float %1 FClamp %215 %float_0 %float_1 %217 = OpExtInst %float %1 Sqrt %216 %218 = OpFDiv %float %217 %209 %219 = OpSelect %float %213 %218 %211 %220 = OpExtInst %float %1 FClamp %219 %float_0 %211 %221 = OpAccessChain %_ptr_Uniform_float %ShadowDepthPass %int_90 %int_1 %222 = OpLoad %float %221 %223 = OpFMul %float %222 %220 %224 = OpAccessChain %_ptr_Uniform_float %ShadowDepthPass %int_90 %int_0 %225 = OpLoad %float %224 %226 = OpFAdd %float %223 %225 %227 = OpAccessChain %_ptr_Uniform_float %ShadowDepthPass %int_90 %int_3 %228 = OpLoad %float %227 %229 = OpCompositeExtract %float %200 2 %230 = OpFMul %float %229 %228 %231 = OpFAdd %float %230 %226 %232 = OpCompositeExtract %float %200 3 %233 = OpFMul %float %231 %232 %234 = OpCompositeInsert %v4float %233 %200 2 %235 = OpVectorShuffle %v3float %164 %89 0 1 2 OpStore %out_var_TEXCOORD10_centroid %180 OpStore %out_var_TEXCOORD11_centroid %182 OpStore %out_var_TEXCOORD6 %float_0 OpStore %out_var_TEXCOORD7 %235 OpStore %gl_Position %234 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/tese/ds-texcoord-array.asm.tese000066400000000000000000001272231400026215700252550ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 183 ; Schema: 0 OpCapability Tessellation OpCapability SampledBuffer OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %MainDomain "main" %gl_TessLevelOuter %gl_TessLevelInner %in_var_TEXCOORD10_centroid %in_var_TEXCOORD11_centroid %in_var_TEXCOORD0 %in_var_COLOR1 %in_var_COLOR2 %in_var_VS_To_DS_Position %in_var_TEXCOORD7 %in_var_Flat_DisplacementScales %in_var_Flat_TessellationMultiplier %in_var_Flat_WorldDisplacementMultiplier %gl_TessCoord %out_var_TEXCOORD10_centroid %out_var_TEXCOORD11_centroid %out_var_TEXCOORD0 %out_var_COLOR1 %out_var_COLOR2 %out_var_TEXCOORD6 %out_var_TEXCOORD7 %gl_Position OpExecutionMode %MainDomain Triangles OpExecutionMode %MainDomain SpacingFractionalOdd OpExecutionMode %MainDomain VertexOrderCw OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_ClipToWorld" OpMemberName %type_View 3 "View_TranslatedWorldToView" OpMemberName %type_View 4 "View_ViewToTranslatedWorld" OpMemberName %type_View 5 "View_TranslatedWorldToCameraView" OpMemberName %type_View 6 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 7 "View_ViewToClip" OpMemberName %type_View 8 "View_ViewToClipNoAA" OpMemberName %type_View 9 "View_ClipToView" OpMemberName %type_View 10 "View_ClipToTranslatedWorld" OpMemberName %type_View 11 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 12 "View_ScreenToWorld" OpMemberName %type_View 13 "View_ScreenToTranslatedWorld" OpMemberName %type_View 14 "View_ViewForward" OpMemberName %type_View 15 "PrePadding_View_908" OpMemberName %type_View 16 "View_ViewUp" OpMemberName %type_View 17 "PrePadding_View_924" OpMemberName %type_View 18 "View_ViewRight" OpMemberName %type_View 19 "PrePadding_View_940" OpMemberName %type_View 20 "View_HMDViewNoRollUp" OpMemberName %type_View 21 "PrePadding_View_956" OpMemberName %type_View 22 "View_HMDViewNoRollRight" OpMemberName %type_View 23 "PrePadding_View_972" OpMemberName %type_View 24 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 25 "View_ScreenPositionScaleBias" OpMemberName %type_View 26 "View_WorldCameraOrigin" OpMemberName %type_View 27 "PrePadding_View_1020" OpMemberName %type_View 28 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 29 "PrePadding_View_1036" OpMemberName %type_View 30 "View_WorldViewOrigin" OpMemberName %type_View 31 "PrePadding_View_1052" OpMemberName %type_View 32 "View_PreViewTranslation" OpMemberName %type_View 33 "PrePadding_View_1068" OpMemberName %type_View 34 "View_PrevProjection" OpMemberName %type_View 35 "View_PrevViewProj" OpMemberName %type_View 36 "View_PrevViewRotationProj" OpMemberName %type_View 37 "View_PrevViewToClip" OpMemberName %type_View 38 "View_PrevClipToView" OpMemberName %type_View 39 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 40 "View_PrevTranslatedWorldToView" OpMemberName %type_View 41 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 42 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 43 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 44 "View_PrevWorldCameraOrigin" OpMemberName %type_View 45 "PrePadding_View_1724" OpMemberName %type_View 46 "View_PrevWorldViewOrigin" OpMemberName %type_View 47 "PrePadding_View_1740" OpMemberName %type_View 48 "View_PrevPreViewTranslation" OpMemberName %type_View 49 "PrePadding_View_1756" OpMemberName %type_View 50 "View_PrevInvViewProj" OpMemberName %type_View 51 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 52 "View_ClipToPrevClip" OpMemberName %type_View 53 "View_TemporalAAJitter" OpMemberName %type_View 54 "View_GlobalClippingPlane" OpMemberName %type_View 55 "View_FieldOfViewWideAngles" OpMemberName %type_View 56 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 57 "View_ViewRectMin" OpMemberName %type_View 58 "View_ViewSizeAndInvSize" OpMemberName %type_View 59 "View_BufferSizeAndInvSize" OpMemberName %type_View 60 "View_BufferBilinearUVMinMax" OpMemberName %type_View 61 "View_NumSceneColorMSAASamples" OpMemberName %type_View 62 "View_PreExposure" OpMemberName %type_View 63 "View_OneOverPreExposure" OpMemberName %type_View 64 "PrePadding_View_2076" OpMemberName %type_View 65 "View_DiffuseOverrideParameter" OpMemberName %type_View 66 "View_SpecularOverrideParameter" OpMemberName %type_View 67 "View_NormalOverrideParameter" OpMemberName %type_View 68 "View_RoughnessOverrideParameter" OpMemberName %type_View 69 "View_PrevFrameGameTime" OpMemberName %type_View 70 "View_PrevFrameRealTime" OpMemberName %type_View 71 "View_OutOfBoundsMask" OpMemberName %type_View 72 "PrePadding_View_2148" OpMemberName %type_View 73 "PrePadding_View_2152" OpMemberName %type_View 74 "PrePadding_View_2156" OpMemberName %type_View 75 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 76 "View_CullingSign" OpMemberName %type_View 77 "View_NearPlane" OpMemberName %type_View 78 "View_AdaptiveTessellationFactor" OpMemberName %type_View 79 "View_GameTime" OpMemberName %type_View 80 "View_RealTime" OpMemberName %type_View 81 "View_DeltaTime" OpMemberName %type_View 82 "View_MaterialTextureMipBias" OpMemberName %type_View 83 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 84 "View_Random" OpMemberName %type_View 85 "View_FrameNumber" OpMemberName %type_View 86 "View_StateFrameIndexMod8" OpMemberName %type_View 87 "View_StateFrameIndex" OpMemberName %type_View 88 "View_CameraCut" OpMemberName %type_View 89 "View_UnlitViewmodeMask" OpMemberName %type_View 90 "PrePadding_View_2228" OpMemberName %type_View 91 "PrePadding_View_2232" OpMemberName %type_View 92 "PrePadding_View_2236" OpMemberName %type_View 93 "View_DirectionalLightColor" OpMemberName %type_View 94 "View_DirectionalLightDirection" OpMemberName %type_View 95 "PrePadding_View_2268" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 97 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 98 "View_TemporalAAParams" OpMemberName %type_View 99 "View_CircleDOFParams" OpMemberName %type_View 100 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 101 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 102 "View_DepthOfFieldScale" OpMemberName %type_View 103 "View_DepthOfFieldFocalLength" OpMemberName %type_View 104 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 105 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 106 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 107 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 108 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 109 "View_GeneralPurposeTweak" OpMemberName %type_View 110 "View_DemosaicVposOffset" OpMemberName %type_View 111 "PrePadding_View_2412" OpMemberName %type_View 112 "View_IndirectLightingColorScale" OpMemberName %type_View 113 "View_HDR32bppEncodingMode" OpMemberName %type_View 114 "View_AtmosphericFogSunDirection" OpMemberName %type_View 115 "View_AtmosphericFogSunPower" OpMemberName %type_View 116 "View_AtmosphericFogPower" OpMemberName %type_View 117 "View_AtmosphericFogDensityScale" OpMemberName %type_View 118 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 119 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 120 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 121 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 122 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 123 "View_AtmosphericFogStartDistance" OpMemberName %type_View 124 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 125 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 126 "View_AtmosphericFogSunDiscHalfApexAngleRadian" OpMemberName %type_View 127 "PrePadding_View_2492" OpMemberName %type_View 128 "View_AtmosphericFogSunDiscLuminance" OpMemberName %type_View 129 "View_AtmosphericFogRenderMask" OpMemberName %type_View 130 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 131 "PrePadding_View_2520" OpMemberName %type_View 132 "PrePadding_View_2524" OpMemberName %type_View 133 "View_AtmosphericFogSunColor" OpMemberName %type_View 134 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 135 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 136 "View_AmbientCubemapTint" OpMemberName %type_View 137 "View_AmbientCubemapIntensity" OpMemberName %type_View 138 "View_SkyLightParameters" OpMemberName %type_View 139 "PrePadding_View_2584" OpMemberName %type_View 140 "PrePadding_View_2588" OpMemberName %type_View 141 "View_SkyLightColor" OpMemberName %type_View 142 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 143 "View_MobilePreviewMode" OpMemberName %type_View 144 "View_HMDEyePaddingOffset" OpMemberName %type_View 145 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 146 "View_ShowDecalsMask" OpMemberName %type_View 147 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 148 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 149 "PrePadding_View_2744" OpMemberName %type_View 150 "PrePadding_View_2748" OpMemberName %type_View 151 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 152 "View_StereoPassIndex" OpMemberName %type_View 153 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 154 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 155 "View_GlobalVolumeDimension" OpMemberName %type_View 156 "View_GlobalVolumeTexelSize" OpMemberName %type_View 157 "View_MaxGlobalDistance" OpMemberName %type_View 158 "PrePadding_View_2908" OpMemberName %type_View 159 "View_CursorPosition" OpMemberName %type_View 160 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 161 "PrePadding_View_2924" OpMemberName %type_View 162 "View_VolumetricFogInvGridSize" OpMemberName %type_View 163 "PrePadding_View_2940" OpMemberName %type_View 164 "View_VolumetricFogGridZParams" OpMemberName %type_View 165 "PrePadding_View_2956" OpMemberName %type_View 166 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 167 "View_VolumetricFogMaxDistance" OpMemberName %type_View 168 "PrePadding_View_2972" OpMemberName %type_View 169 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 170 "PrePadding_View_2988" OpMemberName %type_View 171 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 172 "PrePadding_View_3004" OpMemberName %type_View 173 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 174 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 175 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 176 "View_StereoIPD" OpMemberName %type_View 177 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 178 "View_EyeToPixelSpreadAngle" OpMemberName %type_View 179 "PrePadding_View_3048" OpMemberName %type_View 180 "PrePadding_View_3052" OpMemberName %type_View 181 "View_WorldToVirtualTexture" OpMemberName %type_View 182 "View_VirtualTextureParams" OpMemberName %type_View 183 "View_XRPassthroughCameraUVs" OpName %View "View" OpName %in_var_TEXCOORD10_centroid "in.var.TEXCOORD10_centroid" OpName %in_var_TEXCOORD11_centroid "in.var.TEXCOORD11_centroid" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %in_var_COLOR1 "in.var.COLOR1" OpName %in_var_COLOR2 "in.var.COLOR2" OpName %in_var_VS_To_DS_Position "in.var.VS_To_DS_Position" OpName %in_var_TEXCOORD7 "in.var.TEXCOORD7" OpName %in_var_Flat_DisplacementScales "in.var.Flat_DisplacementScales" OpName %in_var_Flat_TessellationMultiplier "in.var.Flat_TessellationMultiplier" OpName %in_var_Flat_WorldDisplacementMultiplier "in.var.Flat_WorldDisplacementMultiplier" OpName %out_var_TEXCOORD10_centroid "out.var.TEXCOORD10_centroid" OpName %out_var_TEXCOORD11_centroid "out.var.TEXCOORD11_centroid" OpName %out_var_TEXCOORD0 "out.var.TEXCOORD0" OpName %out_var_COLOR1 "out.var.COLOR1" OpName %out_var_COLOR2 "out.var.COLOR2" OpName %out_var_TEXCOORD6 "out.var.TEXCOORD6" OpName %out_var_TEXCOORD7 "out.var.TEXCOORD7" OpName %MainDomain "MainDomain" OpDecorate %gl_TessLevelOuter BuiltIn TessLevelOuter OpDecorateString %gl_TessLevelOuter UserSemantic "SV_TessFactor" OpDecorate %gl_TessLevelOuter Patch OpDecorate %gl_TessLevelInner BuiltIn TessLevelInner OpDecorateString %gl_TessLevelInner UserSemantic "SV_InsideTessFactor" OpDecorate %gl_TessLevelInner Patch OpDecorateString %in_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %in_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %in_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %in_var_COLOR1 UserSemantic "COLOR1" OpDecorateString %in_var_COLOR2 UserSemantic "COLOR2" OpDecorateString %in_var_VS_To_DS_Position UserSemantic "VS_To_DS_Position" OpDecorateString %in_var_TEXCOORD7 UserSemantic "TEXCOORD7" OpDecorateString %in_var_Flat_DisplacementScales UserSemantic "Flat_DisplacementScales" OpDecorateString %in_var_Flat_TessellationMultiplier UserSemantic "Flat_TessellationMultiplier" OpDecorateString %in_var_Flat_WorldDisplacementMultiplier UserSemantic "Flat_WorldDisplacementMultiplier" OpDecorate %gl_TessCoord BuiltIn TessCoord OpDecorateString %gl_TessCoord UserSemantic "SV_DomainLocation" OpDecorate %gl_TessCoord Patch OpDecorateString %out_var_TEXCOORD10_centroid UserSemantic "TEXCOORD10_centroid" OpDecorateString %out_var_TEXCOORD11_centroid UserSemantic "TEXCOORD11_centroid" OpDecorateString %out_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %out_var_COLOR1 UserSemantic "COLOR1" OpDecorateString %out_var_COLOR2 UserSemantic "COLOR2" OpDecorateString %out_var_TEXCOORD6 UserSemantic "TEXCOORD6" OpDecorateString %out_var_TEXCOORD7 UserSemantic "TEXCOORD7" OpDecorate %gl_Position BuiltIn Position OpDecorateString %gl_Position UserSemantic "SV_POSITION" OpDecorate %in_var_COLOR1 Location 0 OpDecorate %in_var_COLOR2 Location 1 OpDecorate %in_var_Flat_DisplacementScales Location 2 OpDecorate %in_var_Flat_TessellationMultiplier Location 3 OpDecorate %in_var_Flat_WorldDisplacementMultiplier Location 4 OpDecorate %in_var_TEXCOORD0 Location 5 OpDecorate %in_var_TEXCOORD10_centroid Location 6 OpDecorate %in_var_TEXCOORD11_centroid Location 7 OpDecorate %in_var_TEXCOORD7 Location 8 OpDecorate %in_var_VS_To_DS_Position Location 9 OpDecorate %out_var_TEXCOORD10_centroid Location 0 OpDecorate %out_var_TEXCOORD11_centroid Location 1 OpDecorate %out_var_TEXCOORD0 Location 2 OpDecorate %out_var_COLOR1 Location 3 OpDecorate %out_var_COLOR2 Location 4 OpDecorate %out_var_TEXCOORD6 Location 5 OpDecorate %out_var_TEXCOORD7 Location 6 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 13 MatrixStride 16 OpMemberDecorate %type_View 13 ColMajor OpMemberDecorate %type_View 14 Offset 896 OpMemberDecorate %type_View 15 Offset 908 OpMemberDecorate %type_View 16 Offset 912 OpMemberDecorate %type_View 17 Offset 924 OpMemberDecorate %type_View 18 Offset 928 OpMemberDecorate %type_View 19 Offset 940 OpMemberDecorate %type_View 20 Offset 944 OpMemberDecorate %type_View 21 Offset 956 OpMemberDecorate %type_View 22 Offset 960 OpMemberDecorate %type_View 23 Offset 972 OpMemberDecorate %type_View 24 Offset 976 OpMemberDecorate %type_View 25 Offset 992 OpMemberDecorate %type_View 26 Offset 1008 OpMemberDecorate %type_View 27 Offset 1020 OpMemberDecorate %type_View 28 Offset 1024 OpMemberDecorate %type_View 29 Offset 1036 OpMemberDecorate %type_View 30 Offset 1040 OpMemberDecorate %type_View 31 Offset 1052 OpMemberDecorate %type_View 32 Offset 1056 OpMemberDecorate %type_View 33 Offset 1068 OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 43 MatrixStride 16 OpMemberDecorate %type_View 43 ColMajor OpMemberDecorate %type_View 44 Offset 1712 OpMemberDecorate %type_View 45 Offset 1724 OpMemberDecorate %type_View 46 Offset 1728 OpMemberDecorate %type_View 47 Offset 1740 OpMemberDecorate %type_View 48 Offset 1744 OpMemberDecorate %type_View 49 Offset 1756 OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 52 MatrixStride 16 OpMemberDecorate %type_View 52 ColMajor OpMemberDecorate %type_View 53 Offset 1952 OpMemberDecorate %type_View 54 Offset 1968 OpMemberDecorate %type_View 55 Offset 1984 OpMemberDecorate %type_View 56 Offset 1992 OpMemberDecorate %type_View 57 Offset 2000 OpMemberDecorate %type_View 58 Offset 2016 OpMemberDecorate %type_View 59 Offset 2032 OpMemberDecorate %type_View 60 Offset 2048 OpMemberDecorate %type_View 61 Offset 2064 OpMemberDecorate %type_View 62 Offset 2068 OpMemberDecorate %type_View 63 Offset 2072 OpMemberDecorate %type_View 64 Offset 2076 OpMemberDecorate %type_View 65 Offset 2080 OpMemberDecorate %type_View 66 Offset 2096 OpMemberDecorate %type_View 67 Offset 2112 OpMemberDecorate %type_View 68 Offset 2128 OpMemberDecorate %type_View 69 Offset 2136 OpMemberDecorate %type_View 70 Offset 2140 OpMemberDecorate %type_View 71 Offset 2144 OpMemberDecorate %type_View 72 Offset 2148 OpMemberDecorate %type_View 73 Offset 2152 OpMemberDecorate %type_View 74 Offset 2156 OpMemberDecorate %type_View 75 Offset 2160 OpMemberDecorate %type_View 76 Offset 2172 OpMemberDecorate %type_View 77 Offset 2176 OpMemberDecorate %type_View 78 Offset 2180 OpMemberDecorate %type_View 79 Offset 2184 OpMemberDecorate %type_View 80 Offset 2188 OpMemberDecorate %type_View 81 Offset 2192 OpMemberDecorate %type_View 82 Offset 2196 OpMemberDecorate %type_View 83 Offset 2200 OpMemberDecorate %type_View 84 Offset 2204 OpMemberDecorate %type_View 85 Offset 2208 OpMemberDecorate %type_View 86 Offset 2212 OpMemberDecorate %type_View 87 Offset 2216 OpMemberDecorate %type_View 88 Offset 2220 OpMemberDecorate %type_View 89 Offset 2224 OpMemberDecorate %type_View 90 Offset 2228 OpMemberDecorate %type_View 91 Offset 2232 OpMemberDecorate %type_View 92 Offset 2236 OpMemberDecorate %type_View 93 Offset 2240 OpMemberDecorate %type_View 94 Offset 2256 OpMemberDecorate %type_View 95 Offset 2268 OpMemberDecorate %type_View 96 Offset 2272 OpMemberDecorate %type_View 97 Offset 2304 OpMemberDecorate %type_View 98 Offset 2336 OpMemberDecorate %type_View 99 Offset 2352 OpMemberDecorate %type_View 100 Offset 2368 OpMemberDecorate %type_View 101 Offset 2372 OpMemberDecorate %type_View 102 Offset 2376 OpMemberDecorate %type_View 103 Offset 2380 OpMemberDecorate %type_View 104 Offset 2384 OpMemberDecorate %type_View 105 Offset 2388 OpMemberDecorate %type_View 106 Offset 2392 OpMemberDecorate %type_View 107 Offset 2396 OpMemberDecorate %type_View 108 Offset 2400 OpMemberDecorate %type_View 109 Offset 2404 OpMemberDecorate %type_View 110 Offset 2408 OpMemberDecorate %type_View 111 Offset 2412 OpMemberDecorate %type_View 112 Offset 2416 OpMemberDecorate %type_View 113 Offset 2428 OpMemberDecorate %type_View 114 Offset 2432 OpMemberDecorate %type_View 115 Offset 2444 OpMemberDecorate %type_View 116 Offset 2448 OpMemberDecorate %type_View 117 Offset 2452 OpMemberDecorate %type_View 118 Offset 2456 OpMemberDecorate %type_View 119 Offset 2460 OpMemberDecorate %type_View 120 Offset 2464 OpMemberDecorate %type_View 121 Offset 2468 OpMemberDecorate %type_View 122 Offset 2472 OpMemberDecorate %type_View 123 Offset 2476 OpMemberDecorate %type_View 124 Offset 2480 OpMemberDecorate %type_View 125 Offset 2484 OpMemberDecorate %type_View 126 Offset 2488 OpMemberDecorate %type_View 127 Offset 2492 OpMemberDecorate %type_View 128 Offset 2496 OpMemberDecorate %type_View 129 Offset 2512 OpMemberDecorate %type_View 130 Offset 2516 OpMemberDecorate %type_View 131 Offset 2520 OpMemberDecorate %type_View 132 Offset 2524 OpMemberDecorate %type_View 133 Offset 2528 OpMemberDecorate %type_View 134 Offset 2544 OpMemberDecorate %type_View 135 Offset 2556 OpMemberDecorate %type_View 136 Offset 2560 OpMemberDecorate %type_View 137 Offset 2576 OpMemberDecorate %type_View 138 Offset 2580 OpMemberDecorate %type_View 139 Offset 2584 OpMemberDecorate %type_View 140 Offset 2588 OpMemberDecorate %type_View 141 Offset 2592 OpMemberDecorate %type_View 142 Offset 2608 OpMemberDecorate %type_View 143 Offset 2720 OpMemberDecorate %type_View 144 Offset 2724 OpMemberDecorate %type_View 145 Offset 2728 OpMemberDecorate %type_View 146 Offset 2732 OpMemberDecorate %type_View 147 Offset 2736 OpMemberDecorate %type_View 148 Offset 2740 OpMemberDecorate %type_View 149 Offset 2744 OpMemberDecorate %type_View 150 Offset 2748 OpMemberDecorate %type_View 151 Offset 2752 OpMemberDecorate %type_View 152 Offset 2764 OpMemberDecorate %type_View 153 Offset 2768 OpMemberDecorate %type_View 154 Offset 2832 OpMemberDecorate %type_View 155 Offset 2896 OpMemberDecorate %type_View 156 Offset 2900 OpMemberDecorate %type_View 157 Offset 2904 OpMemberDecorate %type_View 158 Offset 2908 OpMemberDecorate %type_View 159 Offset 2912 OpMemberDecorate %type_View 160 Offset 2920 OpMemberDecorate %type_View 161 Offset 2924 OpMemberDecorate %type_View 162 Offset 2928 OpMemberDecorate %type_View 163 Offset 2940 OpMemberDecorate %type_View 164 Offset 2944 OpMemberDecorate %type_View 165 Offset 2956 OpMemberDecorate %type_View 166 Offset 2960 OpMemberDecorate %type_View 167 Offset 2968 OpMemberDecorate %type_View 168 Offset 2972 OpMemberDecorate %type_View 169 Offset 2976 OpMemberDecorate %type_View 170 Offset 2988 OpMemberDecorate %type_View 171 Offset 2992 OpMemberDecorate %type_View 172 Offset 3004 OpMemberDecorate %type_View 173 Offset 3008 OpMemberDecorate %type_View 174 Offset 3020 OpMemberDecorate %type_View 175 Offset 3024 OpMemberDecorate %type_View 176 Offset 3036 OpMemberDecorate %type_View 177 Offset 3040 OpMemberDecorate %type_View 178 Offset 3044 OpMemberDecorate %type_View 179 Offset 3048 OpMemberDecorate %type_View 180 Offset 3052 OpMemberDecorate %type_View 181 Offset 3056 OpMemberDecorate %type_View 181 MatrixStride 16 OpMemberDecorate %type_View 181 ColMajor OpMemberDecorate %type_View 182 Offset 3120 OpMemberDecorate %type_View 183 Offset 3136 OpDecorate %type_View Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %v2int = OpTypeVector %int 2 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint_1 = OpConstant %uint 1 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %float %float %v4float %uint %uint %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v2int %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %float %float %mat4v4float %v4float %_arr_v4float_uint_2 %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Input__arr_float_uint_4 = OpTypePointer Input %_arr_float_uint_4 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Input__arr_float_uint_2 = OpTypePointer Input %_arr_float_uint_2 %uint_3 = OpConstant %uint 3 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %_arr__arr_v4float_uint_1_uint_3 = OpTypeArray %_arr_v4float_uint_1 %uint_3 %_ptr_Input__arr__arr_v4float_uint_1_uint_3 = OpTypePointer Input %_arr__arr_v4float_uint_1_uint_3 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Input__arr_v3float_uint_3 = OpTypePointer Input %_arr_v3float_uint_3 %_arr_float_uint_3 = OpTypeArray %float %uint_3 %_ptr_Input__arr_float_uint_3 = OpTypePointer Input %_arr_float_uint_3 %_ptr_Input_v3float = OpTypePointer Input %v3float %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Output__arr_v4float_uint_1 = OpTypePointer Output %_arr_v4float_uint_1 %_ptr_Output_v3float = OpTypePointer Output %v3float %void = OpTypeVoid %63 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %bool = OpTypeBool %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %View = OpVariable %_ptr_Uniform_type_View Uniform %gl_TessLevelOuter = OpVariable %_ptr_Input__arr_float_uint_4 Input %gl_TessLevelInner = OpVariable %_ptr_Input__arr_float_uint_2 Input %in_var_TEXCOORD10_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_TEXCOORD11_centroid = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_TEXCOORD0 = OpVariable %_ptr_Input__arr__arr_v4float_uint_1_uint_3 Input %in_var_COLOR1 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_COLOR2 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_VS_To_DS_Position = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %in_var_TEXCOORD7 = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %in_var_Flat_DisplacementScales = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %in_var_Flat_TessellationMultiplier = OpVariable %_ptr_Input__arr_float_uint_3 Input %in_var_Flat_WorldDisplacementMultiplier = OpVariable %_ptr_Input__arr_float_uint_3 Input %gl_TessCoord = OpVariable %_ptr_Input_v3float Input %out_var_TEXCOORD10_centroid = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD11_centroid = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD0 = OpVariable %_ptr_Output__arr_v4float_uint_1 Output %out_var_COLOR1 = OpVariable %_ptr_Output_v4float Output %out_var_COLOR2 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD6 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD7 = OpVariable %_ptr_Output_v3float Output %gl_Position = OpVariable %_ptr_Output_v4float Output %_ptr_Function__arr_v4float_uint_1 = OpTypePointer Function %_arr_v4float_uint_1 %68 = OpUndef %v4float %69 = OpConstantNull %v4float %MainDomain = OpFunction %void None %63 %70 = OpLabel %71 = OpVariable %_ptr_Function__arr_v4float_uint_1 Function %72 = OpVariable %_ptr_Function__arr_v4float_uint_1 Function %73 = OpVariable %_ptr_Function__arr_v4float_uint_1 Function %74 = OpVariable %_ptr_Function__arr_v4float_uint_1 Function %75 = OpVariable %_ptr_Function__arr_v4float_uint_1 Function %76 = OpVariable %_ptr_Function__arr_v4float_uint_1 Function %77 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD10_centroid %78 = OpLoad %_arr_v4float_uint_3 %in_var_TEXCOORD11_centroid %79 = OpLoad %_arr__arr_v4float_uint_1_uint_3 %in_var_TEXCOORD0 %80 = OpLoad %_arr_v4float_uint_3 %in_var_COLOR1 %81 = OpLoad %_arr_v4float_uint_3 %in_var_COLOR2 %82 = OpCompositeExtract %v4float %77 0 %83 = OpCompositeExtract %v4float %78 0 %84 = OpCompositeExtract %_arr_v4float_uint_1 %79 0 %85 = OpCompositeExtract %v4float %80 0 %86 = OpCompositeExtract %v4float %81 0 %87 = OpCompositeExtract %v4float %77 1 %88 = OpCompositeExtract %v4float %78 1 %89 = OpCompositeExtract %_arr_v4float_uint_1 %79 1 %90 = OpCompositeExtract %v4float %80 1 %91 = OpCompositeExtract %v4float %81 1 %92 = OpCompositeExtract %v4float %77 2 %93 = OpCompositeExtract %v4float %78 2 %94 = OpCompositeExtract %_arr_v4float_uint_1 %79 2 %95 = OpCompositeExtract %v4float %80 2 %96 = OpCompositeExtract %v4float %81 2 %97 = OpLoad %_arr_v4float_uint_3 %in_var_VS_To_DS_Position %98 = OpLoad %_arr_v3float_uint_3 %in_var_TEXCOORD7 %99 = OpCompositeExtract %v4float %97 0 %100 = OpCompositeExtract %v3float %98 0 %101 = OpCompositeExtract %v4float %97 1 %102 = OpCompositeExtract %v3float %98 1 %103 = OpCompositeExtract %v4float %97 2 %104 = OpCompositeExtract %v3float %98 2 %105 = OpLoad %v3float %gl_TessCoord %106 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_0 %107 = OpLoad %mat4v4float %106 %108 = OpCompositeExtract %float %105 0 %109 = OpCompositeExtract %float %105 1 %110 = OpCompositeExtract %float %105 2 %111 = OpCompositeConstruct %v4float %108 %108 %108 %108 %112 = OpFMul %v4float %99 %111 %113 = OpCompositeConstruct %v4float %109 %109 %109 %109 %114 = OpFMul %v4float %101 %113 %115 = OpFAdd %v4float %112 %114 %116 = OpCompositeConstruct %v4float %110 %110 %110 %110 %117 = OpFMul %v4float %103 %116 %118 = OpFAdd %v4float %115 %117 OpStore %72 %84 OpStore %71 %89 %119 = OpVectorShuffle %v3float %82 %82 0 1 2 %120 = OpCompositeConstruct %v3float %108 %108 %108 %121 = OpFMul %v3float %119 %120 %122 = OpVectorShuffle %v3float %87 %87 0 1 2 %123 = OpCompositeConstruct %v3float %109 %109 %109 %124 = OpFMul %v3float %122 %123 %125 = OpFAdd %v3float %121 %124 %126 = OpFMul %v4float %83 %111 %127 = OpFMul %v4float %88 %113 %128 = OpFAdd %v4float %126 %127 %129 = OpFMul %v4float %85 %111 %130 = OpFMul %v4float %90 %113 %131 = OpFAdd %v4float %129 %130 OpBranch %132 %132 = OpLabel %133 = OpPhi %int %int_0 %70 %134 %135 %136 = OpSLessThan %bool %133 %int_1 OpLoopMerge %137 %135 None OpBranchConditional %136 %135 %137 %135 = OpLabel %138 = OpAccessChain %_ptr_Function_v4float %72 %133 %139 = OpLoad %v4float %138 %140 = OpFMul %v4float %139 %111 %141 = OpAccessChain %_ptr_Function_v4float %71 %133 %142 = OpLoad %v4float %141 %143 = OpFMul %v4float %142 %113 %144 = OpFAdd %v4float %140 %143 %145 = OpAccessChain %_ptr_Function_v4float %73 %133 OpStore %145 %144 %134 = OpIAdd %int %133 %int_1 OpBranch %132 %137 = OpLabel %146 = OpFMul %v4float %86 %111 %147 = OpFMul %v4float %91 %113 %148 = OpFAdd %v4float %146 %147 %149 = OpLoad %_arr_v4float_uint_1 %73 %150 = OpFMul %v3float %100 %120 %151 = OpFMul %v3float %102 %123 %152 = OpFAdd %v3float %150 %151 OpStore %75 %149 OpStore %74 %94 %153 = OpVectorShuffle %v3float %125 %69 0 1 2 %154 = OpVectorShuffle %v3float %92 %92 0 1 2 %155 = OpCompositeConstruct %v3float %110 %110 %110 %156 = OpFMul %v3float %154 %155 %157 = OpFAdd %v3float %153 %156 %158 = OpVectorShuffle %v4float %68 %157 4 5 6 3 %159 = OpFMul %v4float %93 %116 %160 = OpFAdd %v4float %128 %159 %161 = OpFMul %v4float %95 %116 %162 = OpFAdd %v4float %131 %161 OpBranch %163 %163 = OpLabel %164 = OpPhi %int %int_0 %137 %165 %166 %167 = OpSLessThan %bool %164 %int_1 OpLoopMerge %168 %166 None OpBranchConditional %167 %166 %168 %166 = OpLabel %169 = OpAccessChain %_ptr_Function_v4float %75 %164 %170 = OpLoad %v4float %169 %171 = OpAccessChain %_ptr_Function_v4float %74 %164 %172 = OpLoad %v4float %171 %173 = OpFMul %v4float %172 %116 %174 = OpFAdd %v4float %170 %173 %175 = OpAccessChain %_ptr_Function_v4float %76 %164 OpStore %175 %174 %165 = OpIAdd %int %164 %int_1 OpBranch %163 %168 = OpLabel %176 = OpFMul %v4float %96 %116 %177 = OpFAdd %v4float %148 %176 %178 = OpLoad %_arr_v4float_uint_1 %76 %179 = OpFMul %v3float %104 %155 %180 = OpFAdd %v3float %152 %179 %181 = OpVectorShuffle %v4float %118 %118 4 5 6 3 %182 = OpMatrixTimesVector %v4float %107 %181 OpStore %out_var_TEXCOORD10_centroid %158 OpStore %out_var_TEXCOORD11_centroid %160 OpStore %out_var_TEXCOORD0 %178 OpStore %out_var_COLOR1 %162 OpStore %out_var_COLOR2 %177 OpStore %out_var_TEXCOORD6 %181 OpStore %out_var_TEXCOORD7 %180 OpStore %gl_Position %182 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/vert/000077500000000000000000000000001400026215700202565ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders-ue4/asm/vert/array-missing-copies.asm.vert000066400000000000000000002027401400026215700260110ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 487 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %Main "main" %in_var_ATTRIBUTE0 %in_var_ATTRIBUTE1 %out_var_TEXCOORD0 %out_var_TEXCOORD1 %out_var_TEXCOORD2 %out_var_TEXCOORD3 %out_var_TEXCOORD8 %gl_Position OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_TranslatedWorldToView" OpMemberName %type_View 3 "View_ViewToTranslatedWorld" OpMemberName %type_View 4 "View_TranslatedWorldToCameraView" OpMemberName %type_View 5 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 6 "View_ViewToClip" OpMemberName %type_View 7 "View_ViewToClipNoAA" OpMemberName %type_View 8 "View_ClipToView" OpMemberName %type_View 9 "View_ClipToTranslatedWorld" OpMemberName %type_View 10 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 11 "View_ScreenToWorld" OpMemberName %type_View 12 "View_ScreenToTranslatedWorld" OpMemberName %type_View 13 "View_ViewForward" OpMemberName %type_View 14 "PrePadding_View_844" OpMemberName %type_View 15 "View_ViewUp" OpMemberName %type_View 16 "PrePadding_View_860" OpMemberName %type_View 17 "View_ViewRight" OpMemberName %type_View 18 "PrePadding_View_876" OpMemberName %type_View 19 "View_HMDViewNoRollUp" OpMemberName %type_View 20 "PrePadding_View_892" OpMemberName %type_View 21 "View_HMDViewNoRollRight" OpMemberName %type_View 22 "PrePadding_View_908" OpMemberName %type_View 23 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 24 "View_ScreenPositionScaleBias" OpMemberName %type_View 25 "View_WorldCameraOrigin" OpMemberName %type_View 26 "PrePadding_View_956" OpMemberName %type_View 27 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 28 "PrePadding_View_972" OpMemberName %type_View 29 "View_WorldViewOrigin" OpMemberName %type_View 30 "PrePadding_View_988" OpMemberName %type_View 31 "View_PreViewTranslation" OpMemberName %type_View 32 "PrePadding_View_1004" OpMemberName %type_View 33 "View_PrevProjection" OpMemberName %type_View 34 "View_PrevViewProj" OpMemberName %type_View 35 "View_PrevViewRotationProj" OpMemberName %type_View 36 "View_PrevViewToClip" OpMemberName %type_View 37 "View_PrevClipToView" OpMemberName %type_View 38 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 39 "View_PrevTranslatedWorldToView" OpMemberName %type_View 40 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 41 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 42 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 43 "View_PrevWorldCameraOrigin" OpMemberName %type_View 44 "PrePadding_View_1660" OpMemberName %type_View 45 "View_PrevWorldViewOrigin" OpMemberName %type_View 46 "PrePadding_View_1676" OpMemberName %type_View 47 "View_PrevPreViewTranslation" OpMemberName %type_View 48 "PrePadding_View_1692" OpMemberName %type_View 49 "View_PrevInvViewProj" OpMemberName %type_View 50 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 51 "View_ClipToPrevClip" OpMemberName %type_View 52 "View_TemporalAAJitter" OpMemberName %type_View 53 "View_GlobalClippingPlane" OpMemberName %type_View 54 "View_FieldOfViewWideAngles" OpMemberName %type_View 55 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 56 "View_ViewRectMin" OpMemberName %type_View 57 "View_ViewSizeAndInvSize" OpMemberName %type_View 58 "View_BufferSizeAndInvSize" OpMemberName %type_View 59 "View_BufferBilinearUVMinMax" OpMemberName %type_View 60 "View_NumSceneColorMSAASamples" OpMemberName %type_View 61 "View_PreExposure" OpMemberName %type_View 62 "View_OneOverPreExposure" OpMemberName %type_View 63 "PrePadding_View_2012" OpMemberName %type_View 64 "View_DiffuseOverrideParameter" OpMemberName %type_View 65 "View_SpecularOverrideParameter" OpMemberName %type_View 66 "View_NormalOverrideParameter" OpMemberName %type_View 67 "View_RoughnessOverrideParameter" OpMemberName %type_View 68 "View_PrevFrameGameTime" OpMemberName %type_View 69 "View_PrevFrameRealTime" OpMemberName %type_View 70 "View_OutOfBoundsMask" OpMemberName %type_View 71 "PrePadding_View_2084" OpMemberName %type_View 72 "PrePadding_View_2088" OpMemberName %type_View 73 "PrePadding_View_2092" OpMemberName %type_View 74 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 75 "View_CullingSign" OpMemberName %type_View 76 "View_NearPlane" OpMemberName %type_View 77 "View_AdaptiveTessellationFactor" OpMemberName %type_View 78 "View_GameTime" OpMemberName %type_View 79 "View_RealTime" OpMemberName %type_View 80 "View_DeltaTime" OpMemberName %type_View 81 "View_MaterialTextureMipBias" OpMemberName %type_View 82 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 83 "View_Random" OpMemberName %type_View 84 "View_FrameNumber" OpMemberName %type_View 85 "View_StateFrameIndexMod8" OpMemberName %type_View 86 "View_StateFrameIndex" OpMemberName %type_View 87 "View_CameraCut" OpMemberName %type_View 88 "View_UnlitViewmodeMask" OpMemberName %type_View 89 "PrePadding_View_2164" OpMemberName %type_View 90 "PrePadding_View_2168" OpMemberName %type_View 91 "PrePadding_View_2172" OpMemberName %type_View 92 "View_DirectionalLightColor" OpMemberName %type_View 93 "View_DirectionalLightDirection" OpMemberName %type_View 94 "PrePadding_View_2204" OpMemberName %type_View 95 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 97 "View_TemporalAAParams" OpMemberName %type_View 98 "View_CircleDOFParams" OpMemberName %type_View 99 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 100 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 101 "View_DepthOfFieldScale" OpMemberName %type_View 102 "View_DepthOfFieldFocalLength" OpMemberName %type_View 103 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 104 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 105 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 106 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 107 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 108 "View_GeneralPurposeTweak" OpMemberName %type_View 109 "View_DemosaicVposOffset" OpMemberName %type_View 110 "PrePadding_View_2348" OpMemberName %type_View 111 "View_IndirectLightingColorScale" OpMemberName %type_View 112 "View_HDR32bppEncodingMode" OpMemberName %type_View 113 "View_AtmosphericFogSunDirection" OpMemberName %type_View 114 "View_AtmosphericFogSunPower" OpMemberName %type_View 115 "View_AtmosphericFogPower" OpMemberName %type_View 116 "View_AtmosphericFogDensityScale" OpMemberName %type_View 117 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 118 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 119 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 120 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 121 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 122 "View_AtmosphericFogStartDistance" OpMemberName %type_View 123 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 124 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 125 "View_AtmosphericFogRenderMask" OpMemberName %type_View 126 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 127 "View_AtmosphericFogSunColor" OpMemberName %type_View 128 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 129 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 130 "View_AmbientCubemapTint" OpMemberName %type_View 131 "View_AmbientCubemapIntensity" OpMemberName %type_View 132 "View_SkyLightParameters" OpMemberName %type_View 133 "PrePadding_View_2488" OpMemberName %type_View 134 "PrePadding_View_2492" OpMemberName %type_View 135 "View_SkyLightColor" OpMemberName %type_View 136 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 137 "View_MobilePreviewMode" OpMemberName %type_View 138 "View_HMDEyePaddingOffset" OpMemberName %type_View 139 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 140 "View_ShowDecalsMask" OpMemberName %type_View 141 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 142 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 143 "PrePadding_View_2648" OpMemberName %type_View 144 "PrePadding_View_2652" OpMemberName %type_View 145 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 146 "View_StereoPassIndex" OpMemberName %type_View 147 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 148 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 149 "View_GlobalVolumeDimension" OpMemberName %type_View 150 "View_GlobalVolumeTexelSize" OpMemberName %type_View 151 "View_MaxGlobalDistance" OpMemberName %type_View 152 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 153 "View_VolumetricFogInvGridSize" OpMemberName %type_View 154 "PrePadding_View_2828" OpMemberName %type_View 155 "View_VolumetricFogGridZParams" OpMemberName %type_View 156 "PrePadding_View_2844" OpMemberName %type_View 157 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 158 "View_VolumetricFogMaxDistance" OpMemberName %type_View 159 "PrePadding_View_2860" OpMemberName %type_View 160 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 161 "PrePadding_View_2876" OpMemberName %type_View 162 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 163 "PrePadding_View_2892" OpMemberName %type_View 164 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 165 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 166 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 167 "View_StereoIPD" OpMemberName %type_View 168 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 169 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_MobileBasePass "type.MobileBasePass" OpMemberName %type_MobileBasePass 0 "MobileBasePass_Fog_ExponentialFogParameters" OpMemberName %type_MobileBasePass 1 "MobileBasePass_Fog_ExponentialFogParameters2" OpMemberName %type_MobileBasePass 2 "MobileBasePass_Fog_ExponentialFogColorParameter" OpMemberName %type_MobileBasePass 3 "MobileBasePass_Fog_ExponentialFogParameters3" OpMemberName %type_MobileBasePass 4 "MobileBasePass_Fog_InscatteringLightDirection" OpMemberName %type_MobileBasePass 5 "MobileBasePass_Fog_DirectionalInscatteringColor" OpMemberName %type_MobileBasePass 6 "MobileBasePass_Fog_SinCosInscatteringColorCubemapRotation" OpMemberName %type_MobileBasePass 7 "PrePadding_MobileBasePass_Fog_104" OpMemberName %type_MobileBasePass 8 "PrePadding_MobileBasePass_Fog_108" OpMemberName %type_MobileBasePass 9 "MobileBasePass_Fog_FogInscatteringTextureParameters" OpMemberName %type_MobileBasePass 10 "MobileBasePass_Fog_ApplyVolumetricFog" OpMemberName %type_MobileBasePass 11 "PrePadding_MobileBasePass_PlanarReflection_128" OpMemberName %type_MobileBasePass 12 "PrePadding_MobileBasePass_PlanarReflection_132" OpMemberName %type_MobileBasePass 13 "PrePadding_MobileBasePass_PlanarReflection_136" OpMemberName %type_MobileBasePass 14 "PrePadding_MobileBasePass_PlanarReflection_140" OpMemberName %type_MobileBasePass 15 "PrePadding_MobileBasePass_PlanarReflection_144" OpMemberName %type_MobileBasePass 16 "PrePadding_MobileBasePass_PlanarReflection_148" OpMemberName %type_MobileBasePass 17 "PrePadding_MobileBasePass_PlanarReflection_152" OpMemberName %type_MobileBasePass 18 "PrePadding_MobileBasePass_PlanarReflection_156" OpMemberName %type_MobileBasePass 19 "MobileBasePass_PlanarReflection_ReflectionPlane" OpMemberName %type_MobileBasePass 20 "MobileBasePass_PlanarReflection_PlanarReflectionOrigin" OpMemberName %type_MobileBasePass 21 "MobileBasePass_PlanarReflection_PlanarReflectionXAxis" OpMemberName %type_MobileBasePass 22 "MobileBasePass_PlanarReflection_PlanarReflectionYAxis" OpMemberName %type_MobileBasePass 23 "MobileBasePass_PlanarReflection_InverseTransposeMirrorMatrix" OpMemberName %type_MobileBasePass 24 "MobileBasePass_PlanarReflection_PlanarReflectionParameters" OpMemberName %type_MobileBasePass 25 "PrePadding_MobileBasePass_PlanarReflection_284" OpMemberName %type_MobileBasePass 26 "MobileBasePass_PlanarReflection_PlanarReflectionParameters2" OpMemberName %type_MobileBasePass 27 "PrePadding_MobileBasePass_PlanarReflection_296" OpMemberName %type_MobileBasePass 28 "PrePadding_MobileBasePass_PlanarReflection_300" OpMemberName %type_MobileBasePass 29 "MobileBasePass_PlanarReflection_ProjectionWithExtraFOV" OpMemberName %type_MobileBasePass 30 "MobileBasePass_PlanarReflection_PlanarReflectionScreenScaleBias" OpMemberName %type_MobileBasePass 31 "MobileBasePass_PlanarReflection_PlanarReflectionScreenBound" OpMemberName %type_MobileBasePass 32 "MobileBasePass_PlanarReflection_bIsStereo" OpName %MobileBasePass "MobileBasePass" OpName %type_Primitive "type.Primitive" OpMemberName %type_Primitive 0 "Primitive_LocalToWorld" OpMemberName %type_Primitive 1 "Primitive_InvNonUniformScaleAndDeterminantSign" OpMemberName %type_Primitive 2 "Primitive_ObjectWorldPositionAndRadius" OpMemberName %type_Primitive 3 "Primitive_WorldToLocal" OpMemberName %type_Primitive 4 "Primitive_PreviousLocalToWorld" OpMemberName %type_Primitive 5 "Primitive_PreviousWorldToLocal" OpMemberName %type_Primitive 6 "Primitive_ActorWorldPosition" OpMemberName %type_Primitive 7 "Primitive_UseSingleSampleShadowFromStationaryLights" OpMemberName %type_Primitive 8 "Primitive_ObjectBounds" OpMemberName %type_Primitive 9 "Primitive_LpvBiasMultiplier" OpMemberName %type_Primitive 10 "Primitive_DecalReceiverMask" OpMemberName %type_Primitive 11 "Primitive_PerObjectGBufferData" OpMemberName %type_Primitive 12 "Primitive_UseVolumetricLightmapShadowFromStationaryLights" OpMemberName %type_Primitive 13 "Primitive_UseEditorDepthTest" OpMemberName %type_Primitive 14 "Primitive_ObjectOrientation" OpMemberName %type_Primitive 15 "Primitive_NonUniformScale" OpMemberName %type_Primitive 16 "Primitive_LocalObjectBoundsMin" OpMemberName %type_Primitive 17 "PrePadding_Primitive_380" OpMemberName %type_Primitive 18 "Primitive_LocalObjectBoundsMax" OpMemberName %type_Primitive 19 "Primitive_LightingChannelMask" OpMemberName %type_Primitive 20 "Primitive_LightmapDataIndex" OpMemberName %type_Primitive 21 "Primitive_SingleCaptureIndex" OpName %Primitive "Primitive" OpName %type_LandscapeParameters "type.LandscapeParameters" OpMemberName %type_LandscapeParameters 0 "LandscapeParameters_HeightmapUVScaleBias" OpMemberName %type_LandscapeParameters 1 "LandscapeParameters_WeightmapUVScaleBias" OpMemberName %type_LandscapeParameters 2 "LandscapeParameters_LandscapeLightmapScaleBias" OpMemberName %type_LandscapeParameters 3 "LandscapeParameters_SubsectionSizeVertsLayerUVPan" OpMemberName %type_LandscapeParameters 4 "LandscapeParameters_SubsectionOffsetParams" OpMemberName %type_LandscapeParameters 5 "LandscapeParameters_LightmapSubsectionOffsetParams" OpMemberName %type_LandscapeParameters 6 "LandscapeParameters_LocalToWorldNoScaling" OpName %LandscapeParameters "LandscapeParameters" OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "LodBias" OpMemberName %type__Globals 1 "LodValues" OpMemberName %type__Globals 2 "SectionLods" OpMemberName %type__Globals 3 "NeighborSectionLod" OpName %_Globals "$Globals" OpName %in_var_ATTRIBUTE0 "in.var.ATTRIBUTE0" OpName %in_var_ATTRIBUTE1 "in.var.ATTRIBUTE1" OpName %out_var_TEXCOORD0 "out.var.TEXCOORD0" OpName %out_var_TEXCOORD1 "out.var.TEXCOORD1" OpName %out_var_TEXCOORD2 "out.var.TEXCOORD2" OpName %out_var_TEXCOORD3 "out.var.TEXCOORD3" OpName %out_var_TEXCOORD8 "out.var.TEXCOORD8" OpName %Main "Main" OpDecorateString %in_var_ATTRIBUTE0 UserSemantic "ATTRIBUTE0" OpDecorateString %in_var_ATTRIBUTE1 UserSemantic "ATTRIBUTE1" OpDecorateString %out_var_TEXCOORD0 UserSemantic "TEXCOORD0" OpDecorateString %out_var_TEXCOORD1 UserSemantic "TEXCOORD1" OpDecorateString %out_var_TEXCOORD2 UserSemantic "TEXCOORD2" OpDecorateString %out_var_TEXCOORD3 UserSemantic "TEXCOORD3" OpDecorateString %out_var_TEXCOORD8 UserSemantic "TEXCOORD8" OpDecorate %gl_Position BuiltIn Position OpDecorateString %gl_Position UserSemantic "SV_POSITION" OpDecorate %in_var_ATTRIBUTE0 Location 0 OpDecorate %in_var_ATTRIBUTE1 Location 1 OpDecorate %out_var_TEXCOORD0 Location 0 OpDecorate %out_var_TEXCOORD1 Location 1 OpDecorate %out_var_TEXCOORD2 Location 2 OpDecorate %out_var_TEXCOORD3 Location 3 OpDecorate %out_var_TEXCOORD8 Location 4 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 0 OpDecorate %MobileBasePass DescriptorSet 0 OpDecorate %MobileBasePass Binding 1 OpDecorate %Primitive DescriptorSet 0 OpDecorate %Primitive Binding 2 OpDecorate %LandscapeParameters DescriptorSet 0 OpDecorate %LandscapeParameters Binding 3 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 4 OpDecorate %_arr_v4float_uint_2_0 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 14 Offset 844 OpMemberDecorate %type_View 15 Offset 848 OpMemberDecorate %type_View 16 Offset 860 OpMemberDecorate %type_View 17 Offset 864 OpMemberDecorate %type_View 18 Offset 876 OpMemberDecorate %type_View 19 Offset 880 OpMemberDecorate %type_View 20 Offset 892 OpMemberDecorate %type_View 21 Offset 896 OpMemberDecorate %type_View 22 Offset 908 OpMemberDecorate %type_View 23 Offset 912 OpMemberDecorate %type_View 24 Offset 928 OpMemberDecorate %type_View 25 Offset 944 OpMemberDecorate %type_View 26 Offset 956 OpMemberDecorate %type_View 27 Offset 960 OpMemberDecorate %type_View 28 Offset 972 OpMemberDecorate %type_View 29 Offset 976 OpMemberDecorate %type_View 30 Offset 988 OpMemberDecorate %type_View 31 Offset 992 OpMemberDecorate %type_View 32 Offset 1004 OpMemberDecorate %type_View 33 Offset 1008 OpMemberDecorate %type_View 33 MatrixStride 16 OpMemberDecorate %type_View 33 ColMajor OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 44 Offset 1660 OpMemberDecorate %type_View 45 Offset 1664 OpMemberDecorate %type_View 46 Offset 1676 OpMemberDecorate %type_View 47 Offset 1680 OpMemberDecorate %type_View 48 Offset 1692 OpMemberDecorate %type_View 49 Offset 1696 OpMemberDecorate %type_View 49 MatrixStride 16 OpMemberDecorate %type_View 49 ColMajor OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 53 Offset 1904 OpMemberDecorate %type_View 54 Offset 1920 OpMemberDecorate %type_View 55 Offset 1928 OpMemberDecorate %type_View 56 Offset 1936 OpMemberDecorate %type_View 57 Offset 1952 OpMemberDecorate %type_View 58 Offset 1968 OpMemberDecorate %type_View 59 Offset 1984 OpMemberDecorate %type_View 60 Offset 2000 OpMemberDecorate %type_View 61 Offset 2004 OpMemberDecorate %type_View 62 Offset 2008 OpMemberDecorate %type_View 63 Offset 2012 OpMemberDecorate %type_View 64 Offset 2016 OpMemberDecorate %type_View 65 Offset 2032 OpMemberDecorate %type_View 66 Offset 2048 OpMemberDecorate %type_View 67 Offset 2064 OpMemberDecorate %type_View 68 Offset 2072 OpMemberDecorate %type_View 69 Offset 2076 OpMemberDecorate %type_View 70 Offset 2080 OpMemberDecorate %type_View 71 Offset 2084 OpMemberDecorate %type_View 72 Offset 2088 OpMemberDecorate %type_View 73 Offset 2092 OpMemberDecorate %type_View 74 Offset 2096 OpMemberDecorate %type_View 75 Offset 2108 OpMemberDecorate %type_View 76 Offset 2112 OpMemberDecorate %type_View 77 Offset 2116 OpMemberDecorate %type_View 78 Offset 2120 OpMemberDecorate %type_View 79 Offset 2124 OpMemberDecorate %type_View 80 Offset 2128 OpMemberDecorate %type_View 81 Offset 2132 OpMemberDecorate %type_View 82 Offset 2136 OpMemberDecorate %type_View 83 Offset 2140 OpMemberDecorate %type_View 84 Offset 2144 OpMemberDecorate %type_View 85 Offset 2148 OpMemberDecorate %type_View 86 Offset 2152 OpMemberDecorate %type_View 87 Offset 2156 OpMemberDecorate %type_View 88 Offset 2160 OpMemberDecorate %type_View 89 Offset 2164 OpMemberDecorate %type_View 90 Offset 2168 OpMemberDecorate %type_View 91 Offset 2172 OpMemberDecorate %type_View 92 Offset 2176 OpMemberDecorate %type_View 93 Offset 2192 OpMemberDecorate %type_View 94 Offset 2204 OpMemberDecorate %type_View 95 Offset 2208 OpMemberDecorate %type_View 96 Offset 2240 OpMemberDecorate %type_View 97 Offset 2272 OpMemberDecorate %type_View 98 Offset 2288 OpMemberDecorate %type_View 99 Offset 2304 OpMemberDecorate %type_View 100 Offset 2308 OpMemberDecorate %type_View 101 Offset 2312 OpMemberDecorate %type_View 102 Offset 2316 OpMemberDecorate %type_View 103 Offset 2320 OpMemberDecorate %type_View 104 Offset 2324 OpMemberDecorate %type_View 105 Offset 2328 OpMemberDecorate %type_View 106 Offset 2332 OpMemberDecorate %type_View 107 Offset 2336 OpMemberDecorate %type_View 108 Offset 2340 OpMemberDecorate %type_View 109 Offset 2344 OpMemberDecorate %type_View 110 Offset 2348 OpMemberDecorate %type_View 111 Offset 2352 OpMemberDecorate %type_View 112 Offset 2364 OpMemberDecorate %type_View 113 Offset 2368 OpMemberDecorate %type_View 114 Offset 2380 OpMemberDecorate %type_View 115 Offset 2384 OpMemberDecorate %type_View 116 Offset 2388 OpMemberDecorate %type_View 117 Offset 2392 OpMemberDecorate %type_View 118 Offset 2396 OpMemberDecorate %type_View 119 Offset 2400 OpMemberDecorate %type_View 120 Offset 2404 OpMemberDecorate %type_View 121 Offset 2408 OpMemberDecorate %type_View 122 Offset 2412 OpMemberDecorate %type_View 123 Offset 2416 OpMemberDecorate %type_View 124 Offset 2420 OpMemberDecorate %type_View 125 Offset 2424 OpMemberDecorate %type_View 126 Offset 2428 OpMemberDecorate %type_View 127 Offset 2432 OpMemberDecorate %type_View 128 Offset 2448 OpMemberDecorate %type_View 129 Offset 2460 OpMemberDecorate %type_View 130 Offset 2464 OpMemberDecorate %type_View 131 Offset 2480 OpMemberDecorate %type_View 132 Offset 2484 OpMemberDecorate %type_View 133 Offset 2488 OpMemberDecorate %type_View 134 Offset 2492 OpMemberDecorate %type_View 135 Offset 2496 OpMemberDecorate %type_View 136 Offset 2512 OpMemberDecorate %type_View 137 Offset 2624 OpMemberDecorate %type_View 138 Offset 2628 OpMemberDecorate %type_View 139 Offset 2632 OpMemberDecorate %type_View 140 Offset 2636 OpMemberDecorate %type_View 141 Offset 2640 OpMemberDecorate %type_View 142 Offset 2644 OpMemberDecorate %type_View 143 Offset 2648 OpMemberDecorate %type_View 144 Offset 2652 OpMemberDecorate %type_View 145 Offset 2656 OpMemberDecorate %type_View 146 Offset 2668 OpMemberDecorate %type_View 147 Offset 2672 OpMemberDecorate %type_View 148 Offset 2736 OpMemberDecorate %type_View 149 Offset 2800 OpMemberDecorate %type_View 150 Offset 2804 OpMemberDecorate %type_View 151 Offset 2808 OpMemberDecorate %type_View 152 Offset 2812 OpMemberDecorate %type_View 153 Offset 2816 OpMemberDecorate %type_View 154 Offset 2828 OpMemberDecorate %type_View 155 Offset 2832 OpMemberDecorate %type_View 156 Offset 2844 OpMemberDecorate %type_View 157 Offset 2848 OpMemberDecorate %type_View 158 Offset 2856 OpMemberDecorate %type_View 159 Offset 2860 OpMemberDecorate %type_View 160 Offset 2864 OpMemberDecorate %type_View 161 Offset 2876 OpMemberDecorate %type_View 162 Offset 2880 OpMemberDecorate %type_View 163 Offset 2892 OpMemberDecorate %type_View 164 Offset 2896 OpMemberDecorate %type_View 165 Offset 2908 OpMemberDecorate %type_View 166 Offset 2912 OpMemberDecorate %type_View 167 Offset 2924 OpMemberDecorate %type_View 168 Offset 2928 OpMemberDecorate %type_View 169 Offset 2932 OpDecorate %type_View Block OpDecorate %_arr_mat4v4float_uint_2 ArrayStride 64 OpMemberDecorate %type_MobileBasePass 0 Offset 0 OpMemberDecorate %type_MobileBasePass 1 Offset 16 OpMemberDecorate %type_MobileBasePass 2 Offset 32 OpMemberDecorate %type_MobileBasePass 3 Offset 48 OpMemberDecorate %type_MobileBasePass 4 Offset 64 OpMemberDecorate %type_MobileBasePass 5 Offset 80 OpMemberDecorate %type_MobileBasePass 6 Offset 96 OpMemberDecorate %type_MobileBasePass 7 Offset 104 OpMemberDecorate %type_MobileBasePass 8 Offset 108 OpMemberDecorate %type_MobileBasePass 9 Offset 112 OpMemberDecorate %type_MobileBasePass 10 Offset 124 OpMemberDecorate %type_MobileBasePass 11 Offset 128 OpMemberDecorate %type_MobileBasePass 12 Offset 132 OpMemberDecorate %type_MobileBasePass 13 Offset 136 OpMemberDecorate %type_MobileBasePass 14 Offset 140 OpMemberDecorate %type_MobileBasePass 15 Offset 144 OpMemberDecorate %type_MobileBasePass 16 Offset 148 OpMemberDecorate %type_MobileBasePass 17 Offset 152 OpMemberDecorate %type_MobileBasePass 18 Offset 156 OpMemberDecorate %type_MobileBasePass 19 Offset 160 OpMemberDecorate %type_MobileBasePass 20 Offset 176 OpMemberDecorate %type_MobileBasePass 21 Offset 192 OpMemberDecorate %type_MobileBasePass 22 Offset 208 OpMemberDecorate %type_MobileBasePass 23 Offset 224 OpMemberDecorate %type_MobileBasePass 23 MatrixStride 16 OpMemberDecorate %type_MobileBasePass 23 ColMajor OpMemberDecorate %type_MobileBasePass 24 Offset 272 OpMemberDecorate %type_MobileBasePass 25 Offset 284 OpMemberDecorate %type_MobileBasePass 26 Offset 288 OpMemberDecorate %type_MobileBasePass 27 Offset 296 OpMemberDecorate %type_MobileBasePass 28 Offset 300 OpMemberDecorate %type_MobileBasePass 29 Offset 304 OpMemberDecorate %type_MobileBasePass 29 MatrixStride 16 OpMemberDecorate %type_MobileBasePass 29 ColMajor OpMemberDecorate %type_MobileBasePass 30 Offset 432 OpMemberDecorate %type_MobileBasePass 31 Offset 464 OpMemberDecorate %type_MobileBasePass 32 Offset 472 OpDecorate %type_MobileBasePass Block OpMemberDecorate %type_Primitive 0 Offset 0 OpMemberDecorate %type_Primitive 0 MatrixStride 16 OpMemberDecorate %type_Primitive 0 ColMajor OpMemberDecorate %type_Primitive 1 Offset 64 OpMemberDecorate %type_Primitive 2 Offset 80 OpMemberDecorate %type_Primitive 3 Offset 96 OpMemberDecorate %type_Primitive 3 MatrixStride 16 OpMemberDecorate %type_Primitive 3 ColMajor OpMemberDecorate %type_Primitive 4 Offset 160 OpMemberDecorate %type_Primitive 4 MatrixStride 16 OpMemberDecorate %type_Primitive 4 ColMajor OpMemberDecorate %type_Primitive 5 Offset 224 OpMemberDecorate %type_Primitive 5 MatrixStride 16 OpMemberDecorate %type_Primitive 5 ColMajor OpMemberDecorate %type_Primitive 6 Offset 288 OpMemberDecorate %type_Primitive 7 Offset 300 OpMemberDecorate %type_Primitive 8 Offset 304 OpMemberDecorate %type_Primitive 9 Offset 316 OpMemberDecorate %type_Primitive 10 Offset 320 OpMemberDecorate %type_Primitive 11 Offset 324 OpMemberDecorate %type_Primitive 12 Offset 328 OpMemberDecorate %type_Primitive 13 Offset 332 OpMemberDecorate %type_Primitive 14 Offset 336 OpMemberDecorate %type_Primitive 15 Offset 352 OpMemberDecorate %type_Primitive 16 Offset 368 OpMemberDecorate %type_Primitive 17 Offset 380 OpMemberDecorate %type_Primitive 18 Offset 384 OpMemberDecorate %type_Primitive 19 Offset 396 OpMemberDecorate %type_Primitive 20 Offset 400 OpMemberDecorate %type_Primitive 21 Offset 404 OpDecorate %type_Primitive Block OpMemberDecorate %type_LandscapeParameters 0 Offset 0 OpMemberDecorate %type_LandscapeParameters 1 Offset 16 OpMemberDecorate %type_LandscapeParameters 2 Offset 32 OpMemberDecorate %type_LandscapeParameters 3 Offset 48 OpMemberDecorate %type_LandscapeParameters 4 Offset 64 OpMemberDecorate %type_LandscapeParameters 5 Offset 80 OpMemberDecorate %type_LandscapeParameters 6 Offset 96 OpMemberDecorate %type_LandscapeParameters 6 MatrixStride 16 OpMemberDecorate %type_LandscapeParameters 6 ColMajor OpDecorate %type_LandscapeParameters Block OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 32 OpMemberDecorate %type__Globals 3 Offset 48 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %float_0_00999999978 = OpConstant %float 0.00999999978 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %40 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %float_255 = OpConstant %float 255 %44 = OpConstantComposite %v4float %float_255 %float_255 %float_255 %float_255 %float_0_5 = OpConstant %float 0.5 %46 = OpConstantComposite %v2float %float_0_5 %float_0_5 %float_2 = OpConstant %float 2 %48 = OpConstantComposite %v2float %float_2 %float_2 %float_1 = OpConstant %float 1 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %float_3 = OpConstant %float 3 %float_0_25 = OpConstant %float 0.25 %uint_3 = OpConstant %uint 3 %float_4 = OpConstant %float 4 %float_0_125 = OpConstant %float 0.125 %float_5 = OpConstant %float 5 %float_0_0625 = OpConstant %float 0.0625 %float_0_03125 = OpConstant %float 0.03125 %60 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %int_5 = OpConstant %int 5 %int_4 = OpConstant %int 4 %63 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %int_25 = OpConstant %int 25 %int_27 = OpConstant %int 27 %int_31 = OpConstant %int 31 %67 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %float_32768 = OpConstant %float 32768 %_arr_v4float_uint_2_0 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2_0 %_arr_v4float_uint_2_0 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %mat3v4float = OpTypeMatrix %v4float 3 %_arr_mat4v4float_uint_2 = OpTypeArray %mat4v4float %uint_2 %type_MobileBasePass = OpTypeStruct %v4float %v4float %v4float %v4float %v4float %v4float %v2float %float %float %v3float %float %float %float %float %float %float %float %float %float %v4float %v4float %v4float %v4float %mat3v4float %v3float %float %v2float %float %float %_arr_mat4v4float_uint_2 %_arr_v4float_uint_2_0 %v2float %uint %_ptr_Uniform_type_MobileBasePass = OpTypePointer Uniform %type_MobileBasePass %type_Primitive = OpTypeStruct %mat4v4float %v4float %v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %float %float %float %float %v4float %v4float %v3float %float %v3float %uint %uint %int %_ptr_Uniform_type_Primitive = OpTypePointer Uniform %type_Primitive %type_LandscapeParameters = OpTypeStruct %v4float %v4float %v4float %v4float %v4float %v4float %mat4v4float %_ptr_Uniform_type_LandscapeParameters = OpTypePointer Uniform %type_LandscapeParameters %type__Globals = OpTypeStruct %v4float %v4float %v4float %_arr_v4float_uint_4 %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input__arr_v4float_uint_2 = OpTypePointer Input %_arr_v4float_uint_2 %_ptr_Output_v2float = OpTypePointer Output %v2float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %80 = OpTypeFunction %void %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %_ptr_Function__arr_v4float_uint_1 = OpTypePointer Function %_arr_v4float_uint_1 %_ptr_Function_v4float = OpTypePointer Function %v4float %bool = OpTypeBool %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %v3bool = OpTypeVector %bool 3 %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %View = OpVariable %_ptr_Uniform_type_View Uniform %MobileBasePass = OpVariable %_ptr_Uniform_type_MobileBasePass Uniform %Primitive = OpVariable %_ptr_Uniform_type_Primitive Uniform %LandscapeParameters = OpVariable %_ptr_Uniform_type_LandscapeParameters Uniform %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %in_var_ATTRIBUTE0 = OpVariable %_ptr_Input_v4float Input %in_var_ATTRIBUTE1 = OpVariable %_ptr_Input__arr_v4float_uint_2 Input %out_var_TEXCOORD0 = OpVariable %_ptr_Output_v2float Output %out_var_TEXCOORD1 = OpVariable %_ptr_Output_v2float Output %out_var_TEXCOORD2 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD3 = OpVariable %_ptr_Output_v4float Output %out_var_TEXCOORD8 = OpVariable %_ptr_Output_v4float Output %gl_Position = OpVariable %_ptr_Output_v4float Output %float_0_0078125 = OpConstant %float 0.0078125 %float_n127 = OpConstant %float -127 %92 = OpConstantNull %v4float %float_0_00392156886 = OpConstant %float 0.00392156886 %94 = OpConstantComposite %v2float %float_0_00392156886 %float_0_00392156886 %float_65280 = OpConstant %float 65280 %Main = OpFunction %void None %80 %96 = OpLabel %97 = OpVariable %_ptr_Function__arr_v4float_uint_1 Function %98 = OpLoad %v4float %in_var_ATTRIBUTE0 %99 = OpLoad %_arr_v4float_uint_2 %in_var_ATTRIBUTE1 %100 = OpAccessChain %_ptr_Uniform_mat4v4float %View %int_0 %101 = OpLoad %mat4v4float %100 %102 = OpAccessChain %_ptr_Uniform_v3float %View %int_27 %103 = OpLoad %v3float %102 %104 = OpAccessChain %_ptr_Uniform_v3float %View %int_31 %105 = OpLoad %v3float %104 OpBranch %106 %106 = OpLabel %107 = OpPhi %int %int_0 %96 %108 %109 %110 = OpSLessThan %bool %107 %int_1 OpLoopMerge %111 %109 Unroll OpBranchConditional %110 %109 %111 %109 = OpLabel %112 = OpAccessChain %_ptr_Function_v4float %97 %107 OpStore %112 %40 %108 = OpIAdd %int %107 %int_1 OpBranch %106 %111 = OpLabel %113 = OpCompositeExtract %v4float %99 0 %114 = OpCompositeExtract %v4float %99 1 %115 = OpFMul %v4float %98 %44 %116 = OpVectorShuffle %v2float %115 %115 2 3 %117 = OpFMul %v2float %116 %46 %118 = OpExtInst %v2float %1 Fract %117 %119 = OpFMul %v2float %118 %48 %120 = OpFSub %v2float %116 %119 %121 = OpFMul %v2float %120 %94 %122 = OpVectorShuffle %v2float %115 %92 0 1 %123 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %int_3 %124 = OpLoad %float %123 %125 = OpCompositeConstruct %v2float %124 %124 %126 = OpFMul %v2float %122 %125 %127 = OpCompositeExtract %float %126 1 %128 = OpCompositeExtract %float %126 0 %129 = OpFSub %float %float_1 %128 %130 = OpFSub %float %float_1 %127 %131 = OpCompositeConstruct %v4float %127 %128 %129 %130 %132 = OpFMul %v4float %131 %67 %133 = OpCompositeExtract %float %119 1 %134 = OpFOrdGreaterThan %bool %133 %float_0_5 OpSelectionMerge %135 None OpBranchConditional %134 %136 %137 %136 = OpLabel %138 = OpCompositeExtract %float %119 0 %139 = OpFOrdGreaterThan %bool %138 %float_0_5 OpSelectionMerge %140 None OpBranchConditional %139 %141 %142 %141 = OpLabel %143 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %int_3 %144 = OpLoad %float %143 %145 = OpCompositeConstruct %v4float %144 %144 %144 %144 %146 = OpFMul %v4float %132 %145 %147 = OpFSub %v4float %60 %132 %148 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_3 %int_3 %149 = OpLoad %v4float %148 %150 = OpFMul %v4float %147 %149 %151 = OpFAdd %v4float %146 %150 OpBranch %140 %142 = OpLabel %152 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %int_2 %153 = OpLoad %float %152 %154 = OpCompositeConstruct %v4float %153 %153 %153 %153 %155 = OpFMul %v4float %132 %154 %156 = OpFSub %v4float %60 %132 %157 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_3 %int_2 %158 = OpLoad %v4float %157 %159 = OpFMul %v4float %156 %158 %160 = OpFAdd %v4float %155 %159 OpBranch %140 %140 = OpLabel %161 = OpPhi %v4float %151 %141 %160 %142 OpBranch %135 %137 = OpLabel %162 = OpCompositeExtract %float %119 0 %163 = OpFOrdGreaterThan %bool %162 %float_0_5 OpSelectionMerge %164 None OpBranchConditional %163 %165 %166 %165 = OpLabel %167 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %int_1 %168 = OpLoad %float %167 %169 = OpCompositeConstruct %v4float %168 %168 %168 %168 %170 = OpFMul %v4float %132 %169 %171 = OpFSub %v4float %60 %132 %172 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_3 %int_1 %173 = OpLoad %v4float %172 %174 = OpFMul %v4float %171 %173 %175 = OpFAdd %v4float %170 %174 OpBranch %164 %166 = OpLabel %176 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %int_0 %177 = OpLoad %float %176 %178 = OpCompositeConstruct %v4float %177 %177 %177 %177 %179 = OpFMul %v4float %132 %178 %180 = OpFSub %v4float %60 %132 %181 = OpAccessChain %_ptr_Uniform_v4float %_Globals %int_3 %int_0 %182 = OpLoad %v4float %181 %183 = OpFMul %v4float %180 %182 %184 = OpFAdd %v4float %179 %183 OpBranch %164 %164 = OpLabel %185 = OpPhi %v4float %175 %165 %184 %166 OpBranch %135 %135 = OpLabel %186 = OpPhi %v4float %161 %140 %185 %164 %187 = OpFAdd %float %128 %127 %188 = OpFOrdGreaterThan %bool %187 %float_1 OpSelectionMerge %189 None OpBranchConditional %188 %190 %191 %190 = OpLabel %192 = OpFOrdLessThan %bool %128 %127 OpSelectionMerge %193 None OpBranchConditional %192 %194 %195 %194 = OpLabel %196 = OpCompositeExtract %float %186 3 OpBranch %193 %195 = OpLabel %197 = OpCompositeExtract %float %186 2 OpBranch %193 %193 = OpLabel %198 = OpPhi %float %196 %194 %197 %195 OpBranch %189 %191 = OpLabel %199 = OpFOrdLessThan %bool %128 %127 OpSelectionMerge %200 None OpBranchConditional %199 %201 %202 %201 = OpLabel %203 = OpCompositeExtract %float %186 1 OpBranch %200 %202 = OpLabel %204 = OpCompositeExtract %float %186 0 OpBranch %200 %200 = OpLabel %205 = OpPhi %float %203 %201 %204 %202 OpBranch %189 %189 = OpLabel %206 = OpPhi %float %198 %193 %205 %200 %207 = OpExtInst %float %1 Floor %206 %208 = OpFSub %float %206 %207 %209 = OpFOrdLessThan %bool %207 %float_1 %210 = OpCompositeExtract %float %114 0 %211 = OpCompositeExtract %float %114 1 %212 = OpCompositeConstruct %v3float %float_1 %210 %211 %213 = OpFOrdLessThan %bool %207 %float_2 %214 = OpCompositeExtract %float %114 2 %215 = OpCompositeConstruct %v3float %float_0_5 %211 %214 %216 = OpFOrdLessThan %bool %207 %float_3 %217 = OpCompositeExtract %float %114 3 %218 = OpCompositeConstruct %v3float %float_0_25 %214 %217 %219 = OpFOrdLessThan %bool %207 %float_4 %220 = OpCompositeExtract %float %121 0 %221 = OpCompositeConstruct %v3float %float_0_125 %217 %220 %222 = OpFOrdLessThan %bool %207 %float_5 %223 = OpCompositeExtract %float %121 1 %224 = OpCompositeConstruct %v3float %float_0_0625 %220 %223 %225 = OpCompositeConstruct %v3float %float_0_03125 %223 %223 %226 = OpCompositeConstruct %v3bool %222 %222 %222 %227 = OpSelect %v3float %226 %224 %225 %228 = OpCompositeConstruct %v3bool %219 %219 %219 %229 = OpSelect %v3float %228 %221 %227 %230 = OpCompositeConstruct %v3bool %216 %216 %216 %231 = OpSelect %v3float %230 %218 %229 %232 = OpCompositeConstruct %v3bool %213 %213 %213 %233 = OpSelect %v3float %232 %215 %231 %234 = OpCompositeConstruct %v3bool %209 %209 %209 %235 = OpSelect %v3float %234 %212 %233 %236 = OpCompositeExtract %float %235 0 %237 = OpCompositeExtract %float %235 1 %238 = OpCompositeExtract %float %235 2 %239 = OpCompositeExtract %float %113 0 %240 = OpFMul %float %239 %float_65280 %241 = OpCompositeExtract %float %113 1 %242 = OpFMul %float %241 %float_255 %243 = OpFAdd %float %240 %242 %244 = OpFSub %float %243 %float_32768 %245 = OpFMul %float %244 %float_0_0078125 %246 = OpCompositeExtract %float %113 2 %247 = OpFMul %float %246 %float_65280 %248 = OpCompositeExtract %float %113 3 %249 = OpFMul %float %248 %float_255 %250 = OpFAdd %float %247 %249 %251 = OpFSub %float %250 %float_32768 %252 = OpFMul %float %251 %float_0_0078125 %253 = OpExtInst %float %1 FMix %245 %252 %237 %254 = OpExtInst %float %1 FMix %245 %252 %238 %255 = OpCompositeConstruct %v2float %236 %236 %256 = OpFMul %v2float %122 %255 %257 = OpExtInst %v2float %1 Floor %256 %258 = OpAccessChain %_ptr_Uniform_v4float %LandscapeParameters %int_3 %259 = OpAccessChain %_ptr_Uniform_float %LandscapeParameters %int_3 %int_0 %260 = OpLoad %float %259 %261 = OpFMul %float %260 %236 %262 = OpFSub %float %261 %float_1 %263 = OpFMul %float %260 %float_0_5 %264 = OpFMul %float %263 %236 %265 = OpExtInst %float %1 FMax %264 %float_2 %266 = OpFSub %float %265 %float_1 %267 = OpCompositeConstruct %v2float %262 %266 %268 = OpAccessChain %_ptr_Uniform_float %LandscapeParameters %int_3 %int_1 %269 = OpLoad %float %268 %270 = OpCompositeConstruct %v2float %269 %269 %271 = OpFMul %v2float %267 %270 %272 = OpCompositeExtract %float %271 0 %273 = OpCompositeConstruct %v2float %272 %272 %274 = OpFDiv %v2float %257 %273 %275 = OpFMul %v2float %257 %46 %276 = OpExtInst %v2float %1 Floor %275 %277 = OpCompositeExtract %float %271 1 %278 = OpCompositeConstruct %v2float %277 %277 %279 = OpFDiv %v2float %276 %278 %280 = OpCompositeExtract %float %274 0 %281 = OpCompositeExtract %float %274 1 %282 = OpCompositeConstruct %v3float %280 %281 %253 %283 = OpCompositeExtract %float %279 0 %284 = OpCompositeExtract %float %279 1 %285 = OpCompositeConstruct %v3float %283 %284 %254 %286 = OpCompositeConstruct %v3float %208 %208 %208 %287 = OpExtInst %v3float %1 FMix %282 %285 %286 %288 = OpVectorShuffle %v2float %119 %92 0 1 %289 = OpAccessChain %_ptr_Uniform_v4float %LandscapeParameters %int_4 %290 = OpLoad %v4float %289 %291 = OpVectorShuffle %v2float %290 %290 3 3 %292 = OpFMul %v2float %288 %291 %293 = OpCompositeExtract %float %292 0 %294 = OpCompositeExtract %float %292 1 %295 = OpCompositeConstruct %v3float %293 %294 %float_0 %296 = OpFAdd %v3float %287 %295 %297 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_0 %uint_0 %298 = OpLoad %v4float %297 %299 = OpVectorShuffle %v3float %298 %298 0 1 2 %300 = OpVectorShuffle %v3float %296 %296 0 0 0 %301 = OpFMul %v3float %299 %300 %302 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_0 %uint_1 %303 = OpLoad %v4float %302 %304 = OpVectorShuffle %v3float %303 %303 0 1 2 %305 = OpVectorShuffle %v3float %296 %296 1 1 1 %306 = OpFMul %v3float %304 %305 %307 = OpFAdd %v3float %301 %306 %308 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_0 %uint_2 %309 = OpLoad %v4float %308 %310 = OpVectorShuffle %v3float %309 %309 0 1 2 %311 = OpVectorShuffle %v3float %296 %296 2 2 2 %312 = OpFMul %v3float %310 %311 %313 = OpFAdd %v3float %307 %312 %314 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_0 %uint_3 %315 = OpLoad %v4float %314 %316 = OpVectorShuffle %v3float %315 %315 0 1 2 %317 = OpFAdd %v3float %316 %105 %318 = OpFAdd %v3float %313 %317 %319 = OpCompositeExtract %float %318 0 %320 = OpCompositeExtract %float %318 1 %321 = OpCompositeExtract %float %318 2 %322 = OpCompositeConstruct %v4float %319 %320 %321 %float_1 %323 = OpVectorShuffle %v2float %287 %287 0 1 %324 = OpLoad %v4float %258 %325 = OpVectorShuffle %v2float %324 %324 2 3 %326 = OpFAdd %v2float %323 %325 %327 = OpFAdd %v2float %326 %292 %328 = OpAccessChain %_ptr_Uniform_v4float %LandscapeParameters %int_1 %329 = OpLoad %v4float %328 %330 = OpVectorShuffle %v2float %329 %329 0 1 %331 = OpFMul %v2float %323 %330 %332 = OpVectorShuffle %v2float %329 %329 2 3 %333 = OpFAdd %v2float %331 %332 %334 = OpVectorShuffle %v2float %290 %290 2 2 %335 = OpFMul %v2float %288 %334 %336 = OpFAdd %v2float %333 %335 %337 = OpVectorShuffle %v2float %327 %92 0 1 %338 = OpVectorShuffle %v4float %322 %322 4 5 6 3 %339 = OpMatrixTimesVector %v4float %101 %338 %340 = OpVectorShuffle %v3float %322 %92 0 1 2 %341 = OpFSub %v3float %340 %103 %342 = OpAccessChain %_ptr_Uniform_v4float %MobileBasePass %int_2 %343 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_2 %int_3 %344 = OpLoad %float %343 %345 = OpDot %float %341 %341 %346 = OpExtInst %float %1 InverseSqrt %345 %347 = OpFMul %float %345 %346 %348 = OpCompositeConstruct %v3float %346 %346 %346 %349 = OpFMul %v3float %341 %348 %350 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_0 %int_0 %351 = OpLoad %float %350 %352 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_1 %int_0 %353 = OpLoad %float %352 %354 = OpCompositeExtract %float %341 2 %355 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_0 %int_3 %356 = OpLoad %float %355 %357 = OpExtInst %float %1 FMax %float_0 %356 %358 = OpFOrdGreaterThan %bool %357 %float_0 OpSelectionMerge %359 None OpBranchConditional %358 %360 %359 %360 = OpLabel %361 = OpFMul %float %357 %346 %362 = OpFMul %float %361 %354 %363 = OpAccessChain %_ptr_Uniform_float %View %int_25 %int_2 %364 = OpLoad %float %363 %365 = OpFAdd %float %364 %362 %366 = OpFSub %float %354 %362 %367 = OpFSub %float %float_1 %361 %368 = OpFMul %float %367 %347 %369 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_0 %int_1 %370 = OpLoad %float %369 %371 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_3 %int_1 %372 = OpLoad %float %371 %373 = OpFSub %float %365 %372 %374 = OpFMul %float %370 %373 %375 = OpExtInst %float %1 FMax %float_n127 %374 %376 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_3 %int_0 %377 = OpLoad %float %376 %378 = OpFNegate %float %375 %379 = OpExtInst %float %1 Exp2 %378 %380 = OpFMul %float %377 %379 %381 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_1 %int_1 %382 = OpLoad %float %381 %383 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_1 %int_3 %384 = OpLoad %float %383 %385 = OpFSub %float %365 %384 %386 = OpFMul %float %382 %385 %387 = OpExtInst %float %1 FMax %float_n127 %386 %388 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_1 %int_2 %389 = OpLoad %float %388 %390 = OpFNegate %float %387 %391 = OpExtInst %float %1 Exp2 %390 %392 = OpFMul %float %389 %391 OpBranch %359 %359 = OpLabel %393 = OpPhi %float %347 %189 %368 %360 %394 = OpPhi %float %353 %189 %392 %360 %395 = OpPhi %float %351 %189 %380 %360 %396 = OpPhi %float %354 %189 %366 %360 %397 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_0 %int_1 %398 = OpLoad %float %397 %399 = OpFMul %float %398 %396 %400 = OpExtInst %float %1 FMax %float_n127 %399 %401 = OpFNegate %float %400 %402 = OpExtInst %float %1 Exp2 %401 %403 = OpFSub %float %float_1 %402 %404 = OpFDiv %float %403 %400 %405 = OpExtInst %float %1 Log %float_2 %406 = OpFMul %float %405 %405 %407 = OpFMul %float %float_0_5 %406 %408 = OpFMul %float %407 %400 %409 = OpFSub %float %405 %408 %410 = OpExtInst %float %1 FAbs %400 %411 = OpFOrdGreaterThan %bool %410 %float_0_00999999978 %412 = OpSelect %float %411 %404 %409 %413 = OpFMul %float %395 %412 %414 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_1 %int_1 %415 = OpLoad %float %414 %416 = OpFMul %float %415 %396 %417 = OpExtInst %float %1 FMax %float_n127 %416 %418 = OpFNegate %float %417 %419 = OpExtInst %float %1 Exp2 %418 %420 = OpFSub %float %float_1 %419 %421 = OpFDiv %float %420 %417 %422 = OpFMul %float %407 %417 %423 = OpFSub %float %405 %422 %424 = OpExtInst %float %1 FAbs %417 %425 = OpFOrdGreaterThan %bool %424 %float_0_00999999978 %426 = OpSelect %float %425 %421 %423 %427 = OpFMul %float %394 %426 %428 = OpFAdd %float %413 %427 %429 = OpFMul %float %428 %393 %430 = OpLoad %v4float %342 %431 = OpVectorShuffle %v3float %430 %430 0 1 2 %432 = OpAccessChain %_ptr_Uniform_v4float %MobileBasePass %int_4 %433 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_4 %int_3 %434 = OpLoad %float %433 %435 = OpFOrdGreaterThanEqual %bool %434 %float_0 OpSelectionMerge %436 DontFlatten OpBranchConditional %435 %437 %436 %437 = OpLabel %438 = OpAccessChain %_ptr_Uniform_v4float %MobileBasePass %int_5 %439 = OpLoad %v4float %438 %440 = OpVectorShuffle %v3float %439 %439 0 1 2 %441 = OpLoad %v4float %432 %442 = OpVectorShuffle %v3float %441 %441 0 1 2 %443 = OpDot %float %349 %442 %444 = OpExtInst %float %1 FClamp %443 %float_0 %float_1 %445 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_5 %int_3 %446 = OpLoad %float %445 %447 = OpExtInst %float %1 Pow %444 %446 %448 = OpCompositeConstruct %v3float %447 %447 %447 %449 = OpFMul %v3float %440 %448 %450 = OpFSub %float %393 %434 %451 = OpExtInst %float %1 FMax %450 %float_0 %452 = OpFMul %float %428 %451 %453 = OpFNegate %float %452 %454 = OpExtInst %float %1 Exp2 %453 %455 = OpExtInst %float %1 FClamp %454 %float_0 %float_1 %456 = OpFSub %float %float_1 %455 %457 = OpCompositeConstruct %v3float %456 %456 %456 %458 = OpFMul %v3float %449 %457 OpBranch %436 %436 = OpLabel %459 = OpPhi %v3float %63 %359 %458 %437 %460 = OpFNegate %float %429 %461 = OpExtInst %float %1 Exp2 %460 %462 = OpExtInst %float %1 FClamp %461 %float_0 %float_1 %463 = OpExtInst %float %1 FMax %462 %344 %464 = OpAccessChain %_ptr_Uniform_float %MobileBasePass %int_3 %int_3 %465 = OpLoad %float %464 %466 = OpFOrdGreaterThan %bool %465 %float_0 %467 = OpFOrdGreaterThan %bool %347 %465 %468 = OpLogicalAnd %bool %466 %467 %469 = OpCompositeConstruct %v3bool %468 %468 %468 %470 = OpSelect %v3float %469 %63 %459 %471 = OpSelect %float %468 %float_1 %463 %472 = OpFSub %float %float_1 %471 %473 = OpCompositeConstruct %v3float %472 %472 %472 %474 = OpFMul %v3float %431 %473 %475 = OpFAdd %v3float %474 %470 %476 = OpCompositeExtract %float %475 0 %477 = OpCompositeExtract %float %475 1 %478 = OpCompositeExtract %float %475 2 %479 = OpCompositeConstruct %v4float %476 %477 %478 %471 %480 = OpAccessChain %_ptr_Function_v4float %97 %int_0 OpStore %480 %479 %481 = OpCompositeExtract %float %339 3 %482 = OpCompositeInsert %v4float %481 %338 3 %483 = OpLoad %_arr_v4float_uint_1 %97 %484 = OpCompositeExtract %v4float %483 0 %485 = OpVectorShuffle %v4float %92 %484 0 1 4 5 %486 = OpVectorShuffle %v4float %92 %484 0 1 6 7 OpStore %out_var_TEXCOORD0 %337 OpStore %out_var_TEXCOORD1 %336 OpStore %out_var_TEXCOORD2 %485 OpStore %out_var_TEXCOORD3 %486 OpStore %out_var_TEXCOORD8 %482 OpStore %gl_Position %339 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders-ue4/asm/vert/texture-buffer.asm.vert000066400000000000000000001765541400026215700247300ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 397 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability StorageImageExtendedFormats OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %Main "main" %gl_VertexIndex %gl_InstanceIndex %in_var_ATTRIBUTE0 %out_var_TEXCOORD6 %gl_Position OpSource HLSL 600 OpName %type_View "type.View" OpMemberName %type_View 0 "View_TranslatedWorldToClip" OpMemberName %type_View 1 "View_WorldToClip" OpMemberName %type_View 2 "View_TranslatedWorldToView" OpMemberName %type_View 3 "View_ViewToTranslatedWorld" OpMemberName %type_View 4 "View_TranslatedWorldToCameraView" OpMemberName %type_View 5 "View_CameraViewToTranslatedWorld" OpMemberName %type_View 6 "View_ViewToClip" OpMemberName %type_View 7 "View_ViewToClipNoAA" OpMemberName %type_View 8 "View_ClipToView" OpMemberName %type_View 9 "View_ClipToTranslatedWorld" OpMemberName %type_View 10 "View_SVPositionToTranslatedWorld" OpMemberName %type_View 11 "View_ScreenToWorld" OpMemberName %type_View 12 "View_ScreenToTranslatedWorld" OpMemberName %type_View 13 "View_ViewForward" OpMemberName %type_View 14 "PrePadding_View_844" OpMemberName %type_View 15 "View_ViewUp" OpMemberName %type_View 16 "PrePadding_View_860" OpMemberName %type_View 17 "View_ViewRight" OpMemberName %type_View 18 "PrePadding_View_876" OpMemberName %type_View 19 "View_HMDViewNoRollUp" OpMemberName %type_View 20 "PrePadding_View_892" OpMemberName %type_View 21 "View_HMDViewNoRollRight" OpMemberName %type_View 22 "PrePadding_View_908" OpMemberName %type_View 23 "View_InvDeviceZToWorldZTransform" OpMemberName %type_View 24 "View_ScreenPositionScaleBias" OpMemberName %type_View 25 "View_WorldCameraOrigin" OpMemberName %type_View 26 "PrePadding_View_956" OpMemberName %type_View 27 "View_TranslatedWorldCameraOrigin" OpMemberName %type_View 28 "PrePadding_View_972" OpMemberName %type_View 29 "View_WorldViewOrigin" OpMemberName %type_View 30 "PrePadding_View_988" OpMemberName %type_View 31 "View_PreViewTranslation" OpMemberName %type_View 32 "PrePadding_View_1004" OpMemberName %type_View 33 "View_PrevProjection" OpMemberName %type_View 34 "View_PrevViewProj" OpMemberName %type_View 35 "View_PrevViewRotationProj" OpMemberName %type_View 36 "View_PrevViewToClip" OpMemberName %type_View 37 "View_PrevClipToView" OpMemberName %type_View 38 "View_PrevTranslatedWorldToClip" OpMemberName %type_View 39 "View_PrevTranslatedWorldToView" OpMemberName %type_View 40 "View_PrevViewToTranslatedWorld" OpMemberName %type_View 41 "View_PrevTranslatedWorldToCameraView" OpMemberName %type_View 42 "View_PrevCameraViewToTranslatedWorld" OpMemberName %type_View 43 "View_PrevWorldCameraOrigin" OpMemberName %type_View 44 "PrePadding_View_1660" OpMemberName %type_View 45 "View_PrevWorldViewOrigin" OpMemberName %type_View 46 "PrePadding_View_1676" OpMemberName %type_View 47 "View_PrevPreViewTranslation" OpMemberName %type_View 48 "PrePadding_View_1692" OpMemberName %type_View 49 "View_PrevInvViewProj" OpMemberName %type_View 50 "View_PrevScreenToTranslatedWorld" OpMemberName %type_View 51 "View_ClipToPrevClip" OpMemberName %type_View 52 "View_TemporalAAJitter" OpMemberName %type_View 53 "View_GlobalClippingPlane" OpMemberName %type_View 54 "View_FieldOfViewWideAngles" OpMemberName %type_View 55 "View_PrevFieldOfViewWideAngles" OpMemberName %type_View 56 "View_ViewRectMin" OpMemberName %type_View 57 "View_ViewSizeAndInvSize" OpMemberName %type_View 58 "View_BufferSizeAndInvSize" OpMemberName %type_View 59 "View_BufferBilinearUVMinMax" OpMemberName %type_View 60 "View_NumSceneColorMSAASamples" OpMemberName %type_View 61 "View_PreExposure" OpMemberName %type_View 62 "View_OneOverPreExposure" OpMemberName %type_View 63 "PrePadding_View_2012" OpMemberName %type_View 64 "View_DiffuseOverrideParameter" OpMemberName %type_View 65 "View_SpecularOverrideParameter" OpMemberName %type_View 66 "View_NormalOverrideParameter" OpMemberName %type_View 67 "View_RoughnessOverrideParameter" OpMemberName %type_View 68 "View_PrevFrameGameTime" OpMemberName %type_View 69 "View_PrevFrameRealTime" OpMemberName %type_View 70 "View_OutOfBoundsMask" OpMemberName %type_View 71 "PrePadding_View_2084" OpMemberName %type_View 72 "PrePadding_View_2088" OpMemberName %type_View 73 "PrePadding_View_2092" OpMemberName %type_View 74 "View_WorldCameraMovementSinceLastFrame" OpMemberName %type_View 75 "View_CullingSign" OpMemberName %type_View 76 "View_NearPlane" OpMemberName %type_View 77 "View_AdaptiveTessellationFactor" OpMemberName %type_View 78 "View_GameTime" OpMemberName %type_View 79 "View_RealTime" OpMemberName %type_View 80 "View_DeltaTime" OpMemberName %type_View 81 "View_MaterialTextureMipBias" OpMemberName %type_View 82 "View_MaterialTextureDerivativeMultiply" OpMemberName %type_View 83 "View_Random" OpMemberName %type_View 84 "View_FrameNumber" OpMemberName %type_View 85 "View_StateFrameIndexMod8" OpMemberName %type_View 86 "View_StateFrameIndex" OpMemberName %type_View 87 "View_CameraCut" OpMemberName %type_View 88 "View_UnlitViewmodeMask" OpMemberName %type_View 89 "PrePadding_View_2164" OpMemberName %type_View 90 "PrePadding_View_2168" OpMemberName %type_View 91 "PrePadding_View_2172" OpMemberName %type_View 92 "View_DirectionalLightColor" OpMemberName %type_View 93 "View_DirectionalLightDirection" OpMemberName %type_View 94 "PrePadding_View_2204" OpMemberName %type_View 95 "View_TranslucencyLightingVolumeMin" OpMemberName %type_View 96 "View_TranslucencyLightingVolumeInvSize" OpMemberName %type_View 97 "View_TemporalAAParams" OpMemberName %type_View 98 "View_CircleDOFParams" OpMemberName %type_View 99 "View_DepthOfFieldSensorWidth" OpMemberName %type_View 100 "View_DepthOfFieldFocalDistance" OpMemberName %type_View 101 "View_DepthOfFieldScale" OpMemberName %type_View 102 "View_DepthOfFieldFocalLength" OpMemberName %type_View 103 "View_DepthOfFieldFocalRegion" OpMemberName %type_View 104 "View_DepthOfFieldNearTransitionRegion" OpMemberName %type_View 105 "View_DepthOfFieldFarTransitionRegion" OpMemberName %type_View 106 "View_MotionBlurNormalizedToPixel" OpMemberName %type_View 107 "View_bSubsurfacePostprocessEnabled" OpMemberName %type_View 108 "View_GeneralPurposeTweak" OpMemberName %type_View 109 "View_DemosaicVposOffset" OpMemberName %type_View 110 "PrePadding_View_2348" OpMemberName %type_View 111 "View_IndirectLightingColorScale" OpMemberName %type_View 112 "View_HDR32bppEncodingMode" OpMemberName %type_View 113 "View_AtmosphericFogSunDirection" OpMemberName %type_View 114 "View_AtmosphericFogSunPower" OpMemberName %type_View 115 "View_AtmosphericFogPower" OpMemberName %type_View 116 "View_AtmosphericFogDensityScale" OpMemberName %type_View 117 "View_AtmosphericFogDensityOffset" OpMemberName %type_View 118 "View_AtmosphericFogGroundOffset" OpMemberName %type_View 119 "View_AtmosphericFogDistanceScale" OpMemberName %type_View 120 "View_AtmosphericFogAltitudeScale" OpMemberName %type_View 121 "View_AtmosphericFogHeightScaleRayleigh" OpMemberName %type_View 122 "View_AtmosphericFogStartDistance" OpMemberName %type_View 123 "View_AtmosphericFogDistanceOffset" OpMemberName %type_View 124 "View_AtmosphericFogSunDiscScale" OpMemberName %type_View 125 "View_AtmosphericFogRenderMask" OpMemberName %type_View 126 "View_AtmosphericFogInscatterAltitudeSampleNum" OpMemberName %type_View 127 "View_AtmosphericFogSunColor" OpMemberName %type_View 128 "View_NormalCurvatureToRoughnessScaleBias" OpMemberName %type_View 129 "View_RenderingReflectionCaptureMask" OpMemberName %type_View 130 "View_AmbientCubemapTint" OpMemberName %type_View 131 "View_AmbientCubemapIntensity" OpMemberName %type_View 132 "View_SkyLightParameters" OpMemberName %type_View 133 "PrePadding_View_2488" OpMemberName %type_View 134 "PrePadding_View_2492" OpMemberName %type_View 135 "View_SkyLightColor" OpMemberName %type_View 136 "View_SkyIrradianceEnvironmentMap" OpMemberName %type_View 137 "View_MobilePreviewMode" OpMemberName %type_View 138 "View_HMDEyePaddingOffset" OpMemberName %type_View 139 "View_ReflectionCubemapMaxMip" OpMemberName %type_View 140 "View_ShowDecalsMask" OpMemberName %type_View 141 "View_DistanceFieldAOSpecularOcclusionMode" OpMemberName %type_View 142 "View_IndirectCapsuleSelfShadowingIntensity" OpMemberName %type_View 143 "PrePadding_View_2648" OpMemberName %type_View 144 "PrePadding_View_2652" OpMemberName %type_View 145 "View_ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight" OpMemberName %type_View 146 "View_StereoPassIndex" OpMemberName %type_View 147 "View_GlobalVolumeCenterAndExtent" OpMemberName %type_View 148 "View_GlobalVolumeWorldToUVAddAndMul" OpMemberName %type_View 149 "View_GlobalVolumeDimension" OpMemberName %type_View 150 "View_GlobalVolumeTexelSize" OpMemberName %type_View 151 "View_MaxGlobalDistance" OpMemberName %type_View 152 "View_bCheckerboardSubsurfaceProfileRendering" OpMemberName %type_View 153 "View_VolumetricFogInvGridSize" OpMemberName %type_View 154 "PrePadding_View_2828" OpMemberName %type_View 155 "View_VolumetricFogGridZParams" OpMemberName %type_View 156 "PrePadding_View_2844" OpMemberName %type_View 157 "View_VolumetricFogSVPosToVolumeUV" OpMemberName %type_View 158 "View_VolumetricFogMaxDistance" OpMemberName %type_View 159 "PrePadding_View_2860" OpMemberName %type_View 160 "View_VolumetricLightmapWorldToUVScale" OpMemberName %type_View 161 "PrePadding_View_2876" OpMemberName %type_View 162 "View_VolumetricLightmapWorldToUVAdd" OpMemberName %type_View 163 "PrePadding_View_2892" OpMemberName %type_View 164 "View_VolumetricLightmapIndirectionTextureSize" OpMemberName %type_View 165 "View_VolumetricLightmapBrickSize" OpMemberName %type_View 166 "View_VolumetricLightmapBrickTexelSize" OpMemberName %type_View 167 "View_StereoIPD" OpMemberName %type_View 168 "View_IndirectLightingCacheShowFlag" OpMemberName %type_View 169 "View_EyeToPixelSpreadAngle" OpName %View "View" OpName %type_Primitive "type.Primitive" OpMemberName %type_Primitive 0 "Primitive_LocalToWorld" OpMemberName %type_Primitive 1 "Primitive_InvNonUniformScaleAndDeterminantSign" OpMemberName %type_Primitive 2 "Primitive_ObjectWorldPositionAndRadius" OpMemberName %type_Primitive 3 "Primitive_WorldToLocal" OpMemberName %type_Primitive 4 "Primitive_PreviousLocalToWorld" OpMemberName %type_Primitive 5 "Primitive_PreviousWorldToLocal" OpMemberName %type_Primitive 6 "Primitive_ActorWorldPosition" OpMemberName %type_Primitive 7 "Primitive_UseSingleSampleShadowFromStationaryLights" OpMemberName %type_Primitive 8 "Primitive_ObjectBounds" OpMemberName %type_Primitive 9 "Primitive_LpvBiasMultiplier" OpMemberName %type_Primitive 10 "Primitive_DecalReceiverMask" OpMemberName %type_Primitive 11 "Primitive_PerObjectGBufferData" OpMemberName %type_Primitive 12 "Primitive_UseVolumetricLightmapShadowFromStationaryLights" OpMemberName %type_Primitive 13 "Primitive_UseEditorDepthTest" OpMemberName %type_Primitive 14 "Primitive_ObjectOrientation" OpMemberName %type_Primitive 15 "Primitive_NonUniformScale" OpMemberName %type_Primitive 16 "Primitive_LocalObjectBoundsMin" OpMemberName %type_Primitive 17 "PrePadding_Primitive_380" OpMemberName %type_Primitive 18 "Primitive_LocalObjectBoundsMax" OpMemberName %type_Primitive 19 "Primitive_LightingChannelMask" OpMemberName %type_Primitive 20 "Primitive_LightmapDataIndex" OpMemberName %type_Primitive 21 "Primitive_SingleCaptureIndex" OpName %Primitive "Primitive" OpName %type_MobileShadowDepthPass "type.MobileShadowDepthPass" OpMemberName %type_MobileShadowDepthPass 0 "PrePadding_MobileShadowDepthPass_0" OpMemberName %type_MobileShadowDepthPass 1 "PrePadding_MobileShadowDepthPass_4" OpMemberName %type_MobileShadowDepthPass 2 "PrePadding_MobileShadowDepthPass_8" OpMemberName %type_MobileShadowDepthPass 3 "PrePadding_MobileShadowDepthPass_12" OpMemberName %type_MobileShadowDepthPass 4 "PrePadding_MobileShadowDepthPass_16" OpMemberName %type_MobileShadowDepthPass 5 "PrePadding_MobileShadowDepthPass_20" OpMemberName %type_MobileShadowDepthPass 6 "PrePadding_MobileShadowDepthPass_24" OpMemberName %type_MobileShadowDepthPass 7 "PrePadding_MobileShadowDepthPass_28" OpMemberName %type_MobileShadowDepthPass 8 "PrePadding_MobileShadowDepthPass_32" OpMemberName %type_MobileShadowDepthPass 9 "PrePadding_MobileShadowDepthPass_36" OpMemberName %type_MobileShadowDepthPass 10 "PrePadding_MobileShadowDepthPass_40" OpMemberName %type_MobileShadowDepthPass 11 "PrePadding_MobileShadowDepthPass_44" OpMemberName %type_MobileShadowDepthPass 12 "PrePadding_MobileShadowDepthPass_48" OpMemberName %type_MobileShadowDepthPass 13 "PrePadding_MobileShadowDepthPass_52" OpMemberName %type_MobileShadowDepthPass 14 "PrePadding_MobileShadowDepthPass_56" OpMemberName %type_MobileShadowDepthPass 15 "PrePadding_MobileShadowDepthPass_60" OpMemberName %type_MobileShadowDepthPass 16 "PrePadding_MobileShadowDepthPass_64" OpMemberName %type_MobileShadowDepthPass 17 "PrePadding_MobileShadowDepthPass_68" OpMemberName %type_MobileShadowDepthPass 18 "PrePadding_MobileShadowDepthPass_72" OpMemberName %type_MobileShadowDepthPass 19 "PrePadding_MobileShadowDepthPass_76" OpMemberName %type_MobileShadowDepthPass 20 "MobileShadowDepthPass_ProjectionMatrix" OpMemberName %type_MobileShadowDepthPass 21 "MobileShadowDepthPass_ShadowParams" OpMemberName %type_MobileShadowDepthPass 22 "MobileShadowDepthPass_bClampToNearPlane" OpMemberName %type_MobileShadowDepthPass 23 "PrePadding_MobileShadowDepthPass_156" OpMemberName %type_MobileShadowDepthPass 24 "MobileShadowDepthPass_ShadowViewProjectionMatrices" OpName %MobileShadowDepthPass "MobileShadowDepthPass" OpName %type_EmitterDynamicUniforms "type.EmitterDynamicUniforms" OpMemberName %type_EmitterDynamicUniforms 0 "EmitterDynamicUniforms_LocalToWorldScale" OpMemberName %type_EmitterDynamicUniforms 1 "EmitterDynamicUniforms_EmitterInstRandom" OpMemberName %type_EmitterDynamicUniforms 2 "PrePadding_EmitterDynamicUniforms_12" OpMemberName %type_EmitterDynamicUniforms 3 "EmitterDynamicUniforms_AxisLockRight" OpMemberName %type_EmitterDynamicUniforms 4 "EmitterDynamicUniforms_AxisLockUp" OpMemberName %type_EmitterDynamicUniforms 5 "EmitterDynamicUniforms_DynamicColor" OpMemberName %type_EmitterDynamicUniforms 6 "EmitterDynamicUniforms_MacroUVParameters" OpName %EmitterDynamicUniforms "EmitterDynamicUniforms" OpName %type_EmitterUniforms "type.EmitterUniforms" OpMemberName %type_EmitterUniforms 0 "EmitterUniforms_ColorCurve" OpMemberName %type_EmitterUniforms 1 "EmitterUniforms_ColorScale" OpMemberName %type_EmitterUniforms 2 "EmitterUniforms_ColorBias" OpMemberName %type_EmitterUniforms 3 "EmitterUniforms_MiscCurve" OpMemberName %type_EmitterUniforms 4 "EmitterUniforms_MiscScale" OpMemberName %type_EmitterUniforms 5 "EmitterUniforms_MiscBias" OpMemberName %type_EmitterUniforms 6 "EmitterUniforms_SizeBySpeed" OpMemberName %type_EmitterUniforms 7 "EmitterUniforms_SubImageSize" OpMemberName %type_EmitterUniforms 8 "EmitterUniforms_TangentSelector" OpMemberName %type_EmitterUniforms 9 "EmitterUniforms_CameraFacingBlend" OpMemberName %type_EmitterUniforms 10 "EmitterUniforms_RemoveHMDRoll" OpMemberName %type_EmitterUniforms 11 "EmitterUniforms_RotationRateScale" OpMemberName %type_EmitterUniforms 12 "EmitterUniforms_RotationBias" OpMemberName %type_EmitterUniforms 13 "EmitterUniforms_CameraMotionBlurAmount" OpMemberName %type_EmitterUniforms 14 "PrePadding_EmitterUniforms_172" OpMemberName %type_EmitterUniforms 15 "EmitterUniforms_PivotOffset" OpName %EmitterUniforms "EmitterUniforms" OpName %type_buffer_image "type.buffer.image" OpName %ParticleIndices "ParticleIndices" OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "ParticleIndicesOffset" OpName %_Globals "$Globals" OpName %type_2d_image "type.2d.image" OpName %PositionTexture "PositionTexture" OpName %type_sampler "type.sampler" OpName %PositionTextureSampler "PositionTextureSampler" OpName %VelocityTexture "VelocityTexture" OpName %VelocityTextureSampler "VelocityTextureSampler" OpName %AttributesTexture "AttributesTexture" OpName %AttributesTextureSampler "AttributesTextureSampler" OpName %CurveTexture "CurveTexture" OpName %CurveTextureSampler "CurveTextureSampler" OpName %in_var_ATTRIBUTE0 "in.var.ATTRIBUTE0" OpName %out_var_TEXCOORD6 "out.var.TEXCOORD6" OpName %Main "Main" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpDecorateString %gl_VertexIndex UserSemantic "SV_VertexID" OpDecorate %gl_InstanceIndex BuiltIn InstanceIndex OpDecorateString %gl_InstanceIndex UserSemantic "SV_InstanceID" OpDecorateString %in_var_ATTRIBUTE0 UserSemantic "ATTRIBUTE0" OpDecorateString %out_var_TEXCOORD6 UserSemantic "TEXCOORD6" OpDecorate %gl_Position BuiltIn Position OpDecorateString %gl_Position UserSemantic "SV_POSITION" OpDecorate %in_var_ATTRIBUTE0 Location 0 OpDecorate %out_var_TEXCOORD6 Location 0 OpDecorate %View DescriptorSet 0 OpDecorate %View Binding 1 OpDecorate %Primitive DescriptorSet 0 OpDecorate %Primitive Binding 2 OpDecorate %MobileShadowDepthPass DescriptorSet 0 OpDecorate %MobileShadowDepthPass Binding 3 OpDecorate %EmitterDynamicUniforms DescriptorSet 0 OpDecorate %EmitterDynamicUniforms Binding 4 OpDecorate %EmitterUniforms DescriptorSet 0 OpDecorate %EmitterUniforms Binding 5 OpDecorate %ParticleIndices DescriptorSet 0 OpDecorate %ParticleIndices Binding 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 6 OpDecorate %PositionTexture DescriptorSet 0 OpDecorate %PositionTexture Binding 1 OpDecorate %PositionTextureSampler DescriptorSet 0 OpDecorate %PositionTextureSampler Binding 0 OpDecorate %VelocityTexture DescriptorSet 0 OpDecorate %VelocityTexture Binding 2 OpDecorate %VelocityTextureSampler DescriptorSet 0 OpDecorate %VelocityTextureSampler Binding 1 OpDecorate %AttributesTexture DescriptorSet 0 OpDecorate %AttributesTexture Binding 3 OpDecorate %AttributesTextureSampler DescriptorSet 0 OpDecorate %AttributesTextureSampler Binding 2 OpDecorate %CurveTexture DescriptorSet 0 OpDecorate %CurveTexture Binding 4 OpDecorate %CurveTextureSampler DescriptorSet 0 OpDecorate %CurveTextureSampler Binding 3 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr_v4float_uint_7 ArrayStride 16 OpDecorate %_arr_v4float_uint_4 ArrayStride 16 OpMemberDecorate %type_View 0 Offset 0 OpMemberDecorate %type_View 0 MatrixStride 16 OpMemberDecorate %type_View 0 ColMajor OpMemberDecorate %type_View 1 Offset 64 OpMemberDecorate %type_View 1 MatrixStride 16 OpMemberDecorate %type_View 1 ColMajor OpMemberDecorate %type_View 2 Offset 128 OpMemberDecorate %type_View 2 MatrixStride 16 OpMemberDecorate %type_View 2 ColMajor OpMemberDecorate %type_View 3 Offset 192 OpMemberDecorate %type_View 3 MatrixStride 16 OpMemberDecorate %type_View 3 ColMajor OpMemberDecorate %type_View 4 Offset 256 OpMemberDecorate %type_View 4 MatrixStride 16 OpMemberDecorate %type_View 4 ColMajor OpMemberDecorate %type_View 5 Offset 320 OpMemberDecorate %type_View 5 MatrixStride 16 OpMemberDecorate %type_View 5 ColMajor OpMemberDecorate %type_View 6 Offset 384 OpMemberDecorate %type_View 6 MatrixStride 16 OpMemberDecorate %type_View 6 ColMajor OpMemberDecorate %type_View 7 Offset 448 OpMemberDecorate %type_View 7 MatrixStride 16 OpMemberDecorate %type_View 7 ColMajor OpMemberDecorate %type_View 8 Offset 512 OpMemberDecorate %type_View 8 MatrixStride 16 OpMemberDecorate %type_View 8 ColMajor OpMemberDecorate %type_View 9 Offset 576 OpMemberDecorate %type_View 9 MatrixStride 16 OpMemberDecorate %type_View 9 ColMajor OpMemberDecorate %type_View 10 Offset 640 OpMemberDecorate %type_View 10 MatrixStride 16 OpMemberDecorate %type_View 10 ColMajor OpMemberDecorate %type_View 11 Offset 704 OpMemberDecorate %type_View 11 MatrixStride 16 OpMemberDecorate %type_View 11 ColMajor OpMemberDecorate %type_View 12 Offset 768 OpMemberDecorate %type_View 12 MatrixStride 16 OpMemberDecorate %type_View 12 ColMajor OpMemberDecorate %type_View 13 Offset 832 OpMemberDecorate %type_View 14 Offset 844 OpMemberDecorate %type_View 15 Offset 848 OpMemberDecorate %type_View 16 Offset 860 OpMemberDecorate %type_View 17 Offset 864 OpMemberDecorate %type_View 18 Offset 876 OpMemberDecorate %type_View 19 Offset 880 OpMemberDecorate %type_View 20 Offset 892 OpMemberDecorate %type_View 21 Offset 896 OpMemberDecorate %type_View 22 Offset 908 OpMemberDecorate %type_View 23 Offset 912 OpMemberDecorate %type_View 24 Offset 928 OpMemberDecorate %type_View 25 Offset 944 OpMemberDecorate %type_View 26 Offset 956 OpMemberDecorate %type_View 27 Offset 960 OpMemberDecorate %type_View 28 Offset 972 OpMemberDecorate %type_View 29 Offset 976 OpMemberDecorate %type_View 30 Offset 988 OpMemberDecorate %type_View 31 Offset 992 OpMemberDecorate %type_View 32 Offset 1004 OpMemberDecorate %type_View 33 Offset 1008 OpMemberDecorate %type_View 33 MatrixStride 16 OpMemberDecorate %type_View 33 ColMajor OpMemberDecorate %type_View 34 Offset 1072 OpMemberDecorate %type_View 34 MatrixStride 16 OpMemberDecorate %type_View 34 ColMajor OpMemberDecorate %type_View 35 Offset 1136 OpMemberDecorate %type_View 35 MatrixStride 16 OpMemberDecorate %type_View 35 ColMajor OpMemberDecorate %type_View 36 Offset 1200 OpMemberDecorate %type_View 36 MatrixStride 16 OpMemberDecorate %type_View 36 ColMajor OpMemberDecorate %type_View 37 Offset 1264 OpMemberDecorate %type_View 37 MatrixStride 16 OpMemberDecorate %type_View 37 ColMajor OpMemberDecorate %type_View 38 Offset 1328 OpMemberDecorate %type_View 38 MatrixStride 16 OpMemberDecorate %type_View 38 ColMajor OpMemberDecorate %type_View 39 Offset 1392 OpMemberDecorate %type_View 39 MatrixStride 16 OpMemberDecorate %type_View 39 ColMajor OpMemberDecorate %type_View 40 Offset 1456 OpMemberDecorate %type_View 40 MatrixStride 16 OpMemberDecorate %type_View 40 ColMajor OpMemberDecorate %type_View 41 Offset 1520 OpMemberDecorate %type_View 41 MatrixStride 16 OpMemberDecorate %type_View 41 ColMajor OpMemberDecorate %type_View 42 Offset 1584 OpMemberDecorate %type_View 42 MatrixStride 16 OpMemberDecorate %type_View 42 ColMajor OpMemberDecorate %type_View 43 Offset 1648 OpMemberDecorate %type_View 44 Offset 1660 OpMemberDecorate %type_View 45 Offset 1664 OpMemberDecorate %type_View 46 Offset 1676 OpMemberDecorate %type_View 47 Offset 1680 OpMemberDecorate %type_View 48 Offset 1692 OpMemberDecorate %type_View 49 Offset 1696 OpMemberDecorate %type_View 49 MatrixStride 16 OpMemberDecorate %type_View 49 ColMajor OpMemberDecorate %type_View 50 Offset 1760 OpMemberDecorate %type_View 50 MatrixStride 16 OpMemberDecorate %type_View 50 ColMajor OpMemberDecorate %type_View 51 Offset 1824 OpMemberDecorate %type_View 51 MatrixStride 16 OpMemberDecorate %type_View 51 ColMajor OpMemberDecorate %type_View 52 Offset 1888 OpMemberDecorate %type_View 53 Offset 1904 OpMemberDecorate %type_View 54 Offset 1920 OpMemberDecorate %type_View 55 Offset 1928 OpMemberDecorate %type_View 56 Offset 1936 OpMemberDecorate %type_View 57 Offset 1952 OpMemberDecorate %type_View 58 Offset 1968 OpMemberDecorate %type_View 59 Offset 1984 OpMemberDecorate %type_View 60 Offset 2000 OpMemberDecorate %type_View 61 Offset 2004 OpMemberDecorate %type_View 62 Offset 2008 OpMemberDecorate %type_View 63 Offset 2012 OpMemberDecorate %type_View 64 Offset 2016 OpMemberDecorate %type_View 65 Offset 2032 OpMemberDecorate %type_View 66 Offset 2048 OpMemberDecorate %type_View 67 Offset 2064 OpMemberDecorate %type_View 68 Offset 2072 OpMemberDecorate %type_View 69 Offset 2076 OpMemberDecorate %type_View 70 Offset 2080 OpMemberDecorate %type_View 71 Offset 2084 OpMemberDecorate %type_View 72 Offset 2088 OpMemberDecorate %type_View 73 Offset 2092 OpMemberDecorate %type_View 74 Offset 2096 OpMemberDecorate %type_View 75 Offset 2108 OpMemberDecorate %type_View 76 Offset 2112 OpMemberDecorate %type_View 77 Offset 2116 OpMemberDecorate %type_View 78 Offset 2120 OpMemberDecorate %type_View 79 Offset 2124 OpMemberDecorate %type_View 80 Offset 2128 OpMemberDecorate %type_View 81 Offset 2132 OpMemberDecorate %type_View 82 Offset 2136 OpMemberDecorate %type_View 83 Offset 2140 OpMemberDecorate %type_View 84 Offset 2144 OpMemberDecorate %type_View 85 Offset 2148 OpMemberDecorate %type_View 86 Offset 2152 OpMemberDecorate %type_View 87 Offset 2156 OpMemberDecorate %type_View 88 Offset 2160 OpMemberDecorate %type_View 89 Offset 2164 OpMemberDecorate %type_View 90 Offset 2168 OpMemberDecorate %type_View 91 Offset 2172 OpMemberDecorate %type_View 92 Offset 2176 OpMemberDecorate %type_View 93 Offset 2192 OpMemberDecorate %type_View 94 Offset 2204 OpMemberDecorate %type_View 95 Offset 2208 OpMemberDecorate %type_View 96 Offset 2240 OpMemberDecorate %type_View 97 Offset 2272 OpMemberDecorate %type_View 98 Offset 2288 OpMemberDecorate %type_View 99 Offset 2304 OpMemberDecorate %type_View 100 Offset 2308 OpMemberDecorate %type_View 101 Offset 2312 OpMemberDecorate %type_View 102 Offset 2316 OpMemberDecorate %type_View 103 Offset 2320 OpMemberDecorate %type_View 104 Offset 2324 OpMemberDecorate %type_View 105 Offset 2328 OpMemberDecorate %type_View 106 Offset 2332 OpMemberDecorate %type_View 107 Offset 2336 OpMemberDecorate %type_View 108 Offset 2340 OpMemberDecorate %type_View 109 Offset 2344 OpMemberDecorate %type_View 110 Offset 2348 OpMemberDecorate %type_View 111 Offset 2352 OpMemberDecorate %type_View 112 Offset 2364 OpMemberDecorate %type_View 113 Offset 2368 OpMemberDecorate %type_View 114 Offset 2380 OpMemberDecorate %type_View 115 Offset 2384 OpMemberDecorate %type_View 116 Offset 2388 OpMemberDecorate %type_View 117 Offset 2392 OpMemberDecorate %type_View 118 Offset 2396 OpMemberDecorate %type_View 119 Offset 2400 OpMemberDecorate %type_View 120 Offset 2404 OpMemberDecorate %type_View 121 Offset 2408 OpMemberDecorate %type_View 122 Offset 2412 OpMemberDecorate %type_View 123 Offset 2416 OpMemberDecorate %type_View 124 Offset 2420 OpMemberDecorate %type_View 125 Offset 2424 OpMemberDecorate %type_View 126 Offset 2428 OpMemberDecorate %type_View 127 Offset 2432 OpMemberDecorate %type_View 128 Offset 2448 OpMemberDecorate %type_View 129 Offset 2460 OpMemberDecorate %type_View 130 Offset 2464 OpMemberDecorate %type_View 131 Offset 2480 OpMemberDecorate %type_View 132 Offset 2484 OpMemberDecorate %type_View 133 Offset 2488 OpMemberDecorate %type_View 134 Offset 2492 OpMemberDecorate %type_View 135 Offset 2496 OpMemberDecorate %type_View 136 Offset 2512 OpMemberDecorate %type_View 137 Offset 2624 OpMemberDecorate %type_View 138 Offset 2628 OpMemberDecorate %type_View 139 Offset 2632 OpMemberDecorate %type_View 140 Offset 2636 OpMemberDecorate %type_View 141 Offset 2640 OpMemberDecorate %type_View 142 Offset 2644 OpMemberDecorate %type_View 143 Offset 2648 OpMemberDecorate %type_View 144 Offset 2652 OpMemberDecorate %type_View 145 Offset 2656 OpMemberDecorate %type_View 146 Offset 2668 OpMemberDecorate %type_View 147 Offset 2672 OpMemberDecorate %type_View 148 Offset 2736 OpMemberDecorate %type_View 149 Offset 2800 OpMemberDecorate %type_View 150 Offset 2804 OpMemberDecorate %type_View 151 Offset 2808 OpMemberDecorate %type_View 152 Offset 2812 OpMemberDecorate %type_View 153 Offset 2816 OpMemberDecorate %type_View 154 Offset 2828 OpMemberDecorate %type_View 155 Offset 2832 OpMemberDecorate %type_View 156 Offset 2844 OpMemberDecorate %type_View 157 Offset 2848 OpMemberDecorate %type_View 158 Offset 2856 OpMemberDecorate %type_View 159 Offset 2860 OpMemberDecorate %type_View 160 Offset 2864 OpMemberDecorate %type_View 161 Offset 2876 OpMemberDecorate %type_View 162 Offset 2880 OpMemberDecorate %type_View 163 Offset 2892 OpMemberDecorate %type_View 164 Offset 2896 OpMemberDecorate %type_View 165 Offset 2908 OpMemberDecorate %type_View 166 Offset 2912 OpMemberDecorate %type_View 167 Offset 2924 OpMemberDecorate %type_View 168 Offset 2928 OpMemberDecorate %type_View 169 Offset 2932 OpDecorate %type_View Block OpMemberDecorate %type_Primitive 0 Offset 0 OpMemberDecorate %type_Primitive 0 MatrixStride 16 OpMemberDecorate %type_Primitive 0 ColMajor OpMemberDecorate %type_Primitive 1 Offset 64 OpMemberDecorate %type_Primitive 2 Offset 80 OpMemberDecorate %type_Primitive 3 Offset 96 OpMemberDecorate %type_Primitive 3 MatrixStride 16 OpMemberDecorate %type_Primitive 3 ColMajor OpMemberDecorate %type_Primitive 4 Offset 160 OpMemberDecorate %type_Primitive 4 MatrixStride 16 OpMemberDecorate %type_Primitive 4 ColMajor OpMemberDecorate %type_Primitive 5 Offset 224 OpMemberDecorate %type_Primitive 5 MatrixStride 16 OpMemberDecorate %type_Primitive 5 ColMajor OpMemberDecorate %type_Primitive 6 Offset 288 OpMemberDecorate %type_Primitive 7 Offset 300 OpMemberDecorate %type_Primitive 8 Offset 304 OpMemberDecorate %type_Primitive 9 Offset 316 OpMemberDecorate %type_Primitive 10 Offset 320 OpMemberDecorate %type_Primitive 11 Offset 324 OpMemberDecorate %type_Primitive 12 Offset 328 OpMemberDecorate %type_Primitive 13 Offset 332 OpMemberDecorate %type_Primitive 14 Offset 336 OpMemberDecorate %type_Primitive 15 Offset 352 OpMemberDecorate %type_Primitive 16 Offset 368 OpMemberDecorate %type_Primitive 17 Offset 380 OpMemberDecorate %type_Primitive 18 Offset 384 OpMemberDecorate %type_Primitive 19 Offset 396 OpMemberDecorate %type_Primitive 20 Offset 400 OpMemberDecorate %type_Primitive 21 Offset 404 OpDecorate %type_Primitive Block OpDecorate %_arr_mat4v4float_uint_6 ArrayStride 64 OpMemberDecorate %type_MobileShadowDepthPass 0 Offset 0 OpMemberDecorate %type_MobileShadowDepthPass 1 Offset 4 OpMemberDecorate %type_MobileShadowDepthPass 2 Offset 8 OpMemberDecorate %type_MobileShadowDepthPass 3 Offset 12 OpMemberDecorate %type_MobileShadowDepthPass 4 Offset 16 OpMemberDecorate %type_MobileShadowDepthPass 5 Offset 20 OpMemberDecorate %type_MobileShadowDepthPass 6 Offset 24 OpMemberDecorate %type_MobileShadowDepthPass 7 Offset 28 OpMemberDecorate %type_MobileShadowDepthPass 8 Offset 32 OpMemberDecorate %type_MobileShadowDepthPass 9 Offset 36 OpMemberDecorate %type_MobileShadowDepthPass 10 Offset 40 OpMemberDecorate %type_MobileShadowDepthPass 11 Offset 44 OpMemberDecorate %type_MobileShadowDepthPass 12 Offset 48 OpMemberDecorate %type_MobileShadowDepthPass 13 Offset 52 OpMemberDecorate %type_MobileShadowDepthPass 14 Offset 56 OpMemberDecorate %type_MobileShadowDepthPass 15 Offset 60 OpMemberDecorate %type_MobileShadowDepthPass 16 Offset 64 OpMemberDecorate %type_MobileShadowDepthPass 17 Offset 68 OpMemberDecorate %type_MobileShadowDepthPass 18 Offset 72 OpMemberDecorate %type_MobileShadowDepthPass 19 Offset 76 OpMemberDecorate %type_MobileShadowDepthPass 20 Offset 80 OpMemberDecorate %type_MobileShadowDepthPass 20 MatrixStride 16 OpMemberDecorate %type_MobileShadowDepthPass 20 ColMajor OpMemberDecorate %type_MobileShadowDepthPass 21 Offset 144 OpMemberDecorate %type_MobileShadowDepthPass 22 Offset 152 OpMemberDecorate %type_MobileShadowDepthPass 23 Offset 156 OpMemberDecorate %type_MobileShadowDepthPass 24 Offset 160 OpMemberDecorate %type_MobileShadowDepthPass 24 MatrixStride 16 OpMemberDecorate %type_MobileShadowDepthPass 24 ColMajor OpDecorate %type_MobileShadowDepthPass Block OpMemberDecorate %type_EmitterDynamicUniforms 0 Offset 0 OpMemberDecorate %type_EmitterDynamicUniforms 1 Offset 8 OpMemberDecorate %type_EmitterDynamicUniforms 2 Offset 12 OpMemberDecorate %type_EmitterDynamicUniforms 3 Offset 16 OpMemberDecorate %type_EmitterDynamicUniforms 4 Offset 32 OpMemberDecorate %type_EmitterDynamicUniforms 5 Offset 48 OpMemberDecorate %type_EmitterDynamicUniforms 6 Offset 64 OpDecorate %type_EmitterDynamicUniforms Block OpMemberDecorate %type_EmitterUniforms 0 Offset 0 OpMemberDecorate %type_EmitterUniforms 1 Offset 16 OpMemberDecorate %type_EmitterUniforms 2 Offset 32 OpMemberDecorate %type_EmitterUniforms 3 Offset 48 OpMemberDecorate %type_EmitterUniforms 4 Offset 64 OpMemberDecorate %type_EmitterUniforms 5 Offset 80 OpMemberDecorate %type_EmitterUniforms 6 Offset 96 OpMemberDecorate %type_EmitterUniforms 7 Offset 112 OpMemberDecorate %type_EmitterUniforms 8 Offset 128 OpMemberDecorate %type_EmitterUniforms 9 Offset 144 OpMemberDecorate %type_EmitterUniforms 10 Offset 156 OpMemberDecorate %type_EmitterUniforms 11 Offset 160 OpMemberDecorate %type_EmitterUniforms 12 Offset 164 OpMemberDecorate %type_EmitterUniforms 13 Offset 168 OpMemberDecorate %type_EmitterUniforms 14 Offset 172 OpMemberDecorate %type_EmitterUniforms 15 Offset 176 OpDecorate %type_EmitterUniforms Block OpMemberDecorate %type__Globals 0 Offset 0 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_7 = OpConstant %uint 7 %uint_4 = OpConstant %uint 4 %float_0 = OpConstant %float 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint_16 = OpConstant %uint 16 %int_3 = OpConstant %int 3 %float_1 = OpConstant %float 1 %float_9_99999975en05 = OpConstant %float 9.99999975e-05 %54 = OpConstantComposite %v3float %float_0 %float_0 %float_9_99999975en05 %int_2 = OpConstant %int 2 %int_5 = OpConstant %int 5 %int_4 = OpConstant %int 4 %float_0_5 = OpConstant %float 0.5 %float_n0_5 = OpConstant %float -0.5 %float_2 = OpConstant %float 2 %61 = OpConstantComposite %v2float %float_2 %float_2 %int_6 = OpConstant %int 6 %63 = OpConstantComposite %v2float %float_1 %float_1 %int_11 = OpConstant %int 11 %int_15 = OpConstant %int 15 %int_8 = OpConstant %int 8 %int_9 = OpConstant %int 9 %int_10 = OpConstant %int 10 %int_12 = OpConstant %int 12 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %mat3v3float = OpTypeMatrix %v3float 3 %int_20 = OpConstant %int 20 %int_22 = OpConstant %int 22 %float_9_99999997en07 = OpConstant %float 9.99999997e-07 %int_21 = OpConstant %int 21 %int_17 = OpConstant %int 17 %int_19 = OpConstant %int 19 %int_27 = OpConstant %int 27 %int_31 = OpConstant %int 31 %uint_3 = OpConstant %uint 3 %82 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %float_0_00999999978 = OpConstant %float 0.00999999978 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr_v4float_uint_7 = OpTypeArray %v4float %uint_7 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %type_View = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v4float %v4float %v3float %float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %v3float %float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %v2float %v2float %v4float %v4float %v4float %v4float %int %float %float %float %v4float %v4float %v4float %v2float %float %float %float %float %float %float %v3float %float %float %float %float %float %float %float %float %uint %uint %uint %uint %float %float %float %float %float %v4float %v3float %float %_arr_v4float_uint_2 %_arr_v4float_uint_2 %v4float %v4float %float %float %float %float %float %float %float %float %float %float %float %float %v3float %float %v3float %float %float %float %float %float %float %float %float %float %float %float %uint %uint %v4float %v3float %float %v4float %float %float %float %float %v4float %_arr_v4float_uint_7 %float %float %float %float %uint %float %float %float %v3float %int %_arr_v4float_uint_4 %_arr_v4float_uint_4 %float %float %float %float %v3float %float %v3float %float %v2float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %_ptr_Uniform_type_View = OpTypePointer Uniform %type_View %type_Primitive = OpTypeStruct %mat4v4float %v4float %v4float %mat4v4float %mat4v4float %mat4v4float %v3float %float %v3float %float %float %float %float %float %v4float %v4float %v3float %float %v3float %uint %uint %int %_ptr_Uniform_type_Primitive = OpTypePointer Uniform %type_Primitive %uint_6 = OpConstant %uint 6 %_arr_mat4v4float_uint_6 = OpTypeArray %mat4v4float %uint_6 %type_MobileShadowDepthPass = OpTypeStruct %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %float %mat4v4float %v2float %float %float %_arr_mat4v4float_uint_6 %_ptr_Uniform_type_MobileShadowDepthPass = OpTypePointer Uniform %type_MobileShadowDepthPass %type_EmitterDynamicUniforms = OpTypeStruct %v2float %float %float %v4float %v4float %v4float %v4float %_ptr_Uniform_type_EmitterDynamicUniforms = OpTypePointer Uniform %type_EmitterDynamicUniforms %type_EmitterUniforms = OpTypeStruct %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v4float %v3float %float %float %float %float %float %v2float %_ptr_Uniform_type_EmitterUniforms = OpTypePointer Uniform %type_EmitterUniforms %type_buffer_image = OpTypeImage %float Buffer 2 0 0 1 Rg32f %_ptr_UniformConstant_type_buffer_image = OpTypePointer UniformConstant %type_buffer_image %type__Globals = OpTypeStruct %uint %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Output_float = OpTypePointer Output %float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %99 = OpTypeFunction %void %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %bool = OpTypeBool %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %type_sampled_image = OpTypeSampledImage %type_2d_image %View = OpVariable %_ptr_Uniform_type_View Uniform %Primitive = OpVariable %_ptr_Uniform_type_Primitive Uniform %MobileShadowDepthPass = OpVariable %_ptr_Uniform_type_MobileShadowDepthPass Uniform %EmitterDynamicUniforms = OpVariable %_ptr_Uniform_type_EmitterDynamicUniforms Uniform %EmitterUniforms = OpVariable %_ptr_Uniform_type_EmitterUniforms Uniform %ParticleIndices = OpVariable %_ptr_UniformConstant_type_buffer_image UniformConstant %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %PositionTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %PositionTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %VelocityTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %VelocityTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %AttributesTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %AttributesTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %CurveTexture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %CurveTextureSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %gl_VertexIndex = OpVariable %_ptr_Input_uint Input %gl_InstanceIndex = OpVariable %_ptr_Input_uint Input %in_var_ATTRIBUTE0 = OpVariable %_ptr_Input_v2float Input %out_var_TEXCOORD6 = OpVariable %_ptr_Output_float Output %gl_Position = OpVariable %_ptr_Output_v4float Output %float_6_28318548 = OpConstant %float 6.28318548 %108 = OpConstantNull %v3float %Main = OpFunction %void None %99 %109 = OpLabel %110 = OpLoad %uint %gl_VertexIndex %111 = OpLoad %uint %gl_InstanceIndex %112 = OpLoad %v2float %in_var_ATTRIBUTE0 %113 = OpAccessChain %_ptr_Uniform_v3float %View %int_15 %114 = OpLoad %v3float %113 %115 = OpAccessChain %_ptr_Uniform_v3float %View %int_17 %116 = OpLoad %v3float %115 %117 = OpAccessChain %_ptr_Uniform_v3float %View %int_19 %118 = OpLoad %v3float %117 %119 = OpAccessChain %_ptr_Uniform_v3float %View %int_21 %120 = OpLoad %v3float %119 %121 = OpAccessChain %_ptr_Uniform_v3float %View %int_27 %122 = OpLoad %v3float %121 %123 = OpAccessChain %_ptr_Uniform_v3float %View %int_31 %124 = OpLoad %v3float %123 %125 = OpIMul %uint %111 %uint_16 %126 = OpUDiv %uint %110 %uint_4 %127 = OpIAdd %uint %125 %126 %128 = OpAccessChain %_ptr_Uniform_uint %_Globals %int_0 %129 = OpLoad %uint %128 %130 = OpIAdd %uint %129 %127 %131 = OpLoad %type_buffer_image %ParticleIndices %132 = OpImageFetch %v4float %131 %130 None %133 = OpVectorShuffle %v2float %132 %132 0 1 %134 = OpLoad %type_2d_image %PositionTexture %135 = OpLoad %type_sampler %PositionTextureSampler %136 = OpSampledImage %type_sampled_image %134 %135 %137 = OpImageSampleExplicitLod %v4float %136 %133 Lod %float_0 %138 = OpLoad %type_2d_image %VelocityTexture %139 = OpLoad %type_sampler %VelocityTextureSampler %140 = OpSampledImage %type_sampled_image %138 %139 %141 = OpImageSampleExplicitLod %v4float %140 %133 Lod %float_0 %142 = OpLoad %type_2d_image %AttributesTexture %143 = OpLoad %type_sampler %AttributesTextureSampler %144 = OpSampledImage %type_sampled_image %142 %143 %145 = OpImageSampleExplicitLod %v4float %144 %133 Lod %float_0 %146 = OpCompositeExtract %float %137 3 %147 = OpExtInst %float %1 Step %146 %float_1 %148 = OpVectorShuffle %v3float %141 %141 0 1 2 %149 = OpAccessChain %_ptr_Uniform_mat4v4float %Primitive %int_0 %150 = OpLoad %mat4v4float %149 %151 = OpCompositeExtract %v4float %150 0 %152 = OpVectorShuffle %v3float %151 %151 0 1 2 %153 = OpCompositeExtract %v4float %150 1 %154 = OpVectorShuffle %v3float %153 %153 0 1 2 %155 = OpCompositeExtract %v4float %150 2 %156 = OpVectorShuffle %v3float %155 %155 0 1 2 %157 = OpCompositeConstruct %mat3v3float %152 %154 %156 %158 = OpMatrixTimesVector %v3float %157 %148 %159 = OpFAdd %v3float %158 %54 %160 = OpExtInst %v3float %1 Normalize %159 %161 = OpExtInst %float %1 Length %158 %162 = OpAccessChain %_ptr_Uniform_v4float %EmitterUniforms %int_3 %163 = OpLoad %v4float %162 %164 = OpVectorShuffle %v2float %163 %163 0 1 %165 = OpVectorShuffle %v2float %163 %163 2 3 %166 = OpCompositeConstruct %v2float %146 %146 %167 = OpFMul %v2float %165 %166 %168 = OpFAdd %v2float %164 %167 %169 = OpLoad %type_2d_image %CurveTexture %170 = OpLoad %type_sampler %CurveTextureSampler %171 = OpSampledImage %type_sampled_image %169 %170 %172 = OpImageSampleExplicitLod %v4float %171 %168 Lod %float_0 %173 = OpAccessChain %_ptr_Uniform_v4float %EmitterUniforms %int_4 %174 = OpLoad %v4float %173 %175 = OpFMul %v4float %172 %174 %176 = OpAccessChain %_ptr_Uniform_v4float %EmitterUniforms %int_5 %177 = OpLoad %v4float %176 %178 = OpFAdd %v4float %175 %177 %179 = OpCompositeExtract %float %145 0 %180 = OpFOrdLessThan %bool %179 %float_0_5 %181 = OpSelect %float %180 %float_0 %float_n0_5 %182 = OpCompositeExtract %float %145 1 %183 = OpFOrdLessThan %bool %182 %float_0_5 %184 = OpSelect %float %183 %float_0 %float_n0_5 %185 = OpCompositeConstruct %v2float %181 %184 %186 = OpVectorShuffle %v2float %145 %145 0 1 %187 = OpFAdd %v2float %186 %185 %188 = OpFMul %v2float %187 %61 %189 = OpVectorShuffle %v2float %178 %178 0 1 %190 = OpAccessChain %_ptr_Uniform_v2float %EmitterDynamicUniforms %int_0 %191 = OpLoad %v2float %190 %192 = OpFMul %v2float %189 %191 %193 = OpAccessChain %_ptr_Uniform_v4float %EmitterUniforms %int_6 %194 = OpLoad %v4float %193 %195 = OpVectorShuffle %v2float %194 %194 0 1 %196 = OpCompositeConstruct %v2float %161 %161 %197 = OpFMul %v2float %195 %196 %198 = OpExtInst %v2float %1 FMax %197 %63 %199 = OpVectorShuffle %v2float %194 %194 2 3 %200 = OpExtInst %v2float %1 FMin %198 %199 %201 = OpFMul %v2float %188 %192 %202 = OpFMul %v2float %201 %200 %203 = OpCompositeConstruct %v2float %147 %147 %204 = OpFMul %v2float %202 %203 %205 = OpCompositeExtract %float %145 3 %206 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_11 %207 = OpLoad %float %206 %208 = OpFMul %float %205 %207 %209 = OpCompositeExtract %float %145 2 %210 = OpFMul %float %208 %146 %211 = OpFAdd %float %209 %210 %212 = OpFMul %float %211 %float_6_28318548 %213 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_0 %uint_0 %214 = OpLoad %v4float %213 %215 = OpVectorShuffle %v3float %214 %214 0 1 2 %216 = OpVectorShuffle %v3float %137 %108 0 0 0 %217 = OpFMul %v3float %215 %216 %218 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_0 %uint_1 %219 = OpLoad %v4float %218 %220 = OpVectorShuffle %v3float %219 %219 0 1 2 %221 = OpVectorShuffle %v3float %137 %108 1 1 1 %222 = OpFMul %v3float %220 %221 %223 = OpFAdd %v3float %217 %222 %224 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_0 %uint_2 %225 = OpLoad %v4float %224 %226 = OpVectorShuffle %v3float %225 %225 0 1 2 %227 = OpVectorShuffle %v3float %137 %108 2 2 2 %228 = OpFMul %v3float %226 %227 %229 = OpFAdd %v3float %223 %228 %230 = OpAccessChain %_ptr_Uniform_v4float %Primitive %int_0 %uint_3 %231 = OpLoad %v4float %230 %232 = OpVectorShuffle %v3float %231 %231 0 1 2 %233 = OpFAdd %v3float %232 %124 %234 = OpFAdd %v3float %229 %233 %235 = OpCompositeExtract %float %234 0 %236 = OpCompositeExtract %float %234 1 %237 = OpCompositeExtract %float %234 2 %238 = OpCompositeConstruct %v4float %235 %236 %237 %float_1 %239 = OpVectorShuffle %v3float %238 %238 0 1 2 %240 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_10 %241 = OpLoad %float %240 %242 = OpCompositeConstruct %v3float %241 %241 %241 %243 = OpExtInst %v3float %1 FMix %116 %120 %242 %244 = OpExtInst %v3float %1 FMix %114 %118 %242 %245 = OpAccessChain %_ptr_Uniform_v4float %EmitterDynamicUniforms %int_3 %246 = OpLoad %v4float %245 %247 = OpVectorShuffle %v3float %246 %246 0 1 2 %248 = OpAccessChain %_ptr_Uniform_float %EmitterDynamicUniforms %int_3 %int_3 %249 = OpLoad %float %248 %250 = OpCompositeConstruct %v3float %249 %249 %249 %251 = OpExtInst %v3float %1 FMix %243 %247 %250 %252 = OpFNegate %v3float %244 %253 = OpAccessChain %_ptr_Uniform_v4float %EmitterDynamicUniforms %int_4 %254 = OpLoad %v4float %253 %255 = OpVectorShuffle %v3float %254 %254 0 1 2 %256 = OpAccessChain %_ptr_Uniform_float %EmitterDynamicUniforms %int_4 %int_3 %257 = OpLoad %float %256 %258 = OpCompositeConstruct %v3float %257 %257 %257 %259 = OpExtInst %v3float %1 FMix %252 %255 %258 %260 = OpFSub %v3float %122 %239 %261 = OpDot %float %260 %260 %262 = OpExtInst %float %1 FMax %261 %float_0_00999999978 %263 = OpExtInst %float %1 Sqrt %262 %264 = OpCompositeConstruct %v3float %263 %263 %263 %265 = OpFDiv %v3float %260 %264 %266 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_9 %int_0 %267 = OpLoad %float %266 %268 = OpFOrdGreaterThan %bool %267 %float_0 OpSelectionMerge %269 DontFlatten OpBranchConditional %268 %270 %271 %270 = OpLabel %272 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_9 %int_1 %273 = OpLoad %float %272 %274 = OpFMul %float %261 %273 %275 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_9 %int_2 %276 = OpLoad %float %275 %277 = OpFSub %float %274 %276 %278 = OpExtInst %float %1 FClamp %277 %float_0 %float_1 %279 = OpExtInst %v3float %1 Cross %265 %82 %280 = OpDot %float %279 %279 %281 = OpExtInst %float %1 FMax %280 %float_0_00999999978 %282 = OpExtInst %float %1 Sqrt %281 %283 = OpCompositeConstruct %v3float %282 %282 %282 %284 = OpFDiv %v3float %279 %283 %285 = OpExtInst %v3float %1 Cross %265 %284 %286 = OpCompositeConstruct %v3float %278 %278 %278 %287 = OpExtInst %v3float %1 FMix %251 %284 %286 %288 = OpExtInst %v3float %1 Normalize %287 %289 = OpExtInst %v3float %1 FMix %259 %285 %286 %290 = OpExtInst %v3float %1 Normalize %289 OpBranch %269 %271 = OpLabel %291 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_8 %int_1 %292 = OpLoad %float %291 %293 = OpFOrdGreaterThan %bool %292 %float_0 OpSelectionMerge %294 Flatten OpBranchConditional %293 %295 %296 %295 = OpLabel %297 = OpExtInst %v3float %1 Cross %265 %160 %298 = OpDot %float %297 %297 %299 = OpExtInst %float %1 FMax %298 %float_0_00999999978 %300 = OpExtInst %float %1 Sqrt %299 %301 = OpCompositeConstruct %v3float %300 %300 %300 %302 = OpFDiv %v3float %297 %301 %303 = OpFNegate %v3float %160 OpBranch %294 %296 = OpLabel %304 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_8 %int_2 %305 = OpLoad %float %304 %306 = OpFOrdGreaterThan %bool %305 %float_0 OpSelectionMerge %307 None OpBranchConditional %306 %308 %309 %308 = OpLabel %310 = OpExtInst %v3float %1 Cross %247 %265 %311 = OpDot %float %310 %310 %312 = OpExtInst %float %1 FMax %311 %float_0_00999999978 %313 = OpExtInst %float %1 Sqrt %312 %314 = OpCompositeConstruct %v3float %313 %313 %313 %315 = OpFDiv %v3float %310 %314 %316 = OpFNegate %v3float %315 OpBranch %307 %309 = OpLabel %317 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_8 %int_3 %318 = OpLoad %float %317 %319 = OpFOrdGreaterThan %bool %318 %float_0 OpSelectionMerge %320 None OpBranchConditional %319 %321 %320 %321 = OpLabel %322 = OpExtInst %v3float %1 Cross %265 %82 %323 = OpDot %float %322 %322 %324 = OpExtInst %float %1 FMax %323 %float_0_00999999978 %325 = OpExtInst %float %1 Sqrt %324 %326 = OpCompositeConstruct %v3float %325 %325 %325 %327 = OpFDiv %v3float %322 %326 %328 = OpExtInst %v3float %1 Cross %265 %327 OpBranch %320 %320 = OpLabel %329 = OpPhi %v3float %251 %309 %327 %321 %330 = OpPhi %v3float %259 %309 %328 %321 OpBranch %307 %307 = OpLabel %331 = OpPhi %v3float %247 %308 %329 %320 %332 = OpPhi %v3float %316 %308 %330 %320 OpBranch %294 %294 = OpLabel %333 = OpPhi %v3float %302 %295 %331 %307 %334 = OpPhi %v3float %303 %295 %332 %307 OpBranch %269 %269 = OpLabel %335 = OpPhi %v3float %288 %270 %333 %294 %336 = OpPhi %v3float %290 %270 %334 %294 %337 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_12 %338 = OpLoad %float %337 %339 = OpFAdd %float %212 %338 %340 = OpExtInst %float %1 Sin %339 %341 = OpExtInst %float %1 Cos %339 %342 = OpCompositeConstruct %v3float %340 %340 %340 %343 = OpFMul %v3float %342 %336 %344 = OpCompositeConstruct %v3float %341 %341 %341 %345 = OpFMul %v3float %344 %335 %346 = OpFAdd %v3float %343 %345 %347 = OpFMul %v3float %344 %336 %348 = OpFMul %v3float %342 %335 %349 = OpFSub %v3float %347 %348 %350 = OpCompositeExtract %float %204 0 %351 = OpCompositeExtract %float %112 0 %352 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_15 %int_0 %353 = OpLoad %float %352 %354 = OpFAdd %float %351 %353 %355 = OpFMul %float %350 %354 %356 = OpCompositeConstruct %v3float %355 %355 %355 %357 = OpFMul %v3float %356 %346 %358 = OpCompositeExtract %float %204 1 %359 = OpCompositeExtract %float %112 1 %360 = OpAccessChain %_ptr_Uniform_float %EmitterUniforms %int_15 %int_1 %361 = OpLoad %float %360 %362 = OpFAdd %float %359 %361 %363 = OpFMul %float %358 %362 %364 = OpCompositeConstruct %v3float %363 %363 %363 %365 = OpFMul %v3float %364 %349 %366 = OpFAdd %v3float %357 %365 %367 = OpFAdd %v3float %239 %366 %368 = OpCompositeExtract %float %367 0 %369 = OpCompositeExtract %float %367 1 %370 = OpCompositeExtract %float %367 2 %371 = OpCompositeConstruct %v4float %368 %369 %370 %float_1 %372 = OpVectorShuffle %v4float %371 %371 4 5 6 3 %373 = OpAccessChain %_ptr_Uniform_mat4v4float %MobileShadowDepthPass %int_20 %374 = OpLoad %mat4v4float %373 %375 = OpMatrixTimesVector %v4float %374 %372 %376 = OpAccessChain %_ptr_Uniform_float %MobileShadowDepthPass %int_22 %377 = OpLoad %float %376 %378 = OpFOrdGreaterThan %bool %377 %float_0 %379 = OpCompositeExtract %float %375 2 %380 = OpFOrdLessThan %bool %379 %float_0 %381 = OpLogicalAnd %bool %378 %380 OpSelectionMerge %382 None OpBranchConditional %381 %383 %382 %383 = OpLabel %384 = OpCompositeInsert %v4float %float_9_99999997en07 %375 2 %385 = OpCompositeInsert %v4float %float_1 %384 3 OpBranch %382 %382 = OpLabel %386 = OpPhi %v4float %375 %269 %385 %383 %387 = OpAccessChain %_ptr_Uniform_float %MobileShadowDepthPass %int_21 %int_0 %388 = OpLoad %float %387 %389 = OpAccessChain %_ptr_Uniform_float %MobileShadowDepthPass %int_21 %int_1 %390 = OpLoad %float %389 %391 = OpCompositeExtract %float %386 2 %392 = OpFMul %float %391 %390 %393 = OpFAdd %float %392 %388 %394 = OpCompositeExtract %float %386 3 %395 = OpFMul %float %393 %394 %396 = OpCompositeInsert %v4float %395 %386 2 OpStore %out_var_TEXCOORD6 %float_0 OpStore %gl_Position %396 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/000077500000000000000000000000001400026215700160235ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/amd/000077500000000000000000000000001400026215700165645ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/amd/gcn_shader.comp000066400000000000000000000004331400026215700215410ustar00rootroot00000000000000#version 450 #extension GL_AMD_gcn_shader : require #extension GL_ARB_gpu_shader_int64 : require layout (local_size_x = 64) in; void main () { float cubeFace = cubeFaceIndexAMD(vec3(0.0)); vec2 cubeFaceCoord = cubeFaceCoordAMD(vec3(1.0)); uint64_t time = timeAMD(); } spirv-cross-2021.01.15/shaders/amd/shader_ballot.comp000066400000000000000000000016641400026215700222560ustar00rootroot00000000000000#version 450 #extension GL_AMD_shader_ballot : require #extension GL_ARB_shader_ballot : require layout (local_size_x = 64) in; layout (std430, binding = 0) buffer inputData { float inputDataArray[]; }; layout (std430, binding = 1) buffer outputData { float outputDataArray[]; }; void main () { float thisLaneData = inputDataArray [gl_LocalInvocationID.x]; bool laneActive = (thisLaneData > 0); uint thisLaneOutputSlot = mbcntAMD (ballotARB (laneActive)); int firstInvocation = readFirstInvocationARB(1); int invocation = readInvocationARB(1, 0); vec3 swizzleInvocations = swizzleInvocationsAMD(vec3(0.0, 2.0, 1.0), uvec4(3)); vec3 swizzelInvocationsMasked = swizzleInvocationsMaskedAMD(vec3(0.0, 2.0, 1.0), uvec3(2)); vec3 writeInvocation = writeInvocationAMD(swizzleInvocations, swizzelInvocationsMasked, 0); if (laneActive) { outputDataArray[thisLaneOutputSlot] = thisLaneData; } } spirv-cross-2021.01.15/shaders/amd/shader_group_vote.comp000066400000000000000000000007351400026215700231700ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_group_vote : require layout (local_size_x = 64) in; layout (std430, binding = 0) buffer inputData { float inputDataArray[]; }; void main () { float thisLaneData = inputDataArray [gl_LocalInvocationID.x]; bool laneActive = (thisLaneData > 0); bool allInvocations = allInvocationsARB(laneActive); bool anyInvocations = anyInvocationARB(laneActive); bool allInvocationsEqual = allInvocationsEqualARB(laneActive); } spirv-cross-2021.01.15/shaders/amd/shader_trinary_minmax.comp000066400000000000000000000003101400026215700240250ustar00rootroot00000000000000#version 450 #extension GL_AMD_shader_trinary_minmax : require layout (local_size_x = 64) in; void main () { int t11 = min3(0, 3, 2); int t12 = max3(0, 3, 2); int t13 = mid3(0, 3, 2); } spirv-cross-2021.01.15/shaders/asm/000077500000000000000000000000001400026215700166035ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/asm/comp/000077500000000000000000000000001400026215700175415ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/asm/comp/atomic-decrement.asm.comp000066400000000000000000000050431400026215700244220ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "main" %15 OpExecutionMode %3 LocalSize 4 1 1 OpName %3 "main" OpName %8 "u0" OpName %9 "u0_counters" OpMemberName %9 0 "c" OpName %11 "u0_counter" OpName %15 "vThreadID" OpName %19 "r0" OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 1 OpDecorate %11 Binding 0 OpDecorate %15 BuiltIn GlobalInvocationId %1 = OpTypeVoid %2 = OpTypeFunction %1 %5 = OpTypeInt 32 0 %6 = OpTypeImage %5 Buffer 0 0 0 2 R32ui %7 = OpTypePointer UniformConstant %6 %8 = OpVariable %7 UniformConstant %9 = OpTypeStruct %5 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpTypeVector %12 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpTypeFloat 32 %17 = OpTypeVector %16 4 %18 = OpTypePointer Function %17 %20 = OpTypePointer Uniform %5 %21 = OpConstant %5 0 %23 = OpConstant %5 1 %26 = OpTypePointer Function %16 %33 = OpConstant %12 0 %34 = OpConstant %5 2 %37 = OpTypePointer Input %12 %41 = OpTypeVector %5 4 %3 = OpFunction %1 None %2 %4 = OpLabel %19 = OpVariable %18 Function %22 = OpAccessChain %20 %11 %21 %24 = OpAtomicIDecrement %5 %22 %23 %21 %25 = OpBitcast %16 %24 %27 = OpInBoundsAccessChain %26 %19 %21 OpStore %27 %25 %28 = OpLoad %6 %8 %29 = OpInBoundsAccessChain %26 %19 %21 %30 = OpLoad %16 %29 %31 = OpBitcast %12 %30 %32 = OpIMul %5 %31 %23 %35 = OpShiftRightLogical %5 %33 %34 %36 = OpIAdd %5 %32 %35 %38 = OpInBoundsAccessChain %37 %15 %21 %39 = OpLoad %12 %38 %40 = OpBitcast %5 %39 %42 = OpCompositeConstruct %41 %40 %40 %40 %40 OpImageWrite %28 %36 %42 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/atomic-increment.asm.comp000066400000000000000000000050431400026215700244400ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "main" %15 OpExecutionMode %3 LocalSize 4 1 1 OpName %3 "main" OpName %8 "u0" OpName %9 "u0_counters" OpMemberName %9 0 "c" OpName %11 "u0_counter" OpName %15 "vThreadID" OpName %19 "r0" OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 1 OpDecorate %11 Binding 0 OpDecorate %15 BuiltIn GlobalInvocationId %1 = OpTypeVoid %2 = OpTypeFunction %1 %5 = OpTypeInt 32 0 %6 = OpTypeImage %5 Buffer 0 0 0 2 R32ui %7 = OpTypePointer UniformConstant %6 %8 = OpVariable %7 UniformConstant %9 = OpTypeStruct %5 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpTypeVector %12 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpTypeFloat 32 %17 = OpTypeVector %16 4 %18 = OpTypePointer Function %17 %20 = OpTypePointer Uniform %5 %21 = OpConstant %5 0 %23 = OpConstant %5 1 %26 = OpTypePointer Function %16 %33 = OpConstant %12 0 %34 = OpConstant %5 2 %37 = OpTypePointer Input %12 %41 = OpTypeVector %5 4 %3 = OpFunction %1 None %2 %4 = OpLabel %19 = OpVariable %18 Function %22 = OpAccessChain %20 %11 %21 %24 = OpAtomicIIncrement %5 %22 %23 %21 %25 = OpBitcast %16 %24 %27 = OpInBoundsAccessChain %26 %19 %21 OpStore %27 %25 %28 = OpLoad %6 %8 %29 = OpInBoundsAccessChain %26 %19 %21 %30 = OpLoad %16 %29 %31 = OpBitcast %12 %30 %32 = OpIMul %5 %31 %23 %35 = OpShiftRightLogical %5 %33 %34 %36 = OpIAdd %5 %32 %35 %38 = OpInBoundsAccessChain %37 %15 %21 %39 = OpLoad %12 %38 %40 = OpBitcast %5 %39 %42 = OpCompositeConstruct %41 %40 %40 %40 %40 OpImageWrite %28 %36 %42 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/bitcast_iadd.asm.comp000066400000000000000000000061311400026215700236130ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %inputs Restrict OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 OpDecorate %outputs Restrict %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of IAdd %result_iadd_0 = OpIAdd %uvec4 %input0 %input1 %result_iadd_1 = OpIAdd %uvec4 %input1 %input0 %result_iadd_2 = OpIAdd %uvec4 %input0 %input0 %result_iadd_3 = OpIAdd %uvec4 %input1 %input1 %result_iadd_4 = OpIAdd %ivec4 %input0 %input0 %result_iadd_5 = OpIAdd %ivec4 %input1 %input1 %result_iadd_6 = OpIAdd %ivec4 %input0 %input1 %result_iadd_7 = OpIAdd %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/bitcast_icmp.asm.comp000066400000000000000000000072541400026215700236510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %inputs Restrict OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 OpDecorate %outputs Restrict %void = OpTypeVoid %main_func = OpTypeFunction %void %bool = OpTypeBool %bvec4 = OpTypeVector %bool 4 %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %uzero = OpConstant %uint 0 %uone = OpConstant %uint 1 %utrue = OpConstantComposite %uvec4 %uone %uone %uone %uone %ufalse = OpConstantComposite %uvec4 %uzero %uzero %uzero %uzero %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %result_slt = OpSLessThan %bvec4 %input0 %input1 %result_sle = OpSLessThanEqual %bvec4 %input0 %input1 %result_ult = OpULessThan %bvec4 %input0 %input1 %result_ule = OpULessThanEqual %bvec4 %input0 %input1 %result_sgt = OpSGreaterThan %bvec4 %input0 %input1 %result_sge = OpSGreaterThanEqual %bvec4 %input0 %input1 %result_ugt = OpUGreaterThan %bvec4 %input0 %input1 %result_uge = OpUGreaterThanEqual %bvec4 %input0 %input1 %int_slt = OpSelect %uvec4 %result_slt %utrue %ufalse OpStore %output_ptr_uvec4 %int_slt %int_sle = OpSelect %uvec4 %result_sle %utrue %ufalse OpStore %output_ptr_uvec4 %int_sle %int_ult = OpSelect %uvec4 %result_ult %utrue %ufalse OpStore %output_ptr_uvec4 %int_ult %int_ule = OpSelect %uvec4 %result_ule %utrue %ufalse OpStore %output_ptr_uvec4 %int_ule %int_sgt = OpSelect %uvec4 %result_sgt %utrue %ufalse OpStore %output_ptr_uvec4 %int_sgt %int_sge = OpSelect %uvec4 %result_sge %utrue %ufalse OpStore %output_ptr_uvec4 %int_sge %int_ugt = OpSelect %uvec4 %result_ugt %utrue %ufalse OpStore %output_ptr_uvec4 %int_ugt %int_uge = OpSelect %uvec4 %result_uge %utrue %ufalse OpStore %output_ptr_uvec4 %int_uge OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/bitcast_iequal.asm.comp000066400000000000000000000072671400026215700242050ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %bool = OpTypeBool %bvec4 = OpTypeVector %bool 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %uone = OpConstant %uint 1 %uzero = OpConstant %uint 0 %uvec41 = OpConstantComposite %uvec4 %uone %uone %uone %uone %ivec41 = OpConstantComposite %ivec4 %one %one %one %one %uvec40 = OpConstantComposite %uvec4 %uzero %uzero %uzero %uzero %ivec40 = OpConstantComposite %ivec4 %zero %zero %zero %zero %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of IEqual %result_iequal0 = OpIEqual %bvec4 %input0 %input1 %result_iequal1 = OpIEqual %bvec4 %input1 %input0 %result_iequal2 = OpIEqual %bvec4 %input0 %input0 %result_iequal3 = OpIEqual %bvec4 %input1 %input1 %result_0 = OpSelect %uvec4 %result_iequal0 %uvec41 %uvec40 %result_1 = OpSelect %uvec4 %result_iequal1 %uvec41 %uvec40 %result_2 = OpSelect %uvec4 %result_iequal2 %uvec41 %uvec40 %result_3 = OpSelect %uvec4 %result_iequal3 %uvec41 %uvec40 %result_4 = OpSelect %ivec4 %result_iequal0 %ivec41 %ivec40 %result_5 = OpSelect %ivec4 %result_iequal1 %ivec41 %ivec40 %result_6 = OpSelect %ivec4 %result_iequal2 %ivec41 %ivec40 %result_7 = OpSelect %ivec4 %result_iequal3 %ivec41 %ivec40 OpStore %output_ptr_uvec4 %result_0 OpStore %output_ptr_uvec4 %result_1 OpStore %output_ptr_uvec4 %result_2 OpStore %output_ptr_uvec4 %result_3 OpStore %output_ptr_ivec4 %result_4 OpStore %output_ptr_ivec4 %result_5 OpStore %output_ptr_ivec4 %result_6 OpStore %output_ptr_ivec4 %result_7 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/bitcast_sar.asm.comp000066400000000000000000000062441400026215700235040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of ShiftRightArithmetic %result_iadd_0 = OpShiftRightArithmetic %uvec4 %input0 %input1 %result_iadd_1 = OpShiftRightArithmetic %uvec4 %input1 %input0 %result_iadd_2 = OpShiftRightArithmetic %uvec4 %input0 %input0 %result_iadd_3 = OpShiftRightArithmetic %uvec4 %input1 %input1 %result_iadd_4 = OpShiftRightArithmetic %ivec4 %input0 %input0 %result_iadd_5 = OpShiftRightArithmetic %ivec4 %input1 %input1 %result_iadd_6 = OpShiftRightArithmetic %ivec4 %input0 %input1 %result_iadd_7 = OpShiftRightArithmetic %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/bitcast_sdiv.asm.comp000066400000000000000000000060241400026215700236600ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of SDiv %result_iadd_0 = OpSDiv %uvec4 %input0 %input1 %result_iadd_1 = OpSDiv %uvec4 %input1 %input0 %result_iadd_2 = OpSDiv %uvec4 %input0 %input0 %result_iadd_3 = OpSDiv %uvec4 %input1 %input1 %result_iadd_4 = OpSDiv %ivec4 %input0 %input0 %result_iadd_5 = OpSDiv %ivec4 %input1 %input1 %result_iadd_6 = OpSDiv %ivec4 %input0 %input1 %result_iadd_7 = OpSDiv %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/bitcast_slr.asm.comp000066400000000000000000000062111400026215700235110ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of ShiftRightLogical %result_iadd_0 = OpShiftRightLogical %uvec4 %input0 %input1 %result_iadd_1 = OpShiftRightLogical %uvec4 %input1 %input0 %result_iadd_2 = OpShiftRightLogical %uvec4 %input0 %input0 %result_iadd_3 = OpShiftRightLogical %uvec4 %input1 %input1 %result_iadd_4 = OpShiftRightLogical %ivec4 %input0 %input0 %result_iadd_5 = OpShiftRightLogical %ivec4 %input1 %input1 %result_iadd_6 = OpShiftRightLogical %ivec4 %input0 %input1 %result_iadd_7 = OpShiftRightLogical %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/block-name-alias-global.asm.comp000066400000000000000000000120731400026215700255400ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 59 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %Foo "A" OpMemberName %Foo 0 "a" OpMemberName %Foo 1 "b" OpName %A "A" OpMemberName %A 0 "Data" OpName %C1 "C1" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpName %Foo_0 "A" OpMemberName %Foo_0 0 "a" OpMemberName %Foo_0 1 "b" OpName %A_0 "A" OpMemberName %A_0 0 "Data" OpName %C2 "C2" OpName %B "B" OpMemberName %B 0 "Data" OpName %C3 "C3" OpName %B_0 "B" OpMemberName %B_0 0 "Data" OpName %C4 "C4" OpMemberDecorate %Foo 0 Offset 0 OpMemberDecorate %Foo 1 Offset 4 OpDecorate %_runtimearr_Foo ArrayStride 8 OpMemberDecorate %A 0 Offset 0 OpDecorate %A BufferBlock OpDecorate %C1 DescriptorSet 0 OpDecorate %C1 Binding 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpMemberDecorate %Foo_0 0 Offset 0 OpMemberDecorate %Foo_0 1 Offset 4 OpDecorate %_arr_Foo_0_uint_1024 ArrayStride 16 OpMemberDecorate %A_0 0 Offset 0 OpDecorate %A_0 Block OpDecorate %C2 DescriptorSet 0 OpDecorate %C2 Binding 2 OpDecorate %_runtimearr_Foo_0 ArrayStride 8 OpMemberDecorate %B 0 Offset 0 OpDecorate %B BufferBlock OpDecorate %C3 DescriptorSet 0 OpDecorate %C3 Binding 0 OpDecorate %_arr_Foo_0_uint_1024_0 ArrayStride 16 OpMemberDecorate %B_0 0 Offset 0 OpDecorate %B_0 Block OpDecorate %C4 DescriptorSet 0 OpDecorate %C4 Binding 3 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %Foo = OpTypeStruct %int %int %_runtimearr_Foo = OpTypeRuntimeArray %Foo %A = OpTypeStruct %_runtimearr_Foo %_ptr_Uniform_A = OpTypePointer Uniform %A %C1 = OpVariable %_ptr_Uniform_A Uniform %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %Foo_0 = OpTypeStruct %int %int %uint_1024 = OpConstant %uint 1024 %_arr_Foo_0_uint_1024 = OpTypeArray %Foo_0 %uint_1024 %A_0 = OpTypeStruct %_arr_Foo_0_uint_1024 %_ptr_Uniform_A_0 = OpTypePointer Uniform %A_0 %C2 = OpVariable %_ptr_Uniform_A_0 Uniform %_ptr_Uniform_Foo_0 = OpTypePointer Uniform %Foo_0 %_ptr_Uniform_Foo = OpTypePointer Uniform %Foo %_ptr_Uniform_int = OpTypePointer Uniform %int %int_1 = OpConstant %int 1 %_runtimearr_Foo_0 = OpTypeRuntimeArray %Foo %B = OpTypeStruct %_runtimearr_Foo_0 %_ptr_Uniform_B = OpTypePointer Uniform %B %C3 = OpVariable %_ptr_Uniform_B Uniform %_arr_Foo_0_uint_1024_0 = OpTypeArray %Foo_0 %uint_1024 %B_0 = OpTypeStruct %_arr_Foo_0_uint_1024_0 %_ptr_Uniform_B_0 = OpTypePointer Uniform %B_0 %C4 = OpVariable %_ptr_Uniform_B_0 Uniform %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %20 = OpLoad %uint %19 %27 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %28 = OpLoad %uint %27 %30 = OpAccessChain %_ptr_Uniform_Foo_0 %C2 %int_0 %28 %31 = OpLoad %Foo_0 %30 %33 = OpAccessChain %_ptr_Uniform_Foo %C1 %int_0 %20 %34 = OpCompositeExtract %int %31 0 %36 = OpAccessChain %_ptr_Uniform_int %33 %int_0 OpStore %36 %34 %37 = OpCompositeExtract %int %31 1 %39 = OpAccessChain %_ptr_Uniform_int %33 %int_1 OpStore %39 %37 %44 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %45 = OpLoad %uint %44 %50 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_0 %51 = OpLoad %uint %50 %52 = OpAccessChain %_ptr_Uniform_Foo_0 %C4 %int_0 %51 %53 = OpLoad %Foo_0 %52 %54 = OpAccessChain %_ptr_Uniform_Foo %C3 %int_0 %45 %55 = OpCompositeExtract %int %53 0 %56 = OpAccessChain %_ptr_Uniform_int %54 %int_0 OpStore %56 %55 %57 = OpCompositeExtract %int %53 1 %58 = OpAccessChain %_ptr_Uniform_int %54 %int_1 OpStore %58 %57 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/builtin-compute-bitcast.asm.comp000066400000000000000000000040751400026215700257550ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 26 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_WorkGroupID %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %BUF "BUF" OpMemberName %BUF 0 "values" OpName %_ "" OpName %gl_WorkGroupID "gl_WorkGroupID" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %_runtimearr_int ArrayStride 4 OpMemberDecorate %BUF 0 Offset 0 OpDecorate %BUF BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId %void = OpTypeVoid %int = OpTypeInt 32 1 %_runtimearr_int = OpTypeRuntimeArray %int %3 = OpTypeFunction %void %BUF = OpTypeStruct %_runtimearr_int %_ptr_Uniform_BUF = OpTypePointer Uniform %BUF %_ = OpVariable %_ptr_Uniform_BUF Uniform %int_0 = OpConstant %int 0 %v3int = OpTypeVector %int 3 %_ptr_Input_v3int = OpTypePointer Input %v3int %gl_WorkGroupID = OpVariable %_ptr_Input_v3int Input %int_1 = OpConstant %int 1 %_ptr_Input_int = OpTypePointer Input %int %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3int Input %int_2 = OpConstant %int 2 %_ptr_Uniform_int = OpTypePointer Uniform %int %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_Input_int %gl_WorkGroupID %int_1 %19 = OpLoad %int %18 %22 = OpAccessChain %_ptr_Input_int %gl_GlobalInvocationID %int_2 %23 = OpLoad %int %22 %25 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %19 OpStore %25 %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/decoration-group.asm.comp000066400000000000000000000071131400026215700244630ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 58 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %2 OpExecutionMode %1 LocalSize 1 1 1 OpSource GLSL 430 OpName %1 "main" OpName %2 "gl_GlobalInvocationID" OpDecorate %2 BuiltIn GlobalInvocationId OpDecorate %3 ArrayStride 4 OpDecorate %4 BufferBlock OpDecorate %5 Offset 0 %4 = OpDecorationGroup %5 = OpDecorationGroup OpGroupDecorate %4 %6 %7 %8 %9 %10 %11 OpGroupMemberDecorate %5 %6 0 %7 0 %8 0 %9 0 %10 0 %11 0 OpDecorate %12 DescriptorSet 0 OpDecorate %13 DescriptorSet 0 OpDecorate %13 NonWritable OpDecorate %13 Restrict %14 = OpDecorationGroup %12 = OpDecorationGroup %13 = OpDecorationGroup OpGroupDecorate %12 %15 OpGroupDecorate %12 %15 OpGroupDecorate %12 %15 OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 5 OpGroupDecorate %14 %16 OpDecorate %16 DescriptorSet 0 OpDecorate %16 Binding 0 OpGroupDecorate %12 %17 OpDecorate %17 Binding 1 OpGroupDecorate %13 %18 %19 OpDecorate %18 Binding 2 OpDecorate %19 Binding 3 OpGroupDecorate %14 %20 OpGroupDecorate %12 %20 OpGroupDecorate %13 %20 OpDecorate %20 Binding 4 %21 = OpTypeBool %22 = OpTypeVoid %23 = OpTypeFunction %22 %24 = OpTypeInt 32 0 %25 = OpTypeInt 32 1 %26 = OpTypeFloat 32 %27 = OpTypeVector %24 3 %28 = OpTypeVector %26 3 %29 = OpTypePointer Input %27 %30 = OpTypePointer Uniform %25 %31 = OpTypePointer Uniform %26 %32 = OpTypeRuntimeArray %25 %3 = OpTypeRuntimeArray %26 %2 = OpVariable %29 Input %33 = OpConstant %25 0 %6 = OpTypeStruct %3 %34 = OpTypePointer Uniform %6 %15 = OpVariable %34 Uniform %7 = OpTypeStruct %3 %35 = OpTypePointer Uniform %7 %16 = OpVariable %35 Uniform %8 = OpTypeStruct %3 %36 = OpTypePointer Uniform %8 %17 = OpVariable %36 Uniform %9 = OpTypeStruct %3 %37 = OpTypePointer Uniform %9 %18 = OpVariable %37 Uniform %10 = OpTypeStruct %3 %38 = OpTypePointer Uniform %10 %19 = OpVariable %38 Uniform %11 = OpTypeStruct %3 %39 = OpTypePointer Uniform %11 %20 = OpVariable %39 Uniform %1 = OpFunction %22 None %23 %40 = OpLabel %41 = OpLoad %27 %2 %42 = OpCompositeExtract %24 %41 0 %43 = OpAccessChain %31 %16 %33 %42 %44 = OpAccessChain %31 %17 %33 %42 %45 = OpAccessChain %31 %18 %33 %42 %46 = OpAccessChain %31 %19 %33 %42 %47 = OpAccessChain %31 %20 %33 %42 %48 = OpAccessChain %31 %15 %33 %42 %49 = OpLoad %26 %43 %50 = OpLoad %26 %44 %51 = OpLoad %26 %45 %52 = OpLoad %26 %46 %53 = OpLoad %26 %47 %54 = OpFAdd %26 %49 %50 %55 = OpFAdd %26 %54 %51 %56 = OpFAdd %26 %55 %52 %57 = OpFAdd %26 %56 %53 OpStore %48 %57 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/global-parameter-name-alias.asm.comp000066400000000000000000000101621400026215700264230ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 61 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %id_1 OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 500 OpName %main "main" OpName %Load_u1_ "Load(u1;" OpName %size "size" OpName %_main_vu3_ "@main(vu3;" OpName %id "id" OpName %data "data" OpName %byteAddrTemp "byteAddrTemp" OpName %ssbo "ssbo" OpMemberName %ssbo 0 "@data" OpName %ssbo_0 "ssbo" OpName %param "param" OpName %id_0 "id" OpName %id_1 "id" OpName %param_0 "param" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %ssbo 0 NonWritable OpMemberDecorate %ssbo 0 Offset 0 OpDecorate %ssbo BufferBlock OpDecorate %ssbo_0 DescriptorSet 0 OpDecorate %ssbo_0 Binding 1 OpDecorate %id_1 BuiltIn GlobalInvocationId %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %8 = OpTypeFunction %void %_ptr_Function_uint %v3uint = OpTypeVector %uint 3 %_ptr_Function_v3uint = OpTypePointer Function %v3uint %14 = OpTypeFunction %void %_ptr_Function_v3uint %v4uint = OpTypeVector %uint 4 %_ptr_Function_v4uint = OpTypePointer Function %v4uint %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_2 = OpConstant %int 2 %_runtimearr_uint = OpTypeRuntimeArray %uint %ssbo = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_ssbo = OpTypePointer Uniform %ssbo %ssbo_0 = OpVariable %_ptr_Uniform_ssbo Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %uint_4 = OpConstant %uint 4 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %id_1 = OpVariable %_ptr_Input_v3uint Input %main = OpFunction %void None %3 %5 = OpLabel %id_0 = OpVariable %_ptr_Function_v3uint Function %param_0 = OpVariable %_ptr_Function_v3uint Function %57 = OpLoad %v3uint %id_1 OpStore %id_0 %57 %59 = OpLoad %v3uint %id_0 OpStore %param_0 %59 %60 = OpFunctionCall %void %_main_vu3_ %param_0 OpReturn OpFunctionEnd %Load_u1_ = OpFunction %void None %8 %size = OpFunctionParameter %_ptr_Function_uint %11 = OpLabel %data = OpVariable %_ptr_Function_v4uint Function %byteAddrTemp = OpVariable %_ptr_Function_int Function %24 = OpLoad %uint %size %26 = OpShiftRightLogical %int %24 %int_2 OpStore %byteAddrTemp %26 %32 = OpLoad %int %byteAddrTemp %34 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %32 %35 = OpLoad %uint %34 %36 = OpLoad %int %byteAddrTemp %38 = OpIAdd %int %36 %int_1 %39 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %38 %40 = OpLoad %uint %39 %41 = OpLoad %int %byteAddrTemp %42 = OpIAdd %int %41 %int_2 %43 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %42 %44 = OpLoad %uint %43 %45 = OpLoad %int %byteAddrTemp %47 = OpIAdd %int %45 %int_3 %48 = OpAccessChain %_ptr_Uniform_uint %ssbo_0 %int_0 %47 %49 = OpLoad %uint %48 %50 = OpCompositeConstruct %v4uint %35 %40 %44 %49 OpStore %data %50 OpReturn OpFunctionEnd %_main_vu3_ = OpFunction %void None %14 %id = OpFunctionParameter %_ptr_Function_v3uint %17 = OpLabel %param = OpVariable %_ptr_Function_uint Function OpStore %param %uint_4 %53 = OpFunctionCall %void %Load_u1_ %param OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/hlsl-functionality.asm.comp000066400000000000000000000051411400026215700250310ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 31 ; Schema: 0 OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %Buf "Buf" OpMemberName %Buf 0 "@data" OpName %Buf_0 "Buf" OpName %Buf_count "Buf@count" OpMemberName %Buf_count 0 "@count" OpName %Buf_count_0 "Buf@count" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %Buf 0 Offset 0 OpDecorate %Buf BufferBlock OpDecorate %Buf_0 DescriptorSet 0 OpDecorate %Buf_0 Binding 0 OpMemberDecorate %Buf_count 0 Offset 0 OpDecorate %Buf_count BufferBlock OpDecorate %Buf_count_0 DescriptorSet 0 OpDecorate %Buf_count_0 Binding 1 OpDecorateId %Buf_0 HlslCounterBufferGOOGLE %Buf_count_0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_runtimearr_v4float = OpTypeRuntimeArray %v4float %Buf = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_Buf = OpTypePointer Uniform %Buf %Buf_0 = OpVariable %_ptr_Uniform_Buf Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %Buf_count = OpTypeStruct %int %_ptr_Uniform_Buf_count = OpTypePointer Uniform %Buf_count %Buf_count_0 = OpVariable %_ptr_Uniform_Buf_count Uniform %_ptr_Uniform_int = OpTypePointer Uniform %int %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %float_1 = OpConstant %float 1 %27 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %main = OpFunction %void None %3 %5 = OpLabel %30 = OpFunctionCall %void %_main_ OpReturn OpFunctionEnd %_main_ = OpFunction %void None %3 %7 = OpLabel %20 = OpAccessChain %_ptr_Uniform_int %Buf_count_0 %int_0 %25 = OpAtomicIAdd %int %20 %uint_1 %uint_0 %int_1 %29 = OpAccessChain %_ptr_Uniform_v4float %Buf_0 %int_0 %25 OpStore %29 %27 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/logical.asm.comp000066400000000000000000000176441400026215700226260ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 152 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource ESSL 310 OpName %main "main" OpName %and_b1_b1_ "and(b1;b1;" OpName %a "a" OpName %b "b" OpName %and_vb2_vb2_ "and(vb2;vb2;" OpName %a_0 "a" OpName %b_0 "b" OpName %and_vb3_vb3_ "and(vb3;vb3;" OpName %a_1 "a" OpName %b_1 "b" OpName %and_vb4_vb4_ "and(vb4;vb4;" OpName %a_2 "a" OpName %b_2 "b" OpName %b0 "b0" OpName %SSBO0 "SSBO0" OpMemberName %SSBO0 0 "a" OpMemberName %SSBO0 1 "b" OpMemberName %SSBO0 2 "c" OpMemberName %SSBO0 3 "d" OpName %s0 "s0" OpName %SSBO1 "SSBO1" OpMemberName %SSBO1 0 "a" OpMemberName %SSBO1 1 "b" OpMemberName %SSBO1 2 "c" OpMemberName %SSBO1 3 "d" OpName %s1 "s1" OpName %param "param" OpName %param_0 "param" OpName %b1 "b1" OpName %param_1 "param" OpName %param_2 "param" OpName %b2 "b2" OpName %param_3 "param" OpName %param_4 "param" OpName %b3 "b3" OpName %param_5 "param" OpName %param_6 "param" OpMemberDecorate %SSBO0 0 Offset 0 OpMemberDecorate %SSBO0 1 Offset 8 OpMemberDecorate %SSBO0 2 Offset 16 OpMemberDecorate %SSBO0 3 Offset 32 OpDecorate %SSBO0 BufferBlock OpDecorate %s0 DescriptorSet 0 OpDecorate %s0 Binding 0 OpMemberDecorate %SSBO1 0 Offset 0 OpMemberDecorate %SSBO1 1 Offset 8 OpMemberDecorate %SSBO1 2 Offset 16 OpMemberDecorate %SSBO1 3 Offset 32 OpDecorate %SSBO1 BufferBlock OpDecorate %s1 DescriptorSet 0 OpDecorate %s1 Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %8 = OpTypeFunction %bool %_ptr_Function_bool %_ptr_Function_bool %v2bool = OpTypeVector %bool 2 %_ptr_Function_v2bool = OpTypePointer Function %v2bool %15 = OpTypeFunction %v2bool %_ptr_Function_v2bool %_ptr_Function_v2bool %v3bool = OpTypeVector %bool 3 %_ptr_Function_v3bool = OpTypePointer Function %v3bool %22 = OpTypeFunction %v3bool %_ptr_Function_v3bool %_ptr_Function_v3bool %v4bool = OpTypeVector %bool 4 %_ptr_Function_v4bool = OpTypePointer Function %v4bool %29 = OpTypeFunction %v4bool %_ptr_Function_v4bool %_ptr_Function_v4bool %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %SSBO0 = OpTypeStruct %float %v2float %v3float %v4float %_ptr_Uniform_SSBO0 = OpTypePointer Uniform %SSBO0 %s0 = OpVariable %_ptr_Uniform_SSBO0 Uniform %int = OpTypeInt 32 1 %102 = OpConstant %int 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %SSBO1 = OpTypeStruct %float %v2float %v3float %v4float %_ptr_Uniform_SSBO1 = OpTypePointer Uniform %SSBO1 %s1 = OpVariable %_ptr_Uniform_SSBO1 Uniform %117 = OpConstant %int 1 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %129 = OpConstant %int 2 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %141 = OpConstant %int 3 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %main = OpFunction %void None %3 %5 = OpLabel %b0 = OpVariable %_ptr_Function_bool Function %param = OpVariable %_ptr_Function_bool Function %param_0 = OpVariable %_ptr_Function_bool Function %b1 = OpVariable %_ptr_Function_v2bool Function %param_1 = OpVariable %_ptr_Function_v2bool Function %param_2 = OpVariable %_ptr_Function_v2bool Function %b2 = OpVariable %_ptr_Function_v3bool Function %param_3 = OpVariable %_ptr_Function_v3bool Function %param_4 = OpVariable %_ptr_Function_v3bool Function %b3 = OpVariable %_ptr_Function_v4bool Function %param_5 = OpVariable %_ptr_Function_v4bool Function %param_6 = OpVariable %_ptr_Function_v4bool Function %104 = OpAccessChain %_ptr_Uniform_float %s0 %102 %105 = OpLoad %float %104 %106 = OpIsInf %bool %105 %110 = OpAccessChain %_ptr_Uniform_float %s1 %102 %111 = OpLoad %float %110 %112 = OpIsNan %bool %111 OpStore %param %106 OpStore %param_0 %112 %115 = OpFunctionCall %bool %and_b1_b1_ %param %param_0 OpStore %b0 %115 %119 = OpAccessChain %_ptr_Uniform_v2float %s0 %117 %120 = OpLoad %v2float %119 %121 = OpIsInf %v2bool %120 %122 = OpAccessChain %_ptr_Uniform_v2float %s1 %117 %123 = OpLoad %v2float %122 %124 = OpIsNan %v2bool %123 OpStore %param_1 %121 OpStore %param_2 %124 %127 = OpFunctionCall %v2bool %and_vb2_vb2_ %param_1 %param_2 OpStore %b1 %127 %131 = OpAccessChain %_ptr_Uniform_v3float %s0 %129 %132 = OpLoad %v3float %131 %133 = OpIsInf %v3bool %132 %134 = OpAccessChain %_ptr_Uniform_v3float %s1 %129 %135 = OpLoad %v3float %134 %136 = OpIsNan %v3bool %135 OpStore %param_3 %133 OpStore %param_4 %136 %139 = OpFunctionCall %v3bool %and_vb3_vb3_ %param_3 %param_4 OpStore %b2 %139 %143 = OpAccessChain %_ptr_Uniform_v4float %s0 %141 %144 = OpLoad %v4float %143 %145 = OpIsInf %v4bool %144 %146 = OpAccessChain %_ptr_Uniform_v4float %s1 %141 %147 = OpLoad %v4float %146 %148 = OpIsNan %v4bool %147 OpStore %param_5 %145 OpStore %param_6 %148 %151 = OpFunctionCall %v4bool %and_vb4_vb4_ %param_5 %param_6 OpStore %b3 %151 OpReturn OpFunctionEnd %and_b1_b1_ = OpFunction %bool None %8 %a = OpFunctionParameter %_ptr_Function_bool %b = OpFunctionParameter %_ptr_Function_bool %12 = OpLabel %34 = OpLoad %bool %a %35 = OpLoad %bool %b %36 = OpLogicalAnd %bool %34 %35 %37 = OpLogicalOr %bool %36 %35 %38 = OpLogicalNot %bool %37 OpReturnValue %38 OpFunctionEnd %and_vb2_vb2_ = OpFunction %v2bool None %15 %a_0 = OpFunctionParameter %_ptr_Function_v2bool %b_0 = OpFunctionParameter %_ptr_Function_v2bool %19 = OpLabel %39 = OpLoad %v2bool %a_0 %41 = OpLoad %v2bool %b_0 %48 = OpLogicalAnd %v2bool %39 %41 %49 = OpLogicalOr %v2bool %48 %41 %50 = OpLogicalNot %v2bool %49 OpReturnValue %50 OpFunctionEnd %and_vb3_vb3_ = OpFunction %v3bool None %22 %a_1 = OpFunctionParameter %_ptr_Function_v3bool %b_1 = OpFunctionParameter %_ptr_Function_v3bool %26 = OpLabel %52 = OpLoad %v3bool %a_1 %54 = OpLoad %v3bool %b_1 %66 = OpLogicalAnd %v3bool %52 %54 OpReturnValue %66 OpFunctionEnd %and_vb4_vb4_ = OpFunction %v4bool None %29 %a_2 = OpFunctionParameter %_ptr_Function_v4bool %b_2 = OpFunctionParameter %_ptr_Function_v4bool %33 = OpLabel %70 = OpLoad %v4bool %a_2 %72 = OpLoad %v4bool %b_2 %74 = OpLogicalAnd %v4bool %70 %72 OpReturnValue %74 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/multiple-entry.asm.comp000066400000000000000000000074221400026215700241770ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 30 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func_alt "main2" %frag_in %frag_out OpEntryPoint GLCompute %func "main" OpExecutionMode %func LocalSize 1 1 1 OpExecutionMode %func_alt OriginUpperLeft OpSource ESSL 310 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpMemberDecorate %input_struct 0 Offset 0 OpMemberDecorate %input_struct 1 Offset 16 OpMemberDecorate %output_struct 0 Offset 0 OpMemberDecorate %output_struct 1 Offset 16 OpDecorate %input_struct BufferBlock OpDecorate %inputs DescriptorSet 0 OpDecorate %inputs Binding 0 OpDecorate %inputs Restrict OpDecorate %output_struct BufferBlock OpDecorate %outputs DescriptorSet 0 OpDecorate %outputs Binding 1 OpDecorate %outputs Restrict OpDecorate %frag_in Location 0 OpDecorate %frag_out Location 0 %void = OpTypeVoid %main_func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uvec4 = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %ivec4 = OpTypeVector %int 4 %ivec4_ptr = OpTypePointer Uniform %ivec4 %uvec4_ptr = OpTypePointer Uniform %uvec4 %float = OpTypeFloat 32 %vec4 = OpTypeVector %float 4 %vec4_input_ptr = OpTypePointer Input %vec4 %vec4_output_ptr = OpTypePointer Output %vec4 %zero = OpConstant %int 0 %one = OpConstant %int 1 %input_struct = OpTypeStruct %ivec4 %uvec4 %input_struct_ptr = OpTypePointer Uniform %input_struct %inputs = OpVariable %input_struct_ptr Uniform %output_struct = OpTypeStruct %uvec4 %ivec4 %output_struct_ptr = OpTypePointer Uniform %output_struct %outputs = OpVariable %output_struct_ptr Uniform %frag_in = OpVariable %vec4_input_ptr Input %frag_out = OpVariable %vec4_output_ptr Output %func = OpFunction %void None %main_func %block = OpLabel %input1_ptr = OpAccessChain %ivec4_ptr %inputs %zero %input0_ptr = OpAccessChain %uvec4_ptr %inputs %one %input1 = OpLoad %ivec4 %input1_ptr %input0 = OpLoad %uvec4 %input0_ptr %output_ptr_uvec4 = OpAccessChain %uvec4_ptr %outputs %zero %output_ptr_ivec4 = OpAccessChain %ivec4_ptr %outputs %one ; Test all variants of IAdd %result_iadd_0 = OpIAdd %uvec4 %input0 %input1 %result_iadd_1 = OpIAdd %uvec4 %input1 %input0 %result_iadd_2 = OpIAdd %uvec4 %input0 %input0 %result_iadd_3 = OpIAdd %uvec4 %input1 %input1 %result_iadd_4 = OpIAdd %ivec4 %input0 %input0 %result_iadd_5 = OpIAdd %ivec4 %input1 %input1 %result_iadd_6 = OpIAdd %ivec4 %input0 %input1 %result_iadd_7 = OpIAdd %ivec4 %input1 %input0 OpStore %output_ptr_uvec4 %result_iadd_0 OpStore %output_ptr_uvec4 %result_iadd_1 OpStore %output_ptr_uvec4 %result_iadd_2 OpStore %output_ptr_uvec4 %result_iadd_3 OpStore %output_ptr_ivec4 %result_iadd_4 OpStore %output_ptr_ivec4 %result_iadd_5 OpStore %output_ptr_ivec4 %result_iadd_6 OpStore %output_ptr_ivec4 %result_iadd_7 OpReturn OpFunctionEnd %func_alt = OpFunction %void None %main_func %block_alt = OpLabel %frag_input_value = OpLoad %vec4 %frag_in OpStore %frag_out %frag_input_value OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/nmin-max-clamp.asm.comp000066400000000000000000000212161400026215700240200ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 139 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a1" OpMemberName %SSBO 1 "a2" OpMemberName %SSBO 2 "a3" OpMemberName %SSBO 3 "a4" OpMemberName %SSBO 4 "b1" OpMemberName %SSBO 5 "b2" OpMemberName %SSBO 6 "b3" OpMemberName %SSBO 7 "b4" OpMemberName %SSBO 8 "c1" OpMemberName %SSBO 9 "c2" OpMemberName %SSBO 10 "c3" OpMemberName %SSBO 11 "c4" OpName %_ "" OpName %i "i" OpMemberDecorate %SSBO 0 Offset 0 OpMemberDecorate %SSBO 1 Offset 8 OpMemberDecorate %SSBO 2 Offset 16 OpMemberDecorate %SSBO 3 Offset 32 OpMemberDecorate %SSBO 4 Offset 48 OpMemberDecorate %SSBO 5 Offset 56 OpMemberDecorate %SSBO 6 Offset 64 OpMemberDecorate %SSBO 7 Offset 80 OpMemberDecorate %SSBO 8 Offset 96 OpMemberDecorate %SSBO 9 Offset 104 OpMemberDecorate %SSBO 10 Offset 112 OpMemberDecorate %SSBO 11 Offset 128 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %SSBO = OpTypeStruct %float %v2float %v3float %v4float %float %v2float %v3float %v4float %float %v2float %v3float %v4float %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %_ptr_Uniform_float = OpTypePointer Uniform %float %int_8 = OpConstant %int 8 %int_1 = OpConstant %int 1 %int_5 = OpConstant %int 5 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %int_9 = OpConstant %int 9 %int_2 = OpConstant %int 2 %int_6 = OpConstant %int 6 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %int_10 = OpConstant %int 10 %int_3 = OpConstant %int 3 %int_7 = OpConstant %int 7 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_11 = OpConstant %int 11 %_ptr_Function_int = OpTypePointer Function %int %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %7 %35 = OpLabel %i = OpVariable %_ptr_Function_int Function %36 = OpAccessChain %_ptr_Uniform_float %_ %int_4 %37 = OpLoad %float %36 %38 = OpAccessChain %_ptr_Uniform_float %_ %int_8 %39 = OpLoad %float %38 %40 = OpExtInst %float %1 NMin %37 %39 %41 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %41 %40 %42 = OpAccessChain %_ptr_Uniform_v2float %_ %int_5 %43 = OpLoad %v2float %42 %44 = OpAccessChain %_ptr_Uniform_v2float %_ %int_9 %45 = OpLoad %v2float %44 %46 = OpExtInst %v2float %1 NMin %43 %45 %47 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 OpStore %47 %46 %48 = OpAccessChain %_ptr_Uniform_v3float %_ %int_6 %49 = OpLoad %v3float %48 %50 = OpAccessChain %_ptr_Uniform_v3float %_ %int_10 %51 = OpLoad %v3float %50 %52 = OpExtInst %v3float %1 NMin %49 %51 %53 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 OpStore %53 %52 %54 = OpAccessChain %_ptr_Uniform_v4float %_ %int_7 %55 = OpLoad %v4float %54 %56 = OpAccessChain %_ptr_Uniform_v4float %_ %int_11 %57 = OpLoad %v4float %56 %58 = OpExtInst %v4float %1 NMin %55 %57 %59 = OpAccessChain %_ptr_Uniform_v4float %_ %int_3 OpStore %59 %58 %60 = OpAccessChain %_ptr_Uniform_float %_ %int_4 %61 = OpLoad %float %60 %62 = OpAccessChain %_ptr_Uniform_float %_ %int_8 %63 = OpLoad %float %62 %64 = OpExtInst %float %1 NMax %61 %63 %65 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %65 %64 %66 = OpAccessChain %_ptr_Uniform_v2float %_ %int_5 %67 = OpLoad %v2float %66 %68 = OpAccessChain %_ptr_Uniform_v2float %_ %int_9 %69 = OpLoad %v2float %68 %70 = OpExtInst %v2float %1 NMax %67 %69 %71 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 OpStore %71 %70 %72 = OpAccessChain %_ptr_Uniform_v3float %_ %int_6 %73 = OpLoad %v3float %72 %74 = OpAccessChain %_ptr_Uniform_v3float %_ %int_10 %75 = OpLoad %v3float %74 %76 = OpExtInst %v3float %1 NMax %73 %75 %77 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 OpStore %77 %76 %78 = OpAccessChain %_ptr_Uniform_v4float %_ %int_7 %79 = OpLoad %v4float %78 %80 = OpAccessChain %_ptr_Uniform_v4float %_ %int_11 %81 = OpLoad %v4float %80 %82 = OpExtInst %v4float %1 NMax %79 %81 %83 = OpAccessChain %_ptr_Uniform_v4float %_ %int_3 OpStore %83 %82 %84 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %85 = OpLoad %float %84 %86 = OpAccessChain %_ptr_Uniform_float %_ %int_4 %87 = OpLoad %float %86 %88 = OpAccessChain %_ptr_Uniform_float %_ %int_8 %89 = OpLoad %float %88 %90 = OpExtInst %float %1 NClamp %85 %87 %89 %91 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %91 %90 %92 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 %93 = OpLoad %v2float %92 %94 = OpAccessChain %_ptr_Uniform_v2float %_ %int_5 %95 = OpLoad %v2float %94 %96 = OpAccessChain %_ptr_Uniform_v2float %_ %int_9 %97 = OpLoad %v2float %96 %98 = OpExtInst %v2float %1 NClamp %93 %95 %97 %99 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 OpStore %99 %98 %100 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 %101 = OpLoad %v3float %100 %102 = OpAccessChain %_ptr_Uniform_v3float %_ %int_6 %103 = OpLoad %v3float %102 %104 = OpAccessChain %_ptr_Uniform_v3float %_ %int_10 %105 = OpLoad %v3float %104 %106 = OpExtInst %v3float %1 NClamp %101 %103 %105 %107 = OpAccessChain %_ptr_Uniform_v3float %_ %int_2 OpStore %107 %106 %108 = OpAccessChain %_ptr_Uniform_v4float %_ %int_3 %109 = OpLoad %v4float %108 %110 = OpAccessChain %_ptr_Uniform_v4float %_ %int_7 %111 = OpLoad %v4float %110 %112 = OpAccessChain %_ptr_Uniform_v4float %_ %int_11 %113 = OpLoad %v4float %112 %114 = OpExtInst %v4float %1 NClamp %109 %111 %113 %115 = OpAccessChain %_ptr_Uniform_v4float %_ %int_3 OpStore %115 %114 OpStore %i %int_0 OpBranch %116 %116 = OpLabel OpLoopMerge %117 %118 None OpBranch %119 %119 = OpLabel %120 = OpLoad %int %i %121 = OpSLessThan %bool %120 %int_2 OpBranchConditional %121 %122 %117 %122 = OpLabel %123 = OpAccessChain %_ptr_Uniform_v2float %_ %int_5 %124 = OpLoad %v2float %123 %125 = OpAccessChain %_ptr_Uniform_v2float %_ %int_9 %126 = OpLoad %v2float %125 %127 = OpExtInst %v2float %1 NMin %124 %126 %128 = OpAccessChain %_ptr_Uniform_v2float %_ %int_1 OpStore %128 %127 OpBranch %118 %118 = OpLabel %129 = OpLoad %int %i %130 = OpIAdd %int %129 %int_1 OpStore %i %130 %131 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %132 = OpLoad %float %131 %133 = OpAccessChain %_ptr_Uniform_float %_ %int_5 %uint_0 %134 = OpLoad %float %133 %135 = OpAccessChain %_ptr_Uniform_float %_ %int_5 %uint_1 %136 = OpLoad %float %135 %137 = OpExtInst %float %1 NClamp %132 %134 %136 %138 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %138 %137 OpBranch %116 %117 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/op-phi-swap.asm.comp000066400000000000000000000050721400026215700233500ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 39 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %_struct_3 BufferBlock OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 1 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_3 0 Offset 0 %bool = OpTypeBool %void = OpTypeVoid %9 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %v3uint = OpTypeVector %uint 3 %v3float = OpTypeVector %float 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Uniform_int = OpTypePointer Uniform %int %_ptr_Uniform_float = OpTypePointer Uniform %float %_runtimearr_int = OpTypeRuntimeArray %int %_runtimearr_float = OpTypeRuntimeArray %float %_struct_3 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_3 = OpTypePointer Uniform %_struct_3 %4 = OpVariable %_ptr_Uniform__struct_3 Uniform %5 = OpVariable %_ptr_Uniform__struct_3 Uniform %_ptr_Function_float = OpTypePointer Function %float %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %true = OpConstantTrue %bool %false = OpConstantFalse %bool %int_0 = OpConstant %int 0 %float_8_5 = OpConstant %float 8.5 %main = OpFunction %void None %9 %25 = OpLabel %26 = OpVariable %_ptr_Function_float Function %float_8_5 %27 = OpLoad %v3uint %gl_GlobalInvocationID %28 = OpCompositeExtract %uint %27 0 %29 = OpAccessChain %_ptr_Uniform_float %4 %int_0 %28 %30 = OpAccessChain %_ptr_Uniform_float %5 %int_0 %28 %31 = OpLoad %float %29 %32 = OpLoad %float %26 OpBranch %33 %33 = OpLabel %34 = OpPhi %bool %true %25 %false %33 %35 = OpPhi %float %31 %25 %36 %33 %36 = OpPhi %float %32 %25 %35 %33 OpLoopMerge %37 %33 None OpBranchConditional %34 %33 %37 %37 = OpLabel %38 = OpFSub %float %35 %36 OpStore %30 %38 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/quantize.asm.comp000066400000000000000000000045461400026215700230510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 38 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %10 "SSBO0" OpMemberName %10 0 "scalar" OpMemberName %10 1 "vec2_val" OpMemberName %10 2 "vec3_val" OpMemberName %10 3 "vec4_val" OpName %12 "" OpMemberDecorate %10 0 Offset 0 OpMemberDecorate %10 1 Offset 8 OpMemberDecorate %10 2 Offset 16 OpMemberDecorate %10 3 Offset 32 OpDecorate %10 BufferBlock OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypeVector %6 3 %9 = OpTypeVector %6 4 %10 = OpTypeStruct %6 %7 %8 %9 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %13 = OpTypeInt 32 1 %14 = OpConstant %13 0 %15 = OpTypePointer Uniform %6 %20 = OpConstant %13 1 %21 = OpTypePointer Uniform %7 %26 = OpConstant %13 2 %27 = OpTypePointer Uniform %8 %32 = OpConstant %13 3 %33 = OpTypePointer Uniform %9 %4 = OpFunction %2 None %3 %5 = OpLabel %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %6 %16 %18 = OpQuantizeToF16 %6 %17 %19 = OpAccessChain %15 %12 %14 OpStore %19 %18 %22 = OpAccessChain %21 %12 %20 %23 = OpLoad %7 %22 %24 = OpQuantizeToF16 %7 %23 %25 = OpAccessChain %21 %12 %20 OpStore %25 %24 %28 = OpAccessChain %27 %12 %26 %29 = OpLoad %8 %28 %30 = OpQuantizeToF16 %8 %29 %31 = OpAccessChain %27 %12 %26 OpStore %31 %30 %34 = OpAccessChain %33 %12 %32 %35 = OpLoad %9 %34 %36 = OpQuantizeToF16 %9 %35 %37 = OpAccessChain %33 %12 %32 OpStore %37 %36 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/recompile-block-naming.asm.comp000066400000000000000000000140121400026215700255140ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 97 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %a "a" OpName %byteAddrTemp "byteAddrTemp" OpName %MyFirstBuffer "MyFirstBuffer" OpMemberName %MyFirstBuffer 0 "@data" OpName %MyFirstBuffer_0 "MyFirstBuffer" OpName %b "b" OpName %byteAddrTemp_0 "byteAddrTemp" OpName %MySecondBuffer "MySecondBuffer" OpName %byteAddrTemp_1 "byteAddrTemp" OpName %MyThirdBuffer "MyThirdBuffer" OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %MyFirstBuffer 0 Offset 0 OpDecorate %MyFirstBuffer BufferBlock OpDecorate %MyFirstBuffer_0 DescriptorSet 0 OpDecorate %MyFirstBuffer_0 Binding 0 OpDecorate %MySecondBuffer DescriptorSet 0 OpDecorate %MySecondBuffer Binding 0 OpDecorate %MyThirdBuffer DescriptorSet 0 OpDecorate %MyThirdBuffer Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v4uint = OpTypeVector %uint 4 %_ptr_Function_v4uint = OpTypePointer Function %v4uint %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_runtimearr_uint = OpTypeRuntimeArray %uint %MyFirstBuffer = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_MyFirstBuffer = OpTypePointer Uniform %MyFirstBuffer %MyFirstBuffer_0 = OpVariable %_ptr_Uniform_MyFirstBuffer Uniform %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %MySecondBuffer = OpVariable %_ptr_Uniform_MyFirstBuffer Uniform %MyThirdBuffer = OpVariable %_ptr_Uniform_MyFirstBuffer Uniform %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %main = OpFunction %void None %3 %5 = OpLabel %96 = OpFunctionCall %void %_main_ OpReturn OpFunctionEnd %_main_ = OpFunction %void None %3 %7 = OpLabel %a = OpVariable %_ptr_Function_v4uint Function %byteAddrTemp = OpVariable %_ptr_Function_int Function %b = OpVariable %_ptr_Function_v4uint Function %byteAddrTemp_0 = OpVariable %_ptr_Function_int Function %byteAddrTemp_1 = OpVariable %_ptr_Function_int Function %17 = OpShiftRightArithmetic %int %int_0 %int_2 OpStore %byteAddrTemp %17 %22 = OpLoad %int %byteAddrTemp %24 = OpAccessChain %_ptr_Uniform_uint %MyFirstBuffer_0 %int_0 %22 %25 = OpLoad %uint %24 %26 = OpLoad %int %byteAddrTemp %28 = OpIAdd %int %26 %int_1 %29 = OpAccessChain %_ptr_Uniform_uint %MyFirstBuffer_0 %int_0 %28 %30 = OpLoad %uint %29 %31 = OpLoad %int %byteAddrTemp %32 = OpIAdd %int %31 %int_2 %33 = OpAccessChain %_ptr_Uniform_uint %MyFirstBuffer_0 %int_0 %32 %34 = OpLoad %uint %33 %35 = OpLoad %int %byteAddrTemp %37 = OpIAdd %int %35 %int_3 %38 = OpAccessChain %_ptr_Uniform_uint %MyFirstBuffer_0 %int_0 %37 %39 = OpLoad %uint %38 %40 = OpCompositeConstruct %v4uint %25 %30 %34 %39 OpStore %a %40 %44 = OpShiftRightArithmetic %int %int_4 %int_2 OpStore %byteAddrTemp_0 %44 %46 = OpLoad %int %byteAddrTemp_0 %47 = OpAccessChain %_ptr_Uniform_uint %MySecondBuffer %int_0 %46 %48 = OpLoad %uint %47 %49 = OpLoad %int %byteAddrTemp_0 %50 = OpIAdd %int %49 %int_1 %51 = OpAccessChain %_ptr_Uniform_uint %MySecondBuffer %int_0 %50 %52 = OpLoad %uint %51 %53 = OpLoad %int %byteAddrTemp_0 %54 = OpIAdd %int %53 %int_2 %55 = OpAccessChain %_ptr_Uniform_uint %MySecondBuffer %int_0 %54 %56 = OpLoad %uint %55 %57 = OpLoad %int %byteAddrTemp_0 %58 = OpIAdd %int %57 %int_3 %59 = OpAccessChain %_ptr_Uniform_uint %MySecondBuffer %int_0 %58 %60 = OpLoad %uint %59 %61 = OpCompositeConstruct %v4uint %48 %52 %56 %60 OpStore %b %61 %63 = OpShiftRightArithmetic %int %int_0 %int_2 OpStore %byteAddrTemp_1 %63 %65 = OpLoad %int %byteAddrTemp_1 %66 = OpLoad %v4uint %a %67 = OpLoad %v4uint %b %68 = OpIAdd %v4uint %66 %67 %70 = OpCompositeExtract %uint %68 0 %71 = OpAccessChain %_ptr_Uniform_uint %MyThirdBuffer %int_0 %65 OpStore %71 %70 %72 = OpLoad %int %byteAddrTemp_1 %73 = OpIAdd %int %72 %int_1 %74 = OpLoad %v4uint %a %75 = OpLoad %v4uint %b %76 = OpIAdd %v4uint %74 %75 %78 = OpCompositeExtract %uint %76 1 %79 = OpAccessChain %_ptr_Uniform_uint %MyThirdBuffer %int_0 %73 OpStore %79 %78 %80 = OpLoad %int %byteAddrTemp_1 %81 = OpIAdd %int %80 %int_2 %82 = OpLoad %v4uint %a %83 = OpLoad %v4uint %b %84 = OpIAdd %v4uint %82 %83 %86 = OpCompositeExtract %uint %84 2 %87 = OpAccessChain %_ptr_Uniform_uint %MyThirdBuffer %int_0 %81 OpStore %87 %86 %88 = OpLoad %int %byteAddrTemp_1 %89 = OpIAdd %int %88 %int_3 %90 = OpLoad %v4uint %a %91 = OpLoad %v4uint %b %92 = OpIAdd %v4uint %90 %91 %94 = OpCompositeExtract %uint %92 3 %95 = OpAccessChain %_ptr_Uniform_uint %MyThirdBuffer %int_0 %89 OpStore %95 %94 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/specialization-constant-workgroup.asm.comp000066400000000000000000000033751400026215700301120ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 24 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 20 1 OpSource ESSL 310 OpName %main "main" OpName %SSBO "SSBO" OpMemberName %SSBO 0 "a" OpName %_ "" OpMemberDecorate %SSBO 0 Offset 0 OpDecorate %SSBO BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %19 SpecId 10 OpDecorate %21 SpecId 12 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %SSBO = OpTypeStruct %float %_ptr_Uniform_SSBO = OpTypePointer Uniform %SSBO %_ = OpVariable %_ptr_Uniform_SSBO Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %uint = OpTypeInt 32 0 %19 = OpSpecConstant %uint 9 %uint_20 = OpConstant %uint 20 %21 = OpSpecConstant %uint 4 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %19 %uint_20 %21 %main = OpFunction %void None %3 %5 = OpLabel %14 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %15 = OpLoad %float %14 %16 = OpFAdd %float %15 %float_1 %17 = OpAccessChain %_ptr_Uniform_float %_ %int_0 OpStore %17 %16 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/comp/switch-break-ladder.asm.comp000066400000000000000000000060571400026215700250240ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 50 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %c "c" OpName %BUF "BUF" OpMemberName %BUF 0 "a" OpMemberName %BUF 1 "b" OpMemberName %BUF 2 "d" OpName %o "o" OpName %a "a" OpMemberDecorate %BUF 0 Offset 0 OpMemberDecorate %BUF 1 Offset 4 OpMemberDecorate %BUF 2 Offset 8 OpDecorate %BUF BufferBlock OpDecorate %o DescriptorSet 0 OpDecorate %o Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %BUF = OpTypeStruct %int %int %int %_ptr_Uniform_BUF = OpTypePointer Uniform %BUF %o = OpVariable %_ptr_Uniform_BUF Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform_int = OpTypePointer Uniform %int %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %c = OpVariable %_ptr_Function_int Function %a = OpVariable %_ptr_Function_int Function %14 = OpAccessChain %_ptr_Uniform_int %o %int_0 %15 = OpLoad %int %14 OpStore %c %15 OpBranch %16 %16 = OpLabel OpLoopMerge %18 %19 None OpBranch %17 %17 = OpLabel %20 = OpLoad %int %c OpSelectionMerge %23 None OpSwitch %20 %23 5 %21 1 %22 2 %22 3 %22 %21 = OpLabel OpBranch %24 %24 = OpLabel OpLoopMerge %26 %27 None OpBranch %25 %25 = OpLabel %29 = OpAccessChain %_ptr_Uniform_int %o %int_2 %30 = OpLoad %int %29 OpSelectionMerge %33 None OpSwitch %30 %32 10 %31 20 %31 %32 = OpLabel OpBranch %27 %31 = OpLabel %34 = OpLoad %int %c %35 = OpLoad %int %c %36 = OpIAdd %int %35 %34 OpStore %c %36 OpBranch %26 %33 = OpLabel OpUnreachable %27 = OpLabel OpBranch %24 %26 = OpLabel OpBranch %23 %22 = OpLabel %42 = OpLoad %int %c OpStore %a %42 OpBranch %18 %23 = OpLabel %45 = OpLoad %int %c %47 = OpIAdd %int %45 %int_1 OpStore %c %47 OpBranch %19 %19 = OpLabel OpBranch %16 %18 = OpLabel %48 = OpLoad %int %a %49 = OpAccessChain %_ptr_Uniform_int %o %int_1 OpStore %49 %48 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/000077500000000000000000000000001400026215700175225ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/asm/frag/combined-sampler-reuse.vk.asm.frag000066400000000000000000000044421400026215700261270ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 36 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vUV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %uTex "uTex" OpName %uSampler "uSampler" OpName %vUV "vUV" OpDecorate %FragColor Location 0 OpDecorate %uTex DescriptorSet 0 OpDecorate %uTex Binding 1 OpDecorate %uSampler DescriptorSet 0 OpDecorate %uSampler Binding 0 OpDecorate %vUV Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %uTex = OpVariable %_ptr_UniformConstant_10 UniformConstant %14 = OpTypeSampler %_ptr_UniformConstant_14 = OpTypePointer UniformConstant %14 %uSampler = OpVariable %_ptr_UniformConstant_14 UniformConstant %18 = OpTypeSampledImage %10 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %vUV = OpVariable %_ptr_Input_v2float Input %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %int_1 = OpConstant %int 1 %32 = OpConstantComposite %v2int %int_1 %int_1 %main = OpFunction %void None %3 %5 = OpLabel %13 = OpLoad %10 %uTex %17 = OpLoad %14 %uSampler %19 = OpSampledImage %18 %13 %17 %23 = OpLoad %v2float %vUV %24 = OpImageSampleImplicitLod %v4float %19 %23 OpStore %FragColor %24 %28 = OpLoad %v2float %vUV %33 = OpImageSampleImplicitLod %v4float %19 %28 ConstOffset %32 %34 = OpLoad %v4float %FragColor %35 = OpFAdd %v4float %34 %33 OpStore %FragColor %35 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/complex-name-workarounds.asm.frag000066400000000000000000000060651400026215700261120ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 47 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %a %b %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %func__vf4_ "fu__nc_" OpName %a_ "a_" OpName %func_2_vf4_ "fu__nc_" OpName %a_2 "___" OpName %c0 "___" OpName %a "__" OpName %b "a" OpName %param "b" OpName %c1 "b" OpName %param_0 "b" OpName %FragColor "b" OpDecorate %a Location 0 OpDecorate %b Location 1 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %9 = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %a = OpVariable %_ptr_Input_v4float Input %b = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %c0 = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %c1 = OpVariable %_ptr_Function_v4float Function %param_0 = OpVariable %_ptr_Function_v4float Function %25 = OpLoad %v4float %a %27 = OpLoad %v4float %b %28 = OpFAdd %v4float %25 %27 %30 = OpLoad %v4float %a OpStore %param %30 %31 = OpFunctionCall %v4float %func__vf4_ %param %32 = OpFAdd %v4float %28 %31 OpStore %c0 %32 %34 = OpLoad %v4float %a %35 = OpLoad %v4float %b %36 = OpFSub %v4float %34 %35 %38 = OpLoad %v4float %b OpStore %param_0 %38 %39 = OpFunctionCall %v4float %func_2_vf4_ %param_0 %40 = OpFAdd %v4float %36 %39 OpStore %c1 %40 %43 = OpLoad %v4float %c0 OpStore %FragColor %43 %44 = OpLoad %v4float %c1 OpStore %FragColor %44 %45 = OpLoad %v4float %c0 OpStore %FragColor %45 %46 = OpLoad %v4float %c1 OpStore %FragColor %46 OpReturn OpFunctionEnd %func__vf4_ = OpFunction %v4float None %9 %a_ = OpFunctionParameter %_ptr_Function_v4float %12 = OpLabel %16 = OpLoad %v4float %a_ OpReturnValue %16 OpFunctionEnd %func_2_vf4_ = OpFunction %v4float None %9 %a_2 = OpFunctionParameter %_ptr_Function_v4float %15 = OpLabel %19 = OpLoad %v4float %a_2 OpReturnValue %19 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/composite-construct-struct-no-swizzle.asm.frag000066400000000000000000000040771400026215700306370ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 39 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %foo %FooOut OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %foo "foo" OpName %SwizzleTest "SwizzleTest" OpMemberName %SwizzleTest 0 "a" OpMemberName %SwizzleTest 1 "b" OpName %FooOut "FooOut" OpDecorate %foo RelaxedPrecision OpDecorate %foo Location 0 OpDecorate %12 RelaxedPrecision OpMemberDecorate %SwizzleTest 0 RelaxedPrecision OpMemberDecorate %SwizzleTest 1 RelaxedPrecision OpDecorate %FooOut RelaxedPrecision OpDecorate %FooOut Location 0 OpDecorate %34 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %foo = OpVariable %_ptr_Input_v2float Input %SwizzleTest = OpTypeStruct %float %float %_ptr_Function_SwizzleTest = OpTypePointer Function %SwizzleTest %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_float = OpTypePointer Output %float %FooOut = OpVariable %_ptr_Output_float Output %int = OpTypeInt 32 1 %main = OpFunction %void None %3 %5 = OpLabel %12 = OpLoad %v2float %foo %36 = OpCompositeExtract %float %12 0 %38 = OpCompositeExtract %float %12 1 %test0 = OpCompositeConstruct %SwizzleTest %36 %38 %new0 = OpCompositeExtract %float %test0 0 %new1 = OpCompositeExtract %float %test0 1 %34 = OpFAdd %float %new0 %new1 OpStore %FooOut %34 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/default-member-names.asm.frag000066400000000000000000000045351400026215700251430ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 43 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %12 = OpTypeFunction %v4float %_struct_5 = OpTypeStruct %float %_struct_6 = OpTypeStruct %float %float %float %float %float %float %float %float %float %float %float %float %_struct_5 %_ptr_Function__struct_6 = OpTypePointer Function %_struct_6 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Function_float = OpTypePointer Function %float %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %2 = OpFunction %void None %9 %22 = OpLabel %23 = OpVariable %_ptr_Function__struct_6 Function %24 = OpAccessChain %_ptr_Function_float %23 %int_0 %25 = OpLoad %float %24 %26 = OpAccessChain %_ptr_Function_float %23 %int_1 %27 = OpLoad %float %26 %28 = OpAccessChain %_ptr_Function_float %23 %int_2 %29 = OpLoad %float %28 %30 = OpAccessChain %_ptr_Function_float %23 %int_3 %31 = OpLoad %float %30 %32 = OpCompositeConstruct %v4float %25 %27 %29 %31 OpStore %3 %32 OpReturn OpFunctionEnd %4 = OpFunction %v4float None %12 %33 = OpLabel %7 = OpVariable %_ptr_Function__struct_6 Function %34 = OpAccessChain %_ptr_Function_float %7 %int_0 %35 = OpLoad %float %34 %36 = OpAccessChain %_ptr_Function_float %7 %int_1 %37 = OpLoad %float %36 %38 = OpAccessChain %_ptr_Function_float %7 %int_2 %39 = OpLoad %float %38 %40 = OpAccessChain %_ptr_Function_float %7 %int_3 %41 = OpLoad %float %40 %42 = OpCompositeConstruct %v4float %35 %37 %39 %41 OpReturnValue %42 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/do-while-statement-fallback.asm.frag000066400000000000000000000047171400026215700264220ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 35 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %foo "foo" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %bool = OpTypeBool %false = OpConstantFalse %bool %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %float_5 = OpConstant %float 5 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %foo = OpVariable %_ptr_Function_float Function OpStore %foo %float_1 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %11 %11 = OpLabel OpBranch %13 %13 = OpLabel OpStore %foo %float_2 OpBranchConditional %false %10 %12 %12 = OpLabel OpBranch %17 %17 = OpLabel OpLoopMerge %19 %20 None OpBranch %18 %18 = OpLabel OpBranch %20 %20 = OpLabel OpStore %foo %float_3 OpBranchConditional %false %17 %19 %19 = OpLabel OpBranch %22 %22 = OpLabel OpLoopMerge %24 %25 None OpBranch %23 %23 = OpLabel OpBranch %25 %25 = OpLabel OpStore %foo %float_4 OpBranchConditional %false %22 %24 %24 = OpLabel OpBranch %27 %27 = OpLabel OpLoopMerge %29 %30 None OpBranch %28 %28 = OpLabel OpBranch %30 %30 = OpLabel OpStore %foo %float_5 OpBranchConditional %false %27 %29 %29 = OpLabel %34 = OpLoad %float %foo OpStore %FragColor %34 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/empty-struct.asm.frag000066400000000000000000000041221400026215700236210ustar00rootroot00000000000000; SPIR-V ; Version: 1.2 ; Generator: Khronos; 0 ; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %EntryPoint_Main "main" OpExecutionMode %EntryPoint_Main OriginUpperLeft OpSource Unknown 100 OpName %EmptyStructTest "EmptyStructTest" OpName %GetValue "GetValue" OpName %GetValue2 "GetValue" OpName %self "self" OpName %self2 "self" OpName %emptyStruct "emptyStruct" OpName %value "value" OpName %EntryPoint_Main "EntryPoint_Main" %EmptyStructTest = OpTypeStruct %_ptr_Function_EmptyStructTest = OpTypePointer Function %EmptyStructTest %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %5 = OpTypeFunction %float %_ptr_Function_EmptyStructTest %6 = OpTypeFunction %float %EmptyStructTest %void = OpTypeVoid %_ptr_Function_void = OpTypePointer Function %void %8 = OpTypeFunction %void %_ptr_Function_EmptyStructTest %9 = OpTypeFunction %void %float_0 = OpConstant %float 0 %GetValue = OpFunction %float None %5 %self = OpFunctionParameter %_ptr_Function_EmptyStructTest %13 = OpLabel OpReturnValue %float_0 OpFunctionEnd %GetValue2 = OpFunction %float None %6 %self2 = OpFunctionParameter %EmptyStructTest %14 = OpLabel OpReturnValue %float_0 OpFunctionEnd %EntryPoint_Main = OpFunction %void None %9 %37 = OpLabel %emptyStruct = OpVariable %_ptr_Function_EmptyStructTest Function %18 = OpVariable %_ptr_Function_EmptyStructTest Function %value = OpVariable %_ptr_Function_float Function %value2 = OpCompositeConstruct %EmptyStructTest %22 = OpFunctionCall %float %GetValue %emptyStruct %23 = OpFunctionCall %float %GetValue2 %value2 OpStore %value %22 OpStore %value %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/for-loop-phi-only-continue.asm.frag000066400000000000000000000032271400026215700262620ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 51 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %bool = OpTypeBool %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %float_2 = OpConstant %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel OpBranch %14 %14 = OpLabel %50 = OpPhi %float %float_0 %5 %25 %15 %47 = OpPhi %int %int_0 %5 %28 %15 %22 = OpSLessThan %bool %47 %int_16 OpLoopMerge %16 %15 None OpBranchConditional %22 %body1 %16 %body1 = OpLabel %25 = OpFAdd %float %50 %float_1 %28 = OpIAdd %int %47 %int_1 OpBranch %15 %15 = OpLabel OpBranch %14 %16 = OpLabel %46 = OpCompositeConstruct %v4float %50 %50 %50 %50 OpStore %FragColor %46 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/frem.asm.frag000066400000000000000000000030741400026215700220770ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 16 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vA %vB OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %vA "vA" OpName %vB "vB" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %vA RelaxedPrecision OpDecorate %vA Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %vB RelaxedPrecision OpDecorate %vB Location 1 OpDecorate %14 RelaxedPrecision OpDecorate %15 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %vA = OpVariable %_ptr_Input_v4float Input %vB = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %3 %5 = OpLabel %12 = OpLoad %v4float %vA %14 = OpLoad %v4float %vB %15 = OpFRem %v4float %12 %14 OpStore %FragColor %15 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/function-overload-alias.asm.frag000066400000000000000000000150611400026215700256720ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 76 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %foobar_vf4_ "foo" OpName %a "foo" OpName %foobar_vf3_ "foo" OpName %a_0 "foo" OpName %foobaz_vf4_ "foo" OpName %a_1 "foo" OpName %foobaz_vf2_ "foo" OpName %a_2 "foo" OpName %a_3 "foo" OpName %param "foo" OpName %b "foo" OpName %param_0 "foo" OpName %c "foo" OpName %param_1 "foo" OpName %d "foo" OpName %param_2 "foo" OpName %FragColor "FragColor" OpDecorate %foobar_vf4_ RelaxedPrecision OpDecorate %a RelaxedPrecision OpDecorate %foobar_vf3_ RelaxedPrecision OpDecorate %a_0 RelaxedPrecision OpDecorate %foobaz_vf4_ RelaxedPrecision OpDecorate %a_1 RelaxedPrecision OpDecorate %foobaz_vf2_ RelaxedPrecision OpDecorate %a_2 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %a_3 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %b RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %c RelaxedPrecision OpDecorate %62 RelaxedPrecision OpDecorate %d RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %69 RelaxedPrecision OpDecorate %70 RelaxedPrecision OpDecorate %71 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %74 RelaxedPrecision OpDecorate %75 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %9 = OpTypeFunction %v4float %_ptr_Function_v4float %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %15 = OpTypeFunction %v4float %_ptr_Function_v3float %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %24 = OpTypeFunction %v4float %_ptr_Function_v2float %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %53 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %57 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %64 = OpConstantComposite %v2float %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %a_3 = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %b = OpVariable %_ptr_Function_v4float Function %param_0 = OpVariable %_ptr_Function_v3float Function %c = OpVariable %_ptr_Function_v4float Function %param_1 = OpVariable %_ptr_Function_v4float Function %d = OpVariable %_ptr_Function_v4float Function %param_2 = OpVariable %_ptr_Function_v2float Function OpStore %param %53 %55 = OpFunctionCall %v4float %foobar_vf4_ %param OpStore %a_3 %55 OpStore %param_0 %57 %59 = OpFunctionCall %v4float %foobar_vf3_ %param_0 OpStore %b %59 OpStore %param_1 %53 %62 = OpFunctionCall %v4float %foobaz_vf4_ %param_1 OpStore %c %62 OpStore %param_2 %64 %66 = OpFunctionCall %v4float %foobaz_vf2_ %param_2 OpStore %d %66 %69 = OpLoad %v4float %a_3 %70 = OpLoad %v4float %b %71 = OpFAdd %v4float %69 %70 %72 = OpLoad %v4float %c %73 = OpFAdd %v4float %71 %72 %74 = OpLoad %v4float %d %75 = OpFAdd %v4float %73 %74 OpStore %FragColor %75 OpReturn OpFunctionEnd %foobar_vf4_ = OpFunction %v4float None %9 %a = OpFunctionParameter %_ptr_Function_v4float %12 = OpLabel %28 = OpLoad %v4float %a %30 = OpCompositeConstruct %v4float %float_1 %float_1 %float_1 %float_1 %31 = OpFAdd %v4float %28 %30 OpReturnValue %31 OpFunctionEnd %foobar_vf3_ = OpFunction %v4float None %15 %a_0 = OpFunctionParameter %_ptr_Function_v3float %18 = OpLabel %34 = OpLoad %v3float %a_0 %35 = OpVectorShuffle %v4float %34 %34 0 1 2 2 %36 = OpCompositeConstruct %v4float %float_1 %float_1 %float_1 %float_1 %37 = OpFAdd %v4float %35 %36 OpReturnValue %37 OpFunctionEnd %foobaz_vf4_ = OpFunction %v4float None %9 %a_1 = OpFunctionParameter %_ptr_Function_v4float %21 = OpLabel %40 = OpLoad %v4float %a_1 %42 = OpCompositeConstruct %v4float %float_2 %float_2 %float_2 %float_2 %43 = OpFAdd %v4float %40 %42 OpReturnValue %43 OpFunctionEnd %foobaz_vf2_ = OpFunction %v4float None %24 %a_2 = OpFunctionParameter %_ptr_Function_v2float %27 = OpLabel %46 = OpLoad %v2float %a_2 %47 = OpVectorShuffle %v4float %46 %46 0 1 0 1 %48 = OpCompositeConstruct %v4float %float_2 %float_2 %float_2 %float_2 %49 = OpFAdd %v4float %47 %48 OpReturnValue %49 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/hlsl-sample-cmp-level-zero-cube.asm.frag000066400000000000000000000051561400026215700271450ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 38 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %pointLightShadowMap "pointLightShadowMap" OpName %shadowSamplerPCF "shadowSamplerPCF" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %pointLightShadowMap DescriptorSet 0 OpDecorate %shadowSamplerPCF DescriptorSet 0 OpDecorate %pointLightShadowMap Binding 0 OpDecorate %shadowSamplerPCF Binding 1 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeFunction %float %10 = OpTypeImage %float Cube 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %pointLightShadowMap = OpVariable %_ptr_UniformConstant_10 UniformConstant %14 = OpTypeSampler %_ptr_UniformConstant_14 = OpTypePointer UniformConstant %14 %shadowSamplerPCF = OpVariable %_ptr_UniformConstant_14 UniformConstant %18 = OpTypeImage %float Cube 1 0 0 1 Unknown %19 = OpTypeSampledImage %18 %v3float = OpTypeVector %float 3 %float_0_1 = OpConstant %float 0.1 %23 = OpConstantComposite %v3float %float_0_1 %float_0_1 %float_0_1 %float_0_5 = OpConstant %float 0.5 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %_ptr_Output_float = OpTypePointer Output %float %_entryPointOutput = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %37 = OpFunctionCall %float %_main_ OpStore %_entryPointOutput %37 OpReturn OpFunctionEnd %_main_ = OpFunction %float None %7 %9 = OpLabel %13 = OpLoad %10 %pointLightShadowMap %17 = OpLoad %14 %shadowSamplerPCF %20 = OpSampledImage %19 %13 %17 %26 = OpCompositeExtract %float %23 0 %27 = OpCompositeExtract %float %23 1 %28 = OpCompositeExtract %float %23 2 %29 = OpCompositeConstruct %v4float %26 %27 %28 %float_0_5 %31 = OpCompositeExtract %float %29 3 %32 = OpImageSampleDrefExplicitLod %float %20 %29 %31 Lod %float_0 OpReturnValue %32 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/hlsl-sample-cmp-level-zero.asm.frag000066400000000000000000000123061400026215700262240ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 70 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %texCoords_1 %cascadeIndex_1 %fragDepth_1 %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %_main_vf2_f1_f1_ "@main(vf2;f1;f1;" OpName %texCoords "texCoords" OpName %cascadeIndex "cascadeIndex" OpName %fragDepth "fragDepth" OpName %c "c" OpName %ShadowMap "ShadowMap" OpName %ShadowSamplerPCF "ShadowSamplerPCF" OpName %texCoords_0 "texCoords" OpName %texCoords_1 "texCoords" OpName %cascadeIndex_0 "cascadeIndex" OpName %cascadeIndex_1 "cascadeIndex" OpName %fragDepth_0 "fragDepth" OpName %fragDepth_1 "fragDepth" OpName %_entryPointOutput "@entryPointOutput" OpName %param "param" OpName %param_0 "param" OpName %param_1 "param" OpDecorate %ShadowMap DescriptorSet 0 OpDecorate %ShadowSamplerPCF DescriptorSet 0 OpDecorate %ShadowMap Binding 0 OpDecorate %ShadowSamplerPCF Binding 1 OpDecorate %texCoords_1 Location 0 OpDecorate %cascadeIndex_1 Location 1 OpDecorate %fragDepth_1 Location 2 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Function_float = OpTypePointer Function %float %v4float = OpTypeVector %float 4 %11 = OpTypeFunction %v4float %_ptr_Function_v2float %_ptr_Function_float %_ptr_Function_float %18 = OpTypeImage %float 2D 0 1 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %ShadowMap = OpVariable %_ptr_UniformConstant_18 UniformConstant %22 = OpTypeSampler %_ptr_UniformConstant_22 = OpTypePointer UniformConstant %22 %ShadowSamplerPCF = OpVariable %_ptr_UniformConstant_22 UniformConstant %26 = OpTypeImage %float 2D 1 1 0 1 Unknown %27 = OpTypeSampledImage %26 %v3float = OpTypeVector %float 3 %float_0 = OpConstant %float 0 %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords_1 = OpVariable %_ptr_Input_v2float Input %_ptr_Input_float = OpTypePointer Input %float %cascadeIndex_1 = OpVariable %_ptr_Input_float Input %fragDepth_1 = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %texCoords_0 = OpVariable %_ptr_Function_v2float Function %cascadeIndex_0 = OpVariable %_ptr_Function_float Function %fragDepth_0 = OpVariable %_ptr_Function_float Function %param = OpVariable %_ptr_Function_v2float Function %param_0 = OpVariable %_ptr_Function_float Function %param_1 = OpVariable %_ptr_Function_float Function %53 = OpLoad %v2float %texCoords_1 OpStore %texCoords_0 %53 %57 = OpLoad %float %cascadeIndex_1 OpStore %cascadeIndex_0 %57 %60 = OpLoad %float %fragDepth_1 OpStore %fragDepth_0 %60 %64 = OpLoad %v2float %texCoords_0 OpStore %param %64 %66 = OpLoad %float %cascadeIndex_0 OpStore %param_0 %66 %68 = OpLoad %float %fragDepth_0 OpStore %param_1 %68 %69 = OpFunctionCall %v4float %_main_vf2_f1_f1_ %param %param_0 %param_1 OpStore %_entryPointOutput %69 OpReturn OpFunctionEnd %_main_vf2_f1_f1_ = OpFunction %v4float None %11 %texCoords = OpFunctionParameter %_ptr_Function_v2float %cascadeIndex = OpFunctionParameter %_ptr_Function_float %fragDepth = OpFunctionParameter %_ptr_Function_float %16 = OpLabel %c = OpVariable %_ptr_Function_float Function %21 = OpLoad %18 %ShadowMap %25 = OpLoad %22 %ShadowSamplerPCF %28 = OpSampledImage %27 %21 %25 %29 = OpLoad %v2float %texCoords %30 = OpLoad %float %cascadeIndex %32 = OpCompositeExtract %float %29 0 %33 = OpCompositeExtract %float %29 1 %34 = OpCompositeConstruct %v3float %32 %33 %30 %35 = OpLoad %float %fragDepth %36 = OpCompositeExtract %float %34 0 %37 = OpCompositeExtract %float %34 1 %38 = OpCompositeExtract %float %34 2 %39 = OpCompositeConstruct %v4float %36 %37 %38 %35 %41 = OpCompositeExtract %float %39 3 %42 = OpImageSampleDrefExplicitLod %float %28 %39 %41 Lod %float_0 OpStore %c %42 %43 = OpLoad %float %c %44 = OpLoad %float %c %45 = OpLoad %float %c %46 = OpLoad %float %c %47 = OpCompositeConstruct %v4float %43 %44 %45 %46 OpReturnValue %47 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/image-extract-reuse.asm.frag000066400000000000000000000030251400026215700250150ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 19 ; Schema: 0 OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %Size OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %Size "Size" OpName %uTexture "uTexture" OpDecorate %Size Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %_ptr_Output_v2int = OpTypePointer Output %v2int %Size = OpVariable %_ptr_Output_v2int Output %float = OpTypeFloat 32 %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %12 = OpTypeSampledImage %11 %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %uTexture = OpVariable %_ptr_UniformConstant_12 UniformConstant %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpLoad %12 %uTexture %17 = OpImage %11 %15 %18 = OpImageQuerySizeLod %v2int %17 %int_0 %19 = OpImageQuerySizeLod %v2int %17 %int_1 %20 = OpIAdd %v2int %18 %19 OpStore %Size %20 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/image-fetch-no-sampler.asm.vk.frag000066400000000000000000000156251400026215700260160ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 113 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %xIn_1 %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %sample_fetch_t21_vi3_ "sample_fetch(t21;vi3;" OpName %tex "tex" OpName %UV "UV" OpName %sample_sampler_t21_vf2_ "sample_sampler(t21;vf2;" OpName %tex_0 "tex" OpName %UV_0 "UV" OpName %_main_vf4_ "@main(vf4;" OpName %xIn "xIn" OpName %Sampler "Sampler" OpName %coord "coord" OpName %value "value" OpName %SampledImage "SampledImage" OpName %param "param" OpName %param_0 "param" OpName %param_1 "param" OpName %param_2 "param" OpName %xIn_0 "xIn" OpName %xIn_1 "xIn" OpName %_entryPointOutput "@entryPointOutput" OpName %param_3 "param" OpDecorate %Sampler DescriptorSet 0 OpDecorate %Sampler Binding 0 OpDecorate %SampledImage DescriptorSet 0 OpDecorate %SampledImage Binding 0 OpDecorate %xIn_1 BuiltIn FragCoord OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_Function_7 = OpTypePointer Function %7 %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 %_ptr_Function_v3int = OpTypePointer Function %v3int %v4float = OpTypeVector %float 4 %13 = OpTypeFunction %v4float %_ptr_Function_7 %_ptr_Function_v3int %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %20 = OpTypeFunction %v4float %_ptr_Function_7 %_ptr_Function_v2float %_ptr_Function_v4float = OpTypePointer Function %v4float %26 = OpTypeFunction %v4float %_ptr_Function_v4float %v2int = OpTypeVector %int 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_Function_int = OpTypePointer Function %int %43 = OpTypeSampler %_ptr_UniformConstant_43 = OpTypePointer UniformConstant %43 %Sampler = OpVariable %_ptr_UniformConstant_43 UniformConstant %47 = OpTypeSampledImage %7 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %float_1280 = OpConstant %float 1280 %uint_1 = OpConstant %uint 1 %float_720 = OpConstant %float 720 %int_0 = OpConstant %int 0 %_ptr_UniformConstant_7 = OpTypePointer UniformConstant %7 %SampledImage = OpVariable %_ptr_UniformConstant_7 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %xIn_1 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %xIn_0 = OpVariable %_ptr_Function_v4float Function %param_3 = OpVariable %_ptr_Function_v4float Function %107 = OpLoad %v4float %xIn_1 OpStore %xIn_0 %107 %111 = OpLoad %v4float %xIn_0 OpStore %param_3 %111 %112 = OpFunctionCall %v4float %_main_vf4_ %param_3 OpStore %_entryPointOutput %112 OpReturn OpFunctionEnd %sample_fetch_t21_vi3_ = OpFunction %v4float None %13 %tex = OpFunctionParameter %_ptr_Function_7 %UV = OpFunctionParameter %_ptr_Function_v3int %17 = OpLabel %30 = OpLoad %7 %tex %32 = OpLoad %v3int %UV %33 = OpVectorShuffle %v2int %32 %32 0 1 %37 = OpAccessChain %_ptr_Function_int %UV %uint_2 %38 = OpLoad %int %37 %39 = OpImageFetch %v4float %30 %33 Lod %38 OpReturnValue %39 OpFunctionEnd %sample_sampler_t21_vf2_ = OpFunction %v4float None %20 %tex_0 = OpFunctionParameter %_ptr_Function_7 %UV_0 = OpFunctionParameter %_ptr_Function_v2float %24 = OpLabel %42 = OpLoad %7 %tex_0 %46 = OpLoad %43 %Sampler %48 = OpSampledImage %47 %42 %46 %49 = OpLoad %v2float %UV_0 %50 = OpImageSampleImplicitLod %v4float %48 %49 OpReturnValue %50 OpFunctionEnd %_main_vf4_ = OpFunction %v4float None %26 %xIn = OpFunctionParameter %_ptr_Function_v4float %29 = OpLabel %coord = OpVariable %_ptr_Function_v3int Function %value = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_7 Function %param_0 = OpVariable %_ptr_Function_v3int Function %param_1 = OpVariable %_ptr_Function_7 Function %param_2 = OpVariable %_ptr_Function_v2float Function %56 = OpAccessChain %_ptr_Function_float %xIn %uint_0 %57 = OpLoad %float %56 %59 = OpFMul %float %57 %float_1280 %60 = OpConvertFToS %int %59 %62 = OpAccessChain %_ptr_Function_float %xIn %uint_1 %63 = OpLoad %float %62 %65 = OpFMul %float %63 %float_720 %66 = OpConvertFToS %int %65 %68 = OpCompositeConstruct %v3int %60 %66 %int_0 OpStore %coord %68 %73 = OpLoad %7 %SampledImage OpStore %param %73 %75 = OpLoad %v3int %coord OpStore %param_0 %75 %76 = OpFunctionCall %v4float %sample_fetch_t21_vi3_ %param %param_0 OpStore %value %76 %77 = OpLoad %7 %SampledImage %78 = OpLoad %v3int %coord %79 = OpVectorShuffle %v2int %78 %78 0 1 %80 = OpAccessChain %_ptr_Function_int %coord %uint_2 %81 = OpLoad %int %80 %82 = OpImageFetch %v4float %77 %79 Lod %81 %83 = OpLoad %v4float %value %84 = OpFAdd %v4float %83 %82 OpStore %value %84 %86 = OpLoad %7 %SampledImage OpStore %param_1 %86 %88 = OpLoad %v4float %xIn %89 = OpVectorShuffle %v2float %88 %88 0 1 OpStore %param_2 %89 %90 = OpFunctionCall %v4float %sample_sampler_t21_vf2_ %param_1 %param_2 %91 = OpLoad %v4float %value %92 = OpFAdd %v4float %91 %90 OpStore %value %92 %93 = OpLoad %7 %SampledImage %94 = OpLoad %43 %Sampler %95 = OpSampledImage %47 %93 %94 %96 = OpLoad %v4float %xIn %97 = OpVectorShuffle %v2float %96 %96 0 1 %98 = OpImageSampleImplicitLod %v4float %95 %97 %99 = OpLoad %v4float %value %100 = OpFAdd %v4float %99 %98 OpStore %value %100 %101 = OpLoad %v4float %value OpReturnValue %101 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/image-fetch-no-sampler.no-samplerless.asm.vk.frag000066400000000000000000000156251400026215700307610ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 113 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %xIn_1 %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %sample_fetch_t21_vi3_ "sample_fetch(t21;vi3;" OpName %tex "tex" OpName %UV "UV" OpName %sample_sampler_t21_vf2_ "sample_sampler(t21;vf2;" OpName %tex_0 "tex" OpName %UV_0 "UV" OpName %_main_vf4_ "@main(vf4;" OpName %xIn "xIn" OpName %Sampler "Sampler" OpName %coord "coord" OpName %value "value" OpName %SampledImage "SampledImage" OpName %param "param" OpName %param_0 "param" OpName %param_1 "param" OpName %param_2 "param" OpName %xIn_0 "xIn" OpName %xIn_1 "xIn" OpName %_entryPointOutput "@entryPointOutput" OpName %param_3 "param" OpDecorate %Sampler DescriptorSet 0 OpDecorate %Sampler Binding 0 OpDecorate %SampledImage DescriptorSet 0 OpDecorate %SampledImage Binding 0 OpDecorate %xIn_1 BuiltIn FragCoord OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_Function_7 = OpTypePointer Function %7 %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 %_ptr_Function_v3int = OpTypePointer Function %v3int %v4float = OpTypeVector %float 4 %13 = OpTypeFunction %v4float %_ptr_Function_7 %_ptr_Function_v3int %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %20 = OpTypeFunction %v4float %_ptr_Function_7 %_ptr_Function_v2float %_ptr_Function_v4float = OpTypePointer Function %v4float %26 = OpTypeFunction %v4float %_ptr_Function_v4float %v2int = OpTypeVector %int 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_Function_int = OpTypePointer Function %int %43 = OpTypeSampler %_ptr_UniformConstant_43 = OpTypePointer UniformConstant %43 %Sampler = OpVariable %_ptr_UniformConstant_43 UniformConstant %47 = OpTypeSampledImage %7 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %float_1280 = OpConstant %float 1280 %uint_1 = OpConstant %uint 1 %float_720 = OpConstant %float 720 %int_0 = OpConstant %int 0 %_ptr_UniformConstant_7 = OpTypePointer UniformConstant %7 %SampledImage = OpVariable %_ptr_UniformConstant_7 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %xIn_1 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %xIn_0 = OpVariable %_ptr_Function_v4float Function %param_3 = OpVariable %_ptr_Function_v4float Function %107 = OpLoad %v4float %xIn_1 OpStore %xIn_0 %107 %111 = OpLoad %v4float %xIn_0 OpStore %param_3 %111 %112 = OpFunctionCall %v4float %_main_vf4_ %param_3 OpStore %_entryPointOutput %112 OpReturn OpFunctionEnd %sample_fetch_t21_vi3_ = OpFunction %v4float None %13 %tex = OpFunctionParameter %_ptr_Function_7 %UV = OpFunctionParameter %_ptr_Function_v3int %17 = OpLabel %30 = OpLoad %7 %tex %32 = OpLoad %v3int %UV %33 = OpVectorShuffle %v2int %32 %32 0 1 %37 = OpAccessChain %_ptr_Function_int %UV %uint_2 %38 = OpLoad %int %37 %39 = OpImageFetch %v4float %30 %33 Lod %38 OpReturnValue %39 OpFunctionEnd %sample_sampler_t21_vf2_ = OpFunction %v4float None %20 %tex_0 = OpFunctionParameter %_ptr_Function_7 %UV_0 = OpFunctionParameter %_ptr_Function_v2float %24 = OpLabel %42 = OpLoad %7 %tex_0 %46 = OpLoad %43 %Sampler %48 = OpSampledImage %47 %42 %46 %49 = OpLoad %v2float %UV_0 %50 = OpImageSampleImplicitLod %v4float %48 %49 OpReturnValue %50 OpFunctionEnd %_main_vf4_ = OpFunction %v4float None %26 %xIn = OpFunctionParameter %_ptr_Function_v4float %29 = OpLabel %coord = OpVariable %_ptr_Function_v3int Function %value = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_7 Function %param_0 = OpVariable %_ptr_Function_v3int Function %param_1 = OpVariable %_ptr_Function_7 Function %param_2 = OpVariable %_ptr_Function_v2float Function %56 = OpAccessChain %_ptr_Function_float %xIn %uint_0 %57 = OpLoad %float %56 %59 = OpFMul %float %57 %float_1280 %60 = OpConvertFToS %int %59 %62 = OpAccessChain %_ptr_Function_float %xIn %uint_1 %63 = OpLoad %float %62 %65 = OpFMul %float %63 %float_720 %66 = OpConvertFToS %int %65 %68 = OpCompositeConstruct %v3int %60 %66 %int_0 OpStore %coord %68 %73 = OpLoad %7 %SampledImage OpStore %param %73 %75 = OpLoad %v3int %coord OpStore %param_0 %75 %76 = OpFunctionCall %v4float %sample_fetch_t21_vi3_ %param %param_0 OpStore %value %76 %77 = OpLoad %7 %SampledImage %78 = OpLoad %v3int %coord %79 = OpVectorShuffle %v2int %78 %78 0 1 %80 = OpAccessChain %_ptr_Function_int %coord %uint_2 %81 = OpLoad %int %80 %82 = OpImageFetch %v4float %77 %79 Lod %81 %83 = OpLoad %v4float %value %84 = OpFAdd %v4float %83 %82 OpStore %value %84 %86 = OpLoad %7 %SampledImage OpStore %param_1 %86 %88 = OpLoad %v4float %xIn %89 = OpVectorShuffle %v2float %88 %88 0 1 OpStore %param_2 %89 %90 = OpFunctionCall %v4float %sample_sampler_t21_vf2_ %param_1 %param_2 %91 = OpLoad %v4float %value %92 = OpFAdd %v4float %91 %90 OpStore %value %92 %93 = OpLoad %7 %SampledImage %94 = OpLoad %43 %Sampler %95 = OpSampledImage %47 %93 %94 %96 = OpLoad %v4float %xIn %97 = OpVectorShuffle %v2float %96 %96 0 1 %98 = OpImageSampleImplicitLod %v4float %95 %97 %99 = OpLoad %v4float %value %100 = OpFAdd %v4float %99 %98 OpStore %value %100 %101 = OpLoad %v4float %value OpReturnValue %101 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/image-query-no-sampler.no-samplerless.vk.asm.frag000066400000000000000000000044121400026215700310250ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 36 ; Schema: 0 OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %b "b" OpName %uSampler2D "uSampler2D" OpName %c "c" OpName %uSampler2DMS "uSampler2DMS" OpName %l1 "l1" OpName %s0 "s0" OpDecorate %uSampler2D DescriptorSet 0 OpDecorate %uSampler2D Binding 0 OpDecorate %uSampler2DMS DescriptorSet 0 OpDecorate %uSampler2DMS Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %_ptr_Function_v2int = OpTypePointer Function %v2int %float = OpTypeFloat 32 %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %11 %uSampler2D = OpVariable %_ptr_UniformConstant_12 UniformConstant %int_0 = OpConstant %int 0 %20 = OpTypeImage %float 2D 0 0 1 1 Unknown %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %20 %uSampler2DMS = OpVariable %_ptr_UniformConstant_21 UniformConstant %_ptr_Function_int = OpTypePointer Function %int %main = OpFunction %void None %3 %5 = OpLabel %b = OpVariable %_ptr_Function_v2int Function %c = OpVariable %_ptr_Function_v2int Function %l1 = OpVariable %_ptr_Function_int Function %s0 = OpVariable %_ptr_Function_int Function %15 = OpLoad %11 %uSampler2D %18 = OpImageQuerySizeLod %v2int %15 %int_0 OpStore %b %18 %24 = OpLoad %20 %uSampler2DMS %26 = OpImageQuerySize %v2int %24 OpStore %c %26 %29 = OpLoad %11 %uSampler2D %31 = OpImageQueryLevels %int %29 OpStore %l1 %31 %33 = OpLoad %20 %uSampler2DMS %35 = OpImageQuerySamples %int %33 OpStore %s0 %35 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/image-query-no-sampler.vk.asm.frag000066400000000000000000000044121400026215700260620ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 36 ; Schema: 0 OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %b "b" OpName %uSampler2D "uSampler2D" OpName %c "c" OpName %uSampler2DMS "uSampler2DMS" OpName %l1 "l1" OpName %s0 "s0" OpDecorate %uSampler2D DescriptorSet 0 OpDecorate %uSampler2D Binding 0 OpDecorate %uSampler2DMS DescriptorSet 0 OpDecorate %uSampler2DMS Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %_ptr_Function_v2int = OpTypePointer Function %v2int %float = OpTypeFloat 32 %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %11 %uSampler2D = OpVariable %_ptr_UniformConstant_12 UniformConstant %int_0 = OpConstant %int 0 %20 = OpTypeImage %float 2D 0 0 1 1 Unknown %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %20 %uSampler2DMS = OpVariable %_ptr_UniformConstant_21 UniformConstant %_ptr_Function_int = OpTypePointer Function %int %main = OpFunction %void None %3 %5 = OpLabel %b = OpVariable %_ptr_Function_v2int Function %c = OpVariable %_ptr_Function_v2int Function %l1 = OpVariable %_ptr_Function_int Function %s0 = OpVariable %_ptr_Function_int Function %15 = OpLoad %11 %uSampler2D %18 = OpImageQuerySizeLod %v2int %15 %int_0 OpStore %b %18 %24 = OpLoad %20 %uSampler2DMS %26 = OpImageQuerySize %v2int %24 OpStore %c %26 %29 = OpLoad %11 %uSampler2D %31 = OpImageQueryLevels %int %29 OpStore %l1 %31 %33 = OpLoad %20 %uSampler2DMS %35 = OpImageQuerySamples %int %33 OpStore %s0 %35 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/implicit-read-dep-phi.asm.frag000066400000000000000000000064051400026215700252160ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 60 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %v0 %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %phi "phi" OpName %i "i" OpName %v0 "v0" OpName %FragColor "FragColor" OpName %uImage "uImage" OpDecorate %v0 Location 0 OpDecorate %FragColor Location 0 OpDecorate %uImage DescriptorSet 0 OpDecorate %uImage Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %v0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %36 = OpTypeImage %float 2D 0 0 0 1 Unknown %37 = OpTypeSampledImage %36 %_ptr_UniformConstant_37 = OpTypePointer UniformConstant %37 %uImage = OpVariable %_ptr_UniformConstant_37 UniformConstant %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %float_2 = OpConstant %float 2 %int_1 = OpConstant %int 1 %float_1_vec = OpConstantComposite %v4float %float_1 %float_2 %float_1 %float_2 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %loop_header %loop_header = OpLabel %phi = OpPhi %float %float_1 %5 %phi_plus_2 %continue_block %tex_phi = OpPhi %v4float %float_1_vec %5 %texture_load_result %continue_block OpLoopMerge %merge_block %continue_block None OpBranch %loop_body %loop_body = OpLabel OpStore %FragColor %tex_phi %19 = OpLoad %int %i %22 = OpSLessThan %bool %19 %int_4 OpBranchConditional %22 %15 %merge_block %15 = OpLabel %26 = OpLoad %int %i %28 = OpAccessChain %_ptr_Input_float %v0 %26 %29 = OpLoad %float %28 %31 = OpFOrdGreaterThan %bool %29 %float_0 OpBranchConditional %31 %continue_block %merge_block %continue_block = OpLabel %40 = OpLoad %37 %uImage %43 = OpCompositeConstruct %v2float %phi %phi %texture_load_result = OpImageSampleExplicitLod %v4float %40 %43 Lod %float_0 %phi_plus_2 = OpFAdd %float %phi %float_2 %54 = OpLoad %int %i %56 = OpIAdd %int %54 %int_1 OpStore %i %56 OpBranch %loop_header %merge_block = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/inf-nan-constant-double.asm.frag000066400000000000000000000031541400026215700255720ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 22 ; Schema: 0 OpCapability Shader OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vTmp OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %vTmp "vTmp" OpDecorate %FragColor Location 0 OpDecorate %vTmp Flat OpDecorate %vTmp Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %FragColor = OpVariable %_ptr_Output_v3float Output %double = OpTypeFloat 64 %v3double = OpTypeVector %double 3 %double_0x1p_1024 = OpConstant %double 0x1p+1024 %double_n0x1p_1024 = OpConstant %double -0x1p+1024 %double_0x1_8p_1024 = OpConstant %double 0x1.8p+1024 %15 = OpConstantComposite %v3double %double_0x1p_1024 %double_n0x1p_1024 %double_0x1_8p_1024 %_ptr_Input_double = OpTypePointer Input %double %vTmp = OpVariable %_ptr_Input_double Input %main = OpFunction %void None %3 %5 = OpLabel %18 = OpLoad %double %vTmp %19 = OpCompositeConstruct %v3double %18 %18 %18 %20 = OpFAdd %v3double %15 %19 %21 = OpFConvert %v3float %20 OpStore %FragColor %21 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/inf-nan-constant.asm.frag000066400000000000000000000021471400026215700243230ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 14 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %FragColor = OpVariable %_ptr_Output_v3float Output %float_0x1p_128 = OpConstant %float 0x1p+128 %float_n0x1p_128 = OpConstant %float -0x1p+128 %float_0x1_8p_128 = OpConstant %float 0x1.8p+128 %13 = OpConstantComposite %v3float %float_0x1p_128 %float_n0x1p_128 %float_0x1_8p_128 %main = OpFunction %void None %3 %5 = OpLabel OpStore %FragColor %13 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/invalidation.asm.frag000066400000000000000000000031031400026215700236200ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %v0 %v1 %FragColor OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %a "a" OpName %v0 "v0" OpName %b "b" OpName %v1 "v1" OpName %FragColor "FragColor" OpDecorate %v0 Location 0 OpDecorate %v1 Location 1 OpDecorate %FragColor Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %float = OpTypeFloat 32 %pfloat = OpTypePointer Function %float %9 = OpTypePointer Input %float %v0 = OpVariable %9 Input %v1 = OpVariable %9 Input %25 = OpTypePointer Output %float %FragColor = OpVariable %25 Output %4 = OpFunction %2 None %3 %5 = OpLabel %a = OpVariable %pfloat Function %b = OpVariable %pfloat Function %v0_tmp = OpLoad %float %v0 %v1_tmp = OpLoad %float %v1 OpStore %a %v0_tmp OpStore %b %v1_tmp %a_tmp = OpLoad %float %a %b_tmp = OpLoad %float %b %res = OpFAdd %float %a_tmp %b_tmp %res1 = OpFMul %float %res %b_tmp OpStore %a %v1_tmp OpStore %FragColor %res1 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/line-directive.line.asm.frag000066400000000000000000000144301400026215700247750ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google Shaderc over Glslang; 7 ; Bound: 83 ; Schema: 0 OpCapability Shader %2 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vColor OpExecutionMode %main OriginUpperLeft %1 = OpString "test.frag" OpSource GLSL 450 %1 "// OpModuleProcessed entry-point main // OpModuleProcessed client vulkan100 // OpModuleProcessed target-env vulkan1.0 // OpModuleProcessed entry-point main #line 1 #version 450 layout(location = 0) in float vColor; layout(location = 0) out float FragColor; void func() { FragColor = 1.0; FragColor = 2.0; if (vColor < 0.0) { FragColor = 3.0; } else { FragColor = 4.0; } for (int i = 0; i < 40 + vColor; i += int(vColor) + 5) { FragColor += 0.2; FragColor += 0.3; } switch (int(vColor)) { case 0: FragColor += 0.2; break; case 1: FragColor += 0.4; break; default: FragColor += 0.8; break; } do { FragColor += 10.0 + vColor; } while(FragColor < 100.0); } void main() { func(); } " OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %func_ "func(" OpName %FragColor "FragColor" OpName %vColor "vColor" OpName %i "i" OpDecorate %FragColor Location 0 OpDecorate %vColor Location 0 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %_ptr_Input_float = OpTypePointer Input %float %vColor = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %int = OpTypeInt 32 1 ; Should be ignored OpLine %1 5 0 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %float_40 = OpConstant %float 40 %float_0_200000003 = OpConstant %float 0.200000003 %float_0_300000012 = OpConstant %float 0.300000012 %int_5 = OpConstant %int 5 ; Should be ignored OpLine %1 5 0 %float_0_400000006 = OpConstant %float 0.400000006 %float_0_800000012 = OpConstant %float 0.800000012 %float_10 = OpConstant %float 10 %float_100 = OpConstant %float 100 %main = OpFunction %void None %4 OpLine %1 46 0 %6 = OpLabel OpLine %1 48 0 %82 = OpFunctionCall %void %func_ OpReturn OpFunctionEnd ; Should be ignored OpLine %1 5 0 %func_ = OpFunction %void None %4 OpLine %1 6 0 %8 = OpLabel %i = OpVariable %_ptr_Function_int Function OpLine %1 8 0 OpStore %FragColor %float_1 OpLine %1 9 0 OpStore %FragColor %float_2 OpLine %1 10 0 %16 = OpLoad %float %vColor %19 = OpFOrdLessThan %bool %16 %float_0 OpSelectionMerge %21 None OpBranchConditional %19 %20 %23 %20 = OpLabel OpLine %1 12 0 OpStore %FragColor %float_3 OpBranch %21 %23 = OpLabel OpLine %1 16 0 OpStore %FragColor %float_4 OpBranch %21 %21 = OpLabel OpLine %1 19 0 OpStore %i %int_0 OpBranch %29 %29 = OpLabel OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %34 = OpLoad %int %i %35 = OpConvertSToF %float %34 %37 = OpLoad %float %vColor %38 = OpFAdd %float %float_40 %37 %39 = OpFOrdLessThan %bool %35 %38 OpBranchConditional %39 %30 %31 %30 = OpLabel OpLine %1 21 0 %41 = OpLoad %float %FragColor %42 = OpFAdd %float %41 %float_0_200000003 OpStore %FragColor %42 OpLine %1 22 0 %44 = OpLoad %float %FragColor %45 = OpFAdd %float %44 %float_0_300000012 OpStore %FragColor %45 OpBranch %32 %32 = OpLabel OpLine %1 19 0 %46 = OpLoad %float %vColor %47 = OpConvertFToS %int %46 %49 = OpIAdd %int %47 %int_5 %50 = OpLoad %int %i %51 = OpIAdd %int %50 %49 OpStore %i %51 OpBranch %29 %31 = OpLabel OpLine %1 25 0 %52 = OpLoad %float %vColor %53 = OpConvertFToS %int %52 OpSelectionMerge %57 None OpSwitch %53 %56 0 %54 1 %55 %56 = OpLabel OpLine %1 36 0 %66 = OpLoad %float %FragColor %67 = OpFAdd %float %66 %float_0_800000012 OpStore %FragColor %67 OpLine %1 37 0 OpBranch %57 %54 = OpLabel OpLine %1 28 0 %58 = OpLoad %float %FragColor %59 = OpFAdd %float %58 %float_0_200000003 OpStore %FragColor %59 OpLine %1 29 0 OpBranch %57 %55 = OpLabel OpLine %1 32 0 %62 = OpLoad %float %FragColor %63 = OpFAdd %float %62 %float_0_400000006 OpStore %FragColor %63 OpLine %1 33 0 OpBranch %57 %57 = OpLabel OpBranch %70 OpLine %1 43 0 %70 = OpLabel OpLoopMerge %72 %73 None OpBranch %71 %71 = OpLabel OpLine %1 42 0 %75 = OpLoad %float %vColor %76 = OpFAdd %float %float_10 %75 %77 = OpLoad %float %FragColor %78 = OpFAdd %float %77 %76 OpStore %FragColor %78 OpBranch %73 %73 = OpLabel OpLine %1 43 0 %79 = OpLoad %float %FragColor %81 = OpFOrdLessThan %bool %79 %float_100 OpBranchConditional %81 %70 %72 %72 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/locations-components.asm.frag000066400000000000000000000102661400026215700253250ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Wine VKD3D Shader Compiler; 0 ; Bound: 67 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %8 %16 %22 %28 %33 %o0 OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %v1 "v1" OpName %v2 "v2" OpName %o0 "o0" OpName %r0 "r0" OpDecorate %8 Location 1 OpDecorate %16 Location 1 OpDecorate %16 Component 2 OpDecorate %22 Location 2 OpDecorate %22 Flat OpDecorate %28 Location 2 OpDecorate %28 Component 1 OpDecorate %28 Flat OpDecorate %33 Location 2 OpDecorate %33 Component 2 OpDecorate %33 Flat OpDecorate %o0 Location 0 %void = OpTypeVoid %2 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %8 = OpVariable %_ptr_Input_v2float Input %v4float = OpTypeVector %float 4 %_ptr_Private_v4float = OpTypePointer Private %v4float %v1 = OpVariable %_ptr_Private_v4float Private %_ptr_Input_float = OpTypePointer Input %float %16 = OpVariable %_ptr_Input_float Input %_ptr_Private_float = OpTypePointer Private %float %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %22 = OpVariable %_ptr_Input_float Input %v2 = OpVariable %_ptr_Private_v4float Private %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %28 = OpVariable %_ptr_Input_uint Input %uint_1 = OpConstant %uint 1 %33 = OpVariable %_ptr_Input_uint Input %_ptr_Output_v4float = OpTypePointer Output %v4float %o0 = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %int = OpTypeInt 32 1 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %2 %4 = OpLabel %r0 = OpVariable %_ptr_Function_v4float Function %12 = OpLoad %v2float %8 %13 = OpLoad %v4float %v1 %14 = OpVectorShuffle %v4float %13 %12 4 5 2 3 OpStore %v1 %14 %17 = OpLoad %float %16 %21 = OpInBoundsAccessChain %_ptr_Private_float %v1 %uint_2 OpStore %21 %17 %24 = OpLoad %float %22 %26 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_0 OpStore %26 %24 %29 = OpLoad %uint %28 %30 = OpBitcast %float %29 %32 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_1 OpStore %32 %30 %34 = OpLoad %uint %33 %35 = OpBitcast %float %34 %36 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_2 OpStore %36 %35 %42 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_1 %43 = OpLoad %float %42 %44 = OpBitcast %int %43 %45 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_2 %46 = OpLoad %float %45 %47 = OpBitcast %int %46 %48 = OpIAdd %int %44 %47 %49 = OpBitcast %float %48 %51 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_0 OpStore %51 %49 %52 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_0 %53 = OpLoad %float %52 %54 = OpBitcast %uint %53 %55 = OpConvertUToF %float %54 %57 = OpInBoundsAccessChain %_ptr_Output_float %o0 %uint_1 OpStore %57 %55 %58 = OpInBoundsAccessChain %_ptr_Private_float %v1 %uint_1 %59 = OpLoad %float %58 %60 = OpInBoundsAccessChain %_ptr_Private_float %v2 %uint_0 %61 = OpLoad %float %60 %62 = OpFAdd %float %59 %61 %63 = OpInBoundsAccessChain %_ptr_Output_float %o0 %uint_0 OpStore %63 %62 %64 = OpLoad %v4float %v1 %65 = OpLoad %v4float %o0 %66 = OpVectorShuffle %v4float %65 %64 0 1 6 4 OpStore %o0 %66 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/loop-body-dominator-continue-access.asm.frag000066400000000000000000000206511400026215700301250ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 131 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragWorld_1 %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %GetClip2TexMatrix_ "GetClip2TexMatrix(" OpName %GetCascade_vf3_ "GetCascade(vf3;" OpName %fragWorldPosition "fragWorldPosition" OpName %_main_vf3_ "@main(vf3;" OpName %fragWorld "fragWorld" OpName %Foo "Foo" OpMemberName %Foo 0 "lightVP" OpMemberName %Foo 1 "shadowCascadesNum" OpMemberName %Foo 2 "test" OpName %_ "" OpName %cascadeIndex "cascadeIndex" OpName %worldToShadowMap "worldToShadowMap" OpName %fragShadowMapPos "fragShadowMapPos" OpName %param "param" OpName %fragWorld_0 "fragWorld" OpName %fragWorld_1 "fragWorld" OpName %_entryPointOutput "@entryPointOutput" OpName %param_0 "param" OpDecorate %_arr_mat4v4float_uint_64 ArrayStride 64 OpMemberDecorate %Foo 0 RowMajor OpMemberDecorate %Foo 0 Offset 0 OpMemberDecorate %Foo 0 MatrixStride 16 OpMemberDecorate %Foo 1 Offset 4096 OpMemberDecorate %Foo 2 Offset 4100 OpDecorate %Foo Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %fragWorld_1 Location 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %9 = OpTypeFunction %mat4v4float %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %int = OpTypeInt 32 1 %15 = OpTypeFunction %int %_ptr_Function_v3float %uint = OpTypeInt 32 0 %uint_64 = OpConstant %uint 64 %_arr_mat4v4float_uint_64 = OpTypeArray %mat4v4float %uint_64 %Foo = OpTypeStruct %_arr_mat4v4float_uint_64 %uint %int %_ptr_Uniform_Foo = OpTypePointer Uniform %Foo %_ = OpVariable %_ptr_Uniform_Foo Uniform %int_2 = OpConstant %int 2 %_ptr_Uniform_int = OpTypePointer Uniform %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %float_0_5 = OpConstant %float 0.5 %float_0 = OpConstant %float 0 %39 = OpConstantComposite %v4float %float_0_5 %float_0 %float_0 %float_0 %40 = OpConstantComposite %v4float %float_0 %float_0_5 %float_0 %float_0 %41 = OpConstantComposite %v4float %float_0 %float_0 %float_0_5 %float_0 %float_1 = OpConstant %float 1 %43 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1 %44 = OpConstantComposite %mat4v4float %39 %40 %41 %43 %46 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_0 %47 = OpConstantComposite %v4float %float_0 %float_1 %float_0 %float_0 %48 = OpConstantComposite %v4float %float_0 %float_0 %float_1 %float_0 %49 = OpConstantComposite %mat4v4float %46 %47 %48 %43 %_ptr_Function_uint = OpTypePointer Function %uint %uint_0 = OpConstant %uint 0 %int_1 = OpConstant %int 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Function_mat4v4float = OpTypePointer Function %mat4v4float %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %uint_2 = OpConstant %uint 2 %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %int_n1 = OpConstant %int -1 %_ptr_Input_v3float = OpTypePointer Input %v3float %fragWorld_1 = OpVariable %_ptr_Input_v3float Input %_ptr_Output_int = OpTypePointer Output %int %_entryPointOutput = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %3 %5 = OpLabel %fragWorld_0 = OpVariable %_ptr_Function_v3float Function %param_0 = OpVariable %_ptr_Function_v3float Function %125 = OpLoad %v3float %fragWorld_1 OpStore %fragWorld_0 %125 %129 = OpLoad %v3float %fragWorld_0 OpStore %param_0 %129 %130 = OpFunctionCall %int %_main_vf3_ %param_0 OpStore %_entryPointOutput %130 OpReturn OpFunctionEnd %GetClip2TexMatrix_ = OpFunction %mat4v4float None %9 %11 = OpLabel %30 = OpAccessChain %_ptr_Uniform_int %_ %int_2 %31 = OpLoad %int %30 %34 = OpIEqual %bool %31 %int_0 OpSelectionMerge %36 None OpBranchConditional %34 %35 %36 %35 = OpLabel OpReturnValue %44 %36 = OpLabel OpReturnValue %49 OpFunctionEnd %GetCascade_vf3_ = OpFunction %int None %15 %fragWorldPosition = OpFunctionParameter %_ptr_Function_v3float %18 = OpLabel %cascadeIndex = OpVariable %_ptr_Function_uint Function %worldToShadowMap = OpVariable %_ptr_Function_mat4v4float Function %fragShadowMapPos = OpVariable %_ptr_Function_v4float Function OpStore %cascadeIndex %uint_0 OpBranch %55 %55 = OpLabel OpLoopMerge %57 %58 Unroll OpBranch %59 %59 = OpLabel %60 = OpLoad %uint %cascadeIndex %63 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %64 = OpLoad %uint %63 %65 = OpULessThan %bool %60 %64 OpBranchConditional %65 %56 %57 %56 = OpLabel %68 = OpFunctionCall %mat4v4float %GetClip2TexMatrix_ %69 = OpLoad %uint %cascadeIndex %71 = OpAccessChain %_ptr_Uniform_mat4v4float %_ %int_0 %69 %72 = OpLoad %mat4v4float %71 %73 = OpMatrixTimesMatrix %mat4v4float %68 %72 OpStore %worldToShadowMap %73 %76 = OpLoad %mat4v4float %worldToShadowMap %77 = OpLoad %v3float %fragWorldPosition %78 = OpCompositeExtract %float %77 0 %79 = OpCompositeExtract %float %77 1 %80 = OpCompositeExtract %float %77 2 %81 = OpCompositeConstruct %v4float %78 %79 %80 %float_1 %82 = OpMatrixTimesVector %v4float %76 %81 OpStore %fragShadowMapPos %82 %85 = OpAccessChain %_ptr_Function_float %fragShadowMapPos %uint_2 %86 = OpLoad %float %85 %87 = OpFOrdGreaterThanEqual %bool %86 %float_0 %88 = OpAccessChain %_ptr_Function_float %fragShadowMapPos %uint_2 %89 = OpLoad %float %88 %90 = OpFOrdLessThanEqual %bool %89 %float_1 %91 = OpLogicalAnd %bool %87 %90 %92 = OpAccessChain %_ptr_Function_float %fragShadowMapPos %uint_0 %93 = OpLoad %float %92 %95 = OpAccessChain %_ptr_Function_float %fragShadowMapPos %uint_1 %96 = OpLoad %float %95 %97 = OpExtInst %float %1 FMax %93 %96 %98 = OpFOrdLessThanEqual %bool %97 %float_1 %99 = OpLogicalAnd %bool %91 %98 %100 = OpAccessChain %_ptr_Function_float %fragShadowMapPos %uint_0 %101 = OpLoad %float %100 %102 = OpAccessChain %_ptr_Function_float %fragShadowMapPos %uint_1 %103 = OpLoad %float %102 %104 = OpExtInst %float %1 FMin %101 %103 %105 = OpFOrdGreaterThanEqual %bool %104 %float_0 %106 = OpLogicalAnd %bool %99 %105 OpSelectionMerge %108 None OpBranchConditional %106 %107 %108 %107 = OpLabel %109 = OpLoad %uint %cascadeIndex %110 = OpBitcast %int %109 OpReturnValue %110 %108 = OpLabel OpBranch %58 %58 = OpLabel %112 = OpLoad %uint %cascadeIndex %113 = OpIAdd %uint %112 %int_1 OpStore %cascadeIndex %113 OpBranch %55 %57 = OpLabel OpReturnValue %int_n1 OpFunctionEnd %_main_vf3_ = OpFunction %int None %15 %fragWorld = OpFunctionParameter %_ptr_Function_v3float %21 = OpLabel %param = OpVariable %_ptr_Function_v3float Function %118 = OpLoad %v3float %fragWorld OpStore %param %118 %119 = OpFunctionCall %int %GetCascade_vf3_ %param OpReturnValue %119 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/loop-header-to-continue.asm.frag000066400000000000000000000131561400026215700256110ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 279 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %IN_p %IN_uv %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %Params "Params" OpMemberName %Params 0 "TextureSize" OpMemberName %Params 1 "Params1" OpMemberName %Params 2 "Params2" OpMemberName %Params 3 "Params3" OpMemberName %Params 4 "Params4" OpMemberName %Params 5 "Bloom" OpName %CB1 "CB1" OpMemberName %CB1 0 "CB1" OpName %_ "" OpName %mapSampler "mapSampler" OpName %mapTexture "mapTexture" OpName %IN_p "IN.p" OpName %IN_uv "IN.uv" OpName %_entryPointOutput "@entryPointOutput" OpMemberDecorate %Params 0 Offset 0 OpMemberDecorate %Params 1 Offset 16 OpMemberDecorate %Params 2 Offset 32 OpMemberDecorate %Params 3 Offset 48 OpMemberDecorate %Params 4 Offset 64 OpMemberDecorate %Params 5 Offset 80 OpMemberDecorate %CB1 0 Offset 0 OpDecorate %CB1 Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %mapSampler DescriptorSet 1 OpDecorate %mapSampler Binding 2 OpDecorate %mapTexture DescriptorSet 1 OpDecorate %mapTexture Binding 2 OpDecorate %IN_p BuiltIn FragCoord OpDecorate %IN_uv Location 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %9 = OpTypeSampler %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %v4float = OpTypeVector %float 4 %float_0_222222 = OpConstant %float 0.222222 %33 = OpTypeSampledImage %11 %uint = OpTypeInt 32 0 %float_80 = OpConstant %float 80 %float_0_0008 = OpConstant %float 0.0008 %float_8en05 = OpConstant %float 8e-05 %float_0_008 = OpConstant %float 0.008 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %int_n3 = OpConstant %int -3 %int_3 = OpConstant %int 3 %bool = OpTypeBool %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %Params = OpTypeStruct %v4float %v4float %v4float %v4float %v4float %v4float %CB1 = OpTypeStruct %Params %_ptr_Uniform_CB1 = OpTypePointer Uniform %CB1 %_ = OpVariable %_ptr_Uniform_CB1 Uniform %int_0 = OpConstant %int 0 %uint_3 = OpConstant %uint 3 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_UniformConstant_9 = OpTypePointer UniformConstant %9 %mapSampler = OpVariable %_ptr_UniformConstant_9 UniformConstant %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %mapTexture = OpVariable %_ptr_UniformConstant_11 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %IN_p = OpVariable %_ptr_Input_v4float Input %_ptr_Input_v2float = OpTypePointer Input %v2float %IN_uv = OpVariable %_ptr_Input_v2float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %158 = OpLoad %v2float %IN_uv %178 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %int_0 %uint_3 %179 = OpLoad %float %178 %180 = OpCompositeConstruct %v2float %float_0 %179 %184 = OpLoad %9 %mapSampler %185 = OpLoad %11 %mapTexture %204 = OpSampledImage %33 %185 %184 %206 = OpImageSampleImplicitLod %v4float %204 %158 %207 = OpCompositeExtract %float %206 1 %209 = OpFMul %float %207 %float_80 %210 = OpFMul %float %209 %float_0_0008 %211 = OpExtInst %float %1 FClamp %210 %float_8en05 %float_0_008 OpBranch %212 %212 = OpLabel %276 = OpPhi %float %float_0 %5 %252 %218 %277 = OpPhi %float %float_0 %5 %255 %218 %278 = OpPhi %int %int_n3 %5 %257 %218 %217 = OpSLessThanEqual %bool %278 %int_3 OpLoopMerge %213 %218 None OpBranchConditional %217 %218 %213 %218 = OpLabel %220 = OpConvertSToF %float %278 %222 = OpFNegate %float %220 %224 = OpFMul %float %222 %220 %226 = OpFMul %float %224 %float_0_222222 %227 = OpExtInst %float %1 Exp %226 %230 = OpSampledImage %33 %185 %184 %234 = OpVectorTimesScalar %v2float %180 %220 %235 = OpFAdd %v2float %158 %234 %236 = OpImageSampleImplicitLod %v4float %230 %235 %273 = OpCompositeExtract %float %236 1 %241 = OpFSub %float %273 %207 %242 = OpExtInst %float %1 FAbs %241 %244 = OpFOrdLessThan %bool %242 %211 %245 = OpSelect %float %244 %float_1 %float_0 %246 = OpFMul %float %227 %245 %275 = OpCompositeExtract %float %236 0 %250 = OpFMul %float %275 %246 %252 = OpFAdd %float %276 %250 %255 = OpFAdd %float %277 %246 %257 = OpIAdd %int %278 %int_1 OpBranch %212 %213 = OpLabel %260 = OpFDiv %float %276 %277 %190 = OpCompositeConstruct %v4float %260 %207 %float_0 %float_1 OpStore %_entryPointOutput %190 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/lut-promotion-initializer.asm.frag000066400000000000000000000210011400026215700263050ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 111 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %index OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %index "index" OpName %indexable "indexable" OpName %indexable_0 "indexable" OpName %indexable_1 "indexable" OpName %foo "foo" OpName %foobar "foobar" OpName %baz "baz" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %index RelaxedPrecision OpDecorate %index Flat OpDecorate %index Location 0 OpDecorate %20 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %foo RelaxedPrecision OpDecorate %61 RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %71 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %79 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision OpDecorate %foobar RelaxedPrecision OpDecorate %83 RelaxedPrecision OpDecorate %90 RelaxedPrecision OpDecorate %91 RelaxedPrecision OpDecorate %93 RelaxedPrecision OpDecorate %94 RelaxedPrecision OpDecorate %95 RelaxedPrecision OpDecorate %baz RelaxedPrecision OpDecorate %105 RelaxedPrecision OpDecorate %106 RelaxedPrecision OpDecorate %108 RelaxedPrecision OpDecorate %109 RelaxedPrecision OpDecorate %110 RelaxedPrecision OpDecorate %16 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %uint = OpTypeInt 32 0 %uint_16 = OpConstant %uint 16 %_arr_float_uint_16 = OpTypeArray %float %uint_16 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %16 = OpConstantComposite %_arr_float_uint_16 %float_1 %float_2 %float_3 %float_4 %float_1 %float_2 %float_3 %float_4 %float_1 %float_2 %float_3 %float_4 %float_1 %float_2 %float_3 %float_4 %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %index = OpVariable %_ptr_Input_int Input %_ptr_Function__arr_float_uint_16 = OpTypePointer Function %_arr_float_uint_16 %_ptr_Function_float = OpTypePointer Function %float %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %v4float = OpTypeVector %float 4 %uint_4 = OpConstant %uint 4 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %_ptr_Function__arr_v4float_uint_4 = OpTypePointer Function %_arr_v4float_uint_4 %float_0 = OpConstant %float 0 %54 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %55 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_8 = OpConstant %float 8 %57 = OpConstantComposite %v4float %float_8 %float_8 %float_8 %float_8 %float_5 = OpConstant %float 5 %59 = OpConstantComposite %v4float %float_5 %float_5 %float_5 %float_5 %60 = OpConstantComposite %_arr_v4float_uint_4 %54 %55 %57 %59 %int_30 = OpConstant %int 30 %int_3 = OpConstant %int 3 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %float_20 = OpConstant %float 20 %uint_2 = OpConstant %uint 2 %97 = OpConstantComposite %v4float %float_20 %float_20 %float_20 %float_20 %float_30 = OpConstant %float 30 %99 = OpConstantComposite %v4float %float_30 %float_30 %float_30 %float_30 %float_50 = OpConstant %float 50 %101 = OpConstantComposite %v4float %float_50 %float_50 %float_50 %float_50 %float_60 = OpConstant %float 60 %103 = OpConstantComposite %v4float %float_60 %float_60 %float_60 %float_60 %104 = OpConstantComposite %_arr_v4float_uint_4 %97 %99 %101 %103 %main = OpFunction %void None %3 %5 = OpLabel %indexable = OpVariable %_ptr_Function__arr_float_uint_16 Function %16 %indexable_0 = OpVariable %_ptr_Function__arr_float_uint_16 Function %16 %indexable_1 = OpVariable %_ptr_Function__arr_float_uint_16 Function %16 %foo = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %60 %foobar = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %60 %baz = OpVariable %_ptr_Function__arr_v4float_uint_4 Function %60 %20 = OpLoad %int %index %24 = OpAccessChain %_ptr_Function_float %indexable %20 %25 = OpLoad %float %24 OpStore %FragColor %25 %26 = OpLoad %int %index %29 = OpSLessThan %bool %26 %int_10 OpSelectionMerge %31 None OpBranchConditional %29 %30 %40 %30 = OpLabel %32 = OpLoad %int %index %34 = OpBitwiseXor %int %32 %int_1 %36 = OpAccessChain %_ptr_Function_float %indexable_0 %34 %37 = OpLoad %float %36 %38 = OpLoad %float %FragColor %39 = OpFAdd %float %38 %37 OpStore %FragColor %39 OpBranch %31 %40 = OpLabel %41 = OpLoad %int %index %42 = OpBitwiseAnd %int %41 %int_1 %44 = OpAccessChain %_ptr_Function_float %indexable_1 %42 %45 = OpLoad %float %44 %46 = OpLoad %float %FragColor %47 = OpFAdd %float %46 %45 OpStore %FragColor %47 OpBranch %31 %31 = OpLabel %61 = OpLoad %int %index %63 = OpSGreaterThan %bool %61 %int_30 OpSelectionMerge %65 None OpBranchConditional %63 %64 %74 %64 = OpLabel %66 = OpLoad %int %index %68 = OpBitwiseAnd %int %66 %int_3 %70 = OpAccessChain %_ptr_Function_float %foo %68 %uint_1 %71 = OpLoad %float %70 %72 = OpLoad %float %FragColor %73 = OpFAdd %float %72 %71 OpStore %FragColor %73 OpBranch %65 %74 = OpLabel %75 = OpLoad %int %index %76 = OpBitwiseAnd %int %75 %int_1 %78 = OpAccessChain %_ptr_Function_float %foo %76 %uint_0 %79 = OpLoad %float %78 %80 = OpLoad %float %FragColor %81 = OpFAdd %float %80 %79 OpStore %FragColor %81 OpBranch %65 %65 = OpLabel %83 = OpLoad %int %index %84 = OpSGreaterThan %bool %83 %int_30 OpSelectionMerge %86 None OpBranchConditional %84 %85 %86 %85 = OpLabel %89 = OpAccessChain %_ptr_Function_float %foobar %int_1 %uint_2 OpStore %89 %float_20 OpBranch %86 %86 = OpLabel %90 = OpLoad %int %index %91 = OpBitwiseAnd %int %90 %int_3 %92 = OpAccessChain %_ptr_Function_float %foobar %91 %uint_2 %93 = OpLoad %float %92 %94 = OpLoad %float %FragColor %95 = OpFAdd %float %94 %93 OpStore %FragColor %95 OpStore %baz %104 %105 = OpLoad %int %index %106 = OpBitwiseAnd %int %105 %int_3 %107 = OpAccessChain %_ptr_Function_float %baz %106 %uint_2 %108 = OpLoad %float %107 %109 = OpLoad %float %FragColor %110 = OpFAdd %float %109 %108 OpStore %FragColor %110 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/multi-for-loop-init.asm.frag000066400000000000000000000104501400026215700247700ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 52 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %counter %ucounter OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %i "i" OpName %j "j" OpName %counter "counter" OpName %ucounter "ucounter" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %i RelaxedPrecision OpDecorate %j RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %counter RelaxedPrecision OpDecorate %counter Flat OpDecorate %counter Location 0 OpDecorate %43 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %ucounter RelaxedPrecision OpDecorate %ucounter Flat OpDecorate %ucounter Location 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %11 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %int_0 = OpConstant %int 0 %int_1 = OpConstant %uint 1 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_20 = OpConstant %uint 20 %_ptr_Input_int = OpTypePointer Input %int %counter = OpVariable %_ptr_Input_int Input %_ptr_Input_uint = OpTypePointer Input %uint %ucounter = OpVariable %_ptr_Input_uint Input %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_uint Function OpStore %FragColor %11 OpStore %i %int_0 OpStore %j %int_1 OpBranch %18 %18 = OpLabel OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel %23 = OpLoad %int %i %26 = OpSLessThan %bool %23 %int_10 %27 = OpLoad %uint %j %29 = OpSLessThan %bool %27 %int_20 %30 = OpLogicalAnd %bool %26 %29 OpBranchConditional %30 %19 %20 %19 = OpLabel %31 = OpLoad %int %i %32 = OpConvertSToF %float %31 %33 = OpCompositeConstruct %v4float %32 %32 %32 %32 %34 = OpLoad %v4float %FragColor %35 = OpFAdd %v4float %34 %33 OpStore %FragColor %35 %36 = OpLoad %uint %j %37 = OpConvertUToF %float %36 %38 = OpCompositeConstruct %v4float %37 %37 %37 %37 %39 = OpLoad %v4float %FragColor %40 = OpFAdd %v4float %39 %38 OpStore %FragColor %40 OpBranch %21 %21 = OpLabel %43 = OpLoad %int %counter %44 = OpLoad %int %i %45 = OpIAdd %int %44 %43 OpStore %i %45 %46 = OpLoad %int %counter %47 = OpLoad %uint %j %48 = OpIAdd %uint %47 %46 OpStore %j %48 OpBranch %18 %20 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/op-constant-null.asm.frag000066400000000000000000000065551400026215700243720ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 45 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %a "a" OpName %b "b" OpName %c "c" OpName %D "D" OpMemberName %D 0 "a" OpMemberName %D 1 "b" OpName %d "d" OpName %e "e" OpName %FragColor "FragColor" OpDecorate %a RelaxedPrecision OpDecorate %b RelaxedPrecision OpDecorate %c RelaxedPrecision OpMemberDecorate %D 0 RelaxedPrecision OpMemberDecorate %D 1 RelaxedPrecision OpDecorate %e RelaxedPrecision OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %44 RelaxedPrecision OpDecorate %float_1 RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %41 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstantNull %float %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_2 = OpConstantNull %float %14 = OpConstantNull %v4float %v3float = OpTypeVector %float 3 %mat2v3float = OpTypeMatrix %v3float 2 %_ptr_Function_mat2v3float = OpTypePointer Function %mat2v3float %float_4 = OpConstantNull %float %20 = OpConstantNull %v3float %float_5 = OpConstantNull %float %22 = OpConstantNull %v3float %23 = OpConstantNull %mat2v3float %D = OpTypeStruct %v4float %float %_ptr_Function_D = OpTypePointer Function %D %27 = OpConstantNull %D %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %_ptr_Function__arr_v4float_uint_4 = OpTypePointer Function %_arr_v4float_uint_4 %float_10 = OpConstantNull %float %34 = OpConstantNull %v4float %float_11 = OpConstantNull %float %36 = OpConstantNull %v4float %float_12 = OpConstantNull %float %38 = OpConstantNull %v4float %float_13 = OpConstantNull %float %40 = OpConstantNull %v4float %41 = OpConstantNull %_arr_v4float_uint_4 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_float Function %b = OpVariable %_ptr_Function_v4float Function %c = OpVariable %_ptr_Function_mat2v3float Function %d = OpVariable %_ptr_Function_D Function %e = OpVariable %_ptr_Function__arr_v4float_uint_4 Function OpStore %a %float_1 OpStore %b %14 OpStore %c %23 OpStore %d %27 OpStore %e %41 %44 = OpLoad %float %a OpStore %FragColor %44 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/op-phi-swap-continue-block.asm.frag000066400000000000000000000050171400026215700262230ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 55 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %UBO "UBO" OpMemberName %UBO 0 "uCount" OpMemberName %UBO 1 "uJ" OpMemberName %UBO 2 "uK" OpName %_ "" OpName %FragColor "FragColor" OpMemberDecorate %UBO 0 Offset 0 OpMemberDecorate %UBO 1 Offset 4 OpMemberDecorate %UBO 2 Offset 8 OpDecorate %UBO Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %UBO = OpTypeStruct %int %int %int %_ptr_Uniform_UBO = OpTypePointer Uniform %UBO %_ = OpVariable %_ptr_Uniform_UBO Uniform %int_1 = OpConstant %int 1 %_ptr_Uniform_int = OpTypePointer Uniform %int %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %bool = OpTypeBool %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %14 = OpAccessChain %_ptr_Uniform_int %_ %int_1 %15 = OpLoad %int %14 %18 = OpAccessChain %_ptr_Uniform_int %_ %int_2 %19 = OpLoad %int %18 OpBranch %22 %22 = OpLabel %54 = OpPhi %int %19 %5 %53 %23 %53 = OpPhi %int %15 %5 %54 %23 %52 = OpPhi %int %int_0 %5 %37 %23 %28 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %29 = OpLoad %int %28 %31 = OpSLessThan %bool %52 %29 OpLoopMerge %24 %23 None OpBranchConditional %31 %inbetween %24 %inbetween = OpLabel OpBranch %23 %23 = OpLabel %37 = OpIAdd %int %52 %int_1 OpBranch %22 %24 = OpLabel %43 = OpISub %int %53 %54 %44 = OpConvertSToF %float %43 %49 = OpIMul %int %15 %19 %50 = OpConvertSToF %float %49 %51 = OpFMul %float %44 %50 OpStore %FragColor %51 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/pack-and-unpack-uint2.asm.frag000066400000000000000000000042271400026215700251430ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 34 ; Schema: 0 OpCapability Shader OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_ARB_gpu_shader_int64" OpName %main "main" OpName %packed "packed" OpName %unpacked "unpacked" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %uint_18 = OpConstant %uint 18 %uint_52 = OpConstant %uint 52 %13 = OpConstantComposite %v2uint %uint_18 %uint_52 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %uint_0 = OpConstant %uint 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_1 = OpConstant %uint 1 %float_1 = OpConstant %float 1 %main = OpFunction %void None %3 %5 = OpLabel %packed = OpVariable %_ptr_Function_ulong Function %unpacked = OpVariable %_ptr_Function_v2uint Function %14 = OpBitcast %ulong %13 OpStore %packed %14 %17 = OpLoad %ulong %packed %18 = OpBitcast %v2uint %17 OpStore %unpacked %18 %25 = OpAccessChain %_ptr_Function_uint %unpacked %uint_0 %26 = OpLoad %uint %25 %27 = OpConvertUToF %float %26 %29 = OpAccessChain %_ptr_Function_uint %unpacked %uint_1 %30 = OpLoad %uint %29 %31 = OpConvertUToF %float %30 %33 = OpCompositeConstruct %v4float %27 %31 %float_1 %float_1 OpStore %FragColor %33 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/pass-by-value.asm.frag000066400000000000000000000040131400026215700236300ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 32 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %add_value_f1_f1_ "add_value(f1;f1;" OpName %v "v" OpName %w "w" OpName %FragColor "FragColor" OpName %Registers "Registers" OpMemberName %Registers 0 "foo" OpName %registers "registers" OpDecorate %FragColor Location 0 OpMemberDecorate %Registers 0 Offset 0 OpDecorate %Registers Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %8 = OpTypeFunction %float %float %float %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %float_10 = OpConstant %float 10 %Registers = OpTypeStruct %float %_ptr_PushConstant_Registers = OpTypePointer PushConstant %Registers %registers = OpVariable %_ptr_PushConstant_Registers PushConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_PushConstant_float = OpTypePointer PushConstant %float %main = OpFunction %void None %3 %5 = OpLabel %29 = OpAccessChain %_ptr_PushConstant_float %registers %int_0 %30 = OpLoad %float %29 %31 = OpFunctionCall %float %add_value_f1_f1_ %float_10 %30 OpStore %FragColor %31 OpReturn OpFunctionEnd %add_value_f1_f1_ = OpFunction %float None %8 %v = OpFunctionParameter %float %w = OpFunctionParameter %float %12 = OpLabel %15 = OpFAdd %float %v %w OpReturnValue %15 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/phi-loop-variable.asm.frag000066400000000000000000000046751400026215700244700ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 59 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat2v2float = OpTypeMatrix %v2float 2 %_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float %v3float = OpTypeVector %float 3 %11 = OpTypeFunction %v3float %_ptr_Function_mat2v2float %_ptr_Function_v3float = OpTypePointer Function %v3float %float_1 = OpConstant %float 1 %18 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_35 = OpConstant %int 35 %int_0 = OpConstant %int 0 %bool = OpTypeBool %int_1 = OpConstant %int 1 %4 = OpFunction %void None %3 %5 = OpLabel OpBranch %48 %48 = OpLabel %58 = OpPhi %int %int_35 %5 %56 %50 OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %53 = OpSGreaterThanEqual %bool %58 %int_0 OpBranchConditional %53 %54 %49 %54 = OpLabel OpBranch %50 %50 = OpLabel %56 = OpISub %int %58 %int_1 OpBranch %48 %49 = OpLabel OpReturn OpFunctionEnd %13 = OpFunction %v3float None %11 %12 = OpFunctionParameter %_ptr_Function_mat2v2float %14 = OpLabel %16 = OpVariable %_ptr_Function_v3float Function %21 = OpVariable %_ptr_Function_int Function OpStore %16 %18 OpStore %21 %int_35 OpBranch %23 %23 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %28 = OpLoad %int %21 %31 = OpSGreaterThanEqual %bool %28 %int_0 OpBranchConditional %31 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %32 = OpLoad %int %21 %34 = OpISub %int %32 %int_1 OpStore %21 %34 OpBranch %23 %25 = OpLabel %35 = OpLoad %v3float %16 OpReturnValue %35 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/sample-and-compare.asm.frag000066400000000000000000000055611400026215700246160ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google spiregg; 0 ; Bound: 32 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_TEXCOORD0 %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_2d_image "type.2d.image" OpName %g_Texture "g_Texture" OpName %type_sampler "type.sampler" OpName %g_Sampler "g_Sampler" OpName %g_CompareSampler "g_CompareSampler" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %g_Texture DescriptorSet 0 OpDecorate %g_Texture Binding 0 OpDecorate %g_Sampler DescriptorSet 0 OpDecorate %g_Sampler Binding 0 OpDecorate %g_CompareSampler DescriptorSet 0 OpDecorate %g_CompareSampler Binding 1 %float = OpTypeFloat 32 %float_0_5 = OpConstant %float 0.5 %float_0 = OpConstant %float 0 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Output_float = OpTypePointer Output %float %void = OpTypeVoid %19 = OpTypeFunction %void %type_sampled_image = OpTypeSampledImage %type_2d_image %v4float = OpTypeVector %float 4 %g_Texture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_Sampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %g_CompareSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %19 %21 = OpLabel %22 = OpLoad %v2float %in_var_TEXCOORD0 %23 = OpLoad %type_2d_image %g_Texture %24 = OpLoad %type_sampler %g_Sampler %25 = OpSampledImage %type_sampled_image %23 %24 %26 = OpImageSampleImplicitLod %v4float %25 %22 None %27 = OpCompositeExtract %float %26 0 %28 = OpLoad %type_sampler %g_CompareSampler %29 = OpSampledImage %type_sampled_image %23 %28 %30 = OpImageSampleDrefExplicitLod %float %29 %22 %float_0_5 Lod %float_0 %31 = OpFAdd %float %27 %30 OpStore %out_var_SV_Target %31 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/sampler-buffer-array-without-sampler.asm.frag000066400000000000000000000075521400026215700303430ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 63 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %sample_from_func_s21_4__ "sample_from_func(s21[4];" OpName %uSampler "uSampler" OpName %sample_one_from_func_s21_ "sample_one_from_func(s21;" OpName %uSampler_0 "uSampler" OpName %Registers "Registers" OpMemberName %Registers 0 "index" OpName %registers "registers" OpName %FragColor "FragColor" OpName %uSampler_1 "uSampler" OpMemberDecorate %Registers 0 Offset 0 OpDecorate %Registers Block OpDecorate %FragColor Location 0 OpDecorate %uSampler_1 DescriptorSet 0 OpDecorate %uSampler_1 Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float 2D 0 0 0 1 Unknown %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %_arr_8_uint_4 = OpTypeArray %7 %uint_4 %_ptr_UniformConstant__arr_8_uint_4 = OpTypePointer UniformConstant %_arr_8_uint_4 %v4float = OpTypeVector %float 4 %14 = OpTypeFunction %v4float %_ptr_UniformConstant__arr_8_uint_4 %_ptr_UniformConstant_8 = OpTypePointer UniformConstant %7 %19 = OpTypeFunction %v4float %_ptr_UniformConstant_8 %int = OpTypeInt 32 1 %Registers = OpTypeStruct %int %_ptr_PushConstant_Registers = OpTypePointer PushConstant %Registers %registers = OpVariable %_ptr_PushConstant_Registers PushConstant %int_0 = OpConstant %int 0 %_ptr_PushConstant_int = OpTypePointer PushConstant %int %v2int = OpTypeVector %int 2 %int_4 = OpConstant %int 4 %35 = OpConstantComposite %v2int %int_4 %int_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %uSampler_1 = OpVariable %_ptr_UniformConstant__arr_8_uint_4 UniformConstant %int_10 = OpConstant %int 10 %53 = OpConstantComposite %v2int %int_10 %int_10 %main = OpFunction %void None %3 %5 = OpLabel %48 = OpAccessChain %_ptr_PushConstant_int %registers %int_0 %49 = OpLoad %int %48 %50 = OpAccessChain %_ptr_UniformConstant_8 %uSampler_1 %49 %51 = OpLoad %7 %50 %55 = OpImageFetch %v4float %51 %53 Lod %int_0 %56 = OpFunctionCall %v4float %sample_from_func_s21_4__ %uSampler_1 %57 = OpFAdd %v4float %55 %56 %58 = OpAccessChain %_ptr_PushConstant_int %registers %int_0 %59 = OpLoad %int %58 %60 = OpAccessChain %_ptr_UniformConstant_8 %uSampler_1 %59 %61 = OpFunctionCall %v4float %sample_one_from_func_s21_ %60 %62 = OpFAdd %v4float %57 %61 OpStore %FragColor %62 OpReturn OpFunctionEnd %sample_from_func_s21_4__ = OpFunction %v4float None %14 %uSampler = OpFunctionParameter %_ptr_UniformConstant__arr_8_uint_4 %17 = OpLabel %29 = OpAccessChain %_ptr_PushConstant_int %registers %int_0 %30 = OpLoad %int %29 %31 = OpAccessChain %_ptr_UniformConstant_8 %uSampler %30 %32 = OpLoad %7 %31 %37 = OpImageFetch %v4float %32 %35 Lod %int_0 OpReturnValue %37 OpFunctionEnd %sample_one_from_func_s21_ = OpFunction %v4float None %19 %uSampler_0 = OpFunctionParameter %_ptr_UniformConstant_8 %22 = OpLabel %40 = OpLoad %7 %uSampler_0 %42 = OpImageFetch %v4float %40 %35 Lod %int_0 OpReturnValue %42 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/sampler-buffer-without-sampler.asm.frag000066400000000000000000000047621400026215700272270ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 36 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %_main_ "@main(" OpName %storeTemp "storeTemp" OpName %RWTex "RWTex" OpName %Tex "Tex" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %RWTex DescriptorSet 0 OpDecorate %Tex DescriptorSet 0 OpDecorate %RWTex Binding 0 OpDecorate %Tex Binding 1 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %13 = OpConstant %float 1 %14 = OpConstant %float 2 %15 = OpConstant %float 3 %16 = OpConstant %float 4 %17 = OpConstantComposite %v4float %13 %14 %15 %16 %18 = OpTypeImage %float Buffer 0 0 0 2 Rgba32f %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %RWTex = OpVariable %_ptr_UniformConstant_18 UniformConstant %int = OpTypeInt 32 1 %23 = OpConstant %int 20 %25 = OpTypeImage %float Buffer 0 0 0 1 Rgba32f %_ptr_UniformConstant_25 = OpTypePointer UniformConstant %25 %Tex = OpVariable %_ptr_UniformConstant_25 UniformConstant %29 = OpConstant %int 10 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %35 = OpFunctionCall %v4float %_main_ OpStore %_entryPointOutput %35 OpReturn OpFunctionEnd %_main_ = OpFunction %v4float None %8 %10 = OpLabel %storeTemp = OpVariable %_ptr_Function_v4float Function OpStore %storeTemp %17 %21 = OpLoad %18 %RWTex %24 = OpLoad %v4float %storeTemp OpImageWrite %21 %23 %24 %28 = OpLoad %25 %Tex %30 = OpImageFetch %v4float %28 %29 OpReturnValue %30 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/single-function-private-lut.asm.frag000066400000000000000000000070071400026215700265240ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 54 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %o_color OpExecutionMode %main OriginUpperLeft OpSource GLSL 460 OpName %main "main" OpName %myType "myType" OpMemberName %myType 0 "data" OpName %myData "myData" OpName %uv "uv" OpName %gl_FragCoord "gl_FragCoord" OpName %index "index" OpName %elt "elt" OpName %o_color "o_color" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %o_color Location 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %myType = OpTypeStruct %float %uint = OpTypeInt 32 0 %uint_5 = OpConstant %uint 5 %_arr_myType_uint_5 = OpTypeArray %myType %uint_5 %_ptr_Private__arr_myType_uint_5 = OpTypePointer Private %_arr_myType_uint_5 %myData = OpVariable %_ptr_Private__arr_myType_uint_5 Private %float_0 = OpConstant %float 0 %18 = OpConstantComposite %myType %float_0 %float_1 = OpConstant %float 1 %20 = OpConstantComposite %myType %float_1 %21 = OpConstantComposite %_arr_myType_uint_5 %18 %20 %18 %20 %18 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %float_4 = OpConstant %float 4 %_ptr_Function_myType = OpTypePointer Function %myType %_ptr_Private_myType = OpTypePointer Private %myType %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_Output_v4float = OpTypePointer Output %v4float %o_color = OpVariable %_ptr_Output_v4float Output %36 = OpConstantComposite %v4float %float_0 %float_1 %float_0 %float_1 %37 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %main = OpFunction %void None %11 %38 = OpLabel %uv = OpVariable %_ptr_Function_v2float Function %index = OpVariable %_ptr_Function_int Function %elt = OpVariable %_ptr_Function_myType Function OpStore %myData %21 %39 = OpLoad %v4float %gl_FragCoord %40 = OpVectorShuffle %v2float %39 %39 0 1 OpStore %uv %40 %41 = OpAccessChain %_ptr_Function_float %uv %uint_0 %42 = OpLoad %float %41 %43 = OpFMod %float %42 %float_4 %44 = OpConvertFToS %int %43 OpStore %index %44 %45 = OpLoad %int %index %46 = OpAccessChain %_ptr_Private_myType %myData %45 %47 = OpLoad %myType %46 OpStore %elt %47 %48 = OpAccessChain %_ptr_Function_float %elt %int_0 %49 = OpLoad %float %48 %50 = OpFOrdGreaterThan %bool %49 %float_0 OpSelectionMerge %51 None OpBranchConditional %50 %52 %53 %52 = OpLabel OpStore %o_color %36 OpBranch %51 %53 = OpLabel OpStore %o_color %37 OpBranch %51 %51 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/srem.asm.frag000066400000000000000000000030661400026215700221150ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 23 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %vA %vB OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %vA "vA" OpName %vB "vB" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %vA Flat OpDecorate %vA Location 0 OpDecorate %vB Flat OpDecorate %vB Location 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %_ptr_Input_v4int = OpTypePointer Input %v4int %vA = OpVariable %_ptr_Input_v4int Input %vB = OpVariable %_ptr_Input_v4int Input %main = OpFunction %void None %3 %5 = OpLabel %14 = OpLoad %v4int %vA %16 = OpLoad %v4int %vB %17 = OpLoad %v4int %vA %18 = OpLoad %v4int %vB %19 = OpSRem %v4int %17 %18 %20 = OpConvertSToF %v4float %19 OpStore %FragColor %20 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/storage-class-output-initializer.asm.frag000066400000000000000000000033231400026215700275710ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 25 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColors %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColors "FragColors" OpName %FragColor "FragColor" OpDecorate %FragColors Location 0 OpDecorate %FragColor Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_ptr_Output__arr_v4float_uint_2 = OpTypePointer Output %_arr_v4float_uint_2 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %17 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4 %float_10 = OpConstant %float 10 %19 = OpConstantComposite %v4float %float_10 %float_10 %float_10 %float_10 %20 = OpConstantComposite %_arr_v4float_uint_2 %17 %19 %_ptr_Output_v4float = OpTypePointer Output %v4float %float_5 = OpConstant %float 5 %24 = OpConstantComposite %v4float %float_5 %float_5 %float_5 %float_5 %FragColors = OpVariable %_ptr_Output__arr_v4float_uint_2 Output %20 %FragColor = OpVariable %_ptr_Output_v4float Output %24 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/struct-composite-extract-swizzle.asm.frag000066400000000000000000000043661400026215700276540ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 34 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %FragColor "FragColor" OpName %uSampler "uSampler" OpName %Foo "Foo" OpMemberName %Foo 0 "var1" OpMemberName %Foo 1 "var2" OpName %foo "foo" OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 OpDecorate %uSampler RelaxedPrecision OpDecorate %uSampler DescriptorSet 0 OpDecorate %uSampler Binding 0 OpDecorate %14 RelaxedPrecision OpMemberDecorate %Foo 0 RelaxedPrecision OpMemberDecorate %Foo 1 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %uSampler = OpVariable %_ptr_UniformConstant_11 UniformConstant %Foo = OpTypeStruct %float %float %_ptr_Function_Foo = OpTypePointer Function %Foo %int = OpTypeInt 32 1 %_ptr_Function_float = OpTypePointer Function %float %v2float = OpTypeVector %float 2 %33 = OpUndef %Foo %main = OpFunction %void None %3 %5 = OpLabel %foo = OpVariable %_ptr_Function_Foo Function %14 = OpLoad %11 %uSampler %30 = OpCompositeExtract %float %33 0 %32 = OpCompositeExtract %float %33 1 %27 = OpCompositeConstruct %v2float %30 %32 %28 = OpImageSampleImplicitLod %v4float %14 %27 OpStore %FragColor %28 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/switch-label-shared-block.asm.frag000066400000000000000000000032201400026215700260510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vIndex %FragColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %vIndex "vIndex" OpName %FragColor "FragColor" OpDecorate %vIndex RelaxedPrecision OpDecorate %vIndex Flat OpDecorate %vIndex Location 0 OpDecorate %13 RelaxedPrecision OpDecorate %FragColor RelaxedPrecision OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %float_8 = OpConstant %float 8 %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %vIndex = OpVariable %_ptr_Input_int Input %float_1 = OpConstant %float 1 %float_3 = OpConstant %float 3 %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %13 = OpLoad %int %vIndex OpSelectionMerge %17 None OpSwitch %13 %15 0 %14 2 %14 1 %15 8 %17 %15 = OpLabel OpBranch %17 %14 = OpLabel OpBranch %17 %17 = OpLabel %27 = OpPhi %float %float_3 %15 %float_1 %14 %float_8 %5 OpStore %FragColor %27 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/temporary-name-alias.asm.frag000066400000000000000000000043101400026215700251670ustar00rootroot00000000000000; SPIR-V ; Version: 1.2 ; Generator: Khronos; 0 ; Bound: 51 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %EntryPoint_Main "main" OpExecutionMode %EntryPoint_Main OriginUpperLeft OpSource Unknown 100 OpName %mat3 "mat3" OpName %constituent "constituent" OpName %constituent_0 "constituent" OpName %constituent_1 "constituent" OpName %constituent_2 "constituent" OpName %constituent_3 "constituent" OpName %constituent_4 "constituent" OpName %constituent_5 "constituent" OpName %constituent_6 "constituent" OpName %EntryPoint_Main "EntryPoint_Main" %void = OpTypeVoid %_ptr_Function_void = OpTypePointer Function %void %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %v3float = OpTypeVector %float 3 %mat3v3float = OpTypeMatrix %v3float 3 %_ptr_Function_mat3v3float = OpTypePointer Function %mat3v3float %14 = OpTypeFunction %void %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %EntryPoint_Main = OpFunction %void None %14 %45 = OpLabel %mat3 = OpVariable %_ptr_Function_mat3v3float Function %constituent = OpConvertSToF %float %int_0 %constituent_0 = OpCompositeConstruct %v3float %constituent %constituent %constituent %constituent_1 = OpCompositeConstruct %v3float %constituent %constituent %constituent %constituent_2 = OpCompositeConstruct %v3float %constituent %constituent %constituent %25 = OpCompositeConstruct %mat3v3float %constituent_0 %constituent_1 %constituent_2 OpStore %mat3 %25 %constituent_3 = OpConvertSToF %float %int_1 %constituent_4 = OpCompositeConstruct %v3float %constituent_3 %constituent_3 %constituent_3 %constituent_5 = OpCompositeConstruct %v3float %constituent_3 %constituent_3 %constituent_3 %constituent_6 = OpCompositeConstruct %v3float %constituent_3 %constituent_3 %constituent_3 %30 = OpCompositeConstruct %mat3v3float %constituent_4 %constituent_5 %constituent_6 OpStore %mat3 %30 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/temporary-phi-hoisting.asm.frag000066400000000000000000000057651400026215700256010ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 87 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %MyStruct "MyStruct" OpMemberName %MyStruct 0 "color" OpName %MyStruct_CB "MyStruct_CB" OpMemberName %MyStruct_CB 0 "g_MyStruct" OpName %_ "" OpName %_entryPointOutput "@entryPointOutput" OpMemberDecorate %MyStruct 0 Offset 0 OpDecorate %_arr_MyStruct_uint_4 ArrayStride 16 OpMemberDecorate %MyStruct_CB 0 Offset 0 OpDecorate %MyStruct_CB Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %float_0 = OpConstant %float 0 %15 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %MyStruct = OpTypeStruct %v4float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %_arr_MyStruct_uint_4 = OpTypeArray %MyStruct %uint_4 %MyStruct_CB = OpTypeStruct %_arr_MyStruct_uint_4 %_ptr_Uniform_MyStruct_CB = OpTypePointer Uniform %MyStruct_CB %_ = OpVariable %_ptr_Uniform_MyStruct_CB Uniform %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel OpBranch %64 %64 = OpLabel %85 = OpPhi %v3float %15 %5 %77 %66 %86 = OpPhi %int %int_0 %5 %79 %66 OpLoopMerge %65 %66 None OpBranch %67 %67 = OpLabel %69 = OpSLessThan %bool %86 %int_4 OpBranchConditional %69 %70 %65 %70 = OpLabel %72 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %86 %int_0 %73 = OpLoad %v4float %72 %74 = OpVectorShuffle %v3float %73 %73 0 1 2 %77 = OpFAdd %v3float %85 %74 OpBranch %66 %66 = OpLabel %79 = OpIAdd %int %86 %int_1 OpBranch %64 %65 = OpLabel %81 = OpCompositeExtract %float %85 0 %82 = OpCompositeExtract %float %85 1 %83 = OpCompositeExtract %float %85 2 %84 = OpCompositeConstruct %v4float %81 %82 %83 %float_1 OpStore %_entryPointOutput %84 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/texel-fetch-no-lod.asm.frag000066400000000000000000000035061400026215700245440ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 26 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %gl_FragCoord OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %FragColor "FragColor" OpName %uTexture "uTexture" OpName %gl_FragCoord "gl_FragCoord" OpDecorate %FragColor Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 0 OpDecorate %gl_FragCoord BuiltIn FragCoord %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %uTexture = OpVariable %_ptr_UniformConstant_11 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %int_0 = OpConstant %int 0 %main = OpFunction %void None %3 %5 = OpLabel %14 = OpLoad %11 %uTexture %18 = OpLoad %v4float %gl_FragCoord %19 = OpVectorShuffle %v2float %18 %18 0 1 %22 = OpConvertFToS %v2int %19 %24 = OpImage %10 %14 %25 = OpImageFetch %v4float %24 %22 OpStore %FragColor %25 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/texture-sampling-fp16.asm.vk.frag000066400000000000000000000035621400026215700256510ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 25 ; Schema: 0 OpCapability Shader OpCapability StorageInputOutput16 OpCapability Float16 OpExtension "SPV_KHR_16bit_storage" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor %UV OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_shader_explicit_arithmetic_types_float16" OpName %main "main" OpName %FragColor "FragColor" OpName %uTexture "uTexture" OpName %UV "UV" OpDecorate %FragColor Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 0 OpDecorate %UV Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %half = OpTypeFloat 16 %float = OpTypeFloat 32 %v4half = OpTypeVector %half 4 %v4float = OpTypeVector %float 4 %_ptr_Output_v4half = OpTypePointer Output %v4half %FragColor = OpVariable %_ptr_Output_v4half Output %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %12 = OpTypeSampledImage %11 %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %uTexture = OpVariable %_ptr_UniformConstant_12 UniformConstant %v2half = OpTypeVector %half 2 %_ptr_Input_v2half = OpTypePointer Input %v2half %UV = OpVariable %_ptr_Input_v2half Input %main = OpFunction %void None %3 %5 = OpLabel %15 = OpLoad %12 %uTexture %19 = OpLoad %v2half %UV %23 = OpImageSampleImplicitLod %v4float %15 %19 %24 = OpFConvert %v4half %23 OpStore %FragColor %24 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/undef-variable-store.asm.frag000066400000000000000000000063331400026215700251650ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 50 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %fragmentProgram "main" %_entryPointOutput OpExecutionMode %fragmentProgram OriginUpperLeft OpSource HLSL 500 OpName %fragmentProgram "fragmentProgram" OpName %_fragmentProgram_ "@fragmentProgram(" OpName %uv "uv" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %float_0 = OpConstant %float 0 %15 = OpConstantComposite %v2float %float_0 %float_0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %bool = OpTypeBool %float_1 = OpConstant %float 1 %26 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %29 = OpConstantComposite %v4float %float_1 %float_1 %float_0 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %false = OpConstantFalse %bool %fragmentProgram = OpFunction %void None %3 %5 = OpLabel %35 = OpVariable %_ptr_Function_v2float Function %37 = OpVariable %_ptr_Function_v4float Function OpBranch %38 %38 = OpLabel OpLoopMerge %39 %40 None OpBranch %41 %41 = OpLabel OpStore %35 %15 %42 = OpAccessChain %_ptr_Function_float %35 %uint_0 %43 = OpLoad %float %42 %44 = OpFOrdNotEqual %bool %43 %float_0 OpSelectionMerge %45 None OpBranchConditional %44 %46 %47 %46 = OpLabel OpStore %37 %26 OpBranch %39 %47 = OpLabel OpStore %37 %29 OpBranch %39 %45 = OpLabel %48 = OpUndef %v4float OpStore %37 %48 OpBranch %39 %40 = OpLabel OpBranchConditional %false %38 %39 %39 = OpLabel %34 = OpLoad %v4float %37 OpStore %_entryPointOutput %34 OpReturn OpFunctionEnd %_fragmentProgram_ = OpFunction %v4float None %8 %10 = OpLabel %uv = OpVariable %_ptr_Function_v2float Function OpStore %uv %15 %19 = OpAccessChain %_ptr_Function_float %uv %uint_0 %20 = OpLoad %float %19 %22 = OpFOrdNotEqual %bool %20 %float_0 OpSelectionMerge %24 None OpBranchConditional %22 %23 %28 %23 = OpLabel OpReturnValue %26 %28 = OpLabel OpReturnValue %29 %24 = OpLabel %31 = OpUndef %v4float OpReturnValue %31 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/unknown-depth-state.asm.vk.frag000066400000000000000000000056641400026215700255130ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 44 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vUV %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %sample_combined_ "sample_combined(" OpName %sample_separate_ "sample_separate(" OpName %uShadow "uShadow" OpName %vUV "vUV" OpName %uTexture "uTexture" OpName %uSampler "uSampler" OpName %FragColor "FragColor" OpDecorate %uShadow DescriptorSet 0 OpDecorate %uShadow Binding 0 OpDecorate %vUV Location 0 OpDecorate %uTexture DescriptorSet 0 OpDecorate %uTexture Binding 1 OpDecorate %uSampler DescriptorSet 0 OpDecorate %uSampler Binding 2 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeFunction %float %12 = OpTypeImage %float 2D 2 0 0 1 Unknown %13 = OpTypeSampledImage %12 %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %uShadow = OpVariable %_ptr_UniformConstant_13 UniformConstant %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %vUV = OpVariable %_ptr_Input_v3float Input %_ptr_UniformConstant_25 = OpTypePointer UniformConstant %12 %uTexture = OpVariable %_ptr_UniformConstant_25 UniformConstant %29 = OpTypeSampler %_ptr_UniformConstant_29 = OpTypePointer UniformConstant %29 %uSampler = OpVariable %_ptr_UniformConstant_29 UniformConstant %_ptr_Output_float = OpTypePointer Output %float %FragColor = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %41 = OpFunctionCall %float %sample_combined_ %42 = OpFunctionCall %float %sample_separate_ %43 = OpFAdd %float %41 %42 OpStore %FragColor %43 OpReturn OpFunctionEnd %sample_combined_ = OpFunction %float None %7 %9 = OpLabel %16 = OpLoad %13 %uShadow %20 = OpLoad %v3float %vUV %21 = OpCompositeExtract %float %20 2 %22 = OpImageSampleDrefImplicitLod %float %16 %20 %21 OpReturnValue %22 OpFunctionEnd %sample_separate_ = OpFunction %float None %7 %11 = OpLabel %28 = OpLoad %12 %uTexture %32 = OpLoad %29 %uSampler %33 = OpSampledImage %13 %28 %32 %34 = OpLoad %v3float %vUV %35 = OpCompositeExtract %float %34 2 %36 = OpImageSampleDrefImplicitLod %float %33 %34 %35 OpReturnValue %36 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/unreachable.asm.frag000066400000000000000000000043361400026215700234210ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 47 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %counter %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %counter "counter" OpName %FragColor "FragColor" OpDecorate %counter Flat OpDecorate %counter Location 0 OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %counter = OpVariable %_ptr_Input_int Input %int_10 = OpConstant %int 10 %bool = OpTypeBool %float_10 = OpConstant %float 10 %21 = OpConstantComposite %v4float %float_10 %float_10 %float_10 %float_10 %float_30 = OpConstant %float 30 %25 = OpConstantComposite %v4float %float_30 %float_30 %float_30 %float_30 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %false = OpConstantFalse %bool %44 = OpUndef %v4float %main = OpFunction %void None %3 %5 = OpLabel OpBranch %33 %33 = OpLabel %45 = OpPhi %v4float %44 %5 %44 %35 OpLoopMerge %34 %35 None OpBranch %36 %36 = OpLabel %37 = OpLoad %int %counter %38 = OpIEqual %bool %37 %int_10 OpSelectionMerge %39 None OpBranchConditional %38 %40 %41 %40 = OpLabel OpBranch %34 %41 = OpLabel OpBranch %34 %39 = OpLabel OpUnreachable %35 = OpLabel OpBranchConditional %false %33 %34 %34 = OpLabel %46 = OpPhi %v4float %21 %40 %25 %41 %44 %35 OpStore %FragColor %46 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/frag/vector-shuffle-oom.asm.frag000066400000000000000000001322131400026215700246700ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 25007 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %5663 "main" %5800 %gl_FragCoord %4317 OpExecutionMode %5663 OriginUpperLeft OpMemberDecorate %_struct_1116 0 Offset 0 OpMemberDecorate %_struct_1116 1 Offset 16 OpMemberDecorate %_struct_1116 2 Offset 32 OpDecorate %_struct_1116 Block OpDecorate %22044 DescriptorSet 0 OpDecorate %22044 Binding 0 OpDecorate %5785 DescriptorSet 0 OpDecorate %5785 Binding 140 OpDecorate %5688 DescriptorSet 0 OpDecorate %5688 Binding 60 OpMemberDecorate %_struct_994 0 Offset 0 OpMemberDecorate %_struct_994 1 Offset 16 OpMemberDecorate %_struct_994 2 Offset 28 OpMemberDecorate %_struct_994 3 Offset 32 OpMemberDecorate %_struct_994 4 Offset 44 OpMemberDecorate %_struct_994 5 Offset 48 OpMemberDecorate %_struct_994 6 Offset 60 OpMemberDecorate %_struct_994 7 Offset 64 OpMemberDecorate %_struct_994 8 Offset 76 OpMemberDecorate %_struct_994 9 Offset 80 OpMemberDecorate %_struct_994 10 Offset 92 OpMemberDecorate %_struct_994 11 Offset 96 OpMemberDecorate %_struct_994 12 Offset 108 OpMemberDecorate %_struct_994 13 Offset 112 OpMemberDecorate %_struct_994 14 Offset 120 OpMemberDecorate %_struct_994 15 Offset 128 OpMemberDecorate %_struct_994 16 Offset 140 OpMemberDecorate %_struct_994 17 Offset 144 OpMemberDecorate %_struct_994 18 Offset 148 OpMemberDecorate %_struct_994 19 Offset 152 OpMemberDecorate %_struct_994 20 Offset 156 OpMemberDecorate %_struct_994 21 Offset 160 OpMemberDecorate %_struct_994 22 Offset 176 OpMemberDecorate %_struct_994 23 RowMajor OpMemberDecorate %_struct_994 23 Offset 192 OpMemberDecorate %_struct_994 23 MatrixStride 16 OpMemberDecorate %_struct_994 24 Offset 256 OpDecorate %_struct_994 Block OpDecorate %12348 DescriptorSet 0 OpDecorate %12348 Binding 2 OpDecorate %3312 DescriptorSet 0 OpDecorate %3312 Binding 142 OpDecorate %4646 DescriptorSet 0 OpDecorate %4646 Binding 62 OpDecorate %4862 DescriptorSet 0 OpDecorate %4862 Binding 141 OpDecorate %3594 DescriptorSet 0 OpDecorate %3594 Binding 61 OpDecorate %_arr_mat4v4float_uint_2 ArrayStride 64 OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpMemberDecorate %_struct_408 0 RowMajor OpMemberDecorate %_struct_408 0 Offset 0 OpMemberDecorate %_struct_408 0 MatrixStride 16 OpMemberDecorate %_struct_408 1 RowMajor OpMemberDecorate %_struct_408 1 Offset 64 OpMemberDecorate %_struct_408 1 MatrixStride 16 OpMemberDecorate %_struct_408 2 RowMajor OpMemberDecorate %_struct_408 2 Offset 128 OpMemberDecorate %_struct_408 2 MatrixStride 16 OpMemberDecorate %_struct_408 3 RowMajor OpMemberDecorate %_struct_408 3 Offset 192 OpMemberDecorate %_struct_408 3 MatrixStride 16 OpMemberDecorate %_struct_408 4 Offset 256 OpMemberDecorate %_struct_408 5 Offset 272 OpMemberDecorate %_struct_408 6 Offset 288 OpMemberDecorate %_struct_408 7 Offset 292 OpMemberDecorate %_struct_408 8 Offset 296 OpMemberDecorate %_struct_408 9 Offset 300 OpMemberDecorate %_struct_408 10 Offset 304 OpMemberDecorate %_struct_408 11 Offset 316 OpMemberDecorate %_struct_408 12 Offset 320 OpMemberDecorate %_struct_408 13 Offset 332 OpMemberDecorate %_struct_408 14 Offset 336 OpMemberDecorate %_struct_408 15 Offset 348 OpMemberDecorate %_struct_408 16 Offset 352 OpMemberDecorate %_struct_408 17 Offset 364 OpMemberDecorate %_struct_408 18 Offset 368 OpMemberDecorate %_struct_408 19 Offset 372 OpMemberDecorate %_struct_408 20 Offset 376 OpMemberDecorate %_struct_408 21 Offset 384 OpMemberDecorate %_struct_408 22 Offset 392 OpMemberDecorate %_struct_408 23 Offset 400 OpMemberDecorate %_struct_408 24 Offset 416 OpMemberDecorate %_struct_408 25 Offset 424 OpMemberDecorate %_struct_408 26 Offset 432 OpMemberDecorate %_struct_408 27 Offset 448 OpMemberDecorate %_struct_408 28 Offset 460 OpMemberDecorate %_struct_408 29 Offset 464 OpMemberDecorate %_struct_408 30 Offset 468 OpMemberDecorate %_struct_408 31 Offset 472 OpMemberDecorate %_struct_408 32 Offset 476 OpMemberDecorate %_struct_408 33 Offset 480 OpMemberDecorate %_struct_408 34 Offset 488 OpMemberDecorate %_struct_408 35 Offset 492 OpMemberDecorate %_struct_408 36 Offset 496 OpMemberDecorate %_struct_408 37 RowMajor OpMemberDecorate %_struct_408 37 Offset 512 OpMemberDecorate %_struct_408 37 MatrixStride 16 OpMemberDecorate %_struct_408 38 Offset 640 OpDecorate %_struct_408 Block OpDecorate %15259 DescriptorSet 0 OpDecorate %15259 Binding 1 OpDecorate %5800 Location 0 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %4317 Location 0 OpMemberDecorate %_struct_1395 0 Offset 0 OpMemberDecorate %_struct_1395 1 Offset 16 OpMemberDecorate %_struct_1395 2 Offset 32 OpMemberDecorate %_struct_1395 3 Offset 40 OpMemberDecorate %_struct_1395 4 Offset 48 OpMemberDecorate %_struct_1395 5 Offset 60 OpMemberDecorate %_struct_1395 6 Offset 64 OpMemberDecorate %_struct_1395 7 Offset 76 OpMemberDecorate %_struct_1395 8 Offset 80 OpMemberDecorate %_struct_1395 9 Offset 96 OpMemberDecorate %_struct_1395 10 Offset 112 OpMemberDecorate %_struct_1395 11 Offset 128 OpMemberDecorate %_struct_1395 12 Offset 140 OpMemberDecorate %_struct_1395 13 Offset 144 OpMemberDecorate %_struct_1395 14 Offset 156 OpMemberDecorate %_struct_1395 15 Offset 160 OpMemberDecorate %_struct_1395 16 Offset 176 OpMemberDecorate %_struct_1395 17 Offset 192 OpMemberDecorate %_struct_1395 18 Offset 204 OpMemberDecorate %_struct_1395 19 Offset 208 OpMemberDecorate %_struct_1395 20 Offset 224 OpDecorate %_struct_1395 Block OpMemberDecorate %_struct_1018 0 Offset 0 OpDecorate %_struct_1018 Block %void = OpTypeVoid %1282 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %_struct_1017 = OpTypeStruct %v4float %_struct_1116 = OpTypeStruct %v4float %float %v4float %_ptr_Uniform__struct_1116 = OpTypePointer Uniform %_struct_1116 %22044 = OpVariable %_ptr_Uniform__struct_1116 Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %150 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_150 = OpTypePointer UniformConstant %150 %5785 = OpVariable %_ptr_UniformConstant_150 UniformConstant %508 = OpTypeSampler %_ptr_UniformConstant_508 = OpTypePointer UniformConstant %508 %5688 = OpVariable %_ptr_UniformConstant_508 UniformConstant %510 = OpTypeSampledImage %150 %float_0 = OpConstant %float 0 %uint = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %float_1 = OpConstant %float 1 %mat4v4float = OpTypeMatrix %v4float 4 %_struct_994 = OpTypeStruct %v3float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v3float %float %v2float %v2float %v3float %float %float %float %float %float %v4float %v4float %mat4v4float %v4float %_ptr_Uniform__struct_994 = OpTypePointer Uniform %_struct_994 %12348 = OpVariable %_ptr_Uniform__struct_994 Uniform %int_5 = OpConstant %int 5 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %3312 = OpVariable %_ptr_UniformConstant_150 UniformConstant %4646 = OpVariable %_ptr_UniformConstant_508 UniformConstant %bool = OpTypeBool %4862 = OpVariable %_ptr_UniformConstant_150 UniformConstant %3594 = OpVariable %_ptr_UniformConstant_508 UniformConstant %uint_2 = OpConstant %uint 2 %2938 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_arr_mat4v4float_uint_2 = OpTypeArray %mat4v4float %uint_2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_struct_408 = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %mat4v4float %v4float %v4float %float %float %float %float %v3float %float %v3float %float %v3float %float %v3float %float %float %float %v2float %v2float %v2float %v4float %v2float %v2float %v2float %v3float %float %float %float %float %float %v2float %float %float %v3float %_arr_mat4v4float_uint_2 %_arr_v4float_uint_2 %_ptr_Uniform__struct_408 = OpTypePointer Uniform %_struct_408 %15259 = OpVariable %_ptr_Uniform__struct_408 Uniform %int_23 = OpConstant %int 23 %int_2 = OpConstant %int 2 %float_n2 = OpConstant %float -2 %float_0_5 = OpConstant %float 0.5 %1196 = OpConstantComposite %v3float %float_0 %float_n2 %float_0_5 %float_n1 = OpConstant %float -1 %836 = OpConstantComposite %v3float %float_n1 %float_n1 %float_0_5 %float_0_75 = OpConstant %float 0.75 %1367 = OpConstantComposite %v3float %float_0 %float_n1 %float_0_75 %141 = OpConstantComposite %v3float %float_1 %float_n1 %float_0_5 %38 = OpConstantComposite %v3float %float_n2 %float_0 %float_0_5 %95 = OpConstantComposite %v3float %float_n1 %float_0 %float_0_75 %626 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %2411 = OpConstantComposite %v3float %float_1 %float_0 %float_0_75 %float_2 = OpConstant %float 2 %2354 = OpConstantComposite %v3float %float_2 %float_0 %float_0_5 %837 = OpConstantComposite %v3float %float_n1 %float_1 %float_0_5 %1368 = OpConstantComposite %v3float %float_0 %float_1 %float_0_75 %142 = OpConstantComposite %v3float %float_1 %float_1 %float_0_5 %1197 = OpConstantComposite %v3float %float_0 %float_2 %float_0_5 %_ptr_Input_v2float = OpTypePointer Input %v2float %5800 = OpVariable %_ptr_Input_v2float Input %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %4317 = OpVariable %_ptr_Output_v4float Output %_struct_1395 = OpTypeStruct %v4float %v4float %v2float %v2float %v3float %float %v3float %float %v4float %v4float %v4float %v3float %float %v3float %float %v3float %v4float %v3float %float %v3float %v2float %_struct_1018 = OpTypeStruct %v4float %10264 = OpUndef %_struct_1017 %5663 = OpFunction %void None %1282 %25006 = OpLabel %17463 = OpLoad %v4float %gl_FragCoord %13863 = OpCompositeInsert %_struct_1017 %2938 %10264 0 %22969 = OpVectorShuffle %v2float %17463 %17463 0 1 %13206 = OpAccessChain %_ptr_Uniform_v4float %15259 %int_23 %10343 = OpLoad %v4float %13206 %7422 = OpVectorShuffle %v2float %10343 %10343 0 1 %19927 = OpFMul %v2float %22969 %7422 %18174 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_2 %16206 = OpLoad %v4float %18174 %20420 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %21354 = OpLoad %v4float %20420 %7688 = OpVectorShuffle %v4float %21354 %21354 0 1 0 1 %17581 = OpFMul %v4float %16206 %7688 %10673 = OpVectorShuffle %v2float %1196 %1196 0 1 %18824 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10344 = OpLoad %v4float %18824 %8638 = OpVectorShuffle %v2float %10344 %10344 0 1 %9197 = OpFMul %v2float %10673 %8638 %18505 = OpFAdd %v2float %19927 %9197 %7011 = OpVectorShuffle %v2float %17581 %17581 0 1 %21058 = OpVectorShuffle %v2float %17581 %17581 2 3 %13149 = OpExtInst %v2float %1 FClamp %18505 %7011 %21058 %23584 = OpLoad %150 %5785 %10339 = OpLoad %508 %5688 %12147 = OpSampledImage %510 %23584 %10339 %15371 = OpImageSampleExplicitLod %v4float %12147 %13149 Lod %float_0 %15266 = OpCompositeExtract %float %15371 3 %12116 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12972 = OpLoad %float %12116 %15710 = OpFMul %float %15266 %12972 %15279 = OpExtInst %float %1 FClamp %15710 %float_0 %float_1 %22213 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11756 = OpLoad %v3float %22213 %12103 = OpVectorTimesScalar %v3float %11756 %15279 %15516 = OpLoad %150 %3312 %24569 = OpLoad %508 %4646 %12148 = OpSampledImage %510 %15516 %24569 %17670 = OpImageSampleExplicitLod %v4float %12148 %13149 Lod %float_0 %16938 = OpCompositeExtract %float %17670 1 %14185 = OpFOrdGreaterThan %bool %16938 %float_0 OpSelectionMerge %22307 DontFlatten OpBranchConditional %14185 %12821 %22307 %12821 = OpLabel %13239 = OpLoad %150 %4862 %19960 = OpLoad %508 %3594 %12149 = OpSampledImage %510 %13239 %19960 %15675 = OpImageSampleExplicitLod %v4float %12149 %13149 Lod %float_0 %13866 = OpCompositeExtract %float %17670 1 %12427 = OpCompositeExtract %float %17670 2 %23300 = OpFMul %float %13866 %12427 %17612 = OpExtInst %float %1 FClamp %23300 %float_0 %float_1 %20291 = OpVectorShuffle %v3float %15675 %15675 0 1 2 %11186 = OpVectorTimesScalar %v3float %20291 %17612 %15293 = OpFAdd %v3float %12103 %11186 OpBranch %22307 %22307 = OpLabel %7719 = OpPhi %v3float %12103 %25006 %15293 %12821 %23399 = OpVectorTimesScalar %v3float %7719 %float_0_5 %9339 = OpFAdd %float %float_0 %float_0_5 %16235 = OpVectorShuffle %v3float %2938 %2938 0 1 2 %22177 = OpFAdd %v3float %16235 %23399 %15527 = OpVectorShuffle %v4float %2938 %22177 4 5 6 3 %6434 = OpCompositeInsert %_struct_1017 %15527 %13863 0 %24572 = OpVectorShuffle %v2float %836 %836 0 1 %13207 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10345 = OpLoad %v4float %13207 %8639 = OpVectorShuffle %v2float %10345 %10345 0 1 %9198 = OpFMul %v2float %24572 %8639 %18506 = OpFAdd %v2float %19927 %9198 %7012 = OpVectorShuffle %v2float %17581 %17581 0 1 %21059 = OpVectorShuffle %v2float %17581 %17581 2 3 %13150 = OpExtInst %v2float %1 FClamp %18506 %7012 %21059 %23585 = OpLoad %150 %5785 %10340 = OpLoad %508 %5688 %12150 = OpSampledImage %510 %23585 %10340 %15372 = OpImageSampleExplicitLod %v4float %12150 %13150 Lod %float_0 %15267 = OpCompositeExtract %float %15372 3 %12117 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12973 = OpLoad %float %12117 %15711 = OpFMul %float %15267 %12973 %15280 = OpExtInst %float %1 FClamp %15711 %float_0 %float_1 %22214 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11757 = OpLoad %v3float %22214 %12104 = OpVectorTimesScalar %v3float %11757 %15280 %15517 = OpLoad %150 %3312 %24570 = OpLoad %508 %4646 %12151 = OpSampledImage %510 %15517 %24570 %17671 = OpImageSampleExplicitLod %v4float %12151 %13150 Lod %float_0 %16939 = OpCompositeExtract %float %17671 1 %14186 = OpFOrdGreaterThan %bool %16939 %float_0 OpSelectionMerge %22308 DontFlatten OpBranchConditional %14186 %12822 %22308 %12822 = OpLabel %13240 = OpLoad %150 %4862 %19961 = OpLoad %508 %3594 %12152 = OpSampledImage %510 %13240 %19961 %15676 = OpImageSampleExplicitLod %v4float %12152 %13150 Lod %float_0 %13867 = OpCompositeExtract %float %17671 1 %12428 = OpCompositeExtract %float %17671 2 %23301 = OpFMul %float %13867 %12428 %17613 = OpExtInst %float %1 FClamp %23301 %float_0 %float_1 %20292 = OpVectorShuffle %v3float %15676 %15676 0 1 2 %11187 = OpVectorTimesScalar %v3float %20292 %17613 %15294 = OpFAdd %v3float %12104 %11187 OpBranch %22308 %22308 = OpLabel %7720 = OpPhi %v3float %12104 %22307 %15294 %12822 %23400 = OpVectorTimesScalar %v3float %7720 %float_0_5 %9340 = OpFAdd %float %9339 %float_0_5 %16236 = OpVectorShuffle %v3float %15527 %15527 0 1 2 %22178 = OpFAdd %v3float %16236 %23400 %15528 = OpVectorShuffle %v4float %15527 %22178 4 5 6 3 %6435 = OpCompositeInsert %_struct_1017 %15528 %6434 0 %24573 = OpVectorShuffle %v2float %1367 %1367 0 1 %13208 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10346 = OpLoad %v4float %13208 %8640 = OpVectorShuffle %v2float %10346 %10346 0 1 %9199 = OpFMul %v2float %24573 %8640 %18507 = OpFAdd %v2float %19927 %9199 %7013 = OpVectorShuffle %v2float %17581 %17581 0 1 %21060 = OpVectorShuffle %v2float %17581 %17581 2 3 %13151 = OpExtInst %v2float %1 FClamp %18507 %7013 %21060 %23586 = OpLoad %150 %5785 %10341 = OpLoad %508 %5688 %12153 = OpSampledImage %510 %23586 %10341 %15373 = OpImageSampleExplicitLod %v4float %12153 %13151 Lod %float_0 %15268 = OpCompositeExtract %float %15373 3 %12118 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12974 = OpLoad %float %12118 %15712 = OpFMul %float %15268 %12974 %15281 = OpExtInst %float %1 FClamp %15712 %float_0 %float_1 %22215 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11758 = OpLoad %v3float %22215 %12105 = OpVectorTimesScalar %v3float %11758 %15281 %15518 = OpLoad %150 %3312 %24571 = OpLoad %508 %4646 %12154 = OpSampledImage %510 %15518 %24571 %17672 = OpImageSampleExplicitLod %v4float %12154 %13151 Lod %float_0 %16940 = OpCompositeExtract %float %17672 1 %14187 = OpFOrdGreaterThan %bool %16940 %float_0 OpSelectionMerge %22309 DontFlatten OpBranchConditional %14187 %12823 %22309 %12823 = OpLabel %13241 = OpLoad %150 %4862 %19962 = OpLoad %508 %3594 %12155 = OpSampledImage %510 %13241 %19962 %15677 = OpImageSampleExplicitLod %v4float %12155 %13151 Lod %float_0 %13868 = OpCompositeExtract %float %17672 1 %12429 = OpCompositeExtract %float %17672 2 %23302 = OpFMul %float %13868 %12429 %17614 = OpExtInst %float %1 FClamp %23302 %float_0 %float_1 %20293 = OpVectorShuffle %v3float %15677 %15677 0 1 2 %11188 = OpVectorTimesScalar %v3float %20293 %17614 %15295 = OpFAdd %v3float %12105 %11188 OpBranch %22309 %22309 = OpLabel %7721 = OpPhi %v3float %12105 %22308 %15295 %12823 %23401 = OpVectorTimesScalar %v3float %7721 %float_0_75 %9341 = OpFAdd %float %9340 %float_0_75 %16237 = OpVectorShuffle %v3float %15528 %15528 0 1 2 %22179 = OpFAdd %v3float %16237 %23401 %15529 = OpVectorShuffle %v4float %15528 %22179 4 5 6 3 %6436 = OpCompositeInsert %_struct_1017 %15529 %6435 0 %24574 = OpVectorShuffle %v2float %141 %141 0 1 %13209 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10347 = OpLoad %v4float %13209 %8641 = OpVectorShuffle %v2float %10347 %10347 0 1 %9200 = OpFMul %v2float %24574 %8641 %18508 = OpFAdd %v2float %19927 %9200 %7014 = OpVectorShuffle %v2float %17581 %17581 0 1 %21061 = OpVectorShuffle %v2float %17581 %17581 2 3 %13152 = OpExtInst %v2float %1 FClamp %18508 %7014 %21061 %23587 = OpLoad %150 %5785 %10342 = OpLoad %508 %5688 %12156 = OpSampledImage %510 %23587 %10342 %15374 = OpImageSampleExplicitLod %v4float %12156 %13152 Lod %float_0 %15269 = OpCompositeExtract %float %15374 3 %12119 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12975 = OpLoad %float %12119 %15713 = OpFMul %float %15269 %12975 %15282 = OpExtInst %float %1 FClamp %15713 %float_0 %float_1 %22216 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11759 = OpLoad %v3float %22216 %12106 = OpVectorTimesScalar %v3float %11759 %15282 %15519 = OpLoad %150 %3312 %24575 = OpLoad %508 %4646 %12157 = OpSampledImage %510 %15519 %24575 %17673 = OpImageSampleExplicitLod %v4float %12157 %13152 Lod %float_0 %16941 = OpCompositeExtract %float %17673 1 %14188 = OpFOrdGreaterThan %bool %16941 %float_0 OpSelectionMerge %22310 DontFlatten OpBranchConditional %14188 %12824 %22310 %12824 = OpLabel %13242 = OpLoad %150 %4862 %19963 = OpLoad %508 %3594 %12158 = OpSampledImage %510 %13242 %19963 %15678 = OpImageSampleExplicitLod %v4float %12158 %13152 Lod %float_0 %13869 = OpCompositeExtract %float %17673 1 %12430 = OpCompositeExtract %float %17673 2 %23303 = OpFMul %float %13869 %12430 %17615 = OpExtInst %float %1 FClamp %23303 %float_0 %float_1 %20294 = OpVectorShuffle %v3float %15678 %15678 0 1 2 %11189 = OpVectorTimesScalar %v3float %20294 %17615 %15296 = OpFAdd %v3float %12106 %11189 OpBranch %22310 %22310 = OpLabel %7722 = OpPhi %v3float %12106 %22309 %15296 %12824 %23402 = OpVectorTimesScalar %v3float %7722 %float_0_5 %9342 = OpFAdd %float %9341 %float_0_5 %16238 = OpVectorShuffle %v3float %15529 %15529 0 1 2 %22180 = OpFAdd %v3float %16238 %23402 %15530 = OpVectorShuffle %v4float %15529 %22180 4 5 6 3 %6437 = OpCompositeInsert %_struct_1017 %15530 %6436 0 %24576 = OpVectorShuffle %v2float %38 %38 0 1 %13210 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10348 = OpLoad %v4float %13210 %8642 = OpVectorShuffle %v2float %10348 %10348 0 1 %9201 = OpFMul %v2float %24576 %8642 %18509 = OpFAdd %v2float %19927 %9201 %7015 = OpVectorShuffle %v2float %17581 %17581 0 1 %21062 = OpVectorShuffle %v2float %17581 %17581 2 3 %13153 = OpExtInst %v2float %1 FClamp %18509 %7015 %21062 %23588 = OpLoad %150 %5785 %10349 = OpLoad %508 %5688 %12159 = OpSampledImage %510 %23588 %10349 %15375 = OpImageSampleExplicitLod %v4float %12159 %13153 Lod %float_0 %15270 = OpCompositeExtract %float %15375 3 %12120 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12976 = OpLoad %float %12120 %15714 = OpFMul %float %15270 %12976 %15283 = OpExtInst %float %1 FClamp %15714 %float_0 %float_1 %22217 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11760 = OpLoad %v3float %22217 %12107 = OpVectorTimesScalar %v3float %11760 %15283 %15520 = OpLoad %150 %3312 %24577 = OpLoad %508 %4646 %12160 = OpSampledImage %510 %15520 %24577 %17674 = OpImageSampleExplicitLod %v4float %12160 %13153 Lod %float_0 %16942 = OpCompositeExtract %float %17674 1 %14189 = OpFOrdGreaterThan %bool %16942 %float_0 OpSelectionMerge %22311 DontFlatten OpBranchConditional %14189 %12825 %22311 %12825 = OpLabel %13243 = OpLoad %150 %4862 %19964 = OpLoad %508 %3594 %12161 = OpSampledImage %510 %13243 %19964 %15679 = OpImageSampleExplicitLod %v4float %12161 %13153 Lod %float_0 %13870 = OpCompositeExtract %float %17674 1 %12431 = OpCompositeExtract %float %17674 2 %23304 = OpFMul %float %13870 %12431 %17616 = OpExtInst %float %1 FClamp %23304 %float_0 %float_1 %20295 = OpVectorShuffle %v3float %15679 %15679 0 1 2 %11190 = OpVectorTimesScalar %v3float %20295 %17616 %15297 = OpFAdd %v3float %12107 %11190 OpBranch %22311 %22311 = OpLabel %7723 = OpPhi %v3float %12107 %22310 %15297 %12825 %23403 = OpVectorTimesScalar %v3float %7723 %float_0_5 %9343 = OpFAdd %float %9342 %float_0_5 %16239 = OpVectorShuffle %v3float %15530 %15530 0 1 2 %22181 = OpFAdd %v3float %16239 %23403 %15531 = OpVectorShuffle %v4float %15530 %22181 4 5 6 3 %6438 = OpCompositeInsert %_struct_1017 %15531 %6437 0 %24578 = OpVectorShuffle %v2float %95 %95 0 1 %13211 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10350 = OpLoad %v4float %13211 %8643 = OpVectorShuffle %v2float %10350 %10350 0 1 %9202 = OpFMul %v2float %24578 %8643 %18510 = OpFAdd %v2float %19927 %9202 %7016 = OpVectorShuffle %v2float %17581 %17581 0 1 %21063 = OpVectorShuffle %v2float %17581 %17581 2 3 %13154 = OpExtInst %v2float %1 FClamp %18510 %7016 %21063 %23589 = OpLoad %150 %5785 %10351 = OpLoad %508 %5688 %12162 = OpSampledImage %510 %23589 %10351 %15376 = OpImageSampleExplicitLod %v4float %12162 %13154 Lod %float_0 %15271 = OpCompositeExtract %float %15376 3 %12121 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12977 = OpLoad %float %12121 %15715 = OpFMul %float %15271 %12977 %15284 = OpExtInst %float %1 FClamp %15715 %float_0 %float_1 %22218 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11761 = OpLoad %v3float %22218 %12108 = OpVectorTimesScalar %v3float %11761 %15284 %15521 = OpLoad %150 %3312 %24579 = OpLoad %508 %4646 %12163 = OpSampledImage %510 %15521 %24579 %17675 = OpImageSampleExplicitLod %v4float %12163 %13154 Lod %float_0 %16943 = OpCompositeExtract %float %17675 1 %14190 = OpFOrdGreaterThan %bool %16943 %float_0 OpSelectionMerge %22312 DontFlatten OpBranchConditional %14190 %12826 %22312 %12826 = OpLabel %13244 = OpLoad %150 %4862 %19965 = OpLoad %508 %3594 %12164 = OpSampledImage %510 %13244 %19965 %15680 = OpImageSampleExplicitLod %v4float %12164 %13154 Lod %float_0 %13871 = OpCompositeExtract %float %17675 1 %12432 = OpCompositeExtract %float %17675 2 %23305 = OpFMul %float %13871 %12432 %17617 = OpExtInst %float %1 FClamp %23305 %float_0 %float_1 %20296 = OpVectorShuffle %v3float %15680 %15680 0 1 2 %11191 = OpVectorTimesScalar %v3float %20296 %17617 %15298 = OpFAdd %v3float %12108 %11191 OpBranch %22312 %22312 = OpLabel %7724 = OpPhi %v3float %12108 %22311 %15298 %12826 %23404 = OpVectorTimesScalar %v3float %7724 %float_0_75 %9344 = OpFAdd %float %9343 %float_0_75 %16240 = OpVectorShuffle %v3float %15531 %15531 0 1 2 %22182 = OpFAdd %v3float %16240 %23404 %15532 = OpVectorShuffle %v4float %15531 %22182 4 5 6 3 %6439 = OpCompositeInsert %_struct_1017 %15532 %6438 0 %24580 = OpVectorShuffle %v2float %626 %626 0 1 %13212 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10352 = OpLoad %v4float %13212 %8644 = OpVectorShuffle %v2float %10352 %10352 0 1 %9203 = OpFMul %v2float %24580 %8644 %18511 = OpFAdd %v2float %19927 %9203 %7017 = OpVectorShuffle %v2float %17581 %17581 0 1 %21064 = OpVectorShuffle %v2float %17581 %17581 2 3 %13155 = OpExtInst %v2float %1 FClamp %18511 %7017 %21064 %23590 = OpLoad %150 %5785 %10353 = OpLoad %508 %5688 %12165 = OpSampledImage %510 %23590 %10353 %15377 = OpImageSampleExplicitLod %v4float %12165 %13155 Lod %float_0 %15272 = OpCompositeExtract %float %15377 3 %12122 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12978 = OpLoad %float %12122 %15716 = OpFMul %float %15272 %12978 %15285 = OpExtInst %float %1 FClamp %15716 %float_0 %float_1 %22219 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11762 = OpLoad %v3float %22219 %12109 = OpVectorTimesScalar %v3float %11762 %15285 %15522 = OpLoad %150 %3312 %24581 = OpLoad %508 %4646 %12166 = OpSampledImage %510 %15522 %24581 %17676 = OpImageSampleExplicitLod %v4float %12166 %13155 Lod %float_0 %16944 = OpCompositeExtract %float %17676 1 %14191 = OpFOrdGreaterThan %bool %16944 %float_0 OpSelectionMerge %22313 DontFlatten OpBranchConditional %14191 %12827 %22313 %12827 = OpLabel %13245 = OpLoad %150 %4862 %19966 = OpLoad %508 %3594 %12167 = OpSampledImage %510 %13245 %19966 %15681 = OpImageSampleExplicitLod %v4float %12167 %13155 Lod %float_0 %13872 = OpCompositeExtract %float %17676 1 %12433 = OpCompositeExtract %float %17676 2 %23306 = OpFMul %float %13872 %12433 %17618 = OpExtInst %float %1 FClamp %23306 %float_0 %float_1 %20297 = OpVectorShuffle %v3float %15681 %15681 0 1 2 %11192 = OpVectorTimesScalar %v3float %20297 %17618 %15299 = OpFAdd %v3float %12109 %11192 OpBranch %22313 %22313 = OpLabel %7725 = OpPhi %v3float %12109 %22312 %15299 %12827 %23405 = OpVectorTimesScalar %v3float %7725 %float_1 %9345 = OpFAdd %float %9344 %float_1 %16241 = OpVectorShuffle %v3float %15532 %15532 0 1 2 %22183 = OpFAdd %v3float %16241 %23405 %15533 = OpVectorShuffle %v4float %15532 %22183 4 5 6 3 %6440 = OpCompositeInsert %_struct_1017 %15533 %6439 0 %24582 = OpVectorShuffle %v2float %2411 %2411 0 1 %13213 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10354 = OpLoad %v4float %13213 %8645 = OpVectorShuffle %v2float %10354 %10354 0 1 %9204 = OpFMul %v2float %24582 %8645 %18512 = OpFAdd %v2float %19927 %9204 %7018 = OpVectorShuffle %v2float %17581 %17581 0 1 %21065 = OpVectorShuffle %v2float %17581 %17581 2 3 %13156 = OpExtInst %v2float %1 FClamp %18512 %7018 %21065 %23591 = OpLoad %150 %5785 %10355 = OpLoad %508 %5688 %12168 = OpSampledImage %510 %23591 %10355 %15378 = OpImageSampleExplicitLod %v4float %12168 %13156 Lod %float_0 %15273 = OpCompositeExtract %float %15378 3 %12123 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12979 = OpLoad %float %12123 %15717 = OpFMul %float %15273 %12979 %15286 = OpExtInst %float %1 FClamp %15717 %float_0 %float_1 %22220 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11763 = OpLoad %v3float %22220 %12110 = OpVectorTimesScalar %v3float %11763 %15286 %15523 = OpLoad %150 %3312 %24583 = OpLoad %508 %4646 %12169 = OpSampledImage %510 %15523 %24583 %17677 = OpImageSampleExplicitLod %v4float %12169 %13156 Lod %float_0 %16945 = OpCompositeExtract %float %17677 1 %14192 = OpFOrdGreaterThan %bool %16945 %float_0 OpSelectionMerge %22314 DontFlatten OpBranchConditional %14192 %12828 %22314 %12828 = OpLabel %13246 = OpLoad %150 %4862 %19967 = OpLoad %508 %3594 %12170 = OpSampledImage %510 %13246 %19967 %15682 = OpImageSampleExplicitLod %v4float %12170 %13156 Lod %float_0 %13873 = OpCompositeExtract %float %17677 1 %12434 = OpCompositeExtract %float %17677 2 %23307 = OpFMul %float %13873 %12434 %17619 = OpExtInst %float %1 FClamp %23307 %float_0 %float_1 %20298 = OpVectorShuffle %v3float %15682 %15682 0 1 2 %11193 = OpVectorTimesScalar %v3float %20298 %17619 %15300 = OpFAdd %v3float %12110 %11193 OpBranch %22314 %22314 = OpLabel %7726 = OpPhi %v3float %12110 %22313 %15300 %12828 %23406 = OpVectorTimesScalar %v3float %7726 %float_0_75 %9346 = OpFAdd %float %9345 %float_0_75 %16242 = OpVectorShuffle %v3float %15533 %15533 0 1 2 %22184 = OpFAdd %v3float %16242 %23406 %15534 = OpVectorShuffle %v4float %15533 %22184 4 5 6 3 %6441 = OpCompositeInsert %_struct_1017 %15534 %6440 0 %24584 = OpVectorShuffle %v2float %2354 %2354 0 1 %13214 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10356 = OpLoad %v4float %13214 %8646 = OpVectorShuffle %v2float %10356 %10356 0 1 %9205 = OpFMul %v2float %24584 %8646 %18513 = OpFAdd %v2float %19927 %9205 %7019 = OpVectorShuffle %v2float %17581 %17581 0 1 %21066 = OpVectorShuffle %v2float %17581 %17581 2 3 %13157 = OpExtInst %v2float %1 FClamp %18513 %7019 %21066 %23592 = OpLoad %150 %5785 %10357 = OpLoad %508 %5688 %12171 = OpSampledImage %510 %23592 %10357 %15379 = OpImageSampleExplicitLod %v4float %12171 %13157 Lod %float_0 %15274 = OpCompositeExtract %float %15379 3 %12124 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12980 = OpLoad %float %12124 %15718 = OpFMul %float %15274 %12980 %15287 = OpExtInst %float %1 FClamp %15718 %float_0 %float_1 %22221 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11764 = OpLoad %v3float %22221 %12111 = OpVectorTimesScalar %v3float %11764 %15287 %15524 = OpLoad %150 %3312 %24585 = OpLoad %508 %4646 %12172 = OpSampledImage %510 %15524 %24585 %17678 = OpImageSampleExplicitLod %v4float %12172 %13157 Lod %float_0 %16946 = OpCompositeExtract %float %17678 1 %14193 = OpFOrdGreaterThan %bool %16946 %float_0 OpSelectionMerge %22315 DontFlatten OpBranchConditional %14193 %12829 %22315 %12829 = OpLabel %13247 = OpLoad %150 %4862 %19968 = OpLoad %508 %3594 %12173 = OpSampledImage %510 %13247 %19968 %15683 = OpImageSampleExplicitLod %v4float %12173 %13157 Lod %float_0 %13874 = OpCompositeExtract %float %17678 1 %12435 = OpCompositeExtract %float %17678 2 %23308 = OpFMul %float %13874 %12435 %17620 = OpExtInst %float %1 FClamp %23308 %float_0 %float_1 %20299 = OpVectorShuffle %v3float %15683 %15683 0 1 2 %11194 = OpVectorTimesScalar %v3float %20299 %17620 %15301 = OpFAdd %v3float %12111 %11194 OpBranch %22315 %22315 = OpLabel %7727 = OpPhi %v3float %12111 %22314 %15301 %12829 %23407 = OpVectorTimesScalar %v3float %7727 %float_0_5 %9347 = OpFAdd %float %9346 %float_0_5 %16243 = OpVectorShuffle %v3float %15534 %15534 0 1 2 %22185 = OpFAdd %v3float %16243 %23407 %15535 = OpVectorShuffle %v4float %15534 %22185 4 5 6 3 %6442 = OpCompositeInsert %_struct_1017 %15535 %6441 0 %24586 = OpVectorShuffle %v2float %837 %837 0 1 %13215 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10358 = OpLoad %v4float %13215 %8647 = OpVectorShuffle %v2float %10358 %10358 0 1 %9206 = OpFMul %v2float %24586 %8647 %18514 = OpFAdd %v2float %19927 %9206 %7020 = OpVectorShuffle %v2float %17581 %17581 0 1 %21067 = OpVectorShuffle %v2float %17581 %17581 2 3 %13158 = OpExtInst %v2float %1 FClamp %18514 %7020 %21067 %23593 = OpLoad %150 %5785 %10359 = OpLoad %508 %5688 %12174 = OpSampledImage %510 %23593 %10359 %15380 = OpImageSampleExplicitLod %v4float %12174 %13158 Lod %float_0 %15275 = OpCompositeExtract %float %15380 3 %12125 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12981 = OpLoad %float %12125 %15719 = OpFMul %float %15275 %12981 %15288 = OpExtInst %float %1 FClamp %15719 %float_0 %float_1 %22222 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11765 = OpLoad %v3float %22222 %12112 = OpVectorTimesScalar %v3float %11765 %15288 %15525 = OpLoad %150 %3312 %24587 = OpLoad %508 %4646 %12175 = OpSampledImage %510 %15525 %24587 %17679 = OpImageSampleExplicitLod %v4float %12175 %13158 Lod %float_0 %16947 = OpCompositeExtract %float %17679 1 %14194 = OpFOrdGreaterThan %bool %16947 %float_0 OpSelectionMerge %22316 DontFlatten OpBranchConditional %14194 %12830 %22316 %12830 = OpLabel %13248 = OpLoad %150 %4862 %19969 = OpLoad %508 %3594 %12176 = OpSampledImage %510 %13248 %19969 %15684 = OpImageSampleExplicitLod %v4float %12176 %13158 Lod %float_0 %13875 = OpCompositeExtract %float %17679 1 %12436 = OpCompositeExtract %float %17679 2 %23309 = OpFMul %float %13875 %12436 %17621 = OpExtInst %float %1 FClamp %23309 %float_0 %float_1 %20300 = OpVectorShuffle %v3float %15684 %15684 0 1 2 %11195 = OpVectorTimesScalar %v3float %20300 %17621 %15302 = OpFAdd %v3float %12112 %11195 OpBranch %22316 %22316 = OpLabel %7728 = OpPhi %v3float %12112 %22315 %15302 %12830 %23408 = OpVectorTimesScalar %v3float %7728 %float_0_5 %9348 = OpFAdd %float %9347 %float_0_5 %16244 = OpVectorShuffle %v3float %15535 %15535 0 1 2 %22186 = OpFAdd %v3float %16244 %23408 %15536 = OpVectorShuffle %v4float %15535 %22186 4 5 6 3 %6443 = OpCompositeInsert %_struct_1017 %15536 %6442 0 %24588 = OpVectorShuffle %v2float %1368 %1368 0 1 %13216 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10360 = OpLoad %v4float %13216 %8648 = OpVectorShuffle %v2float %10360 %10360 0 1 %9207 = OpFMul %v2float %24588 %8648 %18515 = OpFAdd %v2float %19927 %9207 %7021 = OpVectorShuffle %v2float %17581 %17581 0 1 %21068 = OpVectorShuffle %v2float %17581 %17581 2 3 %13159 = OpExtInst %v2float %1 FClamp %18515 %7021 %21068 %23594 = OpLoad %150 %5785 %10361 = OpLoad %508 %5688 %12177 = OpSampledImage %510 %23594 %10361 %15381 = OpImageSampleExplicitLod %v4float %12177 %13159 Lod %float_0 %15276 = OpCompositeExtract %float %15381 3 %12126 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12982 = OpLoad %float %12126 %15720 = OpFMul %float %15276 %12982 %15289 = OpExtInst %float %1 FClamp %15720 %float_0 %float_1 %22223 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11766 = OpLoad %v3float %22223 %12113 = OpVectorTimesScalar %v3float %11766 %15289 %15526 = OpLoad %150 %3312 %24589 = OpLoad %508 %4646 %12178 = OpSampledImage %510 %15526 %24589 %17680 = OpImageSampleExplicitLod %v4float %12178 %13159 Lod %float_0 %16948 = OpCompositeExtract %float %17680 1 %14195 = OpFOrdGreaterThan %bool %16948 %float_0 OpSelectionMerge %22317 DontFlatten OpBranchConditional %14195 %12831 %22317 %12831 = OpLabel %13249 = OpLoad %150 %4862 %19970 = OpLoad %508 %3594 %12179 = OpSampledImage %510 %13249 %19970 %15685 = OpImageSampleExplicitLod %v4float %12179 %13159 Lod %float_0 %13876 = OpCompositeExtract %float %17680 1 %12437 = OpCompositeExtract %float %17680 2 %23310 = OpFMul %float %13876 %12437 %17622 = OpExtInst %float %1 FClamp %23310 %float_0 %float_1 %20301 = OpVectorShuffle %v3float %15685 %15685 0 1 2 %11196 = OpVectorTimesScalar %v3float %20301 %17622 %15303 = OpFAdd %v3float %12113 %11196 OpBranch %22317 %22317 = OpLabel %7729 = OpPhi %v3float %12113 %22316 %15303 %12831 %23409 = OpVectorTimesScalar %v3float %7729 %float_0_75 %9349 = OpFAdd %float %9348 %float_0_75 %16245 = OpVectorShuffle %v3float %15536 %15536 0 1 2 %22187 = OpFAdd %v3float %16245 %23409 %15537 = OpVectorShuffle %v4float %15536 %22187 4 5 6 3 %6444 = OpCompositeInsert %_struct_1017 %15537 %6443 0 %24590 = OpVectorShuffle %v2float %142 %142 0 1 %13217 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10362 = OpLoad %v4float %13217 %8649 = OpVectorShuffle %v2float %10362 %10362 0 1 %9208 = OpFMul %v2float %24590 %8649 %18516 = OpFAdd %v2float %19927 %9208 %7022 = OpVectorShuffle %v2float %17581 %17581 0 1 %21069 = OpVectorShuffle %v2float %17581 %17581 2 3 %13160 = OpExtInst %v2float %1 FClamp %18516 %7022 %21069 %23595 = OpLoad %150 %5785 %10363 = OpLoad %508 %5688 %12180 = OpSampledImage %510 %23595 %10363 %15382 = OpImageSampleExplicitLod %v4float %12180 %13160 Lod %float_0 %15277 = OpCompositeExtract %float %15382 3 %12127 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12983 = OpLoad %float %12127 %15721 = OpFMul %float %15277 %12983 %15290 = OpExtInst %float %1 FClamp %15721 %float_0 %float_1 %22224 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11767 = OpLoad %v3float %22224 %12114 = OpVectorTimesScalar %v3float %11767 %15290 %15538 = OpLoad %150 %3312 %24591 = OpLoad %508 %4646 %12181 = OpSampledImage %510 %15538 %24591 %17681 = OpImageSampleExplicitLod %v4float %12181 %13160 Lod %float_0 %16949 = OpCompositeExtract %float %17681 1 %14196 = OpFOrdGreaterThan %bool %16949 %float_0 OpSelectionMerge %22318 DontFlatten OpBranchConditional %14196 %12832 %22318 %12832 = OpLabel %13250 = OpLoad %150 %4862 %19971 = OpLoad %508 %3594 %12182 = OpSampledImage %510 %13250 %19971 %15686 = OpImageSampleExplicitLod %v4float %12182 %13160 Lod %float_0 %13877 = OpCompositeExtract %float %17681 1 %12438 = OpCompositeExtract %float %17681 2 %23311 = OpFMul %float %13877 %12438 %17623 = OpExtInst %float %1 FClamp %23311 %float_0 %float_1 %20302 = OpVectorShuffle %v3float %15686 %15686 0 1 2 %11197 = OpVectorTimesScalar %v3float %20302 %17623 %15304 = OpFAdd %v3float %12114 %11197 OpBranch %22318 %22318 = OpLabel %7730 = OpPhi %v3float %12114 %22317 %15304 %12832 %23410 = OpVectorTimesScalar %v3float %7730 %float_0_5 %9350 = OpFAdd %float %9349 %float_0_5 %16246 = OpVectorShuffle %v3float %15537 %15537 0 1 2 %22188 = OpFAdd %v3float %16246 %23410 %15539 = OpVectorShuffle %v4float %15537 %22188 4 5 6 3 %6445 = OpCompositeInsert %_struct_1017 %15539 %6444 0 %24592 = OpVectorShuffle %v2float %1197 %1197 0 1 %13218 = OpAccessChain %_ptr_Uniform_v4float %22044 %int_0 %10364 = OpLoad %v4float %13218 %8650 = OpVectorShuffle %v2float %10364 %10364 0 1 %9209 = OpFMul %v2float %24592 %8650 %18517 = OpFAdd %v2float %19927 %9209 %7023 = OpVectorShuffle %v2float %17581 %17581 0 1 %21070 = OpVectorShuffle %v2float %17581 %17581 2 3 %13161 = OpExtInst %v2float %1 FClamp %18517 %7023 %21070 %23596 = OpLoad %150 %5785 %10365 = OpLoad %508 %5688 %12183 = OpSampledImage %510 %23596 %10365 %15383 = OpImageSampleExplicitLod %v4float %12183 %13161 Lod %float_0 %15278 = OpCompositeExtract %float %15383 3 %12128 = OpAccessChain %_ptr_Uniform_float %22044 %int_1 %12984 = OpLoad %float %12128 %15722 = OpFMul %float %15278 %12984 %15291 = OpExtInst %float %1 FClamp %15722 %float_0 %float_1 %22225 = OpAccessChain %_ptr_Uniform_v3float %12348 %int_5 %11768 = OpLoad %v3float %22225 %12115 = OpVectorTimesScalar %v3float %11768 %15291 %15540 = OpLoad %150 %3312 %24593 = OpLoad %508 %4646 %12184 = OpSampledImage %510 %15540 %24593 %17682 = OpImageSampleExplicitLod %v4float %12184 %13161 Lod %float_0 %16950 = OpCompositeExtract %float %17682 1 %14197 = OpFOrdGreaterThan %bool %16950 %float_0 OpSelectionMerge %22319 DontFlatten OpBranchConditional %14197 %12833 %22319 %12833 = OpLabel %13251 = OpLoad %150 %4862 %19972 = OpLoad %508 %3594 %12185 = OpSampledImage %510 %13251 %19972 %15687 = OpImageSampleExplicitLod %v4float %12185 %13161 Lod %float_0 %13878 = OpCompositeExtract %float %17682 1 %12439 = OpCompositeExtract %float %17682 2 %23312 = OpFMul %float %13878 %12439 %17624 = OpExtInst %float %1 FClamp %23312 %float_0 %float_1 %20303 = OpVectorShuffle %v3float %15687 %15687 0 1 2 %11198 = OpVectorTimesScalar %v3float %20303 %17624 %15305 = OpFAdd %v3float %12115 %11198 OpBranch %22319 %22319 = OpLabel %7731 = OpPhi %v3float %12115 %22318 %15305 %12833 %23411 = OpVectorTimesScalar %v3float %7731 %float_0_5 %9351 = OpFAdd %float %9350 %float_0_5 %16247 = OpVectorShuffle %v3float %15539 %15539 0 1 2 %22189 = OpFAdd %v3float %16247 %23411 %15541 = OpVectorShuffle %v4float %15539 %22189 4 5 6 3 %6719 = OpCompositeInsert %_struct_1017 %15541 %6445 0 %23412 = OpVectorShuffle %v3float %15541 %15541 0 1 2 %10833 = OpCompositeConstruct %v3float %9351 %9351 %9351 %13750 = OpFDiv %v3float %23412 %10833 %24033 = OpVectorShuffle %v4float %15541 %13750 4 5 6 3 %8636 = OpCompositeInsert %_struct_1017 %24033 %6719 0 %16315 = OpCompositeInsert %_struct_1017 %float_1 %8636 0 3 %11544 = OpCompositeExtract %v4float %16315 0 OpStore %4317 %11544 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/geom/000077500000000000000000000000001400026215700175325ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/asm/geom/block-name-namespace.asm.geom000066400000000000000000000115501400026215700251260ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 48 ; Schema: 0 OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %_ %VertexOutput %vin OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %VertexInput3 "VertexInput" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %VertexInput "VertexInput" OpMemberName %VertexInput 0 "a" OpName %VertexInput4 "VertexInput" OpName %VertexInput_0 "VertexInput" OpMemberName %VertexInput_0 0 "b" OpName %VertexInput2 "VertexInput" OpName %VertexInput_1 "VertexInput" OpMemberName %VertexInput_1 0 "vColor" OpName %VertexOutput "VertexInput" OpName %VertexInput_2 "VertexInput" OpMemberName %VertexInput_2 0 "vColor" OpName %vin "vin" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpMemberDecorate %VertexInput 0 Offset 0 OpDecorate %VertexInput Block OpDecorate %VertexInput4 DescriptorSet 0 OpDecorate %VertexInput4 Binding 0 OpMemberDecorate %VertexInput_0 0 Offset 0 OpDecorate %VertexInput_0 BufferBlock OpDecorate %VertexInput2 DescriptorSet 0 OpDecorate %VertexInput2 Binding 0 OpDecorate %VertexInput_1 Block OpDecorate %VertexOutput Location 0 OpDecorate %VertexInput_2 Block OpDecorate %vin Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_1 = OpConstant %float 1 %11 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %VertexInput = OpTypeStruct %v4float %_ptr_Uniform_VertexInput = OpTypePointer Uniform %VertexInput %VertexInput4 = OpVariable %_ptr_Uniform_VertexInput Uniform %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %VertexInput_0 = OpTypeStruct %v4float %_ptr_Uniform_VertexInput_0 = OpTypePointer Uniform %VertexInput_0 %VertexInput2 = OpVariable %_ptr_Uniform_VertexInput_0 Uniform %_ptr_Output_v4float = OpTypePointer Output %v4float %VertexInput_1 = OpTypeStruct %v4float %_ptr_Output_VertexInput_1 = OpTypePointer Output %VertexInput_1 %VertexOutput = OpVariable %_ptr_Output_VertexInput_1 Output %VertexInput_2 = OpTypeStruct %v4float %uint_3 = OpConstant %uint 3 %_arr_VertexInput_2_uint_3 = OpTypeArray %VertexInput_2 %uint_3 %_ptr_Input__arr_VertexInput_2_uint_3 = OpTypePointer Input %_arr_VertexInput_2_uint_3 %vin = OpVariable %_ptr_Input__arr_VertexInput_2_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %main = OpFunction %void None %3 %5 = OpLabel %VertexInput3 = OpVariable %_ptr_Function_v4float Function OpStore %VertexInput3 %11 %20 = OpLoad %v4float %VertexInput3 %25 = OpAccessChain %_ptr_Uniform_v4float %VertexInput4 %int_0 %26 = OpLoad %v4float %25 %27 = OpFAdd %v4float %20 %26 %31 = OpAccessChain %_ptr_Uniform_v4float %VertexInput2 %int_0 %32 = OpLoad %v4float %31 %33 = OpFAdd %v4float %27 %32 %35 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %35 %33 %45 = OpAccessChain %_ptr_Input_v4float %vin %int_0 %int_0 %46 = OpLoad %v4float %45 %47 = OpAccessChain %_ptr_Output_v4float %VertexOutput %int_0 OpStore %47 %46 OpEmitVertex OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/geom/inout-split-access-chain-handle.asm.geom000066400000000000000000000104431400026215700272230ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 42 ; Schema: 0 OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %gl_in %_ OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 5 OpSource GLSL 440 OpName %main "main" OpName %Data "Data" OpMemberName %Data 0 "ApiPerspectivePosition" OpName %Copy_struct_Data_vf41_3__ "Copy(struct-Data-vf41[3];" OpName %inputStream "inputStream" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpName %gl_in "gl_in" OpName %inputStream_0 "inputStream" OpName %param "param" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpMemberName %gl_PerVertex_0 1 "gl_PointSize" OpMemberName %gl_PerVertex_0 2 "gl_ClipDistance" OpName %_ "" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpDecorate %gl_PerVertex Block OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpMemberDecorate %gl_PerVertex_0 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex_0 2 BuiltIn ClipDistance OpDecorate %gl_PerVertex_0 Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Data = OpTypeStruct %v4float %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_Data_uint_3 = OpTypeArray %Data %uint_3 %_ptr_Function__Data = OpTypePointer Function %Data %_ptr_Function__arr_Data_uint_3 = OpTypePointer Function %_arr_Data_uint_3 %13 = OpTypeFunction %void %_ptr_Function__arr_Data_uint_3 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_gl_PerVertex_uint_3 = OpTypeArray %gl_PerVertex %uint_3 %_ptr_Input__arr_gl_PerVertex_uint_3 = OpTypePointer Input %_arr_gl_PerVertex_uint_3 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %gl_PerVertex_0 = OpTypeStruct %v4float %float %_arr_float_uint_1 %_ptr_Output_gl_PerVertex_0 = OpTypePointer Output %gl_PerVertex_0 %_ = OpVariable %_ptr_Output_gl_PerVertex_0 Output %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %inputStream_0 = OpVariable %_ptr_Function__arr_Data_uint_3 Function %param = OpVariable %_ptr_Function__arr_Data_uint_3 Function %32 = OpLoad %_arr_Data_uint_3 %inputStream_0 OpStore %param %32 %33 = OpFunctionCall %void %Copy_struct_Data_vf41_3__ %param %34 = OpLoad %_arr_Data_uint_3 %param OpStore %inputStream_0 %34 %59 = OpAccessChain %_ptr_Function__Data %inputStream_0 %int_0 %38 = OpAccessChain %_ptr_Function_v4float %59 %int_0 %39 = OpLoad %v4float %38 %41 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %41 %39 OpReturn OpFunctionEnd %Copy_struct_Data_vf41_3__ = OpFunction %void None %13 %inputStream = OpFunctionParameter %_ptr_Function__arr_Data_uint_3 %16 = OpLabel %26 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0 %27 = OpLoad %v4float %26 %28 = OpAccessChain %_ptr_Function__Data %inputStream %int_0 %29 = OpAccessChain %_ptr_Function_v4float %28 %int_0 OpStore %29 %27 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/geom/split-access-chain-input.asm.geom000066400000000000000000000044271400026215700260000ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 23 ; Schema: 0 OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %gl_in %position OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 3 OpSource GLSL 440 OpName %main "main" OpName %position "position" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpName %gl_in "gl_in" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpDecorate %gl_PerVertex Block OpDecorate %position BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Output %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %uint_3 = OpConstant %uint 3 %_arr_gl_PerVertex_uint_3 = OpTypeArray %gl_PerVertex %uint_3 %ptr_Input_gl_PerVertex = OpTypePointer Input %gl_PerVertex %_ptr_Input__arr_gl_PerVertex_uint_3 = OpTypePointer Input %_arr_gl_PerVertex_uint_3 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_uint_3 Input %position = OpVariable %_ptr_Function_v4float Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %main = OpFunction %void None %3 %5 = OpLabel %21 = OpAccessChain %ptr_Input_gl_PerVertex %gl_in %int_0 %22 = OpAccessChain %_ptr_Input_v4float %21 %int_0 %23 = OpLoad %v4float %22 OpStore %position %23 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/geom/unroll-glposition-load.asm.geom000066400000000000000000000103331400026215700255770ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 55 ; Schema: 0 OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %OUT_pos %positions_1 OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 3 OpSource HLSL 500 OpName %main "main" OpName %SceneOut "SceneOut" OpMemberName %SceneOut 0 "pos" OpName %_main_vf4_3__struct_SceneOut_vf41_ "@main(vf4[3];struct-SceneOut-vf41;" OpName %positions "positions" OpName %OUT "OUT" OpName %i "i" OpName %o "o" OpName %OUT_pos "OUT.pos" OpName %positions_0 "positions" OpName %positions_1 "positions" OpName %OUT_0 "OUT" OpName %param "param" OpName %param_0 "param" OpDecorate %OUT_pos BuiltIn Position OpDecorate %positions_1 BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Function__arr_v4float_uint_3 = OpTypePointer Function %_arr_v4float_uint_3 %SceneOut = OpTypeStruct %v4float %_ptr_Function_SceneOut = OpTypePointer Function %SceneOut %14 = OpTypeFunction %void %_ptr_Function__arr_v4float_uint_3 %_ptr_Function_SceneOut %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_3 = OpConstant %int 3 %bool = OpTypeBool %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %OUT_pos = OpVariable %_ptr_Output_v4float Output %int_1 = OpConstant %int 1 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %positions_1 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %main = OpFunction %void None %3 %5 = OpLabel %positions_0 = OpVariable %_ptr_Function__arr_v4float_uint_3 Function %OUT_0 = OpVariable %_ptr_Function_SceneOut Function %param = OpVariable %_ptr_Function__arr_v4float_uint_3 Function %param_0 = OpVariable %_ptr_Function_SceneOut Function %48 = OpLoad %_arr_v4float_uint_3 %positions_1 OpStore %positions_0 %48 %51 = OpLoad %_arr_v4float_uint_3 %positions_0 OpStore %param %51 %53 = OpFunctionCall %void %_main_vf4_3__struct_SceneOut_vf41_ %param %param_0 %54 = OpLoad %SceneOut %param_0 OpStore %OUT_0 %54 OpReturn OpFunctionEnd %_main_vf4_3__struct_SceneOut_vf41_ = OpFunction %void None %14 %positions = OpFunctionParameter %_ptr_Function__arr_v4float_uint_3 %OUT = OpFunctionParameter %_ptr_Function_SceneOut %18 = OpLabel %i = OpVariable %_ptr_Function_int Function %o = OpVariable %_ptr_Function_SceneOut Function OpStore %i %int_0 OpBranch %23 %23 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %28 = OpLoad %int %i %31 = OpSLessThan %bool %28 %int_3 OpBranchConditional %31 %24 %25 %24 = OpLabel %33 = OpLoad %int %i %35 = OpAccessChain %_ptr_Function_v4float %positions %33 %36 = OpLoad %v4float %35 %37 = OpAccessChain %_ptr_Function_v4float %o %int_0 OpStore %37 %36 %40 = OpAccessChain %_ptr_Function_v4float %o %int_0 %41 = OpLoad %v4float %40 OpStore %OUT_pos %41 OpEmitVertex OpBranch %26 %26 = OpLabel %42 = OpLoad %int %i %44 = OpIAdd %int %42 %int_1 OpStore %i %44 OpBranch %23 %25 = OpLabel OpEndPrimitive OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/tese/000077500000000000000000000000001400026215700175435ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/asm/tese/unroll-input-array-load.asm.tese000066400000000000000000000142171400026215700257120ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 79 ; Schema: 0 OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" %input_foo %input_bar %uv_1 %CPData_1 %_entryPointOutput_pos OpExecutionMode %main Quads OpSource HLSL 500 OpName %main "main" OpName %HS_INPUT "HS_INPUT" OpMemberName %HS_INPUT 0 "foo" OpMemberName %HS_INPUT 1 "bar" OpName %ControlPoint "ControlPoint" OpMemberName %ControlPoint 0 "baz" OpName %DS_OUTPUT "DS_OUTPUT" OpMemberName %DS_OUTPUT 0 "pos" OpName %_main_struct_HS_INPUT_vf4_vf41_vf2_struct_ControlPoint_vf41_4__ "@main(struct-HS_INPUT-vf4-vf41;vf2;struct-ControlPoint-vf41[4];" OpName %input "input" OpName %uv "uv" OpName %CPData "CPData" OpName %o "o" OpName %input_0 "input" OpName %input_foo "input.foo" OpName %input_bar "input.bar" OpName %uv_0 "uv" OpName %uv_1 "uv" OpName %CPData_0 "CPData" OpName %CPData_1 "CPData" OpName %_entryPointOutput_pos "@entryPointOutput.pos" OpName %param "param" OpName %param_0 "param" OpName %param_1 "param" OpDecorate %input_foo Patch OpDecorate %input_foo Location 0 OpDecorate %input_bar Patch OpDecorate %input_bar Location 1 OpDecorate %uv_1 Patch OpDecorate %uv_1 BuiltIn TessCoord OpDecorate %CPData_1 Location 2 OpDecorate %_entryPointOutput_pos BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %HS_INPUT = OpTypeStruct %v4float %v4float %_ptr_Function_HS_INPUT = OpTypePointer Function %HS_INPUT %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %ControlPoint = OpTypeStruct %v4float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %_arr_ControlPoint_uint_4 = OpTypeArray %ControlPoint %uint_4 %_ptr_Function__arr_ControlPoint_uint_4 = OpTypePointer Function %_arr_ControlPoint_uint_4 %DS_OUTPUT = OpTypeStruct %v4float %18 = OpTypeFunction %DS_OUTPUT %_ptr_Function_HS_INPUT %_ptr_Function_v2float %_ptr_Function__arr_ControlPoint_uint_4 %_ptr_Function_DS_OUTPUT = OpTypePointer Function %DS_OUTPUT %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %_ptr_Input_v4float = OpTypePointer Input %v4float %input_foo = OpVariable %_ptr_Input_v4float Input %input_bar = OpVariable %_ptr_Input_v4float Input %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %uv_1 = OpVariable %_ptr_Input_v3float Input %_ptr_Input__arr_ControlPoint_uint_4 = OpTypePointer Input %_arr_ControlPoint_uint_4 %CPData_1 = OpVariable %_ptr_Input__arr_ControlPoint_uint_4 Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_pos = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %input_0 = OpVariable %_ptr_Function_HS_INPUT Function %uv_0 = OpVariable %_ptr_Function_v2float Function %CPData_0 = OpVariable %_ptr_Function__arr_ControlPoint_uint_4 Function %param = OpVariable %_ptr_Function_HS_INPUT Function %param_0 = OpVariable %_ptr_Function_v2float Function %param_1 = OpVariable %_ptr_Function__arr_ControlPoint_uint_4 Function %52 = OpLoad %v4float %input_foo %53 = OpAccessChain %_ptr_Function_v4float %input_0 %int_0 OpStore %53 %52 %55 = OpLoad %v4float %input_bar %56 = OpAccessChain %_ptr_Function_v4float %input_0 %int_1 OpStore %56 %55 %61 = OpLoad %v3float %uv_1 %62 = OpCompositeExtract %float %61 0 %63 = OpCompositeExtract %float %61 1 %64 = OpCompositeConstruct %v2float %62 %63 OpStore %uv_0 %64 %68 = OpLoad %_arr_ControlPoint_uint_4 %CPData_1 OpStore %CPData_0 %68 %72 = OpLoad %HS_INPUT %input_0 OpStore %param %72 %74 = OpLoad %v2float %uv_0 OpStore %param_0 %74 %76 = OpLoad %_arr_ControlPoint_uint_4 %CPData_0 OpStore %param_1 %76 %77 = OpFunctionCall %DS_OUTPUT %_main_struct_HS_INPUT_vf4_vf41_vf2_struct_ControlPoint_vf41_4__ %param %param_0 %param_1 %78 = OpCompositeExtract %v4float %77 0 OpStore %_entryPointOutput_pos %78 OpReturn OpFunctionEnd %_main_struct_HS_INPUT_vf4_vf41_vf2_struct_ControlPoint_vf41_4__ = OpFunction %DS_OUTPUT None %18 %input = OpFunctionParameter %_ptr_Function_HS_INPUT %uv = OpFunctionParameter %_ptr_Function_v2float %CPData = OpFunctionParameter %_ptr_Function__arr_ControlPoint_uint_4 %23 = OpLabel %o = OpVariable %_ptr_Function_DS_OUTPUT Function %29 = OpAccessChain %_ptr_Function_v4float %input %int_0 %30 = OpLoad %v4float %29 %32 = OpAccessChain %_ptr_Function_v4float %input %int_1 %33 = OpLoad %v4float %32 %34 = OpFAdd %v4float %30 %33 %35 = OpLoad %v2float %uv %36 = OpVectorShuffle %v4float %35 %35 0 1 0 1 %37 = OpFAdd %v4float %34 %36 %38 = OpAccessChain %_ptr_Function_v4float %CPData %int_0 %int_0 %39 = OpLoad %v4float %38 %40 = OpFAdd %v4float %37 %39 %42 = OpAccessChain %_ptr_Function_v4float %CPData %int_3 %int_0 %43 = OpLoad %v4float %42 %44 = OpFAdd %v4float %40 %43 %45 = OpAccessChain %_ptr_Function_v4float %o %int_0 OpStore %45 %44 %46 = OpLoad %DS_OUTPUT %o OpReturnValue %46 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/vert/000077500000000000000000000000001400026215700175635ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/asm/vert/empty-io.asm.vert000066400000000000000000000061511400026215700230120ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 40 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %position %_entryPointOutput_position %_entryPointOutput OpName %main "main" OpName %VSInput "VSInput" OpMemberName %VSInput 0 "position" OpName %VSOutput "VSOutput" OpMemberName %VSOutput 0 "position" OpName %_main_struct_VSInput_vf41_ "@main(struct-VSInput-vf41;" OpName %_input "_input" OpName %_out "_out" OpName %_input_0 "_input" OpName %position "position" OpName %_entryPointOutput_position "@entryPointOutput_position" OpName %param "param" OpName %VSOutput_0 "VSOutput" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %position Location 0 OpDecorate %_entryPointOutput_position BuiltIn Position OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %VSInput = OpTypeStruct %v4float %_ptr_Function_VSInput = OpTypePointer Function %VSInput %VSOutput = OpTypeStruct %v4float %11 = OpTypeFunction %VSOutput %_ptr_Function_VSInput %_ptr_Function_VSOutput = OpTypePointer Function %VSOutput %int = OpTypeInt 32 1 %18 = OpConstant %int 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %position = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_position = OpVariable %_ptr_Output_v4float Output %VSOutput_0 = OpTypeStruct %_ptr_Output_VSOutput_0 = OpTypePointer Output %VSOutput_0 %_entryPointOutput = OpVariable %_ptr_Output_VSOutput_0 Output %main = OpFunction %void None %3 %5 = OpLabel %_input_0 = OpVariable %_ptr_Function_VSInput Function %param = OpVariable %_ptr_Function_VSInput Function %29 = OpLoad %v4float %position %30 = OpAccessChain %_ptr_Function_v4float %_input_0 %18 OpStore %30 %29 %34 = OpLoad %VSInput %_input_0 OpStore %param %34 %35 = OpFunctionCall %VSOutput %_main_struct_VSInput_vf41_ %param %36 = OpCompositeExtract %v4float %35 0 OpStore %_entryPointOutput_position %36 OpReturn OpFunctionEnd %_main_struct_VSInput_vf41_ = OpFunction %VSOutput None %11 %_input = OpFunctionParameter %_ptr_Function_VSInput %14 = OpLabel %_out = OpVariable %_ptr_Function_VSOutput Function %20 = OpAccessChain %_ptr_Function_v4float %_input %18 %21 = OpLoad %v4float %20 %22 = OpAccessChain %_ptr_Function_v4float %_out %18 OpStore %22 %21 %23 = OpLoad %VSOutput %_out OpReturnValue %23 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/vert/extract-transposed-matrix-from-struct.asm.vert000066400000000000000000000153111400026215700306640ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 79 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %VS "main" %PosL_1 %instanceID_1 %_entryPointOutput_Position %_entryPointOutput_Color OpSource HLSL 500 OpName %VS "VS" OpName %V2F "V2F" OpMemberName %V2F 0 "Position" OpMemberName %V2F 1 "Color" OpName %_VS_vf3_u1_ "@VS(vf3;u1;" OpName %PosL "PosL" OpName %instanceID "instanceID" OpName %InstanceData "InstanceData" OpMemberName %InstanceData 0 "MATRIX_MVP" OpMemberName %InstanceData 1 "Color" OpName %instData "instData" OpName %InstanceData_0 "InstanceData" OpMemberName %InstanceData_0 0 "MATRIX_MVP" OpMemberName %InstanceData_0 1 "Color" OpName %gInstanceData "gInstanceData" OpMemberName %gInstanceData 0 "@data" OpName %gInstanceData_0 "gInstanceData" OpName %v2f "v2f" OpName %PosL_0 "PosL" OpName %PosL_1 "PosL" OpName %instanceID_0 "instanceID" OpName %instanceID_1 "instanceID" OpName %flattenTemp "flattenTemp" OpName %param "param" OpName %param_0 "param" OpName %_entryPointOutput_Position "@entryPointOutput.Position" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpMemberDecorate %InstanceData_0 0 RowMajor OpMemberDecorate %InstanceData_0 0 Offset 0 OpMemberDecorate %InstanceData_0 0 MatrixStride 16 OpMemberDecorate %InstanceData_0 1 Offset 64 OpDecorate %_runtimearr_InstanceData_0 ArrayStride 80 OpMemberDecorate %gInstanceData 0 NonWritable OpMemberDecorate %gInstanceData 0 Offset 0 OpDecorate %gInstanceData BufferBlock OpDecorate %gInstanceData_0 DescriptorSet 1 OpDecorate %gInstanceData_0 Binding 0 OpDecorate %PosL_1 Location 0 OpDecorate %instanceID_1 BuiltIn InstanceIndex OpDecorate %_entryPointOutput_Position BuiltIn Position OpDecorate %_entryPointOutput_Color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %v4float = OpTypeVector %float 4 %V2F = OpTypeStruct %v4float %v4float %13 = OpTypeFunction %V2F %_ptr_Function_v3float %_ptr_Function_uint %mat4v4float = OpTypeMatrix %v4float 4 %InstanceData = OpTypeStruct %mat4v4float %v4float %_ptr_Function_InstanceData = OpTypePointer Function %InstanceData %InstanceData_0 = OpTypeStruct %mat4v4float %v4float %_runtimearr_InstanceData_0 = OpTypeRuntimeArray %InstanceData_0 %gInstanceData = OpTypeStruct %_runtimearr_InstanceData_0 %_ptr_Uniform_gInstanceData = OpTypePointer Uniform %gInstanceData %gInstanceData_0 = OpVariable %_ptr_Uniform_gInstanceData Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_InstanceData_0 = OpTypePointer Uniform %InstanceData_0 %_ptr_Function_mat4v4float = OpTypePointer Function %mat4v4float %int_1 = OpConstant %int 1 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_V2F = OpTypePointer Function %V2F %float_1 = OpConstant %float 1 %_ptr_Input_v3float = OpTypePointer Input %v3float %PosL_1 = OpVariable %_ptr_Input_v3float Input %_ptr_Input_uint = OpTypePointer Input %uint %instanceID_1 = OpVariable %_ptr_Input_uint Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Position = OpVariable %_ptr_Output_v4float Output %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %VS = OpFunction %void None %3 %5 = OpLabel %PosL_0 = OpVariable %_ptr_Function_v3float Function %instanceID_0 = OpVariable %_ptr_Function_uint Function %flattenTemp = OpVariable %_ptr_Function_V2F Function %param = OpVariable %_ptr_Function_v3float Function %param_0 = OpVariable %_ptr_Function_uint Function %61 = OpLoad %v3float %PosL_1 OpStore %PosL_0 %61 %65 = OpLoad %uint %instanceID_1 OpStore %instanceID_0 %65 %68 = OpLoad %v3float %PosL_0 OpStore %param %68 %70 = OpLoad %uint %instanceID_0 OpStore %param_0 %70 %71 = OpFunctionCall %V2F %_VS_vf3_u1_ %param %param_0 OpStore %flattenTemp %71 %74 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0 %75 = OpLoad %v4float %74 OpStore %_entryPointOutput_Position %75 %77 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_1 %78 = OpLoad %v4float %77 OpStore %_entryPointOutput_Color %78 OpReturn OpFunctionEnd %_VS_vf3_u1_ = OpFunction %V2F None %13 %PosL = OpFunctionParameter %_ptr_Function_v3float %instanceID = OpFunctionParameter %_ptr_Function_uint %17 = OpLabel %instData = OpVariable %_ptr_Function_InstanceData Function %v2f = OpVariable %_ptr_Function_V2F Function %29 = OpLoad %uint %instanceID %31 = OpAccessChain %_ptr_Uniform_InstanceData_0 %gInstanceData_0 %int_0 %29 %32 = OpLoad %InstanceData_0 %31 %33 = OpCompositeExtract %mat4v4float %32 0 %35 = OpAccessChain %_ptr_Function_mat4v4float %instData %int_0 OpStore %35 %33 %36 = OpCompositeExtract %v4float %32 1 %39 = OpAccessChain %_ptr_Function_v4float %instData %int_1 OpStore %39 %36 %42 = OpAccessChain %_ptr_Function_mat4v4float %instData %int_0 %43 = OpLoad %mat4v4float %42 %44 = OpLoad %v3float %PosL %46 = OpCompositeExtract %float %44 0 %47 = OpCompositeExtract %float %44 1 %48 = OpCompositeExtract %float %44 2 %49 = OpCompositeConstruct %v4float %46 %47 %48 %float_1 %50 = OpMatrixTimesVector %v4float %43 %49 %51 = OpAccessChain %_ptr_Function_v4float %v2f %int_0 OpStore %51 %50 %52 = OpAccessChain %_ptr_Function_v4float %instData %int_1 %53 = OpLoad %v4float %52 %54 = OpAccessChain %_ptr_Function_v4float %v2f %int_1 OpStore %54 %53 %55 = OpLoad %V2F %v2f OpReturnValue %55 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/vert/global-builtin.sso.asm.vert000066400000000000000000000055631400026215700247640ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 40 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_entryPointOutput %_entryPointOutput_pos OpSource HLSL 500 OpName %main "main" OpName %VSOut "VSOut" OpMemberName %VSOut 0 "a" OpMemberName %VSOut 1 "pos" OpName %_main_ "@main(" OpName %vout "vout" OpName %flattenTemp "flattenTemp" OpName %VSOut_0 "VSOut" OpMemberName %VSOut_0 0 "a" OpName %_entryPointOutput "@entryPointOutput" OpName %_entryPointOutput_pos "@entryPointOutput_pos" OpDecorate %_entryPointOutput Location 0 OpDecorate %_entryPointOutput_pos BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %VSOut = OpTypeStruct %float %v4float %9 = OpTypeFunction %VSOut %_ptr_Function_VSOut = OpTypePointer Function %VSOut %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_40 = OpConstant %float 40 %_ptr_Function_float = OpTypePointer Function %float %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %21 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Function_v4float = OpTypePointer Function %v4float %VSOut_0 = OpTypeStruct %float %_ptr_Output_VSOut_0 = OpTypePointer Output %VSOut_0 %_entryPointOutput = OpVariable %_ptr_Output_VSOut_0 Output %_ptr_Output_float = OpTypePointer Output %float %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_pos = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %flattenTemp = OpVariable %_ptr_Function_VSOut Function %28 = OpFunctionCall %VSOut %_main_ OpStore %flattenTemp %28 %32 = OpAccessChain %_ptr_Function_float %flattenTemp %int_0 %33 = OpLoad %float %32 %35 = OpAccessChain %_ptr_Output_float %_entryPointOutput %int_0 OpStore %35 %33 %38 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_1 %39 = OpLoad %v4float %38 OpStore %_entryPointOutput_pos %39 OpReturn OpFunctionEnd %_main_ = OpFunction %VSOut None %9 %11 = OpLabel %vout = OpVariable %_ptr_Function_VSOut Function %18 = OpAccessChain %_ptr_Function_float %vout %int_0 OpStore %18 %float_40 %23 = OpAccessChain %_ptr_Function_v4float %vout %int_1 OpStore %23 %21 %24 = OpLoad %VSOut %vout OpReturnValue %24 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/vert/invariant-block.asm.vert000066400000000000000000000036021400026215700243300ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpMemberDecorate %gl_PerVertex 0 Invariant OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %17 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/vert/invariant-block.sso.asm.vert000066400000000000000000000036021400026215700251330ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpMemberDecorate %gl_PerVertex 0 Invariant OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %17 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/vert/invariant.asm.vert000066400000000000000000000024371400026215700232450ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 18 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_entryPointOutput OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %_entryPointOutput Invariant OpDecorate %_entryPointOutput BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %12 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %17 = OpFunctionCall %v4float %_main_ OpStore %_entryPointOutput %17 OpReturn OpFunctionEnd %_main_ = OpFunction %v4float None %8 %10 = OpLabel OpReturnValue %12 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/vert/invariant.sso.asm.vert000066400000000000000000000024371400026215700240500ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 18 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_entryPointOutput OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %_entryPointOutput Invariant OpDecorate %_entryPointOutput BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %12 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %17 = OpFunctionCall %v4float %_main_ OpStore %_entryPointOutput %17 OpReturn OpFunctionEnd %_main_ = OpFunction %v4float None %8 %10 = OpLabel OpReturnValue %12 OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/vert/spec-constant-op-composite.asm.vk.vert000066400000000000000000000072201400026215700270610ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 1 ; Bound: 58 ; Schema: 0 OpCapability Shader OpCapability ClipDistance OpCapability CullDistance %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %52 %output OpSource GLSL 450 OpName %4 "main" OpName %9 "pos" OpName %50 "gl_PerVertex" OpMemberName %50 0 "gl_Position" OpMemberName %50 1 "gl_PointSize" OpMemberName %50 2 "gl_ClipDistance" OpMemberName %50 3 "gl_CullDistance" OpName %52 "" OpDecorate %13 SpecId 201 OpDecorate %24 SpecId 202 OpMemberDecorate %50 0 BuiltIn Position OpMemberDecorate %50 1 BuiltIn PointSize OpMemberDecorate %50 2 BuiltIn ClipDistance OpMemberDecorate %50 3 BuiltIn CullDistance OpDecorate %50 Block OpDecorate %57 SpecId 200 OpDecorate %output Flat OpDecorate %output Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Function %7 %10 = OpConstant %6 0 %11 = OpConstantComposite %7 %10 %10 %10 %10 %12 = OpTypeInt 32 1 %int_ptr = OpTypePointer Output %12 %13 = OpSpecConstant %12 -10 %14 = OpConstant %12 2 %15 = OpSpecConstantOp %12 IAdd %13 %14 %17 = OpTypeInt 32 0 %18 = OpConstant %17 1 %19 = OpTypePointer Function %6 %24 = OpSpecConstant %17 100 %25 = OpConstant %17 5 %26 = OpSpecConstantOp %17 UMod %24 %25 %28 = OpConstant %17 2 %33 = OpConstant %12 20 %34 = OpConstant %12 30 %35 = OpTypeVector %12 4 %36 = OpSpecConstantComposite %35 %33 %34 %15 %15 %40 = OpTypeVector %12 2 %41 = OpSpecConstantOp %40 VectorShuffle %36 %36 1 0 %foo = OpSpecConstantOp %12 CompositeExtract %36 1 %42 = OpTypeVector %6 2 %49 = OpTypeArray %6 %18 %50 = OpTypeStruct %7 %6 %49 %49 %51 = OpTypePointer Output %50 %52 = OpVariable %51 Output %output = OpVariable %int_ptr Output %53 = OpConstant %12 0 %55 = OpTypePointer Output %7 %57 = OpSpecConstant %6 3.14159 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %11 %16 = OpConvertSToF %6 %15 %20 = OpAccessChain %19 %9 %18 %21 = OpLoad %6 %20 %22 = OpFAdd %6 %21 %16 %23 = OpAccessChain %19 %9 %18 OpStore %23 %22 %27 = OpConvertUToF %6 %26 %29 = OpAccessChain %19 %9 %28 %30 = OpLoad %6 %29 %31 = OpFAdd %6 %30 %27 %32 = OpAccessChain %19 %9 %28 OpStore %32 %31 %37 = OpConvertSToF %7 %36 %38 = OpLoad %7 %9 %39 = OpFAdd %7 %38 %37 OpStore %9 %39 %43 = OpConvertSToF %42 %41 %44 = OpLoad %7 %9 %45 = OpVectorShuffle %42 %44 %44 0 1 %46 = OpFAdd %42 %45 %43 %47 = OpLoad %7 %9 %48 = OpVectorShuffle %7 %47 %46 4 5 2 3 OpStore %9 %48 %54 = OpLoad %7 %9 %56 = OpAccessChain %55 %52 %53 OpStore %56 %54 OpStore %output %foo OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/asm/vert/uint-vertex-id-instance-id.asm.vert000066400000000000000000000051401400026215700263240ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 6 ; Bound: 36 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %vid_1 %iid_1 %_entryPointOutput OpSource HLSL 500 OpName %main "main" OpName %_main_u1_u1_ "@main(u1;u1;" OpName %vid "vid" OpName %iid "iid" OpName %vid_0 "vid" OpName %vid_1 "vid" OpName %iid_0 "iid" OpName %iid_1 "iid" OpName %_entryPointOutput "@entryPointOutput" OpName %param "param" OpName %param_0 "param" OpDecorate %vid_1 BuiltIn VertexIndex OpDecorate %iid_1 BuiltIn InstanceIndex OpDecorate %_entryPointOutput BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %10 = OpTypeFunction %v4float %_ptr_Function_uint %_ptr_Function_uint %_ptr_Input_uint = OpTypePointer Input %uint %vid_1 = OpVariable %_ptr_Input_uint Input %iid_1 = OpVariable %_ptr_Input_uint Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %vid_0 = OpVariable %_ptr_Function_uint Function %iid_0 = OpVariable %_ptr_Function_uint Function %param = OpVariable %_ptr_Function_uint Function %param_0 = OpVariable %_ptr_Function_uint Function %25 = OpLoad %uint %vid_1 OpStore %vid_0 %25 %28 = OpLoad %uint %iid_1 OpStore %iid_0 %28 %32 = OpLoad %uint %vid_0 OpStore %param %32 %34 = OpLoad %uint %iid_0 OpStore %param_0 %34 %35 = OpFunctionCall %v4float %_main_u1_u1_ %param %param_0 OpStore %_entryPointOutput %35 OpReturn OpFunctionEnd %_main_u1_u1_ = OpFunction %v4float None %10 %vid = OpFunctionParameter %_ptr_Function_uint %iid = OpFunctionParameter %_ptr_Function_uint %14 = OpLabel %15 = OpLoad %uint %vid %16 = OpLoad %uint %iid %17 = OpIAdd %uint %15 %16 %18 = OpConvertUToF %float %17 %19 = OpCompositeConstruct %v4float %18 %18 %18 %18 OpReturnValue %19 OpFunctionEnd spirv-cross-2021.01.15/shaders/comp/000077500000000000000000000000001400026215700167615ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/comp/atomic.comp000066400000000000000000000033111400026215700211130ustar00rootroot00000000000000#version 310 es #extension GL_OES_shader_image_atomic : require layout(local_size_x = 1) in; layout(r32ui, binding = 0) uniform highp uimage2D uImage; layout(r32i, binding = 1) uniform highp iimage2D iImage; layout(binding = 2, std430) buffer SSBO { uint u32; int i32; } ssbo; void main() { imageAtomicAdd(uImage, ivec2(1, 5), 1u); // Test that we do not invalidate OpImage variables which are loaded from UniformConstant // address space. imageStore(iImage, ivec2(1, 6), ivec4(imageAtomicAdd(uImage, ivec2(1, 5), 1u))); imageAtomicOr(uImage, ivec2(1, 5), 1u); imageAtomicXor(uImage, ivec2(1, 5), 1u); imageAtomicAnd(uImage, ivec2(1, 5), 1u); imageAtomicMin(uImage, ivec2(1, 5), 1u); imageAtomicMax(uImage, ivec2(1, 5), 1u); //imageAtomicExchange(uImage, ivec2(1, 5), 1u); imageAtomicCompSwap(uImage, ivec2(1, 5), 10u, 2u); imageAtomicAdd(iImage, ivec2(1, 6), 1); imageAtomicOr(iImage, ivec2(1, 6), 1); imageAtomicXor(iImage, ivec2(1, 6), 1); imageAtomicAnd(iImage, ivec2(1, 6), 1); imageAtomicMin(iImage, ivec2(1, 6), 1); imageAtomicMax(iImage, ivec2(1, 6), 1); //imageAtomicExchange(iImage, ivec2(1, 5), 1u); imageAtomicCompSwap(iImage, ivec2(1, 5), 10, 2); atomicAdd(ssbo.u32, 1u); atomicOr(ssbo.u32, 1u); atomicXor(ssbo.u32, 1u); atomicAnd(ssbo.u32, 1u); atomicMin(ssbo.u32, 1u); atomicMax(ssbo.u32, 1u); atomicExchange(ssbo.u32, 1u); atomicCompSwap(ssbo.u32, 10u, 2u); atomicAdd(ssbo.i32, 1); atomicOr(ssbo.i32, 1); atomicXor(ssbo.i32, 1); atomicAnd(ssbo.i32, 1); atomicMin(ssbo.i32, 1); atomicMax(ssbo.i32, 1); atomicExchange(ssbo.i32, 1); atomicCompSwap(ssbo.i32, 10, 2); } spirv-cross-2021.01.15/shaders/comp/bake_gradient.comp000066400000000000000000000037151400026215700224260ustar00rootroot00000000000000#version 310 es layout(local_size_x = 8, local_size_y = 8) in; layout(binding = 0) uniform sampler2D uHeight; layout(binding = 1) uniform sampler2D uDisplacement; layout(rgba16f, binding = 2) uniform writeonly mediump image2D iHeightDisplacement; layout(rgba16f, binding = 3) uniform writeonly mediump image2D iGradJacobian; layout(binding = 4) uniform UBO { vec4 uInvSize; vec4 uScale; }; mediump float jacobian(mediump vec2 dDdx, mediump vec2 dDdy) { return (1.0 + dDdx.x) * (1.0 + dDdy.y) - dDdx.y * dDdy.x; } #define LAMBDA 1.2 void main() { vec4 uv = (vec2(gl_GlobalInvocationID.xy) * uInvSize.xy).xyxy + 0.5 * uInvSize; float h = textureLod(uHeight, uv.xy, 0.0).x; // Compute the heightmap gradient by simple differentiation. float x0 = textureLodOffset(uHeight, uv.xy, 0.0, ivec2(-1, 0)).x; float x1 = textureLodOffset(uHeight, uv.xy, 0.0, ivec2(+1, 0)).x; float y0 = textureLodOffset(uHeight, uv.xy, 0.0, ivec2(0, -1)).x; float y1 = textureLodOffset(uHeight, uv.xy, 0.0, ivec2(0, +1)).x; vec2 grad = uScale.xy * 0.5 * vec2(x1 - x0, y1 - y0); // Displacement map must be sampled with a different offset since it's a smaller texture. vec2 displacement = LAMBDA * textureLod(uDisplacement, uv.zw, 0.0).xy; // Compute jacobian. vec2 dDdx = 0.5 * LAMBDA * ( textureLodOffset(uDisplacement, uv.zw, 0.0, ivec2(+1, 0)).xy - textureLodOffset(uDisplacement, uv.zw, 0.0, ivec2(-1, 0)).xy); vec2 dDdy = 0.5 * LAMBDA * ( textureLodOffset(uDisplacement, uv.zw, 0.0, ivec2(0, +1)).xy - textureLodOffset(uDisplacement, uv.zw, 0.0, ivec2(0, -1)).xy); float j = jacobian(dDdx * uScale.z, dDdy * uScale.z); displacement = vec2(0.0); // Read by vertex shader/tess shader. imageStore(iHeightDisplacement, ivec2(gl_GlobalInvocationID.xy), vec4(h, displacement, 0.0)); // Read by fragment shader. imageStore(iGradJacobian, ivec2(gl_GlobalInvocationID.xy), vec4(grad, j, 0.0)); } spirv-cross-2021.01.15/shaders/comp/barriers.comp000066400000000000000000000016001400026215700214470ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4) in; void barrier_shared() { memoryBarrierShared(); } void full_barrier() { memoryBarrier(); } void image_barrier() { memoryBarrierImage(); } void buffer_barrier() { memoryBarrierBuffer(); } void group_barrier() { groupMemoryBarrier(); } void barrier_shared_exec() { memoryBarrierShared(); barrier(); } void full_barrier_exec() { memoryBarrier(); barrier(); } void image_barrier_exec() { memoryBarrierImage(); barrier(); } void buffer_barrier_exec() { memoryBarrierBuffer(); barrier(); } void group_barrier_exec() { groupMemoryBarrier(); barrier(); } void exec_barrier() { barrier(); } void main() { barrier_shared(); full_barrier(); image_barrier(); buffer_barrier(); group_barrier(); barrier_shared_exec(); full_barrier_exec(); image_barrier_exec(); buffer_barrier_exec(); group_barrier_exec(); exec_barrier(); } spirv-cross-2021.01.15/shaders/comp/basic.comp000066400000000000000000000007261400026215700207270ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; layout(std430, binding = 2) buffer SSBO3 { uint counter; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 idata = in_data[ident]; if (dot(idata, vec4(1.0, 5.0, 6.0, 2.0)) > 8.2) { out_data[atomicAdd(counter, 1u)] = idata; } } spirv-cross-2021.01.15/shaders/comp/casts.comp000066400000000000000000000004431400026215700207570ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO0 { ivec4 inputs[]; }; layout(binding = 1, std430) buffer SSBO1 { ivec4 outputs[]; }; void main() { uint ident = gl_GlobalInvocationID.x; outputs[ident] = ivec4(bvec4(inputs[ident] & 0x3)); } spirv-cross-2021.01.15/shaders/comp/cfg-preserve-parameter.comp000066400000000000000000000014551400026215700242140ustar00rootroot00000000000000#version 310 es // We write in all paths (and no reads), so should just be out. void out_test_0(int cond, inout int i) { if (cond == 0) i = 40; else i = 60; } // We write in all paths (and no reads), so should just be out. void out_test_1(int cond, inout int i) { switch (cond) { case 40: i = 40; break; default: i = 70; break; } } // We don't write in all paths, so should be inout. void inout_test_0(int cond, inout int i) { if (cond == 0) i = 40; } void inout_test_1(int cond, inout int i) { switch (cond) { case 40: i = 40; break; } } void main() { int cond = 40; int i = 50; out_test_0(cond, i); out_test_1(cond, i); inout_test_0(cond, i); inout_test_1(cond, i); } spirv-cross-2021.01.15/shaders/comp/cfg.comp000066400000000000000000000023001400026215700203730ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float data; }; void test() { // Test that variables local to a scope stay local. if (data != 0.0) { float tmp = 10.0; data = tmp; } else { float tmp = 15.0; data = tmp; } // Test that variable access propagates up to dominator if (data != 0.0) { float e; if (data != 5.0) { if (data != 6.0) e = 10.0; } else e = 20.0; } // Test that variables local to a switch block stay local. switch (int(data)) { case 0: { float tmp = 20.0; data = tmp; break; } case 1: { float tmp = 30.0; data = tmp; break; } } // Check that multibranches propagate up to dominator. float f; switch (int(data)) { case 0: { f = 30.0; break; } case 1: { f = 40.0; break; } } // Check that loops work. // Interesting case here is propagating variable access from the continue block. float h; for (int i = 0; i < 20; i++, h += 10.0) ; data = h; // Do the same with do-while, gotta test all the hard cases. float m; do { } while (m != 20.0); data = m; } void main() { // Test that we do the CFG analysis for all functions. test(); } spirv-cross-2021.01.15/shaders/comp/coherent-block.comp000066400000000000000000000002431400026215700225370ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 1) coherent restrict writeonly buffer SSBO { vec4 value; }; void main() { value = vec4(20.0); } spirv-cross-2021.01.15/shaders/comp/coherent-image.comp000066400000000000000000000004151400026215700225300ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 1) coherent restrict writeonly buffer SSBO { ivec4 value; }; layout(r32i, binding = 3) coherent readonly restrict uniform mediump iimage2D uImage; void main() { value = imageLoad(uImage, ivec2(10)); } spirv-cross-2021.01.15/shaders/comp/composite-array-initialization.comp000066400000000000000000000010541400026215700260040ustar00rootroot00000000000000#version 310 es #extension GL_EXT_shader_non_constant_global_initializers : require layout(local_size_x = 2) in; struct Data { float a; float b; }; layout(std430, binding = 0) buffer SSBO { Data outdata[]; }; layout(constant_id = 0) const float X = 4.0; Data data[2] = Data[](Data(1.0, 2.0), Data(3.0, 4.0)); Data data2[2] = Data[](Data(X, 2.0), Data(3.0, 5.0)); Data combine(Data a, Data b) { return Data(a.a + b.a, a.b + b.b); } void main() { outdata[gl_WorkGroupID.x] = combine(data[gl_LocalInvocationID.x], data2[gl_LocalInvocationID.x]); } spirv-cross-2021.01.15/shaders/comp/composite-construct.comp000066400000000000000000000015421400026215700236670ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO0 { vec4 as[]; }; layout(std430, binding = 1) buffer SSBO1 { vec4 bs[]; }; vec4 summe(vec4 values[3][2]) { return values[0][0] + values[2][1] + values[0][1] + values[1][0]; } struct Composite { vec4 a[2]; vec4 b[2]; }; void main() { vec4 values[2] = vec4[](as[gl_GlobalInvocationID.x], bs[gl_GlobalInvocationID.x]); vec4 const_values[2] = vec4[](vec4(10.0), vec4(30.0)); vec4 copy_values[2]; copy_values = const_values; vec4 copy_values2[2] = values; as[gl_GlobalInvocationID.x] = summe(vec4[][](values, copy_values, copy_values2)); Composite c = Composite(values, copy_values); float arrayofarray[2][3] = float[][](float[](1.0, 1.0, 1.0), float[](2.0, 2.0, 2.0)); float b = 10.0; float values_scalar[4] = float[](b, b, b, b); } spirv-cross-2021.01.15/shaders/comp/culling.comp000066400000000000000000000006531400026215700213020ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4) in; layout(std430, binding = 0) readonly buffer SSBO { float in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { float out_data[]; }; layout(std430, binding = 2) buffer SSBO3 { uint count; }; void main() { uint ident = gl_GlobalInvocationID.x; float idata = in_data[ident]; if (idata > 12.0) out_data[atomicAdd(count, 1u)] = idata; } spirv-cross-2021.01.15/shaders/comp/defer-parens.comp000066400000000000000000000010651400026215700222160ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBO { vec4 data; int index; }; void main() { // Tests defer-parens behavior where a binary expression is OpCompositeExtracted chained together // with an OpCompositeConstruct optimization. vec4 d = data; data = vec4(d.x, d.yz + 10.0, d.w); // Verify binary ops. data = d + d + d; // Verify swizzles. data = (d.yz + 10.0).xxyy; // OpCompositeExtract float t = (d.yz + 10.0).y; data = vec4(t); // OpVectorExtractDynamic t = (d.zw + 10.0)[index]; data = vec4(t); } spirv-cross-2021.01.15/shaders/comp/dowhile.comp000066400000000000000000000006531400026215700213000ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; int i; void main() { uint ident = gl_GlobalInvocationID.x; i = 0; vec4 idat = in_data[ident]; do { idat = mvp * idat; i++; } while(i < 16); out_data[ident] = idat; } spirv-cross-2021.01.15/shaders/comp/generate_height.comp000066400000000000000000000044501400026215700227660ustar00rootroot00000000000000#version 310 es layout(local_size_x = 64) in; layout(std430, binding = 0) readonly buffer Distribution { vec2 distribution[]; }; layout(std430, binding = 1) writeonly buffer HeightmapFFT { uint heights[]; }; layout(binding = 2, std140) uniform UBO { vec4 uModTime; }; vec2 alias(vec2 i, vec2 N) { return mix(i, i - N, greaterThan(i, 0.5 * N)); } vec4 cmul(vec4 a, vec4 b) { vec4 r3 = a.yxwz; vec4 r1 = b.xxzz; vec4 R0 = a * r1; vec4 r2 = b.yyww; vec4 R1 = r2 * r3; return R0 + vec4(-R1.x, R1.y, -R1.z, R1.w); } vec2 cmul(vec2 a, vec2 b) { vec2 r3 = a.yx; vec2 r1 = b.xx; vec2 R0 = a * r1; vec2 r2 = b.yy; vec2 R1 = r2 * r3; return R0 + vec2(-R1.x, R1.y); } uint pack2(vec2 v) { return packHalf2x16(v); } uvec2 pack4(vec4 v) { return uvec2(packHalf2x16(v.xy), packHalf2x16(v.zw)); } uvec2 workaround_mix(uvec2 a, uvec2 b, bvec2 sel) { return uvec2(sel.x ? b.x : a.x, sel.y ? b.y : a.y); } void generate_heightmap() { uvec2 N = gl_WorkGroupSize.xy * gl_NumWorkGroups.xy; uvec2 i = gl_GlobalInvocationID.xy; // Pick out the negative frequency variant. uvec2 wi = workaround_mix(N - i, uvec2(0u), equal(i, uvec2(0u))); // Pick out positive and negative travelling waves. vec2 a = distribution[i.y * N.x + i.x]; vec2 b = distribution[wi.y * N.x + wi.x]; vec2 k = uModTime.xy * alias(vec2(i), vec2(N)); float k_len = length(k); const float G = 9.81; // If this sample runs for hours on end, the cosines of very large numbers will eventually become unstable. // It is fairly easy to fix this by wrapping uTime, // and quantizing w such that wrapping uTime does not change the result. // See Tessendorf's paper for how to do it. // The sqrt(G * k_len) factor represents how fast ocean waves at different frequencies propagate. float w = sqrt(G * k_len) * uModTime.z; float cw = cos(w); float sw = sin(w); // Complex multiply to rotate our frequency samples. a = cmul(a, vec2(cw, sw)); b = cmul(b, vec2(cw, sw)); b = vec2(b.x, -b.y); // Complex conjugate since we picked a frequency with the opposite direction. vec2 res = a + b; // Sum up forward and backwards travelling waves. heights[i.y * N.x + i.x] = pack2(res); } void main() { generate_heightmap(); } spirv-cross-2021.01.15/shaders/comp/image.comp000066400000000000000000000005461400026215700207300ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(rgba8, binding = 0) uniform readonly mediump image2D uImageIn; layout(rgba8, binding = 1) uniform writeonly mediump image2D uImageOut; void main() { vec4 v = imageLoad(uImageIn, ivec2(gl_GlobalInvocationID.xy) + imageSize(uImageIn)); imageStore(uImageOut, ivec2(gl_GlobalInvocationID.xy), v); } spirv-cross-2021.01.15/shaders/comp/insert.comp000066400000000000000000000004621400026215700211470ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) writeonly buffer SSBO { vec4 out_data[]; }; void main() { vec4 v; v.x = 10.0; v.y = 30.0; v.z = 70.0; v.w = 90.0; out_data[gl_GlobalInvocationID.x] = v; out_data[gl_GlobalInvocationID.x].y = 20.0; } spirv-cross-2021.01.15/shaders/comp/mat3.comp000066400000000000000000000003671400026215700205130ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 1) writeonly buffer SSBO2 { mat3 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; out_data[ident] = mat3(vec3(10.0), vec3(20.0), vec3(40.0)); } spirv-cross-2021.01.15/shaders/comp/mod.comp000066400000000000000000000011111400026215700204120ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 v = mod(in_data[ident], out_data[ident]); out_data[ident] = v; uvec4 vu = floatBitsToUint(in_data[ident]) % floatBitsToUint(out_data[ident]); out_data[ident] = uintBitsToFloat(vu); ivec4 vi = floatBitsToInt(in_data[ident]) % floatBitsToInt(out_data[ident]); out_data[ident] = intBitsToFloat(vi); } spirv-cross-2021.01.15/shaders/comp/modf.comp000066400000000000000000000006331400026215700205700ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 i; //vec4 v = frexp(in_data[ident], i); //out_data[ident] = ldexp(v, i); vec4 v = modf(in_data[ident], i); out_data[ident] = v; } spirv-cross-2021.01.15/shaders/comp/outer-product.comp000066400000000000000000000011241400026215700224530ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 0, std430) writeonly buffer SSBO { mat2 m22; mat2x3 m23; mat2x4 m24; mat3x2 m32; mat3 m33; mat3x4 m34; mat4x2 m42; mat4x3 m43; mat4 m44; }; layout(set = 0, binding = 1, std430) readonly buffer ReadSSBO { vec2 v2; vec3 v3; vec4 v4; }; void main() { m22 = outerProduct(v2, v2); m23 = outerProduct(v3, v2); m24 = outerProduct(v4, v2); m32 = outerProduct(v2, v3); m33 = outerProduct(v3, v3); m34 = outerProduct(v4, v3); m42 = outerProduct(v2, v4); m43 = outerProduct(v3, v4); m44 = outerProduct(v4, v4); } spirv-cross-2021.01.15/shaders/comp/read-write-only.comp000066400000000000000000000005761400026215700226730ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(binding = 0, std430) readonly buffer SSBO0 { vec4 data0; vec4 data1; }; layout(binding = 1, std430) restrict buffer SSBO1 { vec4 data2; vec4 data3; }; layout(binding = 2, std430) restrict writeonly buffer SSBO2 { vec4 data4; vec4 data5; }; void main() { data4 = data0 + data2; data5 = data1 + data3; } spirv-cross-2021.01.15/shaders/comp/rmw-matrix.comp000066400000000000000000000003061400026215700217470ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { float a; vec4 b; mat4 c; float a1; vec4 b1; mat4 c1; }; void main() { a *= a1; b *= b1; c *= c1; } spirv-cross-2021.01.15/shaders/comp/rmw-opt.comp000066400000000000000000000004501400026215700212450ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { int a; }; void main() { a += 10; a -= 10; a *= 10; a /= 10; a <<= 2; a >>= 3; a &= 40; a ^= 10; a %= 40; a |= 1; bool c = false; bool d = true; c = c && d; d = d || c; a = c && d ? 1 : 0; } spirv-cross-2021.01.15/shaders/comp/scalar-std450-distance-length-normalize.comp000066400000000000000000000003341400026215700271740ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(std430, set = 0, binding = 0) buffer SSBO { float a; float b; float c; float d; float e; }; void main() { c = distance(a, b); d = length(a); e = normalize(a); } spirv-cross-2021.01.15/shaders/comp/shared.comp000066400000000000000000000007751400026215700211200ustar00rootroot00000000000000#version 310 es layout(local_size_x = 4) in; shared float sShared[gl_WorkGroupSize.x]; layout(std430, binding = 0) readonly buffer SSBO { float in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { float out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; float idata = in_data[ident]; sShared[gl_LocalInvocationIndex] = idata; memoryBarrierShared(); barrier(); out_data[ident] = sShared[gl_WorkGroupSize.x - gl_LocalInvocationIndex - 1u]; } spirv-cross-2021.01.15/shaders/comp/ssbo-array-length.comp000066400000000000000000000002351400026215700232020ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(set = 0, binding = 1, std140) buffer SSBO { uint size; float v[]; }; void main() { size = v.length(); } spirv-cross-2021.01.15/shaders/comp/ssbo-array.comp000066400000000000000000000003421400026215700217220ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { vec4 data[]; } ssbos[2]; void main() { uint ident = gl_GlobalInvocationID.x; ssbos[1].data[ident] = ssbos[0].data[ident]; } spirv-cross-2021.01.15/shaders/comp/struct-layout.comp000066400000000000000000000005321400026215700225000ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; struct Foo { mat4 m; }; layout(std430, binding = 0) readonly buffer SSBO { Foo in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { Foo out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; out_data[ident].m = in_data[ident].m * in_data[ident].m; } spirv-cross-2021.01.15/shaders/comp/struct-packing.comp000066400000000000000000000024271400026215700226040ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; struct S0 { vec2 a[1]; float b; }; struct S1 { vec3 a; float b; }; struct S2 { vec3 a[1]; float b; }; struct S3 { vec2 a; float b; }; struct S4 { vec2 c; }; struct Content { S0 m0s[1]; S1 m1s[1]; S2 m2s[1]; S0 m0; S1 m1; S2 m2; S3 m3; float m4; S4 m3s[8]; }; layout(binding = 1, std430) restrict buffer SSBO1 { Content content; Content content1[2]; Content content2; layout(column_major) mat2 m0; layout(column_major) mat2 m1; layout(column_major) mat2x3 m2[4]; layout(column_major) mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_430; layout(binding = 0, std140) restrict buffer SSBO0 { Content content; Content content1[2]; Content content2; layout(column_major) mat2 m0; layout(column_major) mat2 m1; layout(column_major) mat2x3 m2[4]; layout(column_major) mat3x2 m3; layout(row_major) mat2 m4; layout(row_major) mat2 m5[9]; layout(row_major) mat2x3 m6[4][2]; layout(row_major) mat3x2 m7; float array[]; } ssbo_140; void main() { ssbo_430.content = ssbo_140.content; } spirv-cross-2021.01.15/shaders/comp/torture-loop.comp000066400000000000000000000012001400026215700223050ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) readonly buffer SSBO { mat4 mvp; vec4 in_data[]; }; layout(std430, binding = 1) writeonly buffer SSBO2 { vec4 out_data[]; }; void main() { uint ident = gl_GlobalInvocationID.x; vec4 idat = in_data[ident]; int k = 0; // Continue with side effects. while (++k < 10) { idat *= 2.0; k++; } // Again used here ... for (uint i = 0u; i < 16u; i++, k++) for (uint j = 0u; j < 30u; j++) idat = mvp * idat; do { k++; } while (k > 10); out_data[ident] = idat; } spirv-cross-2021.01.15/shaders/comp/type-alias.comp000066400000000000000000000010311400026215700217040ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; struct S0 { vec4 a; }; struct S1 { vec4 a; }; vec4 overload(S0 s0) { return s0.a; } vec4 overload(S1 s1) { return s1.a; } layout(std430, binding = 0) buffer SSBO0 { S0 s0s[]; }; layout(std430, binding = 1) buffer SSBO1 { S1 s1s[]; }; layout(std430, binding = 2) buffer SSBO2 { vec4 outputs[]; }; void main() { S0 s0 = s0s[gl_GlobalInvocationID.x]; S1 s1 = s1s[gl_GlobalInvocationID.x]; outputs[gl_GlobalInvocationID.x] = overload(s0) + overload(s1); } spirv-cross-2021.01.15/shaders/comp/udiv.comp000066400000000000000000000004201400026215700206040ustar00rootroot00000000000000#version 310 es layout(local_size_x = 1) in; layout(std430, binding = 0) buffer SSBO { uint inputs[]; }; layout(std430, binding = 0) buffer SSBO2 { uint outputs[]; }; void main() { outputs[gl_GlobalInvocationID.x] = inputs[gl_GlobalInvocationID.x] / 29u; } spirv-cross-2021.01.15/shaders/desktop-only/000077500000000000000000000000001400026215700204535ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/desktop-only/comp/000077500000000000000000000000001400026215700214115ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/desktop-only/comp/enhanced-layouts.comp000066400000000000000000000011431400026215700255330ustar00rootroot00000000000000#version 450 struct Foo { int a; int b; int c; }; layout(std140, binding = 0) uniform UBO { layout(offset = 4) int a; layout(offset = 8) int b; layout(offset = 16) Foo foo; layout(offset = 48) int c[8]; } ubo; layout(std140, binding = 1) buffer SSBO1 { layout(offset = 4) int a; layout(offset = 8) int b; layout(offset = 16) Foo foo; layout(offset = 48) int c[8]; } ssbo1; layout(std430, binding = 2) buffer SSBO2 { layout(offset = 4) int a; layout(offset = 8) int b; layout(offset = 16) Foo foo; layout(offset = 48) int c[8]; } ssbo2; void main() { ssbo1.a = ssbo2.a; ssbo1.b = ubo.b; } spirv-cross-2021.01.15/shaders/desktop-only/comp/extended-arithmetic.desktop.comp000066400000000000000000000016461400026215700276770ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(binding = 0, std430) buffer SSBOUint { uint a, b, c, d; uvec2 a2, b2, c2, d2; uvec3 a3, b3, c3, d3; uvec4 a4, b4, c4, d4; } u; layout(binding = 1, std430) buffer SSBOInt { int a, b, c, d; ivec2 a2, b2, c2, d2; ivec3 a3, b3, c3, d3; ivec4 a4, b4, c4, d4; } i; void main() { u.c = uaddCarry(u.a, u.b, u.d); u.c2 = uaddCarry(u.a2, u.b2, u.d2); u.c3 = uaddCarry(u.a3, u.b3, u.d3); u.c4 = uaddCarry(u.a4, u.b4, u.d4); u.c = usubBorrow(u.a, u.b, u.d); u.c2 = usubBorrow(u.a2, u.b2, u.d2); u.c3 = usubBorrow(u.a3, u.b3, u.d3); u.c4 = usubBorrow(u.a4, u.b4, u.d4); umulExtended(u.a, u.b, u.c, u.d); umulExtended(u.a2, u.b2, u.c2, u.d2); umulExtended(u.a3, u.b3, u.c3, u.d3); umulExtended(u.a4, u.b4, u.c4, u.d4); imulExtended(i.a, i.b, i.c, i.d); imulExtended(i.a2, i.b2, i.c2, i.d2); imulExtended(i.a3, i.b3, i.c3, i.d3); imulExtended(i.a4, i.b4, i.c4, i.d4); } spirv-cross-2021.01.15/shaders/desktop-only/comp/fp64.desktop.comp000066400000000000000000000030261400026215700245210ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; struct M0 { double v; dvec2 b[2]; dmat2x3 c; dmat3x2 d; }; // Test buffer layout handling. layout(std430, binding = 0) buffer SSBO0 { dvec4 a; M0 m0; dmat4 b; } ssbo_0; layout(std430, binding = 1) buffer SSBO1 { dmat4 a; dvec4 b; M0 m0; } ssbo_1; layout(std430, binding = 2) buffer SSBO2 { double a[4]; dvec2 b[4]; } ssbo_2; layout(std140, binding = 3) buffer SSBO3 { double a[4]; dvec2 b[4]; } ssbo_3; void main() { ssbo_0.a += dvec4(10, 20, 30, 40); ssbo_0.a += 20; dvec4 a = ssbo_0.a; dmat4 amat = ssbo_0.b; ssbo_0.a = abs(a); ssbo_0.a = sign(a); ssbo_0.a = floor(a); ssbo_0.a = trunc(a); ssbo_0.a = round(a); ssbo_0.a = roundEven(a); ssbo_0.a = ceil(a); ssbo_0.a = fract(a); ssbo_0.a = mod(a, 20.0); ssbo_0.a = mod(a, a); ssbo_0.a = min(a, a); ssbo_0.a = max(a, a); ssbo_0.a = clamp(a, a, a); ssbo_0.a = mix(a, a, a); ssbo_0.a = step(a, a); ssbo_0.a = smoothstep(a, a, a); bvec4 b = isnan(a); bvec4 c = isinf(a); double f = packDouble2x32(uvec2(10, 40)); uvec2 g = unpackDouble2x32(f); double d = length(a); d = distance(a, a); d = dot(a, a); dvec3 e = cross(a.xyz, a.yzw); a = faceforward(a, a, a); a = reflect(a, a); //a = refract(a, a, 1.45); dmat4 l = matrixCompMult(amat, amat); l = outerProduct(a, a); l = transpose(l); double m = determinant(l); l = inverse(l); bvec4 k = lessThan(a, a); k = lessThanEqual(a, a); k = greaterThan(a, a); k = greaterThanEqual(a, a); ssbo_1.b.x += 1.0lf; ssbo_2.b[0].x += 1.0lf; ssbo_3.b[0].x += 1.0lf; } spirv-cross-2021.01.15/shaders/desktop-only/comp/image-formats.desktop.noeliminate.comp000066400000000000000000000042131400026215700307770ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(rgba32f, binding = 0) uniform image2D uImg00; layout(rgba16f, binding = 1) uniform image2D uImg01; layout(rg32f, binding = 2) uniform image2D uImg02; layout(rg16f, binding = 3) uniform image2D uImg03; layout(r11f_g11f_b10f, binding = 4) uniform image2D uImg04; layout(r32f, binding = 5) uniform image2D uImg05; layout(r16f, binding = 6) uniform image2D uImg06; layout(rgba16, binding = 7) uniform image2D uImg07; layout(rgb10_a2, binding = 8) uniform image2D uImg08; layout(rgba8, binding = 9) uniform image2D uImg09; layout(rg16, binding = 10) uniform image2D uImg10; layout(rg8, binding = 11) uniform image2D uImg11; layout(r16, binding = 12) uniform image2D uImg12; layout(r8, binding = 13) uniform image2D uImg13; layout(rgba16_snorm, binding = 14) uniform image2D uImg14; layout(rgba8_snorm, binding = 15) uniform image2D uImg15; layout(rg16_snorm, binding = 16) uniform image2D uImg16; layout(rg8_snorm, binding = 17) uniform image2D uImg17; layout(r16_snorm, binding = 18) uniform image2D uImg18; layout(r8_snorm, binding = 19) uniform image2D uImg19; layout(rgba32i, binding = 20) uniform iimage2D uImage20; layout(rgba16i, binding = 21) uniform iimage2D uImage21; layout(rgba8i, binding = 22) uniform iimage2D uImage22; layout(rg32i, binding = 23) uniform iimage2D uImage23; layout(rg16i, binding = 24) uniform iimage2D uImage24; layout(rg8i, binding = 25) uniform iimage2D uImage25; layout(r32i, binding = 26) uniform iimage2D uImage26; layout(r16i, binding = 27) uniform iimage2D uImage27; layout(r8i, binding = 28) uniform iimage2D uImage28; layout(rgba32ui, binding = 29) uniform uimage2D uImage29; layout(rgba16ui, binding = 30) uniform uimage2D uImage30; layout(rgb10_a2ui, binding = 31) uniform uimage2D uImage31; layout(rgba8ui, binding = 32) uniform uimage2D uImage32; layout(rg32ui, binding = 33) uniform uimage2D uImage33; layout(rg16ui, binding = 34) uniform uimage2D uImage34; layout(rg8ui, binding = 35) uniform uimage2D uImage35; layout(r32ui, binding = 36) uniform uimage2D uImage36; layout(r16ui, binding = 37) uniform uimage2D uImage37; layout(r8ui, binding = 38) uniform uimage2D uImage38; void main() { } spirv-cross-2021.01.15/shaders/desktop-only/comp/int64.desktop.comp000066400000000000000000000016641400026215700247140ustar00rootroot00000000000000#version 450 #extension GL_ARB_gpu_shader_int64 : require layout(local_size_x = 1) in; struct M0 { int64_t v; i64vec2 b[2]; uint64_t c; uint64_t d[5]; }; // Test buffer layout handling. layout(std430, binding = 0) buffer SSBO0 { i64vec4 a; M0 m0; } ssbo_0; layout(std430, binding = 1) buffer SSBO1 { u64vec4 b; M0 m0; } ssbo_1; layout(std430, binding = 2) buffer SSBO2 { int64_t a[4]; i64vec2 b[4]; } ssbo_2; layout(std140, binding = 3) buffer SSBO3 { int64_t a[4]; i64vec2 b[4]; } ssbo_3; void main() { ssbo_0.a += i64vec4(10, 20, 30, 40); ssbo_1.b += u64vec4(999999999999999999ul, 8888888888888888ul, 77777777777777777ul, 6666666666666666ul); ssbo_0.a += 20; ssbo_0.a = abs(ssbo_0.a + i64vec4(ssbo_1.b)); ssbo_0.a++; ssbo_1.b++; ssbo_0.a--; ssbo_1.b--; ssbo_1.b = doubleBitsToUint64(int64BitsToDouble(ssbo_0.a)); ssbo_0.a = doubleBitsToInt64(uint64BitsToDouble(ssbo_1.b)); ssbo_2.a[0] += 1l; ssbo_3.a[0] += 2l; } spirv-cross-2021.01.15/shaders/desktop-only/frag/000077500000000000000000000000001400026215700213725ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/desktop-only/frag/clip-cull-distance.desktop.frag000066400000000000000000000002731400026215700273610ustar00rootroot00000000000000#version 450 in float gl_ClipDistance[4]; in float gl_CullDistance[3]; layout(location = 0) out float FragColor; void main() { FragColor = gl_ClipDistance[0] + gl_CullDistance[0]; } spirv-cross-2021.01.15/shaders/desktop-only/frag/control-dependent-in-branch.desktop.frag000066400000000000000000000014041400026215700311650ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) in vec4 vInput; void main() { FragColor = vInput; vec4 t = texture(uSampler, vInput.xy); vec4 d0 = dFdx(vInput); vec4 d1 = dFdy(vInput); vec4 d2 = fwidth(vInput); vec4 d3 = dFdxCoarse(vInput); vec4 d4 = dFdyCoarse(vInput); vec4 d5 = fwidthCoarse(vInput); vec4 d6 = dFdxFine(vInput); vec4 d7 = dFdyFine(vInput); vec4 d8 = fwidthFine(vInput); vec2 lod = textureQueryLod(uSampler, vInput.zw); if (vInput.y > 10.0) { FragColor += t; FragColor += d0; FragColor += d1; FragColor += d2; FragColor += d3; FragColor += d4; FragColor += d5; FragColor += d6; FragColor += d7; FragColor += d8; FragColor += lod.xyxy; } } spirv-cross-2021.01.15/shaders/desktop-only/frag/depth-greater-than.desktop.frag000066400000000000000000000002021400026215700273600ustar00rootroot00000000000000#version 450 layout(early_fragment_tests) in; layout(depth_greater) out float gl_FragDepth; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/shaders/desktop-only/frag/depth-less-than.desktop.frag000066400000000000000000000001771400026215700267100ustar00rootroot00000000000000#version 450 layout(early_fragment_tests) in; layout(depth_less) out float gl_FragDepth; void main() { gl_FragDepth = 0.5; } spirv-cross-2021.01.15/shaders/desktop-only/frag/dual-source-blending.desktop.frag000066400000000000000000000002731400026215700277100ustar00rootroot00000000000000#version 450 layout(location = 0, index = 0) out vec4 FragColor0; layout(location = 0, index = 1) out vec4 FragColor1; void main() { FragColor0 = vec4(1.0); FragColor1 = vec4(2.0); } spirv-cross-2021.01.15/shaders/desktop-only/frag/hlsl-uav-block-alias.asm.frag000066400000000000000000000044501400026215700267270ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 29 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %Foobar "Foobar" OpMemberName %Foobar 0 "@data" OpName %Foobar_0 "Foobar" OpName %Foobaz "Foobaz" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %_runtimearr_v4float ArrayStride 16 OpMemberDecorate %Foobar 0 Offset 0 OpDecorate %Foobar BufferBlock OpDecorate %Foobar_0 DescriptorSet 0 OpDecorate %Foobar_0 Binding 0 OpDecorate %Foobaz DescriptorSet 0 OpDecorate %Foobaz Binding 1 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %_runtimearr_v4float = OpTypeRuntimeArray %v4float %Foobar = OpTypeStruct %_runtimearr_v4float %_ptr_Uniform_Foobar = OpTypePointer Uniform %Foobar %Foobar_0 = OpVariable %_ptr_Uniform_Foobar Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %Foobaz = OpVariable %_ptr_Uniform_Foobar Uniform %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %28 = OpFunctionCall %v4float %_main_ OpStore %_entryPointOutput %28 OpReturn OpFunctionEnd %_main_ = OpFunction %v4float None %8 %10 = OpLabel %18 = OpAccessChain %_ptr_Uniform_v4float %Foobar_0 %int_0 %int_0 %19 = OpLoad %v4float %18 %21 = OpAccessChain %_ptr_Uniform_v4float %Foobaz %int_0 %int_0 %22 = OpLoad %v4float %21 %23 = OpFAdd %v4float %19 %22 OpReturnValue %23 OpFunctionEnd spirv-cross-2021.01.15/shaders/desktop-only/frag/image-ms.desktop.frag000066400000000000000000000005151400026215700254030ustar00rootroot00000000000000#version 450 layout(rgba8, binding = 0) uniform image2DMS uImage; layout(rgba8, binding = 1) uniform image2DMSArray uImageArray; void main() { vec4 a = imageLoad(uImage, ivec2(1, 2), 2); vec4 b = imageLoad(uImageArray, ivec3(1, 2, 4), 3); imageStore(uImage, ivec2(2, 3), 1, a); imageStore(uImageArray, ivec3(2, 3, 7), 1, b); } spirv-cross-2021.01.15/shaders/desktop-only/frag/image-query.desktop.frag000066400000000000000000000040631400026215700261330ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1D uSampler1D; layout(binding = 1) uniform sampler2D uSampler2D; layout(binding = 2) uniform sampler2DArray uSampler2DArray; layout(binding = 3) uniform sampler3D uSampler3D; layout(binding = 4) uniform samplerCube uSamplerCube; layout(binding = 5) uniform samplerCubeArray uSamplerCubeArray; layout(binding = 6) uniform samplerBuffer uSamplerBuffer; layout(binding = 7) uniform sampler2DMS uSamplerMS; layout(binding = 8) uniform sampler2DMSArray uSamplerMSArray; layout(r32f, binding = 9) uniform image1D uImage1D; layout(r32f, binding = 10) uniform image2D uImage2D; layout(r32f, binding = 11) uniform image2DArray uImage2DArray; layout(r32f, binding = 12) uniform image3D uImage3D; layout(r32f, binding = 13) uniform imageCube uImageCube; layout(r32f, binding = 14) uniform imageCubeArray uImageCubeArray; layout(r32f, binding = 15) uniform imageBuffer uImageBuffer; layout(r32f, binding = 16) uniform image2DMS uImageMS; layout(r32f, binding = 17) uniform image2DMSArray uImageMSArray; void main() { int a = textureSize(uSampler1D, 0); ivec2 b = textureSize(uSampler2D, 0); ivec3 c = textureSize(uSampler2DArray, 0); ivec3 d = textureSize(uSampler3D, 0); ivec2 e = textureSize(uSamplerCube, 0); ivec3 f = textureSize(uSamplerCubeArray, 0); int g = textureSize(uSamplerBuffer); ivec2 h = textureSize(uSamplerMS); ivec3 i = textureSize(uSamplerMSArray); int l0 = textureQueryLevels(uSampler1D); int l1 = textureQueryLevels(uSampler2D); int l2 = textureQueryLevels(uSampler2DArray); int l3 = textureQueryLevels(uSampler3D); int l4 = textureQueryLevels(uSamplerCube); int l5 = textureQueryLevels(uSamplerCubeArray); a = imageSize(uImage1D); b = imageSize(uImage2D); c = imageSize(uImage2DArray); d = imageSize(uImage3D); e = imageSize(uImageCube); f = imageSize(uImageCubeArray); g = imageSize(uImageBuffer); h = imageSize(uImageMS); i = imageSize(uImageMSArray); int s0 = textureSamples(uSamplerMS); int s1 = textureSamples(uSamplerMSArray); int s2 = imageSamples(uImageMS); int s3 = imageSamples(uImageMSArray); } spirv-cross-2021.01.15/shaders/desktop-only/frag/image-size.frag000066400000000000000000000003731400026215700242700ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(r32f, set = 0, binding = 0) uniform image2D uImage1; layout(r32f, set = 0, binding = 1) uniform image2D uImage2; void main() { FragColor = vec4(imageSize(uImage1), imageSize(uImage2)); } spirv-cross-2021.01.15/shaders/desktop-only/frag/image-size.no-qualifier-deduction.frag000066400000000000000000000003731400026215700306360ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(r32f, set = 0, binding = 0) uniform image2D uImage1; layout(r32f, set = 0, binding = 1) uniform image2D uImage2; void main() { FragColor = vec4(imageSize(uImage1), imageSize(uImage2)); } spirv-cross-2021.01.15/shaders/desktop-only/frag/in-block-qualifiers.frag000066400000000000000000000006231400026215700260740ustar00rootroot00000000000000#version 450 layout(location = 0) in VertexData { flat float f; centroid vec4 g; flat int h; float i; } vin; layout(location = 4) in flat float f; layout(location = 5) in centroid vec4 g; layout(location = 6) in flat int h; layout(location = 7) in sample float i; layout(location = 0) out vec4 FragColor; void main() { FragColor = vin.f + vin.g + float(vin.h) + vin.i + f + g + float(h) + i; } spirv-cross-2021.01.15/shaders/desktop-only/frag/layout-component.desktop.frag000066400000000000000000000004051400026215700272170ustar00rootroot00000000000000#version 450 layout(location = 0, component = 0) in vec2 v0; layout(location = 0, component = 2) in float v1; layout(location = 0) out vec2 FragColor; in Vertex { layout(location = 1, component = 2) in float v3; }; void main() { FragColor = v0 + v1 + v3; } spirv-cross-2021.01.15/shaders/desktop-only/frag/query-levels.desktop.frag000066400000000000000000000002511400026215700263360ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(textureQueryLevels(uSampler)); } spirv-cross-2021.01.15/shaders/desktop-only/frag/query-lod.desktop.frag000066400000000000000000000003301400026215700256200ustar00rootroot00000000000000#version 450 layout(location = 0) in vec2 vTexCoord; layout(binding = 0) uniform sampler2D uSampler; layout(location = 0) out vec4 FragColor; void main() { FragColor = textureQueryLod(uSampler, vTexCoord).xyxy; } spirv-cross-2021.01.15/shaders/desktop-only/frag/sampler-ms-query.desktop.frag000066400000000000000000000006711400026215700271320ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2DMS uSampler; layout(binding = 1) uniform sampler2DMSArray uSamplerArray; layout(rgba8, binding = 2) uniform image2DMS uImage; layout(rgba8, binding = 3) uniform image2DMSArray uImageArray; void main() { FragColor = vec4( textureSamples(uSampler) + textureSamples(uSamplerArray) + imageSamples(uImage) + imageSamples(uImageArray)); } spirv-cross-2021.01.15/shaders/desktop-only/frag/stencil-export.desktop.frag000066400000000000000000000003521400026215700266630ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_stencil_export : require layout(location = 0) out vec4 MRT0; layout(location = 1) out vec4 MRT1; void main() { MRT0 = vec4(1.0); MRT1 = vec4(1.0, 0.0, 1.0, 1.0); gl_FragStencilRefARB = 100; } spirv-cross-2021.01.15/shaders/desktop-only/frag/texture-proj-shadow.desktop.frag000066400000000000000000000012471400026215700276420ustar00rootroot00000000000000#version 450 layout(binding = 0) uniform sampler1DShadow uShadow1D; layout(binding = 1) uniform sampler2DShadow uShadow2D; layout(binding = 2) uniform sampler1D uSampler1D; layout(binding = 3) uniform sampler2D uSampler2D; layout(binding = 4) uniform sampler3D uSampler3D; layout(location = 0) out float FragColor; layout(location = 0) in vec3 vClip3; layout(location = 1) in vec4 vClip4; layout(location = 2) in vec2 vClip2; void main() { FragColor = textureProj(uShadow1D, vClip4); FragColor = textureProj(uShadow2D, vClip4); FragColor = textureProj(uSampler1D, vClip2).x; FragColor = textureProj(uSampler2D, vClip3).x; FragColor = textureProj(uSampler3D, vClip4).x; } spirv-cross-2021.01.15/shaders/desktop-only/geom/000077500000000000000000000000001400026215700214025ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/desktop-only/geom/basic.desktop.sso.geom000066400000000000000000000012561400026215700256130ustar00rootroot00000000000000#version 450 layout(triangles, invocations = 4) in; layout(triangle_strip, max_vertices = 3) out; in gl_PerVertex { vec4 gl_Position; } gl_in[]; out gl_PerVertex { vec4 gl_Position; }; layout(location = 0) in VertexData { vec3 normal; } vin[]; layout(location = 0) out vec3 vNormal; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal + float(gl_InvocationID); EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal + 4.0 * float(gl_InvocationID); EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal + 2.0 * float(gl_InvocationID); EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/shaders/desktop-only/geom/viewport-index.desktop.geom000066400000000000000000000002071400026215700267060ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(triangle_strip) out; layout(max_vertices = 4) out; void main() { gl_ViewportIndex = 1; } spirv-cross-2021.01.15/shaders/desktop-only/tesc/000077500000000000000000000000001400026215700214115ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/desktop-only/tesc/basic.desktop.sso.tesc000066400000000000000000000010161400026215700256230ustar00rootroot00000000000000#version 450 layout(vertices = 1) out; in gl_PerVertex { vec4 gl_Position; } gl_in[gl_MaxPatchVertices]; out gl_PerVertex { vec4 gl_Position; } gl_out[1]; layout(location = 0) patch out vec3 vFoo; void main() { gl_TessLevelInner[0] = 8.9; gl_TessLevelInner[1] = 6.9; gl_TessLevelOuter[0] = 8.9; gl_TessLevelOuter[1] = 6.9; gl_TessLevelOuter[2] = 3.9; gl_TessLevelOuter[3] = 4.9; vFoo = vec3(1.0); gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position; } spirv-cross-2021.01.15/shaders/desktop-only/tese/000077500000000000000000000000001400026215700214135ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/desktop-only/tese/triangle.desktop.sso.tese000066400000000000000000000005371400026215700263620ustar00rootroot00000000000000#version 450 layout(cw, triangles, fractional_even_spacing) in; in gl_PerVertex { vec4 gl_Position; } gl_in[gl_MaxPatchVertices]; out gl_PerVertex { vec4 gl_Position; }; void main() { gl_Position = gl_in[0].gl_Position * gl_TessCoord.x + gl_in[1].gl_Position * gl_TessCoord.y + gl_in[2].gl_Position * gl_TessCoord.z; } spirv-cross-2021.01.15/shaders/desktop-only/vert/000077500000000000000000000000001400026215700214335ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/desktop-only/vert/basic.desktop.sso.vert000066400000000000000000000004461400026215700256750ustar00rootroot00000000000000#version 450 out gl_PerVertex { vec4 gl_Position; }; layout(std140) uniform UBO { mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders/desktop-only/vert/clip-cull-distance.desktop.sso.vert000066400000000000000000000003731400026215700302670ustar00rootroot00000000000000#version 450 out float gl_ClipDistance[4]; out float gl_CullDistance[3]; void main() { gl_Position = vec4(1.0); gl_ClipDistance[0] = 0.0; gl_ClipDistance[1] = 0.0; gl_ClipDistance[2] = 0.0; gl_ClipDistance[3] = 0.0; gl_CullDistance[1] = 4.0; } spirv-cross-2021.01.15/shaders/desktop-only/vert/clip-cull-distance.desktop.vert000066400000000000000000000003731400026215700274640ustar00rootroot00000000000000#version 450 out float gl_ClipDistance[4]; out float gl_CullDistance[3]; void main() { gl_Position = vec4(1.0); gl_ClipDistance[0] = 0.0; gl_ClipDistance[1] = 0.0; gl_ClipDistance[2] = 0.0; gl_ClipDistance[3] = 0.0; gl_CullDistance[1] = 4.0; } spirv-cross-2021.01.15/shaders/desktop-only/vert/out-block-qualifiers.vert000066400000000000000000000006231400026215700263770ustar00rootroot00000000000000#version 450 layout(location = 0) out VertexData { flat float f; centroid vec4 g; flat int h; float i; } vout; layout(location = 4) out flat float f; layout(location = 5) out centroid vec4 g; layout(location = 6) out flat int h; layout(location = 7) out float i; void main() { vout.f = 10.0; vout.g = vec4(20.0); vout.h = 20; vout.i = 30.0; f = 10.0; g = vec4(20.0); h = 20; i = 30.0; } spirv-cross-2021.01.15/shaders/desktop-only/vert/shader-draw-parameters-450.desktop.vk.vert000066400000000000000000000003141400026215700312720ustar00rootroot00000000000000#version 450 #extension GL_ARB_shader_draw_parameters : enable out gl_PerVertex { vec4 gl_Position; }; void main() { gl_Position = vec4(gl_BaseVertexARB, gl_BaseInstanceARB, gl_DrawIDARB, 1); } spirv-cross-2021.01.15/shaders/desktop-only/vert/shader-draw-parameters.desktop.vk.vert000066400000000000000000000002211400026215700307610ustar00rootroot00000000000000#version 460 out gl_PerVertex { vec4 gl_Position; }; void main() { gl_Position = vec4(gl_BaseVertex, gl_BaseInstance, gl_DrawID, 1); } spirv-cross-2021.01.15/shaders/flatten/000077500000000000000000000000001400026215700174605ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/flatten/array.flatten.vert000066400000000000000000000005731400026215700231410ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { vec4 A4[5][4][2]; mat4 uMVP; vec4 A1[2]; vec4 A2[2][3]; float A3[3]; vec4 Offset; }; layout(location = 0) in vec4 aVertex; void main() { vec4 a4 = A4[2][3][1]; // 2 * (4 * 2) + 3 * 2 + 1 = 16 + 6 + 1 = 23. vec4 offset = A2[1][1] + A1[1] + A3[2]; gl_Position = uMVP * aVertex + Offset + offset; } spirv-cross-2021.01.15/shaders/flatten/basic.flatten.vert000066400000000000000000000003761400026215700231050ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders/flatten/copy.flatten.vert000066400000000000000000000011171400026215700227700ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; layout(std140) uniform UBO { mat4 uMVP; Light lights[4]; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec4 vColor; void main() { gl_Position = uMVP * aVertex; vColor = vec4(0.0); for (int i = 0; i < 4; ++i) { Light light = lights[i]; vec3 L = aVertex.xyz - light.Position; vColor += dot(aNormal, normalize(L)) * (clamp(1.0 - length(L) / light.Radius, 0.0, 1.0) * lights[i].Color); } } spirv-cross-2021.01.15/shaders/flatten/dynamic.flatten.vert000066400000000000000000000010661400026215700234450ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; layout(std140) uniform UBO { mat4 uMVP; Light lights[4]; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec4 vColor; void main() { gl_Position = uMVP * aVertex; vColor = vec4(0.0); for (int i = 0; i < 4; ++i) { vec3 L = aVertex.xyz - lights[i].Position; vColor += dot(aNormal, normalize(L)) * (clamp(1.0 - length(L) / lights[i].Radius, 0.0, 1.0) * lights[i].Color); } } spirv-cross-2021.01.15/shaders/flatten/matrix-conversion.flatten.frag000066400000000000000000000003451400026215700254460ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec3 FragColor; layout(location = 0) flat in vec3 vNormal; layout(binding = 0, std140) uniform UBO { mat4 m; }; void main() { FragColor = mat3(m) * vNormal; } spirv-cross-2021.01.15/shaders/flatten/matrixindex.flatten.vert000066400000000000000000000010011400026215700243420ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { layout(column_major) mat4 M1C; layout(row_major) mat4 M1R; layout(column_major) mat2x4 M2C; layout(row_major) mat2x4 M2R; }; layout(location = 0) out vec4 oA; layout(location = 1) out vec4 oB; layout(location = 2) out vec4 oC; layout(location = 3) out vec4 oD; layout(location = 4) out vec4 oE; void main() { gl_Position = vec4(0.0); oA = M1C[1]; oB = M1R[1]; oC = M2C[1]; oD = M2R[0]; oE = vec4(M1C[1][2], M1R[1][2], M2C[1][2], M2R[1][2]); } spirv-cross-2021.01.15/shaders/flatten/multiindex.flatten.vert000066400000000000000000000002521400026215700241770ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { vec4 Data[3][5]; }; layout(location = 0) in ivec2 aIndex; void main() { gl_Position = Data[aIndex.x][aIndex.y]; } spirv-cross-2021.01.15/shaders/flatten/push-constant.flatten.vert000066400000000000000000000006611400026215700246270ustar00rootroot00000000000000#version 310 es layout(push_constant, std430) uniform PushMe { mat4 MVP; mat2 Rot; // The MatrixStride will be 8 here. float Arr[4]; } registers; layout(location = 0) in vec2 Rot; layout(location = 1) in vec4 Pos; layout(location = 0) out vec2 vRot; void main() { gl_Position = registers.MVP * Pos; vRot = registers.Rot * Rot + registers.Arr[2]; // Constant access should work even if array stride is just 4 here. } spirv-cross-2021.01.15/shaders/flatten/rowmajor.flatten.vert000066400000000000000000000004371400026215700236620ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { layout(column_major) mat4 uMVPR; layout(row_major) mat4 uMVPC; layout(row_major) mat2x4 uMVP; }; layout(location = 0) in vec4 aVertex; void main() { vec2 v = aVertex * uMVP; gl_Position = uMVPR * aVertex + uMVPC * aVertex; } spirv-cross-2021.01.15/shaders/flatten/struct.flatten.vert000066400000000000000000000007621400026215700233470ustar00rootroot00000000000000#version 310 es struct Light { vec3 Position; float Radius; vec4 Color; }; layout(std140) uniform UBO { mat4 uMVP; Light light; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec4 vColor; void main() { gl_Position = uMVP * aVertex; vColor = vec4(0.0); vec3 L = aVertex.xyz - light.Position; vColor += dot(aNormal, normalize(L)) * (clamp(1.0 - length(L) / light.Radius, 0.0, 1.0) * light.Color); } spirv-cross-2021.01.15/shaders/flatten/struct.rowmajor.flatten.vert000066400000000000000000000005751400026215700252100ustar00rootroot00000000000000#version 310 es struct Foo { mat3x4 MVP0; mat3x4 MVP1; }; layout(std140, binding = 0) uniform UBO { layout(row_major) Foo foo; }; layout(location = 0) in vec4 v0; layout(location = 1) in vec4 v1; layout(location = 0) out vec3 V0; layout(location = 1) out vec3 V1; void main() { Foo f = foo; vec3 a = v0 * f.MVP0; vec3 b = v1 * f.MVP1; V0 = a; V1 = b; } spirv-cross-2021.01.15/shaders/flatten/swizzle.flatten.vert000066400000000000000000000016771400026215700235400ustar00rootroot00000000000000#version 310 es // comments note the 16b alignment boundaries (see GL spec 7.6.2.2 Standard Uniform Block Layout) layout(std140, binding = 0) uniform UBO { // 16b boundary vec4 A; // 16b boundary vec2 B0; vec2 B1; // 16b boundary float C0; // 16b boundary (vec3 is aligned to 16b) vec3 C1; // 16b boundary vec3 D0; float D1; // 16b boundary float E0; float E1; float E2; float E3; // 16b boundary float F0; vec2 F1; // 16b boundary (vec2 before us is aligned to 8b) float F2; }; layout(location = 0) out vec4 oA; layout(location = 1) out vec4 oB; layout(location = 2) out vec4 oC; layout(location = 3) out vec4 oD; layout(location = 4) out vec4 oE; layout(location = 5) out vec4 oF; void main() { gl_Position = vec4(0.0); oA = A; oB = vec4(B0, B1); oC = vec4(C0, C1); oD = vec4(D0, D1); oE = vec4(E0, E1, E2, E3); oF = vec4(F0, F1, F2); } spirv-cross-2021.01.15/shaders/flatten/types.flatten.frag000066400000000000000000000005661400026215700231300ustar00rootroot00000000000000#version 310 es precision mediump float; layout(std140, binding = 0) uniform UBO0 { vec4 a; vec4 b; }; layout(std140, binding = 0) uniform UBO1 { ivec4 c; ivec4 d; }; layout(std140, binding = 0) uniform UBO2 { uvec4 e; uvec4 f; }; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(c) + vec4(d) + vec4(e) + vec4(f) + a + b; } spirv-cross-2021.01.15/shaders/frag/000077500000000000000000000000001400026215700167425ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/frag/array-lut-no-loop-variable.frag000066400000000000000000000003571400026215700246740ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 v0; void main() { float lut[5] = float[](1.0, 2.0, 3.0, 4.0, 5.0); for (int i = 0; i < 4; i++, FragColor += lut[i]) { } } spirv-cross-2021.01.15/shaders/frag/avoid-expression-lowering-to-loop.frag000066400000000000000000000007061400026215700263200ustar00rootroot00000000000000#version 310 es precision mediump float; precision mediump int; layout(binding = 0) uniform mediump sampler2D tex; layout(binding = 1) uniform Count { float count; }; layout(location = 0) in highp vec4 vertex; layout(location = 0) out vec4 fragColor; void main() { highp float size = 1.0 / float(textureSize(tex, 0).x); float r = 0.0; float d = dFdx(vertex.x); for (float i = 0.0; i < count ; i += 1.0) r += size * d; fragColor = vec4(r); } spirv-cross-2021.01.15/shaders/frag/barycentric-nv.frag000066400000000000000000000010061400026215700225260ustar00rootroot00000000000000#version 450 #extension GL_NV_fragment_shader_barycentric : require layout(location = 0) out vec2 value; layout(set = 0, binding = 0) readonly buffer Vertices { vec2 uvs[]; }; void main () { int prim = gl_PrimitiveID; vec2 uv0 = uvs[3 * prim + 0]; vec2 uv1 = uvs[3 * prim + 1]; vec2 uv2 = uvs[3 * prim + 2]; value = gl_BaryCoordNV.x * uv0 + gl_BaryCoordNV.y * uv1 + gl_BaryCoordNV.z * uv2; value += gl_BaryCoordNoPerspNV.x * uv0 + gl_BaryCoordNoPerspNV.y * uv1 + gl_BaryCoordNoPerspNV.z * uv2; } spirv-cross-2021.01.15/shaders/frag/basic.frag000066400000000000000000000004071400026215700206650ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; layout(binding = 0) uniform sampler2D uTex; layout(location = 0) out vec4 FragColor; void main() { FragColor = vColor * texture(uTex, vTex); } spirv-cross-2021.01.15/shaders/frag/complex-expression-in-access-chain.frag000066400000000000000000000007651400026215700264020ustar00rootroot00000000000000#version 310 es precision mediump float; struct Foo { vec4 a; vec4 b; }; layout(binding = 0) buffer UBO { vec4 results[1024]; }; layout(binding = 1) uniform highp isampler2D Buf; layout(location = 0) flat in int vIn; layout(location = 1) flat in int vIn2; layout(location = 0) out vec4 FragColor; void main() { ivec4 coords = texelFetch(Buf, ivec2(gl_FragCoord.xy), 0); vec4 foo = results[coords.x % 16]; int c = vIn * vIn; int d = vIn2 * vIn2; FragColor = foo + foo + results[c + d]; } spirv-cross-2021.01.15/shaders/frag/composite-extract-forced-temporary.frag000066400000000000000000000003761400026215700265430ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 0) uniform sampler2D Texture; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTexCoord; void main() { float f = texture(Texture, vTexCoord).x; FragColor = vec4(f * f); } spirv-cross-2021.01.15/shaders/frag/constant-array.frag000066400000000000000000000011071400026215700225470ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in int index; struct Foobar { float a; float b; }; vec4 resolve(Foobar f) { return vec4(f.a + f.b); } void main() { const vec4 foo[3] = vec4[](vec4(1.0), vec4(2.0), vec4(3.0)); const vec4 foobars[2][2] = vec4[][](vec4[](vec4(1.0), vec4(2.0)), vec4[](vec4(8.0), vec4(10.0))); const Foobar foos[2] = Foobar[](Foobar(10.0, 40.0), Foobar(90.0, 70.0)); FragColor = foo[index] + foobars[index][index + 1] + resolve(Foobar(10.0, 20.0)) + resolve(foos[index]); } spirv-cross-2021.01.15/shaders/frag/constant-composites.frag000066400000000000000000000005461400026215700236240ustar00rootroot00000000000000#version 310 es precision mediump float; float lut[4] = float[](1.0, 4.0, 3.0, 2.0); struct Foo { float a; float b; }; Foo foos[2] = Foo[](Foo(10.0, 20.0), Foo(30.0, 40.0)); layout(location = 0) out vec4 FragColor; layout(location = 0) flat in int line; void main() { FragColor = vec4(lut[line]); FragColor += foos[line].a * foos[1 - line].a; } spirv-cross-2021.01.15/shaders/frag/false-loop-init.frag000066400000000000000000000004261400026215700226070ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 accum; layout(location = 0) out vec4 result; void main() { result = vec4(0.0); uint j; for (int i = 0; i < 4; i += int(j)) { if (accum.y > 10.0) j = 40u; else j = 30u; result += accum; } } spirv-cross-2021.01.15/shaders/frag/flush_params.frag000066400000000000000000000004331400026215700222670ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; struct Structy { vec4 c; }; void foo2(out Structy f) { f.c = vec4(10.0); } Structy foo() { Structy f; foo2(f); return f; } void main() { Structy s = foo(); FragColor = s.c; } spirv-cross-2021.01.15/shaders/frag/for-loop-continue-control-flow.frag000066400000000000000000000002711400026215700256050ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(0.0); for (int i = 0; i < 3; (0 > 1) ? 1 : i ++) { int a = i; FragColor[a] += float(i); } } spirv-cross-2021.01.15/shaders/frag/for-loop-init.frag000066400000000000000000000017621400026215700223070ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out int FragColor; void main() { FragColor = 16; // Basic loop variable. for (int i = 0; i < 25; i++) FragColor += 10; // Multiple loop variables. for (int i = 1, j = 4; i < 30; i++, j += 4) FragColor += 11; // A potential loop variables, but we access it outside the loop, // so cannot be one. int k = 0; for (; k < 20; k++) FragColor += 12; k += 3; FragColor += k; // Potential loop variables, but the dominator is not trivial. int l; if (k == 40) { for (l = 0; l < 40; l++) FragColor += 13; return; } else { l = k; FragColor += l; } // Vectors cannot be loop variables for (ivec2 i = ivec2(0); i.x < 10; i.x += 4) { FragColor += i.y; } // Check that static expressions can be used before the loop header. int m = 0; m = k; int o = m; for (; m < 40; m++) FragColor += m; FragColor += o; } spirv-cross-2021.01.15/shaders/frag/frexp-modf.frag000066400000000000000000000006121400026215700216510ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out float FragColor; layout(location = 0) in float v0; layout(location = 1) in vec2 v1; void main() { int e0; float f0 = frexp(v0, e0); f0 = frexp(v0 + 1.0, e0); ivec2 e1; vec2 f1 = frexp(v1, e1); float r0; float m0 = modf(v0, r0); vec2 r1; vec2 m1 = modf(v1, r1); FragColor = f0 + f1.x + f1.y + m0 + m1.x + m1.y; } spirv-cross-2021.01.15/shaders/frag/front-facing.frag000066400000000000000000000003451400026215700221620ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vA; layout(location = 1) in vec4 vB; void main() { if (gl_FrontFacing) FragColor = vA; else FragColor = vB; } spirv-cross-2021.01.15/shaders/frag/gather-dref.frag000066400000000000000000000003551400026215700217760ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 0) uniform mediump sampler2DShadow uT; layout(location = 0) in vec3 vUV; layout(location = 0) out vec4 FragColor; void main() { FragColor = textureGather(uT, vUV.xy, vUV.z); } spirv-cross-2021.01.15/shaders/frag/ground.frag000077500000000000000000000121521400026215700211050ustar00rootroot00000000000000#version 310 es precision mediump float; #define DEBUG_NONE 0 #define DEBUG_DIFFUSE 1 #define DEBUG_SPECULAR 2 #define DEBUG_LIGHTING 3 #define DEBUG_FOG 4 #define DEBUG DEBUG_NONE #define FORWARD 0 #define DEFERRED 1 #define DEFERRED_VTEX 2 float saturate(float x) { return clamp(x, 0.0, 1.0); } layout(std140, binding = 4) uniform GlobalPSData { vec4 g_CamPos; vec4 g_SunDir; vec4 g_SunColor; vec4 g_ResolutionParams; vec4 g_TimeParams; vec4 g_FogColor_Distance; }; vec4 ComputeFogFactor(vec3 WorldPos) { vec4 FogData; vec3 vEye = WorldPos - g_CamPos.xyz; vec3 nEye = normalize(vEye); FogData.w = exp(-dot(vEye, vEye) * g_FogColor_Distance.w * 0.75); float fog_sun_factor = pow(saturate(dot(nEye, g_SunDir.xyz)), 8.0); FogData.xyz = mix(vec3(1.0, 1.0, 1.0), vec3(0.6, 0.6, 0.9), nEye.y * 0.5 + 0.5); FogData.xyz = mix(FogData.xyz, vec3(0.95, 0.87, 0.78), fog_sun_factor); return FogData; } void ApplyFog(inout vec3 Color, vec4 FogData) { Color = mix(FogData.xyz, Color, FogData.w); } void ApplyLighting(inout mediump vec3 Color, mediump float DiffuseFactor) { mediump vec3 DiffuseLight = g_SunColor.xyz * DiffuseFactor; mediump vec3 AmbientLight = vec3(0.2, 0.35, 0.55) * 0.5; mediump vec3 Lighting = DiffuseLight + AmbientLight; #if DEBUG == DEBUG_LIGHTING Color = Lighting; #else Color *= Lighting; #endif } #define SPECULAR 0 #define GLOSSMAP 0 void ApplySpecular(inout mediump vec3 Color, mediump vec3 EyeVec, mediump vec3 Normal, mediump vec3 SpecularColor, mediump float Shininess, mediump float FresnelAmount) { mediump vec3 HalfAngle = normalize(-EyeVec + g_SunDir.xyz); mediump float v_dot_h = saturate(dot(HalfAngle, -EyeVec)); mediump float n_dot_l = saturate(dot(Normal, g_SunDir.xyz)); mediump float n_dot_h = saturate(dot(Normal, HalfAngle)); mediump float n_dot_v = saturate(dot(-EyeVec, Normal)); mediump float h_dot_l = saturate(dot(g_SunDir.xyz, HalfAngle)); const mediump float roughness_value = 0.25; mediump float r_sq = roughness_value * roughness_value; mediump float n_dot_h_sq = n_dot_h * n_dot_h; mediump float roughness_a = 1.0 / (4.0 * r_sq * n_dot_h_sq * n_dot_h_sq); mediump float roughness_b = n_dot_h_sq - 1.0; mediump float roughness_c = r_sq * n_dot_h_sq; mediump float roughness = saturate(roughness_a * exp(roughness_b / roughness_c)); FresnelAmount = 0.5; mediump float fresnel_term = pow(1.0 - n_dot_v, 5.0) * (1.0 - FresnelAmount) + FresnelAmount; mediump float geo_numerator = 2.0 * n_dot_h; mediump float geo_denominator = 1.0 / v_dot_h; mediump float geo_term = min(1.0, min(n_dot_v, n_dot_l) * geo_numerator * geo_denominator); #if SPECULAR || GLOSSMAP Color += SpecularColor * g_SunColor.xyz * fresnel_term * roughness * n_dot_l * geo_term / (n_dot_v * n_dot_l + 0.0001); #endif //Color = vec3(0.025 * 1.0 / (n_dot_v * n_dot_l)); } layout(location = 0) in vec2 TexCoord; layout(location = 1) in vec3 EyeVec; layout(binding = 2) uniform sampler2D TexNormalmap; //layout(binding = 3) uniform sampler2D TexScatteringLUT; #define DIFFUSE_ONLY 0 #define GLOBAL_RENDERER DEFERRED #define OUTPUT_FEEDBACK_TEXTURE 0 #if DIFFUSE_ONLY layout(location = 0) out vec4 ColorOut; layout(location = 1) out vec4 NormalOut; #else layout(location = 0) out vec4 AlbedoOut; layout(location = 1) out vec4 SpecularOut; layout(location = 2) out vec4 NormalOut; layout(location = 3) out vec4 LightingOut; #endif void Resolve(vec3 Albedo, vec3 Normal, float Roughness, float Metallic) { #if (GLOBAL_RENDERER == FORWARD) || OUTPUT_FEEDBACK_TEXTURE float Lighting = saturate(dot(Normal, normalize(vec3(1.0, 0.5, 1.0)))); ColorOut.xyz = Albedo * Lighting; ColorOut.w = 1.0; #elif DIFFUSE_ONLY ColorOut = vec4(Albedo, 0.0); NormalOut.xyz = Normal * 0.5 + 0.5; NormalOut.w = 1.0; // linearize and map to 0..255 range ColorOut.w = -0.003921569 / (gl_FragCoord.z - 1.003921569); ColorOut.w = log2(1.0 + saturate(length(EyeVec.xyz) / 200.0)); ColorOut.w -= 1.0 / 255.0; #else LightingOut = vec4(0.0); NormalOut = vec4(Normal * 0.5 + 0.5, 0.0); SpecularOut = vec4(Roughness, Metallic, 0.0, 0.0); AlbedoOut = vec4(Albedo, 1.0); #endif } void main() { vec3 Normal = texture(TexNormalmap, TexCoord).xyz * 2.0 - 1.0; Normal = normalize(Normal); vec2 scatter_uv; scatter_uv.x = saturate(length(EyeVec) / 1000.0); vec3 nEye = normalize(EyeVec); scatter_uv.y = 0.0; //nEye.x * 0.5 + 0.5; vec3 Color = vec3(0.1, 0.3, 0.1); vec3 grass = vec3(0.1, 0.3, 0.1); vec3 dirt = vec3(0.1, 0.1, 0.1); vec3 snow = vec3(0.8, 0.8, 0.8); float grass_snow = smoothstep(0.0, 0.15, (g_CamPos.y + EyeVec.y) / 200.0); vec3 base = mix(grass, snow, grass_snow); float edge = smoothstep(0.7, 0.75, Normal.y); Color = mix(dirt, base, edge); Color *= Color; float Roughness = 1.0 - edge * grass_snow; Resolve(Color, Normal, Roughness, 0.0); } spirv-cross-2021.01.15/shaders/frag/helper-invocation.frag000066400000000000000000000005261400026215700232340ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vUV; layout(binding = 0) uniform sampler2D uSampler; vec4 foo() { vec4 color; if (!gl_HelperInvocation) color = textureLod(uSampler, vUV, 0.0); else color = vec4(1.0); return color; } void main() { FragColor = foo(); } spirv-cross-2021.01.15/shaders/frag/hoisted-temporary-use-continue-block-as-value.frag000066400000000000000000000005541400026215700305050ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) flat in int vA; layout(location = 1) flat in int vB; void main() { FragColor = vec4(0.0); int k = 0; int j; for (int i = 0; i < vA; i += j) { if ((vA + i) == 20) k = 50; else if ((vB + i) == 40) k = 60; j = k + 10; FragColor += 1.0; } } spirv-cross-2021.01.15/shaders/frag/image-load-store-uint-coord.asm.frag000066400000000000000000000103761400026215700256030ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 2 ; Bound: 63 ; Schema: 0 OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %_main_ "@main(" OpName %storeTemp "storeTemp" OpName %RWIm "RWIm" OpName %v "v" OpName %RWBuf "RWBuf" OpName %ROIm "ROIm" OpName %ROBuf "ROBuf" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %RWIm DescriptorSet 0 OpDecorate %RWIm Binding 1 OpDecorate %RWBuf DescriptorSet 0 OpDecorate %RWBuf Binding 0 OpDecorate %ROIm DescriptorSet 0 OpDecorate %ROIm Binding 1 OpDecorate %ROBuf DescriptorSet 0 OpDecorate %ROBuf Binding 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %float_10 = OpConstant %float 10 %float_0_5 = OpConstant %float 0.5 %float_8 = OpConstant %float 8 %float_2 = OpConstant %float 2 %17 = OpConstantComposite %v4float %float_10 %float_0_5 %float_8 %float_2 %18 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %RWIm = OpVariable %_ptr_UniformConstant_18 UniformConstant %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %uint_10 = OpConstant %uint 10 %25 = OpConstantComposite %v2uint %uint_10 %uint_10 %uint_30 = OpConstant %uint 30 %30 = OpConstantComposite %v2uint %uint_30 %uint_30 %32 = OpTypeImage %float Buffer 0 0 0 2 Rgba32f %_ptr_UniformConstant_32 = OpTypePointer UniformConstant %32 %RWBuf = OpVariable %_ptr_UniformConstant_32 UniformConstant %uint_80 = OpConstant %uint 80 %38 = OpTypeImage %float 2D 0 0 0 1 Unknown %SampledImage = OpTypeSampledImage %38 %_ptr_UniformConstant_38 = OpTypePointer UniformConstant %SampledImage %ROIm = OpVariable %_ptr_UniformConstant_38 UniformConstant %uint_50 = OpConstant %uint 50 %uint_60 = OpConstant %uint 60 %44 = OpConstantComposite %v2uint %uint_50 %uint_60 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %50 = OpTypeImage %float Buffer 0 0 0 1 Rgba32f %_ptr_UniformConstant_50 = OpTypePointer UniformConstant %50 %ROBuf = OpVariable %_ptr_UniformConstant_50 UniformConstant %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %62 = OpFunctionCall %v4float %_main_ OpStore %_entryPointOutput %62 OpReturn OpFunctionEnd %_main_ = OpFunction %v4float None %8 %10 = OpLabel %storeTemp = OpVariable %_ptr_Function_v4float Function %v = OpVariable %_ptr_Function_v4float Function OpStore %storeTemp %17 %21 = OpLoad %18 %RWIm %26 = OpLoad %v4float %storeTemp OpImageWrite %21 %25 %26 %28 = OpLoad %18 %RWIm %31 = OpImageRead %v4float %28 %30 OpStore %v %31 %35 = OpLoad %32 %RWBuf %37 = OpLoad %v4float %v OpImageWrite %35 %uint_80 %37 %41 = OpLoad %SampledImage %ROIm %ROImage = OpImage %38 %41 %47 = OpImageFetch %v4float %ROImage %44 Lod %int_0 %48 = OpLoad %v4float %v %49 = OpFAdd %v4float %48 %47 OpStore %v %49 %53 = OpLoad %50 %ROBuf %54 = OpImageFetch %v4float %53 %uint_80 %55 = OpLoad %v4float %v %56 = OpFAdd %v4float %55 %54 OpStore %v %56 %57 = OpLoad %v4float %v OpReturnValue %57 OpFunctionEnd spirv-cross-2021.01.15/shaders/frag/inside-loop-dominated-variable-preservation.frag000066400000000000000000000005201400026215700302660ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; void main() { float v; bool written = false; for (int j = 0; j < 10; j++) { for (int i = 0; i < 4; i++) { float w = 0.0; if (written) w += v; else v = 20.0; v += float(i); written = true; } } FragColor = vec4(1.0); } spirv-cross-2021.01.15/shaders/frag/loop-dominator-and-switch-default.frag000066400000000000000000000011171400026215700262270ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 fragColor; void main() { vec4 f4; int c = int(f4.x); for (int j = 0; j < c; j++) { switch (c) { case 0: f4.y = 0.0; break; case 1: f4.y = 1.0; break; default: { int i = 0; while (i++ < c) { f4.y += 0.5; } continue; } } f4.y += 0.5; } fragColor = f4; } spirv-cross-2021.01.15/shaders/frag/lut-promotion.frag000066400000000000000000000021661400026215700224400ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out float FragColor; layout(location = 0) flat in int index; const float LUT[16] = float[]( 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0); void main() { // Try reading LUTs, both in branches and not branch. FragColor = LUT[index]; if (index < 10) FragColor += LUT[index ^ 1]; else FragColor += LUT[index & 1]; // Not declared as a LUT, but can be promoted to one. vec4 foo[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); if (index > 30) { FragColor += foo[index & 3].y; } else { FragColor += foo[index & 1].x; } // Not declared as a LUT, but this cannot be promoted, because we have a partial write. vec4 foobar[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); if (index > 30) { foobar[1].z = 20.0; } FragColor += foobar[index & 3].z; // Not declared as a LUT, but this cannot be promoted, because we have two complete writes. vec4 baz[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0)); baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0)); FragColor += baz[index & 3].z; } spirv-cross-2021.01.15/shaders/frag/mix.frag000066400000000000000000000007151400026215700204030ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vIn0; layout(location = 1) in vec4 vIn1; layout(location = 2) in float vIn2; layout(location = 3) in float vIn3; layout(location = 0) out vec4 FragColor; void main() { bvec4 l = bvec4(false, true, false, false); FragColor = mix(vIn0, vIn1, l); bool f = true; FragColor = vec4(mix(vIn2, vIn3, f)); FragColor = f ? vIn0 : vIn1; FragColor = vec4(f ? vIn2 : vIn3); } spirv-cross-2021.01.15/shaders/frag/partial-write-preserve.frag000066400000000000000000000020661400026215700242240ustar00rootroot00000000000000#version 310 es precision mediump float; layout(std140, binding = 0) uniform UBO { int some_value; }; struct B { float a; float b; }; void partial_inout(inout vec4 x) { x.x = 10.0; } void partial_inout(inout B b) { b.b = 40.0; } // Make a complete write, but only conditionally ... void branchy_inout(inout vec4 v) { v.y = 20.0; if (some_value == 20) { v = vec4(50.0); } } void branchy_inout(inout B b) { b.b = 20.0; if (some_value == 20) { b = B(10.0, 40.0); } } void branchy_inout_2(out vec4 v) { if (some_value == 20) { v = vec4(50.0); } else { v = vec4(70.0); } v.y = 20.0; } void branchy_inout_2(out B b) { if (some_value == 20) { b = B(10.0, 40.0); } else { b = B(70.0, 70.0); } b.b = 20.0; } void complete_inout(out vec4 x) { x = vec4(50.0); } void complete_inout(out B b) { b = B(100.0, 200.0); } void main() { vec4 a = vec4(10.0); partial_inout(a); complete_inout(a); branchy_inout(a); branchy_inout_2(a); B b = B(10.0, 20.0); partial_inout(b); complete_inout(b); branchy_inout(b); branchy_inout_2(b); } spirv-cross-2021.01.15/shaders/frag/pixel-interlock-ordered.frag000066400000000000000000000007551400026215700243450ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_ordered) in; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; layout(binding = 2) coherent buffer Buffer { int foo; uint bar; }; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0, 0), vec4(1.0, 0.0, 0.0, 1.0)); imageAtomicAdd(img2, ivec2(0, 0), 1u); foo += 42; atomicAnd(bar, 0xff); endInvocationInterlockARB(); } spirv-cross-2021.01.15/shaders/frag/pixel-interlock-unordered.frag000066400000000000000000000007571400026215700247120ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(pixel_interlock_unordered) in; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; layout(binding = 2) coherent buffer Buffer { int foo; uint bar; }; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0, 0), vec4(1.0, 0.0, 0.0, 1.0)); imageAtomicAdd(img2, ivec2(0, 0), 1u); foo += 42; atomicAnd(bar, 0xff); endInvocationInterlockARB(); } spirv-cross-2021.01.15/shaders/frag/pls.frag000066400000000000000000000007341400026215700204050ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 PLSIn0; layout(location = 1) in vec4 PLSIn1; layout(location = 2) in vec4 PLSIn2; layout(location = 3) in vec4 PLSIn3; layout(location = 0) out vec4 PLSOut0; layout(location = 1) out vec4 PLSOut1; layout(location = 2) out vec4 PLSOut2; layout(location = 3) out vec4 PLSOut3; void main() { PLSOut0 = 2.0 * PLSIn0; PLSOut1 = 6.0 * PLSIn1; PLSOut2 = 7.0 * PLSIn2; PLSOut3 = 4.0 * PLSIn3; } spirv-cross-2021.01.15/shaders/frag/post-depth-coverage-es.frag000066400000000000000000000004371400026215700240740ustar00rootroot00000000000000#version 310 es #extension GL_EXT_post_depth_coverage : require #extension GL_OES_sample_variables : require precision mediump float; layout(early_fragment_tests, post_depth_coverage) in; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(gl_SampleMaskIn[0]); } spirv-cross-2021.01.15/shaders/frag/post-depth-coverage.frag000066400000000000000000000003001400026215700234540ustar00rootroot00000000000000#version 450 #extension GL_ARB_post_depth_coverage : require layout(post_depth_coverage) in; layout(location = 0) out vec4 FragColor; void main() { FragColor = vec4(gl_SampleMaskIn[0]); } spirv-cross-2021.01.15/shaders/frag/round-even.frag000066400000000000000000000003041400026215700216620ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 vA; layout(location = 1) in float vB; layout(location = 0) out vec4 FragColor; void main() { FragColor = roundEven(vA); FragColor *= roundEven(vB); } spirv-cross-2021.01.15/shaders/frag/round.frag000066400000000000000000000002741400026215700207350ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 vA; layout(location = 1) in float vB; layout(location = 0) out vec4 FragColor; void main() { FragColor = round(vA); FragColor *= round(vB); } spirv-cross-2021.01.15/shaders/frag/sample-interlock-ordered.frag000066400000000000000000000007741400026215700245060ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(sample_interlock_ordered) in; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; layout(binding = 2) coherent buffer Buffer { int foo; uint bar; }; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0, 0), vec4(1.0, 0.0, 0.0, 1.0)); imageAtomicAdd(img2, ivec2(0, 0), 1u); foo += 42; atomicAnd(bar, gl_SampleMaskIn[0]); endInvocationInterlockARB(); } spirv-cross-2021.01.15/shaders/frag/sample-interlock-unordered.frag000066400000000000000000000007601400026215700250440ustar00rootroot00000000000000#version 450 #extension GL_ARB_fragment_shader_interlock : require layout(sample_interlock_unordered) in; layout(binding = 0, rgba8) uniform writeonly image2D img; layout(binding = 1, r32ui) uniform uimage2D img2; layout(binding = 2) coherent buffer Buffer { int foo; uint bar; }; void main() { beginInvocationInterlockARB(); imageStore(img, ivec2(0, 0), vec4(1.0, 0.0, 0.0, 1.0)); imageAtomicAdd(img2, ivec2(0, 0), 1u); foo += 42; atomicAnd(bar, 0xff); endInvocationInterlockARB(); } spirv-cross-2021.01.15/shaders/frag/sample-parameter.frag000066400000000000000000000003701400026215700230420ustar00rootroot00000000000000#version 310 es #extension GL_OES_sample_variables : require precision mediump float; layout(location = 0) out vec2 FragColor; void main() { FragColor = gl_SamplePosition + vec2(gl_SampleMaskIn[0]) + float(gl_SampleID); gl_SampleMask[0] = 1; } spirv-cross-2021.01.15/shaders/frag/sampler-ms.frag000066400000000000000000000005621400026215700216660ustar00rootroot00000000000000#version 310 es precision mediump float; precision highp int; layout(binding = 0) uniform mediump sampler2DMS uSampler; layout(location = 0) out vec4 FragColor; void main() { ivec2 coord = ivec2(gl_FragCoord.xy); FragColor = texelFetch(uSampler, coord, 0) + texelFetch(uSampler, coord, 1) + texelFetch(uSampler, coord, 2) + texelFetch(uSampler, coord, 3); } spirv-cross-2021.01.15/shaders/frag/sampler-proj.frag000066400000000000000000000003351400026215700222170ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vTex; layout(binding = 0) uniform sampler2D uTex; layout(location = 0) out vec4 FragColor; void main() { FragColor = textureProj(uTex, vTex); } spirv-cross-2021.01.15/shaders/frag/sampler.frag000066400000000000000000000005341400026215700212500ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) in vec4 vColor; layout(location = 1) in vec2 vTex; layout(binding = 0) uniform sampler2D uTex; layout(location = 0) out vec4 FragColor; vec4 sample_texture(sampler2D tex, vec2 uv) { return texture(tex, uv); } void main() { FragColor = vColor * sample_texture(uTex, vTex); } spirv-cross-2021.01.15/shaders/frag/scalar-refract-reflect.frag000066400000000000000000000005131400026215700241150ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(location = 0) in vec3 vRefract; void main() { FragColor = refract(vRefract.x, vRefract.y, vRefract.z); FragColor += reflect(vRefract.x, vRefract.y); FragColor += refract(vRefract.xy, vRefract.yz, vRefract.z).y; FragColor += reflect(vRefract.xy, vRefract.zy).y; } spirv-cross-2021.01.15/shaders/frag/selection-block-dominator.frag000066400000000000000000000003401400026215700246470ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) flat in int vIndex; void main() { int v; if (vIndex != 1) { FragColor = vec4(1.0); return; } else { v = 10; } FragColor = vec4(v); } spirv-cross-2021.01.15/shaders/frag/struct-type-unrelated-alias.frag000066400000000000000000000003051400026215700251540ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; struct T { float a; }; void main() { T foo; struct T { float b; }; T bar; foo.a = 10.0; bar.b = 20.0; FragColor = foo.a + bar.b; } spirv-cross-2021.01.15/shaders/frag/switch-unsigned-case.frag000066400000000000000000000005461400026215700236340ustar00rootroot00000000000000#version 310 es precision mediump float; #define ENUM_0 0u #define ENUM_1 1u layout(set = 0, binding = 0) uniform Buff { uint TestVal; }; layout(location = 0) out vec4 fsout_Color; void main() { fsout_Color = vec4(1.0); switch (TestVal) { case ENUM_0: fsout_Color = vec4(0.1); break; case ENUM_1: fsout_Color = vec4(0.2); break; } } spirv-cross-2021.01.15/shaders/frag/swizzle.frag000066400000000000000000000010061400026215700213070ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 0) uniform sampler2D samp; layout(location = 0) out vec4 FragColor; layout(location = 1) in vec3 vNormal; layout(location = 2) in vec2 vUV; void main() { FragColor = vec4(texture(samp, vUV).xyz, 1.0); FragColor = vec4(texture(samp, vUV).xz, 1.0, 4.0); FragColor = vec4(texture(samp, vUV).xx, texture(samp, vUV + vec2(0.1)).yy); FragColor = vec4(vNormal, 1.0); FragColor = vec4(vNormal + 1.8, 1.0); FragColor = vec4(vUV, vUV + 1.8); } spirv-cross-2021.01.15/shaders/frag/texel-fetch-offset.frag000066400000000000000000000004671400026215700233060ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uTexture; void main() { FragColor = texelFetchOffset(uTexture, ivec2(gl_FragCoord.xy), 0, ivec2(1, 1)); FragColor += texelFetchOffset(uTexture, ivec2(gl_FragCoord.xy), 0, ivec2(-1, 1)); } spirv-cross-2021.01.15/shaders/frag/ubo-load-row-major-workaround.frag000066400000000000000000000012421400026215700254100ustar00rootroot00000000000000#version 450 struct RowMajor { mat4 B; }; struct NestedRowMajor { RowMajor rm; }; layout(set = 0, binding = 0, row_major) uniform UBO { mat4 A; layout(column_major) mat4 C; // This should also be worked around. }; layout(set = 0, binding = 1, row_major) uniform UBO2 { RowMajor rm; }; layout(set = 0, binding = 2, row_major) uniform UBO3 { NestedRowMajor rm2; }; layout(set = 0, binding = 3) uniform UBONoWorkaround { mat4 D; }; layout(location = 0) in vec4 Clip; layout(location = 0) out vec4 FragColor; void main() { NestedRowMajor rm2_loaded = rm2; FragColor = rm2_loaded.rm.B * rm.B * A * C * Clip; FragColor += D * Clip; FragColor += A[1] * Clip; } spirv-cross-2021.01.15/shaders/frag/ubo_layout.frag000066400000000000000000000005371400026215700217720ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; struct Str { mat4 foo; }; layout(binding = 0, std140) uniform UBO1 { layout(row_major) Str foo; } ubo1; layout(binding = 1, std140) uniform UBO2 { layout(column_major) Str foo; } ubo0; void main() { FragColor = ubo1.foo.foo[0] + ubo0.foo.foo[0]; } spirv-cross-2021.01.15/shaders/frag/unary-enclose.frag000066400000000000000000000003711400026215700223700ustar00rootroot00000000000000#version 310 es precision mediump float; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec4 vIn; layout(location = 1) flat in ivec4 vIn1; void main() { FragColor = +(-(-vIn)); ivec4 a = ~(~vIn1); bool b = false; b = !!b; } spirv-cross-2021.01.15/shaders/geom/000077500000000000000000000000001400026215700167525ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/geom/basic.geom000066400000000000000000000011761400026215700207110ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles, invocations = 4) in; layout(triangle_strip, max_vertices = 3) out; layout(location = 0) in VertexData { vec3 normal; } vin[]; layout(location = 0) out vec3 vNormal; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal + float(gl_InvocationID); EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal + 4.0 * float(gl_InvocationID); EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal + 2.0 * float(gl_InvocationID); EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/shaders/geom/geometry-passthrough.geom000066400000000000000000000006671400026215700240340ustar00rootroot00000000000000#version 450 #extension GL_NV_geometry_shader_passthrough : require layout(triangles) in; layout(passthrough) in gl_PerVertex { vec4 gl_Position; } gl_in[]; layout(passthrough, location = 0) in VertexBlock { int a; int b; } v1[]; layout(location = 2) in VertexBlock2 { int a; layout(passthrough) int b; } v2[]; layout(passthrough, location = 4) in vec4 vPoint[]; void main() { gl_Layer = gl_InvocationID + v1[0].a + v2[1].b; } spirv-cross-2021.01.15/shaders/geom/lines-adjacency.geom000066400000000000000000000010301400026215700226460ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(lines_adjacency) in; layout(line_strip, max_vertices = 3) out; layout(location = 0) in VertexData { vec3 normal; } vin[]; layout(location = 0) out vec3 vNormal; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/shaders/geom/lines.geom000066400000000000000000000006661400026215700207450ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(lines) in; layout(line_strip, max_vertices = 2) out; layout(location = 0) in VertexData { vec3 normal; } vin[]; layout(location = 0) out vec3 vNormal; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/shaders/geom/multi-stream.geom000066400000000000000000000004061400026215700222460ustar00rootroot00000000000000#version 450 layout(triangles) in; layout(points, max_vertices = 2) out; void main() { gl_Position = gl_in[0].gl_Position; EmitStreamVertex(0); EndStreamPrimitive(0); gl_Position = gl_in[0].gl_Position + 2; EmitStreamVertex(1); EndStreamPrimitive(1); } spirv-cross-2021.01.15/shaders/geom/points.geom000066400000000000000000000010131400026215700211320ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(points) in; layout(points, max_vertices = 3) out; layout(location = 0) in VertexData { vec3 normal; } vin[]; layout(location = 0) out vec3 vNormal; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/shaders/geom/single-invocation.geom000066400000000000000000000010261400026215700232520ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles) in; layout(triangle_strip, max_vertices = 3) out; layout(location = 0) in VertexData { vec3 normal; } vin[]; layout(location = 0) out vec3 vNormal; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/shaders/geom/transform-feedback-streams.geom000066400000000000000000000010461400026215700250350ustar00rootroot00000000000000#version 450 layout(max_vertices = 2, points) out; layout(points) in; layout(stream = 1, xfb_stride = 32, xfb_offset = 16, xfb_buffer = 2, location = 0) out vec4 vFoo; layout(stream = 1, xfb_buffer = 1, xfb_stride = 20) out gl_PerVertex { layout(xfb_offset = 4) vec4 gl_Position; float gl_PointSize; }; layout(stream = 2, xfb_buffer = 3) out VertOut { layout(xfb_stride = 16, xfb_offset = 0, location = 1) vec4 vBar; }; void main() { gl_Position = vec4(1.0); vFoo = vec4(3.0); EmitStreamVertex(1); vBar = vec4(5.0); EmitStreamVertex(2); } spirv-cross-2021.01.15/shaders/geom/triangles-adjacency.geom000066400000000000000000000010401400026215700235250ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles_adjacency) in; layout(triangle_strip, max_vertices = 3) out; layout(location = 0) in VertexData { vec3 normal; } vin[]; layout(location = 0) out vec3 vNormal; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/shaders/geom/triangles.geom000066400000000000000000000010261400026215700216120ustar00rootroot00000000000000#version 310 es #extension GL_EXT_geometry_shader : require layout(triangles) in; layout(triangle_strip, max_vertices = 3) out; layout(location = 0) in VertexData { vec3 normal; } vin[]; layout(location = 0) out vec3 vNormal; void main() { gl_Position = gl_in[0].gl_Position; vNormal = vin[0].normal; EmitVertex(); gl_Position = gl_in[1].gl_Position; vNormal = vin[1].normal; EmitVertex(); gl_Position = gl_in[2].gl_Position; vNormal = vin[2].normal; EmitVertex(); EndPrimitive(); } spirv-cross-2021.01.15/shaders/legacy/000077500000000000000000000000001400026215700172675ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/legacy/fragment/000077500000000000000000000000001400026215700210725ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/legacy/fragment/explicit-lod.legacy.frag000066400000000000000000000003041400026215700255700ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 0) uniform sampler2D tex; layout(location = 0) out vec4 FragColor; void main() { FragColor = textureLod(tex, vec2(0.4, 0.6), 0.0); } spirv-cross-2021.01.15/shaders/legacy/fragment/explicit-lod.legacy.vert000066400000000000000000000003041400026215700256310ustar00rootroot00000000000000#version 310 es precision mediump float; layout(binding = 0) uniform sampler2D tex; layout(location = 0) out vec4 FragColor; void main() { FragColor = textureLod(tex, vec2(0.4, 0.6), 3.0); } spirv-cross-2021.01.15/shaders/legacy/fragment/fma.legacy.frag000066400000000000000000000003131400026215700237360ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 vA; layout(location = 1) in vec4 vB; layout(location = 2) in vec4 vC; layout(location = 0) out vec4 FragColor; void main() { FragColor = fma(vA, vB, vC); } spirv-cross-2021.01.15/shaders/legacy/fragment/io-blocks.legacy.frag000066400000000000000000000004161400026215700250610ustar00rootroot00000000000000#version 310 es #extension GL_EXT_shader_io_blocks : require precision mediump float; layout(location = 1) in VertexOut { vec4 color; highp vec3 normal; } vin; layout(location = 0) out vec4 FragColor; void main() { FragColor = vin.color + vin.normal.xyzz; } spirv-cross-2021.01.15/shaders/legacy/fragment/multiple-struct-flattening.legacy.frag000066400000000000000000000006241400026215700305060ustar00rootroot00000000000000#version 450 struct Foo { vec4 a; vec4 b; }; struct Bar { vec4 a; vec4 b; }; struct Baz { Foo foo; Bar bar; }; layout(location = 0) in VertexIn { Foo a; Bar b; }; layout(location = 4) in Baz baz; layout(location = 0) out vec4 FragColor; void main() { Baz bazzy = baz; Foo bazzy_foo = baz.foo; Bar bazzy_bar = baz.bar; FragColor = a.a + b.b + bazzy.foo.b + bazzy_foo.a + bazzy_bar.b; } spirv-cross-2021.01.15/shaders/legacy/fragment/round.legacy.frag000066400000000000000000000002741400026215700243300ustar00rootroot00000000000000#version 450 layout(location = 0) in vec4 vA; layout(location = 1) in float vB; layout(location = 0) out vec4 FragColor; void main() { FragColor = round(vA); FragColor *= round(vB); } spirv-cross-2021.01.15/shaders/legacy/fragment/struct-varying.legacy.frag000066400000000000000000000006231400026215700262000ustar00rootroot00000000000000#version 310 es precision highp float; struct Inputs { vec4 a; vec2 b; }; layout(location = 0) in Inputs vin; layout(location = 0) out vec4 FragColor; void main() { // Read struct once. Inputs v0 = vin; // Read struct again. Inputs v1 = vin; // Read members individually. vec4 a = vin.a; vec4 b = vin.b.xxyy; FragColor = v0.a + v0.b.xxyy + v1.a + v1.b.yyxx + a + b; } spirv-cross-2021.01.15/shaders/legacy/fragment/switch.legacy.frag000066400000000000000000000010631400026215700244770ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in float vIndexF; void main() { int vIndex = int(vIndexF); vec4 v = vec4(0.0); switch (vIndex) { case 2: v = vec4(0, 2, 3, 4); break; case 4: case 5: v = vec4(1, 2, 3, 4); break; case 8: case 9: v = vec4(40, 20, 30, 40); break; case 10: v = vec4(10.0); case 11: v += 1.0; case 12: v += 2.0; break; default: v = vec4(10, 20, 30, 40); break; } vec4 w = vec4(20.0); switch (vIndex) { case 10: case 20: w = vec4(40.0); } FragColor = v + w; } spirv-cross-2021.01.15/shaders/legacy/vert/000077500000000000000000000000001400026215700202475ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/legacy/vert/implicit-lod.legacy.vert000066400000000000000000000001721400026215700250020ustar00rootroot00000000000000#version 310 es layout(binding = 0) uniform sampler2D tex; void main() { gl_Position = texture(tex, vec2(0.4, 0.6)); } spirv-cross-2021.01.15/shaders/legacy/vert/io-block.legacy.vert000066400000000000000000000004251400026215700241140ustar00rootroot00000000000000#version 310 es #extension GL_EXT_shader_io_blocks : require layout(location = 0) out VertexOut { vec4 color; vec3 normal; } vout; layout(location = 0) in vec4 Position; void main() { gl_Position = Position; vout.color = vec4(1.0); vout.normal = vec3(0.5); } spirv-cross-2021.01.15/shaders/legacy/vert/struct-flatten-inner-array.legacy.vert000066400000000000000000000002611400026215700276170ustar00rootroot00000000000000#version 450 struct Foo { float a[4]; }; layout(location = 0) out Foo foo; void main() { gl_Position = vec4(1.0); for (int i = 0; i < 4; i++) foo.a[i] = float(i + 2); } spirv-cross-2021.01.15/shaders/legacy/vert/struct-flatten-stores-multi-dimension.legacy.vert000066400000000000000000000010261400026215700320220ustar00rootroot00000000000000#version 450 struct Foo { vec4 a; vec4 b; }; struct Bar { vec4 a; vec4 b; }; struct Baz { Foo foo; Bar bar; }; layout(location = 0) out VertexIn { Foo a; Bar b; }; layout(location = 4) out Baz baz; void main() { a.a = vec4(10.0); a.b = vec4(20.0); b.a = vec4(30.0); b.b = vec4(40.0); a = Foo(vec4(50.0), vec4(60.0)); b = Bar(vec4(50.0), vec4(60.0)); baz.foo = Foo(vec4(100.0), vec4(200.0)); baz.bar = Bar(vec4(300.0), vec4(400.0)); baz = Baz(Foo(vec4(1000.0), vec4(2000.0)), Bar(vec4(3000.0), vec4(4000.0))); } spirv-cross-2021.01.15/shaders/legacy/vert/struct-varying.legacy.vert000066400000000000000000000007751400026215700254260ustar00rootroot00000000000000#version 310 es struct Output { vec4 a; vec2 b; }; layout(location = 0) out Output vout; void main() { Output s = Output(vec4(0.5), vec2(0.25)); // Write whole struct. vout = s; // Write whole struct again, checks for scoping. vout = s; // Read it back. Output tmp = vout; // Write elements individually. vout.a = tmp.a; vout.b = tmp.b; // Write individual elements. vout.a.x = 1.0; vout.b.y = 1.0; // Read individual elements. float c = vout.a.x; } spirv-cross-2021.01.15/shaders/legacy/vert/switch-nested.legacy.vert000066400000000000000000000005371400026215700252020ustar00rootroot00000000000000#version 450 layout(set = 0, binding = 0) uniform UBO { int func_arg; int inner_func_arg; }; vec4 test_inner_func(bool b) { if (b) return vec4(1.0); else return vec4(0.0); } vec4 test_func(bool b) { if (b) return test_inner_func(inner_func_arg != 0); else return vec4(0.0); } void main() { gl_Position = test_func(func_arg != 0); } spirv-cross-2021.01.15/shaders/legacy/vert/transpose.legacy.vert000066400000000000000000000015451400026215700244370ustar00rootroot00000000000000#version 310 es uniform Buffer { layout(row_major) mat4 MVPRowMajor; layout(column_major) mat4 MVPColMajor; mat4 M; }; layout(location = 0) in vec4 Position; void main() { vec4 c0 = M * (MVPRowMajor * Position); vec4 c1 = M * (MVPColMajor * Position); vec4 c2 = M * (Position * MVPRowMajor); vec4 c3 = M * (Position * MVPColMajor); vec4 c4 = transpose(MVPRowMajor) * Position; vec4 c5 = transpose(MVPColMajor) * Position; vec4 c6 = Position * transpose(MVPRowMajor); vec4 c7 = Position * transpose(MVPColMajor); // Multiplying by scalar forces resolution of the transposition vec4 c8 = (MVPRowMajor * 2.0) * Position; vec4 c9 = (transpose(MVPColMajor) * 2.0) * Position; vec4 c10 = Position * (MVPRowMajor * 2.0); vec4 c11 = Position * (transpose(MVPColMajor) * 2.0); gl_Position = c0 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11; } spirv-cross-2021.01.15/shaders/tesc/000077500000000000000000000000001400026215700167615ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/tesc/basic.tesc000066400000000000000000000005551400026215700207270ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(location = 0) patch out vec3 vFoo; layout(vertices = 1) out; void main() { gl_TessLevelInner[0] = 8.9; gl_TessLevelInner[1] = 6.9; gl_TessLevelOuter[0] = 8.9; gl_TessLevelOuter[1] = 6.9; gl_TessLevelOuter[2] = 3.9; gl_TessLevelOuter[3] = 4.9; vFoo = vec3(1.0); } spirv-cross-2021.01.15/shaders/tesc/water_tess.tesc000066400000000000000000000063451400026215700220310ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(vertices = 1) out; layout(location = 0) in vec2 vPatchPosBase[]; layout(std140) uniform UBO { vec4 uScale; highp vec3 uCamPos; vec2 uPatchSize; vec2 uMaxTessLevel; float uDistanceMod; vec4 uFrustum[6]; }; layout(location = 1) patch out vec2 vOutPatchPosBase; layout(location = 2) patch out vec4 vPatchLods; float lod_factor(vec2 pos_) { vec2 pos = pos_ * uScale.xy; vec3 dist_to_cam = uCamPos - vec3(pos.x, 0.0, pos.y); float level = log2((length(dist_to_cam) + 0.0001) * uDistanceMod); return clamp(level, 0.0, uMaxTessLevel.x); } float tess_level(float lod) { return uMaxTessLevel.y * exp2(-lod); } vec4 tess_level(vec4 lod) { return uMaxTessLevel.y * exp2(-lod); } // Guard band for vertex displacement. #define GUARD_BAND 10.0 bool frustum_cull(vec2 p0) { vec2 min_xz = (p0 - GUARD_BAND) * uScale.xy; vec2 max_xz = (p0 + uPatchSize + GUARD_BAND) * uScale.xy; vec3 bb_min = vec3(min_xz.x, -GUARD_BAND, min_xz.y); vec3 bb_max = vec3(max_xz.x, +GUARD_BAND, max_xz.y); vec3 center = 0.5 * (bb_min + bb_max); float radius = 0.5 * length(bb_max - bb_min); vec3 f0 = vec3( dot(uFrustum[0], vec4(center, 1.0)), dot(uFrustum[1], vec4(center, 1.0)), dot(uFrustum[2], vec4(center, 1.0))); vec3 f1 = vec3( dot(uFrustum[3], vec4(center, 1.0)), dot(uFrustum[4], vec4(center, 1.0)), dot(uFrustum[5], vec4(center, 1.0))); return !(any(lessThanEqual(f0, vec3(-radius))) || any(lessThanEqual(f1, vec3(-radius)))); } void compute_tess_levels(vec2 p0) { vOutPatchPosBase = p0; float l00 = lod_factor(p0 + vec2(-0.5, -0.5) * uPatchSize); float l10 = lod_factor(p0 + vec2(+0.5, -0.5) * uPatchSize); float l20 = lod_factor(p0 + vec2(+1.5, -0.5) * uPatchSize); float l01 = lod_factor(p0 + vec2(-0.5, +0.5) * uPatchSize); float l11 = lod_factor(p0 + vec2(+0.5, +0.5) * uPatchSize); float l21 = lod_factor(p0 + vec2(+1.5, +0.5) * uPatchSize); float l02 = lod_factor(p0 + vec2(-0.5, +1.5) * uPatchSize); float l12 = lod_factor(p0 + vec2(+0.5, +1.5) * uPatchSize); float l22 = lod_factor(p0 + vec2(+1.5, +1.5) * uPatchSize); vec4 lods = vec4( dot(vec4(l01, l11, l02, l12), vec4(0.25)), dot(vec4(l00, l10, l01, l11), vec4(0.25)), dot(vec4(l10, l20, l11, l21), vec4(0.25)), dot(vec4(l11, l21, l12, l22), vec4(0.25))); vPatchLods = lods; vec4 outer_lods = min(lods.xyzw, lods.yzwx); vec4 levels = tess_level(outer_lods); gl_TessLevelOuter[0] = levels.x; gl_TessLevelOuter[1] = levels.y; gl_TessLevelOuter[2] = levels.z; gl_TessLevelOuter[3] = levels.w; float min_lod = min(min(lods.x, lods.y), min(lods.z, lods.w)); float inner = tess_level(min(min_lod, l11)); gl_TessLevelInner[0] = inner; gl_TessLevelInner[1] = inner; } void main() { vec2 p0 = vPatchPosBase[0]; if (!frustum_cull(p0)) { gl_TessLevelOuter[0] = -1.0; gl_TessLevelOuter[1] = -1.0; gl_TessLevelOuter[2] = -1.0; gl_TessLevelOuter[3] = -1.0; gl_TessLevelInner[0] = -1.0; gl_TessLevelInner[1] = -1.0; } else { compute_tess_levels(p0); } } spirv-cross-2021.01.15/shaders/tese/000077500000000000000000000000001400026215700167635ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/tese/ccw.tese000066400000000000000000000002431400026215700204200ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(ccw, triangles, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders/tese/cw.tese000066400000000000000000000002421400026215700202540ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(cw, triangles, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders/tese/equal.tese000066400000000000000000000002301400026215700207470ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(cw, triangles, equal_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders/tese/fractional_even.tese000066400000000000000000000002421400026215700230020ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(cw, triangles, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders/tese/fractional_odd.tese000066400000000000000000000002411400026215700226120ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(cw, triangles, fractional_odd_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders/tese/input-array.tese000066400000000000000000000003711400026215700221210ustar00rootroot00000000000000#version 450 layout(ccw, quads, fractional_odd_spacing) in; layout(location = 0) in vec4 Floats[]; layout(location = 2) in vec4 Floats2[gl_MaxPatchVertices]; void main() { gl_Position = Floats[0] * gl_TessCoord.x + Floats2[1] * gl_TessCoord.y; } spirv-cross-2021.01.15/shaders/tese/line.tese000066400000000000000000000002511400026215700205720ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(isolines, point_mode, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders/tese/load-array-of-array.tese000066400000000000000000000003041400026215700234130ustar00rootroot00000000000000#version 450 layout(ccw, quads) in; layout(location = 0) in vec4 vTexCoord[][1]; void main() { vec4 tmp[gl_MaxPatchVertices][1] = vTexCoord; gl_Position = tmp[0][0] + tmp[2][0] + tmp[3][0]; } spirv-cross-2021.01.15/shaders/tese/patch-input-array.tese000066400000000000000000000002101400026215700232060ustar00rootroot00000000000000#version 450 layout(quads) in; layout(location = 0) patch in float P[4]; void main() { gl_Position = vec4(P[0], P[1], P[2], P[3]); } spirv-cross-2021.01.15/shaders/tese/triangle.tese000066400000000000000000000002421400026215700214500ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require layout(cw, triangles, fractional_even_spacing) in; void main() { gl_Position = vec4(1.0); } spirv-cross-2021.01.15/shaders/tese/water_tess.tese000066400000000000000000000034571400026215700220360ustar00rootroot00000000000000#version 310 es #extension GL_EXT_tessellation_shader : require precision highp int; layout(cw, quads, fractional_even_spacing) in; layout(location = 0) patch in vec2 vOutPatchPosBase; layout(location = 1) patch in vec4 vPatchLods; layout(binding = 1, std140) uniform UBO { mat4 uMVP; vec4 uScale; vec2 uInvScale; vec3 uCamPos; vec2 uPatchSize; vec2 uInvHeightmapSize; }; layout(binding = 0) uniform mediump sampler2D uHeightmapDisplacement; layout(location = 0) highp out vec3 vWorld; layout(location = 1) highp out vec4 vGradNormalTex; vec2 lerp_vertex(vec2 tess_coord) { return vOutPatchPosBase + tess_coord * uPatchSize; } mediump vec2 lod_factor(vec2 tess_coord) { mediump vec2 x = mix(vPatchLods.yx, vPatchLods.zw, tess_coord.x); mediump float level = mix(x.x, x.y, tess_coord.y); mediump float floor_level = floor(level); mediump float fract_level = level - floor_level; return vec2(floor_level, fract_level); } mediump vec3 sample_height_displacement(vec2 uv, vec2 off, mediump vec2 lod) { return mix( textureLod(uHeightmapDisplacement, uv + 0.5 * off, lod.x).xyz, textureLod(uHeightmapDisplacement, uv + 1.0 * off, lod.x + 1.0).xyz, lod.y); } void main() { vec2 tess_coord = gl_TessCoord.xy; vec2 pos = lerp_vertex(tess_coord); mediump vec2 lod = lod_factor(tess_coord); vec2 tex = pos * uInvHeightmapSize.xy; pos *= uScale.xy; mediump float delta_mod = exp2(lod.x); vec2 off = uInvHeightmapSize.xy * delta_mod; vGradNormalTex = vec4(tex + 0.5 * uInvHeightmapSize.xy, tex * uScale.zw); vec3 height_displacement = sample_height_displacement(tex, off, lod); pos += height_displacement.yz; vWorld = vec3(pos.x, height_displacement.x, pos.y); gl_Position = uMVP * vec4(vWorld, 1.0); } spirv-cross-2021.01.15/shaders/vert/000077500000000000000000000000001400026215700170035ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vert/basic.vert000066400000000000000000000004061400026215700207660ustar00rootroot00000000000000#version 310 es layout(std140) uniform UBO { uniform mat4 uMVP; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = uMVP * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders/vert/ground.vert000077500000000000000000000140451400026215700212120ustar00rootroot00000000000000#version 310 es #define YFLIP 0 #define SPECULAR 0 #define GLOSSMAP 0 #define DEBUG_NONE 0 #define DEBUG_DIFFUSE 1 #define DEBUG_SPECULAR 2 #define DEBUG_LIGHTING 3 #define DEBUG_FOG 4 #define DEBUG DEBUG_NONE #define FORWARD 0 #define DEFERRED 1 #define DEFERRED_VTEX 2 float saturate(float x) { return clamp(x, 0.0, 1.0); } layout(std140, binding = 0) uniform GlobalVSData { vec4 g_ViewProj_Row0; vec4 g_ViewProj_Row1; vec4 g_ViewProj_Row2; vec4 g_ViewProj_Row3; vec4 g_CamPos; vec4 g_CamRight; vec4 g_CamUp; vec4 g_CamFront; vec4 g_SunDir; vec4 g_SunColor; vec4 g_TimeParams; vec4 g_ResolutionParams; vec4 g_CamAxisRight; vec4 g_FogColor_Distance; vec4 g_ShadowVP_Row0; vec4 g_ShadowVP_Row1; vec4 g_ShadowVP_Row2; vec4 g_ShadowVP_Row3; }; vec4 ComputeFogFactor(vec3 WorldPos) { vec4 FogData; vec3 vEye = WorldPos - g_CamPos.xyz; vec3 nEye = normalize(vEye); FogData.w = exp(-dot(vEye, vEye) * g_FogColor_Distance.w * 0.75); float fog_sun_factor = pow(saturate(dot(nEye, g_SunDir.xyz)), 8.0); FogData.xyz = mix(vec3(1.0, 1.0, 1.0), vec3(0.6, 0.6, 0.9), nEye.y * 0.5 + 0.5); FogData.xyz = mix(FogData.xyz, vec3(0.95, 0.87, 0.78), fog_sun_factor); return FogData; } void ApplyFog(inout vec3 Color, vec4 FogData) { Color = mix(FogData.xyz, Color, FogData.w); } void ApplyLighting(inout mediump vec3 Color, mediump float DiffuseFactor) { mediump vec3 DiffuseLight = g_SunColor.xyz * DiffuseFactor; mediump vec3 AmbientLight = vec3(0.2, 0.35, 0.55) * 0.5; mediump vec3 Lighting = DiffuseLight + AmbientLight; #if DEBUG == DEBUG_LIGHTING Color = Lighting; #else Color *= Lighting; #endif } #pragma VARIANT SPECULAR #pragma VARIANT GLOSSMAP void ApplySpecular(inout mediump vec3 Color, mediump vec3 EyeVec, mediump vec3 Normal, mediump vec3 SpecularColor, mediump float Shininess, mediump float FresnelAmount) { mediump vec3 HalfAngle = normalize(-EyeVec + g_SunDir.xyz); mediump float v_dot_h = saturate(dot(HalfAngle, -EyeVec)); mediump float n_dot_l = saturate(dot(Normal, g_SunDir.xyz)); mediump float n_dot_h = saturate(dot(Normal, HalfAngle)); mediump float n_dot_v = saturate(dot(-EyeVec, Normal)); mediump float h_dot_l = saturate(dot(g_SunDir.xyz, HalfAngle)); const mediump float roughness_value = 0.25; mediump float r_sq = roughness_value * roughness_value; mediump float n_dot_h_sq = n_dot_h * n_dot_h; mediump float roughness_a = 1.0 / (4.0 * r_sq * n_dot_h_sq * n_dot_h_sq); mediump float roughness_b = n_dot_h_sq - 1.0; mediump float roughness_c = r_sq * n_dot_h_sq; mediump float roughness = saturate(roughness_a * exp(roughness_b / roughness_c)); FresnelAmount = 0.5; mediump float fresnel_term = pow(1.0 - n_dot_v, 5.0) * (1.0 - FresnelAmount) + FresnelAmount; mediump float geo_numerator = 2.0 * n_dot_h; mediump float geo_denominator = 1.0 / v_dot_h; mediump float geo_term = min(1.0, min(n_dot_v, n_dot_l) * geo_numerator * geo_denominator); #if SPECULAR || GLOSSMAP Color += SpecularColor * g_SunColor.xyz * fresnel_term * roughness * n_dot_l * geo_term / (n_dot_v * n_dot_l + 0.0001); #endif //Color = vec3(0.025 * 1.0 / (n_dot_v * n_dot_l)); } layout(location = 0) in vec2 Position; layout(location = 1) in vec4 LODWeights; layout(location = 0) out vec2 TexCoord; layout(location = 1) out vec3 EyeVec; layout(std140, binding = 2) uniform GlobalGround { vec4 GroundScale; vec4 GroundPosition; vec4 InvGroundSize_PatchScale; }; struct PatchData { vec4 Position; vec4 LODs; }; layout(std140, binding = 0) uniform PerPatch { PatchData Patches[256]; }; layout(binding = 0) uniform sampler2D TexHeightmap; layout(binding = 1) uniform sampler2D TexLOD; vec2 lod_factor(vec2 uv) { float level = textureLod(TexLOD, uv, 0.0).x * (255.0 / 32.0); float floor_level = floor(level); float fract_level = level - floor_level; return vec2(floor_level, fract_level); } #ifdef VULKAN #define INSTANCE_ID gl_InstanceIndex #else #define INSTANCE_ID gl_InstanceID #endif vec2 warp_position() { float vlod = dot(LODWeights, Patches[INSTANCE_ID].LODs); vlod = mix(vlod, Patches[INSTANCE_ID].Position.w, all(equal(LODWeights, vec4(0.0)))); #ifdef DEBUG_LOD_HEIGHT LODFactor = vec4(vlod); #endif float floor_lod = floor(vlod); float fract_lod = vlod - floor_lod; uint ufloor_lod = uint(floor_lod); #ifdef DEBUG_LOD_HEIGHT LODFactor = vec4(fract_lod); #endif uvec2 uPosition = uvec2(Position); uvec2 mask = (uvec2(1u) << uvec2(ufloor_lod, ufloor_lod + 1u)) - 1u; //uvec2 rounding = mix(uvec2(0u), mask, lessThan(uPosition, uvec2(32u))); uvec2 rounding = uvec2( uPosition.x < 32u ? mask.x : 0u, uPosition.y < 32u ? mask.y : 0u); vec4 lower_upper_snapped = vec4((uPosition + rounding).xyxy & (~mask).xxyy); return mix(lower_upper_snapped.xy, lower_upper_snapped.zw, fract_lod); } void main() { vec2 PatchPos = Patches[INSTANCE_ID].Position.xz * InvGroundSize_PatchScale.zw; vec2 WarpedPos = warp_position(); vec2 VertexPos = PatchPos + WarpedPos; vec2 NormalizedPos = VertexPos * InvGroundSize_PatchScale.xy; vec2 lod = lod_factor(NormalizedPos); vec2 Offset = exp2(lod.x) * InvGroundSize_PatchScale.xy; float Elevation = mix(textureLod(TexHeightmap, NormalizedPos + 0.5 * Offset, lod.x).x, textureLod(TexHeightmap, NormalizedPos + 1.0 * Offset, lod.x + 1.0).x, lod.y); vec3 WorldPos = vec3(NormalizedPos.x, Elevation, NormalizedPos.y); WorldPos *= GroundScale.xyz; WorldPos += GroundPosition.xyz; EyeVec = WorldPos - g_CamPos.xyz; TexCoord = NormalizedPos + 0.5 * InvGroundSize_PatchScale.xy; gl_Position = WorldPos.x * g_ViewProj_Row0 + WorldPos.y * g_ViewProj_Row1 + WorldPos.z * g_ViewProj_Row2 + g_ViewProj_Row3; } spirv-cross-2021.01.15/shaders/vert/invariant.vert000066400000000000000000000004601400026215700217000ustar00rootroot00000000000000#version 310 es invariant gl_Position; layout(location = 0) invariant out vec4 vColor; layout(location = 0) in vec4 vInput0; layout(location = 1) in vec4 vInput1; layout(location = 2) in vec4 vInput2; void main() { gl_Position = vInput0 + vInput1 * vInput2; vColor = (vInput0 - vInput1) * vInput2; } spirv-cross-2021.01.15/shaders/vert/ocean.vert000066400000000000000000000140701400026215700207740ustar00rootroot00000000000000#version 310 es #define YFLIP 0 #define SPECULAR 0 #define GLOSSMAP 0 #define DEBUG_NONE 0 #define DEBUG_DIFFUSE 1 #define DEBUG_SPECULAR 2 #define DEBUG_LIGHTING 3 #define DEBUG_FOG 4 #define DEBUG DEBUG_NONE #define FORWARD 0 #define DEFERRED 1 #define DEFERRED_VTEX 2 float saturate(float x) { return clamp(x, 0.0, 1.0); } layout(std140, binding = 0) uniform GlobalVSData { vec4 g_ViewProj_Row0; vec4 g_ViewProj_Row1; vec4 g_ViewProj_Row2; vec4 g_ViewProj_Row3; vec4 g_CamPos; vec4 g_CamRight; vec4 g_CamUp; vec4 g_CamFront; vec4 g_SunDir; vec4 g_SunColor; vec4 g_TimeParams; vec4 g_ResolutionParams; vec4 g_CamAxisRight; vec4 g_FogColor_Distance; vec4 g_ShadowVP_Row0; vec4 g_ShadowVP_Row1; vec4 g_ShadowVP_Row2; vec4 g_ShadowVP_Row3; }; vec4 ComputeFogFactor(vec3 WorldPos) { vec4 FogData; vec3 vEye = WorldPos - g_CamPos.xyz; vec3 nEye = normalize(vEye); FogData.w = exp(-dot(vEye, vEye) * g_FogColor_Distance.w * 0.75); float fog_sun_factor = pow(saturate(dot(nEye, g_SunDir.xyz)), 8.0); FogData.xyz = mix(vec3(1.0, 1.0, 1.0), vec3(0.6, 0.6, 0.9), nEye.y * 0.5 + 0.5); FogData.xyz = mix(FogData.xyz, vec3(0.95, 0.87, 0.78), fog_sun_factor); return FogData; } void ApplyFog(inout vec3 Color, vec4 FogData) { Color = mix(FogData.xyz, Color, FogData.w); } void ApplyLighting(inout mediump vec3 Color, mediump float DiffuseFactor) { mediump vec3 DiffuseLight = g_SunColor.xyz * DiffuseFactor; mediump vec3 AmbientLight = vec3(0.2, 0.35, 0.55) * 0.5; mediump vec3 Lighting = DiffuseLight + AmbientLight; #if DEBUG == DEBUG_LIGHTING Color = Lighting; #else Color *= Lighting; #endif } void ApplySpecular(inout mediump vec3 Color, mediump vec3 EyeVec, mediump vec3 Normal, mediump vec3 SpecularColor, mediump float Shininess, mediump float FresnelAmount) { mediump vec3 HalfAngle = normalize(-EyeVec + g_SunDir.xyz); mediump float v_dot_h = saturate(dot(HalfAngle, -EyeVec)); mediump float n_dot_l = saturate(dot(Normal, g_SunDir.xyz)); mediump float n_dot_h = saturate(dot(Normal, HalfAngle)); mediump float n_dot_v = saturate(dot(-EyeVec, Normal)); mediump float h_dot_l = saturate(dot(g_SunDir.xyz, HalfAngle)); const mediump float roughness_value = 0.25; mediump float r_sq = roughness_value * roughness_value; mediump float n_dot_h_sq = n_dot_h * n_dot_h; mediump float roughness_a = 1.0 / (4.0 * r_sq * n_dot_h_sq * n_dot_h_sq); mediump float roughness_b = n_dot_h_sq - 1.0; mediump float roughness_c = r_sq * n_dot_h_sq; mediump float roughness = saturate(roughness_a * exp(roughness_b / roughness_c)); FresnelAmount = 0.5; mediump float fresnel_term = pow(1.0 - n_dot_v, 5.0) * (1.0 - FresnelAmount) + FresnelAmount; mediump float geo_numerator = 2.0 * n_dot_h; mediump float geo_denominator = 1.0 / v_dot_h; mediump float geo_term = min(1.0, min(n_dot_v, n_dot_l) * geo_numerator * geo_denominator); #if SPECULAR || GLOSSMAP Color += SpecularColor * g_SunColor.xyz * fresnel_term * roughness * n_dot_l * geo_term / (n_dot_v * n_dot_l + 0.0001); #endif //Color = vec3(0.025 * 1.0 / (n_dot_v * n_dot_l)); } precision highp int; layout(binding = 0) uniform mediump sampler2D TexDisplacement; layout(binding = 1) uniform mediump sampler2D TexLOD; layout(location = 0) in vec4 Position; layout(location = 1) in vec4 LODWeights; layout(location = 0) out highp vec3 EyeVec; layout(location = 1) out highp vec4 TexCoord; layout(std140, binding = 4) uniform GlobalOcean { vec4 OceanScale; vec4 OceanPosition; vec4 InvOceanSize_PatchScale; vec4 NormalTexCoordScale; }; struct PatchData { vec4 Position; vec4 LODs; }; layout(std140, binding = 0) uniform Offsets { PatchData Patches[256]; }; vec2 lod_factor(vec2 uv) { float level = textureLod(TexLOD, uv, 0.0).x * (255.0 / 32.0); float floor_level = floor(level); float fract_level = level - floor_level; return vec2(floor_level, fract_level); } #ifdef VULKAN #define INSTANCE_ID gl_InstanceIndex #else #define INSTANCE_ID gl_InstanceID #endif vec2 warp_position() { float vlod = dot(LODWeights, Patches[INSTANCE_ID].LODs); vlod = mix(vlod, Patches[INSTANCE_ID].Position.w, all(equal(LODWeights, vec4(0.0)))); float floor_lod = floor(vlod); float fract_lod = vlod - floor_lod; uint ufloor_lod = uint(floor_lod); uvec4 uPosition = uvec4(Position); uvec2 mask = (uvec2(1u) << uvec2(ufloor_lod, ufloor_lod + 1u)) - 1u; uvec4 rounding; rounding.x = uPosition.x < 32u ? mask.x : 0u; rounding.y = uPosition.y < 32u ? mask.x : 0u; rounding.z = uPosition.x < 32u ? mask.y : 0u; rounding.w = uPosition.y < 32u ? mask.y : 0u; //rounding = uPosition.xyxy * mask.xxyy; vec4 lower_upper_snapped = vec4((uPosition.xyxy + rounding) & (~mask).xxyy); return mix(lower_upper_snapped.xy, lower_upper_snapped.zw, fract_lod); } void main() { vec2 PatchPos = Patches[INSTANCE_ID].Position.xz * InvOceanSize_PatchScale.zw; vec2 WarpedPos = warp_position(); vec2 VertexPos = PatchPos + WarpedPos; vec2 NormalizedPos = VertexPos * InvOceanSize_PatchScale.xy; vec2 NormalizedTex = NormalizedPos * NormalTexCoordScale.zw; vec2 lod = lod_factor(NormalizedPos); vec2 Offset = exp2(lod.x) * InvOceanSize_PatchScale.xy * NormalTexCoordScale.zw; vec3 Displacement = mix(textureLod(TexDisplacement, NormalizedTex + 0.5 * Offset, lod.x).yxz, textureLod(TexDisplacement, NormalizedTex + 1.0 * Offset, lod.x + 1.0).yxz, lod.y); vec3 WorldPos = vec3(NormalizedPos.x, 0.0, NormalizedPos.y) + Displacement; WorldPos *= OceanScale.xyz; WorldPos += OceanPosition.xyz; EyeVec = WorldPos - g_CamPos.xyz; TexCoord = vec4(NormalizedTex, NormalizedTex * NormalTexCoordScale.xy) + 0.5 * InvOceanSize_PatchScale.xyxy * NormalTexCoordScale.zwzw; gl_Position = WorldPos.x * g_ViewProj_Row0 + WorldPos.y * g_ViewProj_Row1 + WorldPos.z * g_ViewProj_Row2 + g_ViewProj_Row3; #if YFLIP gl_Position *= vec4(1.0, -1.0, 1.0, 1.0); #endif } spirv-cross-2021.01.15/shaders/vert/read-from-row-major-array.vert000066400000000000000000000013741400026215700246150ustar00rootroot00000000000000#version 310 es layout(location = 0) in highp vec4 a_position; layout(location = 0) out mediump float v_vtxResult; layout(set = 0, binding = 0, std140, row_major) uniform Block { highp mat2x3 var[3][4]; }; mediump float compare_float (highp float a, highp float b) { return abs(a - b) < 0.05 ? 1.0 : 0.0; } mediump float compare_vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z); } mediump float compare_mat2x3 (highp mat2x3 a, highp mat2x3 b){ return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1]); } void main (void) { gl_Position = a_position; mediump float result = 1.0; result *= compare_mat2x3(var[0][0], mat2x3(2.0, 6.0, -6.0, 0.0, 5.0, 5.0)); v_vtxResult = result; } spirv-cross-2021.01.15/shaders/vert/return-array.vert000066400000000000000000000004631400026215700223430ustar00rootroot00000000000000#version 310 es layout(location = 0) in vec4 vInput0; layout(location = 1) in vec4 vInput1; vec4[2] test() { return vec4[](vec4(10.0), vec4(20.0)); } vec4[2] test2() { vec4 foobar[2]; foobar[0] = vInput0; foobar[1] = vInput1; return foobar; } void main() { gl_Position = test()[0] + test2()[1]; } spirv-cross-2021.01.15/shaders/vert/texture_buffer.vert000066400000000000000000000004151400026215700227360ustar00rootroot00000000000000#version 310 es #extension GL_OES_texture_buffer : require layout(binding = 4) uniform highp samplerBuffer uSamp; layout(rgba32f, binding = 5) uniform readonly highp imageBuffer uSampo; void main() { gl_Position = texelFetch(uSamp, 10) + imageLoad(uSampo, 100); } spirv-cross-2021.01.15/shaders/vert/transform-feedback-decorations.vert000066400000000000000000000006351400026215700257560ustar00rootroot00000000000000#version 450 layout(xfb_stride = 32, xfb_offset = 16, xfb_buffer = 2, location = 0) out vec4 vFoo; layout(xfb_buffer = 1, xfb_stride = 20) out gl_PerVertex { layout(xfb_offset = 4) vec4 gl_Position; float gl_PointSize; }; layout(xfb_buffer = 3) out VertOut { layout(xfb_stride = 16, xfb_offset = 0, location = 1) vec4 vBar; }; void main() { gl_Position = vec4(1.0); vFoo = vec4(3.0); vBar = vec4(5.0); } spirv-cross-2021.01.15/shaders/vert/ubo.vert000066400000000000000000000004111400026215700204660ustar00rootroot00000000000000#version 310 es layout(binding = 0, std140) uniform UBO { mat4 mvp; }; layout(location = 0) in vec4 aVertex; layout(location = 1) in vec3 aNormal; layout(location = 0) out vec3 vNormal; void main() { gl_Position = mvp * aVertex; vNormal = aNormal; } spirv-cross-2021.01.15/shaders/vulkan/000077500000000000000000000000001400026215700173235ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/comp/000077500000000000000000000000001400026215700202615ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/comp/array-of-buffer-reference.nocompat.vk.comp000066400000000000000000000006211400026215700303210ustar00rootroot00000000000000#version 450 #extension GL_EXT_buffer_reference : require layout(local_size_x = 1) in; layout(buffer_reference) buffer Block { float v; }; layout(std140, set = 0, binding = 0) uniform UBO { Block blocks[4]; } ubo; void main() { Block blocks[4]; blocks[0] = ubo.blocks[0]; blocks[1] = ubo.blocks[1]; blocks[2] = ubo.blocks[2]; blocks[3] = ubo.blocks[3]; blocks[gl_WorkGroupID.x].v = 20.0; } spirv-cross-2021.01.15/shaders/vulkan/comp/buffer-reference-bitcast.nocompat.vk.comp000066400000000000000000000004231400026215700302320ustar00rootroot00000000000000#version 450 #extension GL_EXT_buffer_reference: require layout(buffer_reference) buffer PtrUint { uint value; }; layout(buffer_reference) buffer PtrInt { int value; }; layout(set = 0, binding = 0) buffer Buf { PtrUint ptr; }; void main() { PtrInt(ptr).value = 10; } spirv-cross-2021.01.15/shaders/vulkan/comp/buffer-reference-decorations.nocompat.vk.comp000066400000000000000000000011021400026215700311060ustar00rootroot00000000000000#version 450 #extension GL_EXT_buffer_reference : require layout(local_size_x = 64) in; layout(std430, buffer_reference) readonly buffer RO { vec4 v[]; }; layout(std430, buffer_reference) restrict buffer RW { vec4 v[]; }; layout(std430, buffer_reference) coherent writeonly buffer WO { vec4 v[]; }; layout(push_constant, std430) uniform Registers { RO ro; RW rw; WO wo; } registers; void main() { registers.rw.v[gl_GlobalInvocationID.x] = registers.ro.v[gl_GlobalInvocationID.x]; registers.wo.v[gl_GlobalInvocationID.x] = registers.ro.v[gl_GlobalInvocationID.x]; } spirv-cross-2021.01.15/shaders/vulkan/comp/buffer-reference.nocompat.vk.comp000066400000000000000000000014471400026215700266120ustar00rootroot00000000000000#version 450 #extension GL_EXT_buffer_reference : require #extension GL_ARB_gpu_shader_int64 : require layout(buffer_reference) buffer Node; layout(buffer_reference) buffer Node { int value; layout(offset = 16) Node next; layout(offset = 32) Node prev; }; layout(std430, set = 0, binding = 0) buffer LinkedList { restrict Node head1; restrict Node head2; }; void copy_node(restrict Node dst, restrict Node a, restrict Node b) { dst.value = a.value + b.value; } void overwrite_node(out restrict Node dst, restrict Node src) { dst = src; } void main() { restrict Node n = gl_WorkGroupID.x < 4u ? head1 : head2; copy_node(n.next, head1, head2); overwrite_node(n, head1); int v = head2.value; n.value = 20; n.value = v * 10; uint64_t uptr = uint64_t(head2.next); Node unode = Node(uptr); } spirv-cross-2021.01.15/shaders/vulkan/comp/spec-constant-op-member-array.vk.comp000066400000000000000000000007761400026215700273500ustar00rootroot00000000000000#version 450 layout(local_size_x = 1) in; layout(constant_id = 0) const int a = 100; layout(constant_id = 1) const int b = 200; layout(constant_id = 2) const int c = 300; const int d = c + 50; layout(constant_id = 3) const int e = 400; struct A { int member0[a]; int member1[b]; }; struct B { int member0[b]; int member1[a]; }; layout(set = 1, binding = 0) buffer SSBO { A member_a; B member_b; int v[a]; int w[d]; }; void main() { w[gl_GlobalInvocationID.x] += v[gl_GlobalInvocationID.x] + e; } spirv-cross-2021.01.15/shaders/vulkan/comp/spec-constant-work-group-size.vk.comp000066400000000000000000000005721400026215700274270ustar00rootroot00000000000000#version 450 layout(local_size_x_id = 10, local_size_y = 20) in; layout(constant_id = 0) const int a = 1; layout(constant_id = 1) const int b = 2; layout(set = 1, binding = 0) writeonly buffer SSBO { int v[]; }; void main() { int spec_const_array_size[b]; spec_const_array_size[a] = a; v[a + gl_WorkGroupSize.x + gl_WorkGroupSize.y] = b + spec_const_array_size[1 - a]; } spirv-cross-2021.01.15/shaders/vulkan/frag/000077500000000000000000000000001400026215700202425ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/frag/combined-texture-sampler-shadow.vk.frag000066400000000000000000000012651400026215700277300ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump samplerShadow uSampler; layout(set = 0, binding = 1) uniform mediump sampler uSampler1; layout(set = 0, binding = 2) uniform texture2D uDepth; layout(location = 0) out float FragColor; float samp2(texture2D t, mediump samplerShadow s) { return texture(sampler2DShadow(t, s), vec3(1.0)); } float samp3(texture2D t, mediump sampler s) { return texture(sampler2D(t, s), vec2(1.0)).x; } float samp(texture2D t, mediump samplerShadow s, mediump sampler s1) { float r0 = samp2(t, s); float r1 = samp3(t, s1); return r0 + r1; } void main() { FragColor = samp(uDepth, uSampler, uSampler1); } spirv-cross-2021.01.15/shaders/vulkan/frag/combined-texture-sampler.vk.frag000066400000000000000000000023201400026215700264360ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump sampler uSampler0; layout(set = 0, binding = 1) uniform mediump sampler uSampler1; layout(set = 0, binding = 2) uniform mediump texture2D uTexture0; layout(set = 0, binding = 3) uniform mediump texture2D uTexture1; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTex; vec4 sample_dual(mediump sampler samp, mediump texture2D tex) { return texture(sampler2D(tex, samp), vTex); } vec4 sample_global_tex(mediump sampler samp) { vec4 a = texture(sampler2D(uTexture0, samp), vTex); vec4 b = sample_dual(samp, uTexture1); return a + b; } vec4 sample_global_sampler(mediump texture2D tex) { vec4 a = texture(sampler2D(tex, uSampler0), vTex); vec4 b = sample_dual(uSampler1, tex); return a + b; } vec4 sample_duals() { vec4 a = sample_dual(uSampler0, uTexture0); vec4 b = sample_dual(uSampler1, uTexture1); return a + b; } void main() { vec4 c0 = sample_duals(); vec4 c1 = sample_global_tex(uSampler0); vec4 c2 = sample_global_tex(uSampler1); vec4 c3 = sample_global_sampler(uTexture0); vec4 c4 = sample_global_sampler(uTexture1); FragColor = c0 + c1 + c2 + c3 + c4; } spirv-cross-2021.01.15/shaders/vulkan/frag/demote-to-helper-forwarding.asm.vk.nocompat.frag000066400000000000000000000030761400026215700314400ustar00rootroot00000000000000; SPIR-V ; Version: 1.3 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 19 ; Schema: 0 OpCapability Shader OpCapability DemoteToHelperInvocationEXT OpExtension "SPV_EXT_demote_to_helper_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_demote_to_helper_invocation" OpName %main "main" OpName %FragColor "FragColor" OpDecorate %FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %FragColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %19 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %main = OpFunction %void None %3 %5 = OpLabel %9 = OpIsHelperInvocationEXT %bool OpDemoteToHelperInvocationEXT %10 = OpLogicalNot %bool %9 OpSelectionMerge %12 None OpBranchConditional %10 %11 %12 %11 = OpLabel OpStore %FragColor %19 OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd spirv-cross-2021.01.15/shaders/vulkan/frag/demote-to-helper.vk.nocompat.frag000066400000000000000000000002051400026215700265100ustar00rootroot00000000000000#version 450 #extension GL_EXT_demote_to_helper_invocation : require void main() { demote; bool helper = helperInvocationEXT(); } spirv-cross-2021.01.15/shaders/vulkan/frag/desktop-mediump.vk.frag000066400000000000000000000003701400026215700246310ustar00rootroot00000000000000#version 450 layout(location = 0) in mediump vec4 F; layout(location = 1) flat in mediump ivec4 I; layout(location = 2) flat in mediump uvec4 U; layout(location = 0) out mediump vec4 FragColor; void main() { FragColor = F + vec4(I) + vec4(U); } spirv-cross-2021.01.15/shaders/vulkan/frag/input-attachment-ms.vk.frag000066400000000000000000000005531400026215700254270ustar00rootroot00000000000000#version 450 layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInputMS uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform subpassInputMS uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = subpassLoad(uSubpass0, 1) + subpassLoad(uSubpass1, 2) + subpassLoad(uSubpass0, gl_SampleID); } spirv-cross-2021.01.15/shaders/vulkan/frag/input-attachment.vk.frag000066400000000000000000000005471400026215700250150ustar00rootroot00000000000000#version 310 es precision mediump float; layout(input_attachment_index = 0, set = 0, binding = 0) uniform mediump subpassInput uSubpass0; layout(input_attachment_index = 1, set = 0, binding = 1) uniform mediump subpassInput uSubpass1; layout(location = 0) out vec4 FragColor; void main() { FragColor = subpassLoad(uSubpass0) + subpassLoad(uSubpass1); } spirv-cross-2021.01.15/shaders/vulkan/frag/nonuniform-qualifier.vk.nocompat.frag000066400000000000000000000014651400026215700275200ustar00rootroot00000000000000#version 450 #extension GL_EXT_nonuniform_qualifier : require layout(binding = 0) uniform texture2D uSamplers[]; layout(binding = 4) uniform sampler2D uCombinedSamplers[]; layout(binding = 1) uniform sampler uSamps[]; layout(location = 0) flat in int vIndex; layout(location = 1) in vec2 vUV; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 2) uniform UBO { vec4 v[64]; } ubos[]; layout(set = 0, binding = 3) readonly buffer SSBO { vec4 v[]; } ssbos[]; void main() { int i = vIndex; FragColor = texture(sampler2D(uSamplers[nonuniformEXT(i + 10)], uSamps[nonuniformEXT(i + 40)]), vUV); FragColor = texture(uCombinedSamplers[nonuniformEXT(i + 10)], vUV); FragColor += ubos[nonuniformEXT(i + 20)].v[nonuniformEXT(i + 40)]; FragColor += ssbos[nonuniformEXT(i + 50)].v[nonuniformEXT(i + 60)]; } spirv-cross-2021.01.15/shaders/vulkan/frag/push-constant-as-ubo.push-ubo.vk.frag000066400000000000000000000002411400026215700272520ustar00rootroot00000000000000#version 450 layout(push_constant, std140) uniform UBO { float ubo[4]; }; layout(location = 0) out float FragColor; void main() { FragColor = ubo[1]; } spirv-cross-2021.01.15/shaders/vulkan/frag/push-constant.vk.frag000066400000000000000000000004331400026215700243300ustar00rootroot00000000000000#version 310 es precision mediump float; layout(push_constant, std430) uniform PushConstants { vec4 value0; vec4 value1; } push; layout(location = 0) in vec4 vColor; layout(location = 0) out vec4 FragColor; void main() { FragColor = vColor + push.value0 + push.value1; } spirv-cross-2021.01.15/shaders/vulkan/frag/separate-combined-fake-overload.vk.frag000066400000000000000000000006071400026215700276240ustar00rootroot00000000000000#version 450 layout(location = 0) out vec4 FragColor; layout(binding = 0) uniform sampler2D uSamp; layout(binding = 1) uniform texture2D uT; layout(binding = 2) uniform sampler uS; vec4 samp(sampler2D uSamp) { return texture(uSamp, vec2(0.5)); } vec4 samp(texture2D T, sampler S) { return texture(sampler2D(T, S), vec2(0.5)); } void main() { FragColor = samp(uSamp) + samp(uT, uS); } spirv-cross-2021.01.15/shaders/vulkan/frag/separate-sampler-texture-array.vk.frag000066400000000000000000000027551400026215700276120ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump sampler uSampler; layout(set = 0, binding = 1) uniform mediump texture2D uTexture[4]; layout(set = 0, binding = 2) uniform mediump texture3D uTexture3D[4]; layout(set = 0, binding = 3) uniform mediump textureCube uTextureCube[4]; layout(set = 0, binding = 4) uniform mediump texture2DArray uTextureArray[4]; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; vec4 sample_func(mediump sampler samp, vec2 uv) { return texture(sampler2D(uTexture[2], samp), uv); } vec4 sample_func_dual(mediump sampler samp, mediump texture2D tex, vec2 uv) { return texture(sampler2D(tex, samp), uv); } vec4 sample_func_dual_array(mediump sampler samp, mediump texture2D tex[4], vec2 uv) { return texture(sampler2D(tex[1], samp), uv); } void main() { vec2 off = 1.0 / vec2(textureSize(sampler2D(uTexture[1], uSampler), 0)); vec2 off2 = 1.0 / vec2(textureSize(sampler2D(uTexture[2], uSampler), 1)); vec4 c0 = sample_func(uSampler, vTex + off + off2); vec4 c1 = sample_func_dual(uSampler, uTexture[1], vTex + off + off2); vec4 c2 = sample_func_dual_array(uSampler, uTexture, vTex + off + off2); vec4 c3 = texture(sampler2DArray(uTextureArray[3], uSampler), vTex3); vec4 c4 = texture(samplerCube(uTextureCube[1], uSampler), vTex3); vec4 c5 = texture(sampler3D(uTexture3D[2], uSampler), vTex3); FragColor = c0 + c1 + c2 + c3 + c4 + c5; } spirv-cross-2021.01.15/shaders/vulkan/frag/separate-sampler-texture.vk.frag000066400000000000000000000023571400026215700264740ustar00rootroot00000000000000#version 310 es precision mediump float; layout(set = 0, binding = 0) uniform mediump sampler uSampler; layout(set = 0, binding = 1) uniform mediump texture2D uTexture; layout(set = 0, binding = 2) uniform mediump texture3D uTexture3D; layout(set = 0, binding = 3) uniform mediump textureCube uTextureCube; layout(set = 0, binding = 4) uniform mediump texture2DArray uTextureArray; layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 vTex; layout(location = 1) in vec3 vTex3; vec4 sample_func(mediump sampler samp, vec2 uv) { return texture(sampler2D(uTexture, samp), uv); } vec4 sample_func_dual(mediump sampler samp, mediump texture2D tex, vec2 uv) { return texture(sampler2D(tex, samp), uv); } void main() { vec2 off = 1.0 / vec2(textureSize(sampler2D(uTexture, uSampler), 0)); vec2 off2 = 1.0 / vec2(textureSize(sampler2D(uTexture, uSampler), 1)); vec4 c0 = sample_func(uSampler, vTex + off + off2); vec4 c1 = sample_func_dual(uSampler, uTexture, vTex + off + off2); vec4 c2 = texture(sampler2DArray(uTextureArray, uSampler), vTex3); vec4 c3 = texture(samplerCube(uTextureCube, uSampler), vTex3); vec4 c4 = texture(sampler3D(uTexture3D, uSampler), vTex3); FragColor = c0 + c1 + c2 + c3 + c4; } spirv-cross-2021.01.15/shaders/vulkan/frag/shader-arithmetic-8bit.nocompat.vk.frag000066400000000000000000000030141400026215700276000ustar00rootroot00000000000000#version 450 #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require #extension GL_EXT_shader_explicit_arithmetic_types_int16 : require layout(location = 0) flat in ivec4 vColor; layout(location = 0) out ivec4 FragColorInt; layout(location = 1) out uvec4 FragColorUint; layout(push_constant, std140) uniform Push { int8_t i8; uint8_t u8; } registers; layout(binding = 0, std140) uniform UBO { int8_t i8; uint8_t u8; } ubo; layout(binding = 1, std430) buffer SSBO { int8_t i8[16]; uint8_t u8[16]; } ssbo; void packing_int8() { int16_t i16 = 10s; int i32 = 20; i8vec2 i8_2 = unpack8(i16); i8vec4 i8_4 = unpack8(i32); i16 = pack16(i8_2); i32 = pack32(i8_4); ssbo.i8[0] = i8_4.x; ssbo.i8[1] = i8_4.y; ssbo.i8[2] = i8_4.z; ssbo.i8[3] = i8_4.w; } void packing_uint8() { uint16_t u16 = 10us; uint u32 = 20u; u8vec2 u8_2 = unpack8(u16); u8vec4 u8_4 = unpack8(u32); u16 = pack16(u8_2); u32 = pack32(u8_4); ssbo.u8[0] = u8_4.x; ssbo.u8[1] = u8_4.y; ssbo.u8[2] = u8_4.z; ssbo.u8[3] = u8_4.w; } void compute_int8() { i8vec4 tmp = i8vec4(vColor); tmp += registers.i8; tmp += int8_t(-40); tmp += i8vec4(-50); tmp += i8vec4(10, 20, 30, 40); tmp += ssbo.i8[4]; tmp += ubo.i8; FragColorInt = ivec4(tmp); } void compute_uint8() { u8vec4 tmp = u8vec4(vColor); tmp += registers.u8; tmp += uint8_t(-40); tmp += u8vec4(-50); tmp += u8vec4(10, 20, 30, 40); tmp += ssbo.u8[4]; tmp += ubo.u8; FragColorUint = uvec4(tmp); } void main() { packing_int8(); packing_uint8(); compute_int8(); compute_uint8(); } spirv-cross-2021.01.15/shaders/vulkan/frag/spec-constant-block-size.vk.frag000066400000000000000000000004371400026215700263470ustar00rootroot00000000000000#version 310 es precision mediump float; layout(constant_id = 10) const int Value = 2; layout(binding = 0) uniform SpecConstArray { vec4 samples[Value]; }; layout(location = 0) flat in int Index; layout(location = 0) out vec4 FragColor; void main() { FragColor = samples[Index]; } spirv-cross-2021.01.15/shaders/vulkan/frag/spec-constant-ternary.vk.frag000066400000000000000000000002571400026215700257710ustar00rootroot00000000000000#version 450 layout(location = 0) out float FragColor; layout(constant_id = 0) const uint s = 10u; const uint f = s > 20u ? 30u : 50u; void main() { FragColor = float(f); } spirv-cross-2021.01.15/shaders/vulkan/rahit/000077500000000000000000000000001400026215700204325ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/rahit/terminators.khr.spv14.nocompat.vk.rahit000066400000000000000000000003141400026215700300250ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require rayPayloadInEXT float payload; void in_func() { if (payload > 0.0) ignoreIntersectionEXT; else terminateRayEXT; } void main() { in_func(); } spirv-cross-2021.01.15/shaders/vulkan/rahit/terminators.nocompat.vk.rahit000066400000000000000000000003141400026215700262660ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require rayPayloadInNV float payload; void in_func() { if (payload > 0.0) ignoreIntersectionNV(); else terminateRayNV(); } void main() { in_func(); } spirv-cross-2021.01.15/shaders/vulkan/rchit/000077500000000000000000000000001400026215700204345ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_attribute_block.khr.spv14.nocompat.vk.rchit000066400000000000000000000003471400026215700315110ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT Foo { float a; float b; } payload; hitAttributeEXT Foo2 { float a; float b; } hit; void main() { payload.a = hit.a; payload.b = hit.b; } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_attribute_block.nocompat.vk.rchit000066400000000000000000000003441400026215700277470ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV Foo { float a; float b; } payload; hitAttributeNV Foo2 { float a; float b; } hit; void main() { payload.a = hit.a; payload.b = hit.b; } hit_attribute_block_in_function.khr.spv14.nocompat.vk.rchit000066400000000000000000000004171400026215700340230ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/rchit#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT Foo { float a; float b; } payload; hitAttributeEXT Foo2 { float a; float b; } hit; void in_function() { payload.a = hit.a; payload.b = hit.b; } void main() { in_function(); } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_attribute_block_in_function.nocompat.vk.rchit000066400000000000000000000004141400026215700323400ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV Foo { float a; float b; } payload; hitAttributeNV Foo2 { float a; float b; } hit; void in_function() { payload.a = hit.a; payload.b = hit.b; } void main() { in_function(); } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_attribute_plain.khr.spv14.nocompat.vk.rchit000066400000000000000000000002441400026215700315160ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec2 payload; hitAttributeEXT vec2 hit; void main() { payload = hit; } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_attribute_plain.nocompat.vk.rchit000066400000000000000000000002411400026215700277540ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec2 payload; hitAttributeNV vec2 hit; void main() { payload = hit; } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_attribute_struct.khr.spv14.nocompat.vk.rchit000066400000000000000000000003051400026215700317350ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require struct Foo { float a; float b; }; layout(location = 0) rayPayloadInEXT Foo payload; hitAttributeEXT Foo hit; void main() { payload = hit; } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_attribute_struct.nocompat.vk.rchit000066400000000000000000000003021400026215700301730ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Foo { float a; float b; }; layout(location = 0) rayPayloadInNV Foo payload; hitAttributeNV Foo hit; void main() { payload = hit; } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_kind.khr.spv14.nocompat.vk.rchit000066400000000000000000000002241400026215700272530ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = gl_HitKindEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_kind.nocompat.vk.rchit000066400000000000000000000002211400026215700255110ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = gl_HitKindNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_t.khr.spv14.nocompat.vk.rchit000066400000000000000000000002221400026215700265670ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = gl_HitTEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/hit_t.nocompat.vk.rchit000066400000000000000000000002171400026215700250340ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = gl_HitTNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/incoming_ray_flags.khr.spv14.nocompat.vk.rchit000066400000000000000000000002351400026215700313160ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = gl_IncomingRayFlagsEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/incoming_ray_flags.nocompat.vk.rchit000066400000000000000000000002321400026215700275540ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = gl_IncomingRayFlagsNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/instance_custom_id.khr.spv14.nocompat.vk.rchit000066400000000000000000000002401400026215700313320ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = gl_InstanceCustomIndexEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/instance_custom_id.nocompat.vk.rchit000066400000000000000000000002351400026215700275770ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = gl_InstanceCustomIndexNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/instance_id.khr.spv14.nocompat.vk.rchit000066400000000000000000000002241400026215700277420ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = gl_InstanceID; } spirv-cross-2021.01.15/shaders/vulkan/rchit/instance_id.nocompat.vk.rchit000066400000000000000000000002221400026215700262010ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = gl_InstanceID; } spirv-cross-2021.01.15/shaders/vulkan/rchit/object_ray_direction.khr.spv14.nocompat.vk.rchit000066400000000000000000000002371400026215700316470ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_ObjectRayDirectionEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/object_ray_direction.nocompat.vk.rchit000066400000000000000000000002341400026215700301050ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_ObjectRayDirectionNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/object_ray_origin.khr.spv14.nocompat.vk.rchit000066400000000000000000000002341400026215700311530ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_ObjectRayOriginEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/object_ray_origin.nocompat.vk.rchit000066400000000000000000000002311400026215700274110ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_ObjectRayOriginNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/object_to_world.khr.spv14.nocompat.vk.rchit000066400000000000000000000002571400026215700306470ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_ObjectToWorldEXT * vec4(payload, 1.0); } spirv-cross-2021.01.15/shaders/vulkan/rchit/object_to_world.nocompat.vk.rchit000066400000000000000000000002541400026215700271050ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_ObjectToWorldNV * vec4(payload, 1.0); } spirv-cross-2021.01.15/shaders/vulkan/rchit/payloads.khr.spv14.nocompat.vk.rchit000066400000000000000000000004131400026215700272760ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require struct Payload { vec4 a; }; layout(location = 0) rayPayloadInEXT Payload payload; void write_incoming_payload_in_function() { payload.a = vec4(10.0); } void main() { write_incoming_payload_in_function(); } spirv-cross-2021.01.15/shaders/vulkan/rchit/payloads.nocompat.vk.rchit000066400000000000000000000004111400026215700255350ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require struct Payload { vec4 a; }; layout(location = 0) rayPayloadInNV Payload payload; void write_incoming_payload_in_function() { payload.a = vec4(10.0); } void main() { write_incoming_payload_in_function(); } spirv-cross-2021.01.15/shaders/vulkan/rchit/primitive_id.khr.spv14.nocompat.vk.rchit000066400000000000000000000002251400026215700301470ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT uint payload; void main() { payload = gl_PrimitiveID; } spirv-cross-2021.01.15/shaders/vulkan/rchit/primitive_id.nocompat.vk.rchit000066400000000000000000000002231400026215700264060ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV uint payload; void main() { payload = gl_PrimitiveID; } spirv-cross-2021.01.15/shaders/vulkan/rchit/ray_tmax.khr.spv14.nocompat.vk.rchit000066400000000000000000000002251400026215700273070ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = gl_RayTmaxEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/ray_tmax.nocompat.vk.rchit000066400000000000000000000002221400026215700255450ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = gl_RayTmaxNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/ray_tmin.khr.spv14.nocompat.vk.rchit000066400000000000000000000002251400026215700273050ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = gl_RayTminEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/ray_tmin.nocompat.vk.rchit000066400000000000000000000002221400026215700255430ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = gl_RayTminNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/ray_tracing.khr.spv14.nocompat.vk.rchit000066400000000000000000000002451400026215700277670ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = 1.0 + float(gl_InstanceID); } spirv-cross-2021.01.15/shaders/vulkan/rchit/ray_tracing.nocompat.vk.rchit000066400000000000000000000002431400026215700262260ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = 1.0 + float(gl_InstanceID); } spirv-cross-2021.01.15/shaders/vulkan/rchit/world_ray_direction.khr.spv14.nocompat.vk.rchit000066400000000000000000000002361400026215700315270ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_WorldRayDirectionEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/world_ray_direction.nocompat.vk.rchit000066400000000000000000000002331400026215700277650ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_WorldRayDirectionNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/world_ray_origin.khr.spv14.nocompat.vk.rchit000066400000000000000000000002331400026215700310330ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_WorldRayOriginEXT; } spirv-cross-2021.01.15/shaders/vulkan/rchit/world_ray_origin.nocompat.vk.rchit000066400000000000000000000002301400026215700272710ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_WorldRayOriginNV; } spirv-cross-2021.01.15/shaders/vulkan/rchit/world_to_object.khr.spv14.nocompat.vk.rchit000066400000000000000000000002571400026215700306470ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 payload; void main() { payload = gl_WorldToObjectEXT * vec4(payload, 1.0); } spirv-cross-2021.01.15/shaders/vulkan/rchit/world_to_object.nocompat.vk.rchit000066400000000000000000000002541400026215700271050ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV vec3 payload; void main() { payload = gl_WorldToObjectNV * vec4(payload, 1.0); } spirv-cross-2021.01.15/shaders/vulkan/rgen/000077500000000000000000000000001400026215700202565ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/rgen/convert-u-to-as.spv14.vk.nocompat.rgen000066400000000000000000000005651400026215700273160ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 3) rayPayloadEXT vec4 payload; layout(push_constant) uniform Registers { uvec2 ptr; }; void main() { vec3 origin = vec3(0.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceRayEXT(accelerationStructureEXT(ptr), gl_RayFlagsOpaqueEXT, 0xFF, 0u, 0u, 0u, origin, 0.0, direction, 100.0f, 3); } spirv-cross-2021.01.15/shaders/vulkan/rgen/execute_callable.nocompat.khr.spv14.vk.rgen000066400000000000000000000011021400026215700304030ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0) uniform accelerationStructureEXT as; layout(set = 0, binding = 1, rgba32f) uniform writeonly image2D image; layout(location = 3) rayPayloadEXT vec4 payload; layout(location = 4) callableDataEXT float blend; void main() { vec3 origin = vec3(0.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceRayEXT(as, gl_RayFlagsOpaqueEXT, 0xFF, 0u, 0u, 0u, origin, 0.0, direction, 100.0f, 3); executeCallableEXT(0u, 4); imageStore(image, ivec2(gl_LaunchIDEXT.xy), payload + vec4(blend)); } spirv-cross-2021.01.15/shaders/vulkan/rgen/execute_callable.nocompat.vk.rgen000066400000000000000000000010671400026215700266560ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0) uniform accelerationStructureNV as; layout(set = 0, binding = 1, rgba32f) uniform writeonly image2D image; layout(location = 0) rayPayloadNV vec4 payload; layout(location = 0) callableDataNV float blend; void main() { vec3 origin = vec3(0.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceNV(as, gl_RayFlagsOpaqueNV, 0xFF, 0u, 0u, 0u, origin, 0.0, direction, 100.0f, 0); executeCallableNV(0u, 0); imageStore(image, ivec2(gl_LaunchIDNV.xy), payload + vec4(blend)); } spirv-cross-2021.01.15/shaders/vulkan/rgen/launch_id.khr.spv14.nocompat.vk.rgen000066400000000000000000000003001400026215700270470ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchIDEXT.xy), vec4(1.0)); } spirv-cross-2021.01.15/shaders/vulkan/rgen/launch_id.nocompat.vk.rgen000066400000000000000000000002761400026215700253240ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchIDNV.xy), vec4(1.0)); } spirv-cross-2021.01.15/shaders/vulkan/rgen/launch_size.khr.spv14.nocompat.vk.rgen000066400000000000000000000003061400026215700274330ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchSizeEXT.xy) - 1, vec4(1.0)); } spirv-cross-2021.01.15/shaders/vulkan/rgen/launch_size.nocompat.vk.rgen000066400000000000000000000003041400026215700256720ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0) uniform writeonly image2D uImage; void main() { imageStore(uImage, ivec2(gl_LaunchSizeNV.xy) - 1, vec4(1.0)); } spirv-cross-2021.01.15/shaders/vulkan/rgen/payloads.khr.spv14.nocompat.vk.rgen000066400000000000000000000023471400026215700267520ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0, rgba8) uniform image2D image; layout(set = 0, binding = 1) uniform accelerationStructureEXT as; struct Payload { float a, b; }; // Plain payload layout(location = 0) rayPayloadEXT float payload1; // Struct payload layout(location = 1) rayPayloadEXT Payload payload2; // This is syntactic sugar with the struct formulation (pretty sure), spec is kinda vague. layout(location = 2) rayPayloadEXT Block { float a, b; Payload c, d; }; vec4 trace_in_function() { vec4 result = vec4(0.0); // Test that we can write to a payload in a function. vec3 origin = vec3(1.0, 0.0, 0.0); vec3 direction = vec3(0.0, 1.0, 0.0); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 1); result += payload2.a; result += payload2.b; return result; } void main() { vec3 origin = vec3(1.0, 0.0, 0.0); vec3 direction = vec3(0.0, 1.0, 0.0); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); vec4 result = vec4(payload1); result += trace_in_function(); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 2); result += a + b + c.a + c.b + d.a + d.b; imageStore(image, ivec2(gl_LaunchIDEXT.xy), result); } spirv-cross-2021.01.15/shaders/vulkan/rgen/payloads.nocompat.vk.rgen000066400000000000000000000023251400026215700252070ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0, rgba8) uniform image2D image; layout(set = 0, binding = 1) uniform accelerationStructureNV as; struct Payload { float a, b; }; // Plain payload layout(location = 0) rayPayloadNV float payload1; // Struct payload layout(location = 1) rayPayloadNV Payload payload2; // This is syntactic sugar with the struct formulation (pretty sure), spec is kinda vague. layout(location = 2) rayPayloadNV Block { float a, b; Payload c, d; }; vec4 trace_in_function() { vec4 result = vec4(0.0); // Test that we can write to a payload in a function. vec3 origin = vec3(1.0, 0.0, 0.0); vec3 direction = vec3(0.0, 1.0, 0.0); traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 1); result += payload2.a; result += payload2.b; return result; } void main() { vec3 origin = vec3(1.0, 0.0, 0.0); vec3 direction = vec3(0.0, 1.0, 0.0); traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); vec4 result = vec4(payload1); result += trace_in_function(); traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 2); result += a + b + c.a + c.b + d.a + d.b; imageStore(image, ivec2(gl_LaunchIDNV.xy), result); } spirv-cross-2021.01.15/shaders/vulkan/rgen/pure_call.khr.spv14.nocompat.vk.rgen000066400000000000000000000010171400026215700270750ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT float payload; float pure_call(vec2 launchID, vec2 launchSize) { vec3 origin = vec3(launchID.x / launchSize.x, launchID.y / launchSize.y, 1.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); return 0.0; } void main() { pure_call(vec2(gl_LaunchIDEXT.xy), vec2(gl_LaunchSizeEXT.xy)); } spirv-cross-2021.01.15/shaders/vulkan/rgen/pure_call.nocompat.vk.rgen000066400000000000000000000010061400026215700253340ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 1) uniform accelerationStructureNV as; layout(location = 0) rayPayloadNV float payload; float pure_call(vec2 launchID, vec2 launchSize) { vec3 origin = vec3(launchID.x / launchSize.x, launchID.y / launchSize.y, 1.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); return 0.0; } void main() { pure_call(vec2(gl_LaunchIDNV.xy), vec2(gl_LaunchSizeNV.xy)); } spirv-cross-2021.01.15/shaders/vulkan/rgen/ray_tracing.khr.spv14.nocompat.vk.rgen000066400000000000000000000011521400026215700274310ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(set = 0, binding = 0, rgba8) uniform image2D image; layout(set = 0, binding = 1) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT float payload; void main() { vec4 col = vec4(0.0, 0.0, 0.0, 1.0); vec3 origin = vec3(float(gl_LaunchIDEXT.x) / float(gl_LaunchSizeEXT.x), float(gl_LaunchIDEXT.y) / float(gl_LaunchSizeEXT.y), 1.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); col.y = payload; imageStore(image, ivec2(gl_LaunchIDEXT.xy), col); } spirv-cross-2021.01.15/shaders/vulkan/rgen/ray_tracing.nocompat.vk.rgen000066400000000000000000000011361400026215700256740ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(set = 0, binding = 0, rgba8) uniform image2D image; layout(set = 0, binding = 1) uniform accelerationStructureNV as; layout(location = 0) rayPayloadNV float payload; void main() { vec4 col = vec4(0.0, 0.0, 0.0, 1.0); vec3 origin = vec3(float(gl_LaunchIDNV.x) / float(gl_LaunchSizeNV.x), float(gl_LaunchIDNV.y) / float(gl_LaunchSizeNV.y), 1.0); vec3 direction = vec3(0.0, 0.0, -1.0); traceNV(as, 0u, 255u, 0u, 1u, 0u, origin, 0.0, direction, 1000.0, 0); col.y = payload; imageStore(image, ivec2(gl_LaunchIDNV.xy), col); } spirv-cross-2021.01.15/shaders/vulkan/rgen/shader_record_buffer.khr.spv14.nocompat.vk.rgen000066400000000000000000000005371400026215700312720ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(shaderRecordEXT, std430) buffer sbt { vec3 direction; float tmax; }; layout(set = 0, binding = 0) uniform accelerationStructureEXT as; layout(location = 0) rayPayloadEXT float payload; void main() { traceRayEXT(as, 0u, 255u, 0u, 1u, 0u, vec3(0.0), 0.0, direction, tmax, 0); } spirv-cross-2021.01.15/shaders/vulkan/rgen/shader_record_buffer.nocompat.vk.rgen000066400000000000000000000005271400026215700275320ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(shaderRecordNV, std430) buffer sbt { vec3 direction; float tmax; }; layout(set = 0, binding = 0) uniform accelerationStructureNV as; layout(location = 0) rayPayloadNV float payload; void main() { traceNV(as, 0u, 255u, 0u, 1u, 0u, vec3(0.0), 0.0, direction, tmax, 0); } spirv-cross-2021.01.15/shaders/vulkan/rint/000077500000000000000000000000001400026215700202775ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/rint/report-intersection.khr.spv14.nocompat.vk.rint000066400000000000000000000002071400026215700312100ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require void in_func() { reportIntersectionEXT(0.5, 10); } void main() { in_func(); } spirv-cross-2021.01.15/shaders/vulkan/rint/report-intersection.nocompat.vk.rint000066400000000000000000000002051400026215700274470ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require void in_func() { reportIntersectionNV(0.5, 10); } void main() { in_func(); } spirv-cross-2021.01.15/shaders/vulkan/rmiss/000077500000000000000000000000001400026215700204605ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/rmiss/ray_tracing.khr.spv14.nocompat.vk.rmiss000066400000000000000000000002161400026215700300350ustar00rootroot00000000000000#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT float payload; void main() { payload = 0.0; } spirv-cross-2021.01.15/shaders/vulkan/rmiss/ray_tracing.nocompat.vk.rmiss000066400000000000000000000002141400026215700262740ustar00rootroot00000000000000#version 460 #extension GL_NV_ray_tracing : require layout(location = 0) rayPayloadInNV float payload; void main() { payload = 0.0; } spirv-cross-2021.01.15/shaders/vulkan/vert/000077500000000000000000000000001400026215700203035ustar00rootroot00000000000000spirv-cross-2021.01.15/shaders/vulkan/vert/device-group.nocompat.vk.vert000066400000000000000000000001611400026215700260320ustar00rootroot00000000000000#version 450 core #extension GL_EXT_device_group : require void main() { gl_Position = vec4(gl_DeviceIndex); } spirv-cross-2021.01.15/shaders/vulkan/vert/multiview.nocompat.vk.vert000066400000000000000000000003311400026215700254650ustar00rootroot00000000000000#version 310 es #extension GL_EXT_multiview : require layout(std140, binding = 0) uniform MVPs { mat4 MVP[2]; }; layout(location = 0) in vec4 Position; void main() { gl_Position = MVP[gl_ViewIndex] * Position; } spirv-cross-2021.01.15/shaders/vulkan/vert/small-storage.vk.vert000066400000000000000000000022411400026215700243750ustar00rootroot00000000000000#version 450 core // GL_EXT_shader_16bit_storage doesn't support input/output. #extension GL_EXT_shader_8bit_storage : require #extension GL_AMD_gpu_shader_int16 : require #extension GL_AMD_gpu_shader_half_float : require layout(location = 0, component = 0) in int16_t foo; layout(location = 0, component = 1) in uint16_t bar; layout(location = 1) in float16_t baz; layout(binding = 0) uniform block { i16vec2 a; u16vec2 b; i8vec2 c; u8vec2 d; f16vec2 e; }; layout(binding = 1) readonly buffer storage { i16vec3 f; u16vec3 g; i8vec3 h; u8vec3 i; f16vec3 j; }; layout(push_constant) uniform pushconst { i16vec4 k; u16vec4 l; i8vec4 m; u8vec4 n; f16vec4 o; }; layout(location = 0) out i16vec4 p; layout(location = 1) out u16vec4 q; layout(location = 2) out f16vec4 r; void main() { p = i16vec4(int(foo) + ivec4(ivec2(a), ivec2(c)) - ivec4(ivec3(f) / ivec3(h), 1) + ivec4(k) + ivec4(m)); q = u16vec4(uint(bar) + uvec4(uvec2(b), uvec2(d)) - uvec4(uvec3(g) / uvec3(i), 1) + uvec4(l) + uvec4(n)); r = f16vec4(float(baz) + vec4(vec2(e), 0, 1) - vec4(vec3(j), 1) + vec4(o)); gl_Position = vec4(0, 0, 0, 1); } spirv-cross-2021.01.15/shaders/vulkan/vert/vulkan-vertex.vk.vert000066400000000000000000000001671400026215700244430ustar00rootroot00000000000000#version 310 es void main() { gl_Position = float(gl_VertexIndex + gl_InstanceIndex) * vec4(1.0, 2.0, 3.0, 4.0); } spirv-cross-2021.01.15/spirv.h000066400000000000000000003337511400026215700157220ustar00rootroot00000000000000/* ** Copyright (c) 2014-2020 The Khronos Group Inc. ** ** Permission is hereby granted, free of charge, to any person obtaining a copy ** of this software and/or associated documentation files (the "Materials"), ** to deal in the Materials without restriction, including without limitation ** the rights to use, copy, modify, merge, publish, distribute, sublicense, ** and/or sell copies of the Materials, and to permit persons to whom the ** Materials are furnished to do so, subject to the following conditions: ** ** The above copyright notice and this permission notice shall be included in ** all copies or substantial portions of the Materials. ** ** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS ** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND ** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ** ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING ** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS ** IN THE MATERIALS. */ /* ** This header is automatically generated by the same tool that creates ** the Binary Section of the SPIR-V specification. */ /* ** Enumeration tokens for SPIR-V, in various styles: ** C, C++, C++11, JSON, Lua, Python, C#, D ** ** - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL ** - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL ** - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL ** - Lua will use tables, e.g.: spv.SourceLanguage.GLSL ** - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL'] ** - C# will use enum classes in the Specification class located in the "Spv" namespace, ** e.g.: Spv.Specification.SourceLanguage.GLSL ** - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL ** ** Some tokens act like mask values, which can be OR'd together, ** while others are mutually exclusive. The mask-like ones have ** "Mask" in their name, and a parallel enum that has the shift ** amount (1 << x) for each corresponding enumerant. */ #ifndef spirv_H #define spirv_H typedef unsigned int SpvId; #define SPV_VERSION 0x10500 #define SPV_REVISION 4 static const unsigned int SpvMagicNumber = 0x07230203; static const unsigned int SpvVersion = 0x00010500; static const unsigned int SpvRevision = 4; static const unsigned int SpvOpCodeMask = 0xffff; static const unsigned int SpvWordCountShift = 16; typedef enum SpvSourceLanguage_ { SpvSourceLanguageUnknown = 0, SpvSourceLanguageESSL = 1, SpvSourceLanguageGLSL = 2, SpvSourceLanguageOpenCL_C = 3, SpvSourceLanguageOpenCL_CPP = 4, SpvSourceLanguageHLSL = 5, SpvSourceLanguageMax = 0x7fffffff, } SpvSourceLanguage; typedef enum SpvExecutionModel_ { SpvExecutionModelVertex = 0, SpvExecutionModelTessellationControl = 1, SpvExecutionModelTessellationEvaluation = 2, SpvExecutionModelGeometry = 3, SpvExecutionModelFragment = 4, SpvExecutionModelGLCompute = 5, SpvExecutionModelKernel = 6, SpvExecutionModelTaskNV = 5267, SpvExecutionModelMeshNV = 5268, SpvExecutionModelRayGenerationKHR = 5313, SpvExecutionModelRayGenerationNV = 5313, SpvExecutionModelIntersectionKHR = 5314, SpvExecutionModelIntersectionNV = 5314, SpvExecutionModelAnyHitKHR = 5315, SpvExecutionModelAnyHitNV = 5315, SpvExecutionModelClosestHitKHR = 5316, SpvExecutionModelClosestHitNV = 5316, SpvExecutionModelMissKHR = 5317, SpvExecutionModelMissNV = 5317, SpvExecutionModelCallableKHR = 5318, SpvExecutionModelCallableNV = 5318, SpvExecutionModelMax = 0x7fffffff, } SpvExecutionModel; typedef enum SpvAddressingModel_ { SpvAddressingModelLogical = 0, SpvAddressingModelPhysical32 = 1, SpvAddressingModelPhysical64 = 2, SpvAddressingModelPhysicalStorageBuffer64 = 5348, SpvAddressingModelPhysicalStorageBuffer64EXT = 5348, SpvAddressingModelMax = 0x7fffffff, } SpvAddressingModel; typedef enum SpvMemoryModel_ { SpvMemoryModelSimple = 0, SpvMemoryModelGLSL450 = 1, SpvMemoryModelOpenCL = 2, SpvMemoryModelVulkan = 3, SpvMemoryModelVulkanKHR = 3, SpvMemoryModelMax = 0x7fffffff, } SpvMemoryModel; typedef enum SpvExecutionMode_ { SpvExecutionModeInvocations = 0, SpvExecutionModeSpacingEqual = 1, SpvExecutionModeSpacingFractionalEven = 2, SpvExecutionModeSpacingFractionalOdd = 3, SpvExecutionModeVertexOrderCw = 4, SpvExecutionModeVertexOrderCcw = 5, SpvExecutionModePixelCenterInteger = 6, SpvExecutionModeOriginUpperLeft = 7, SpvExecutionModeOriginLowerLeft = 8, SpvExecutionModeEarlyFragmentTests = 9, SpvExecutionModePointMode = 10, SpvExecutionModeXfb = 11, SpvExecutionModeDepthReplacing = 12, SpvExecutionModeDepthGreater = 14, SpvExecutionModeDepthLess = 15, SpvExecutionModeDepthUnchanged = 16, SpvExecutionModeLocalSize = 17, SpvExecutionModeLocalSizeHint = 18, SpvExecutionModeInputPoints = 19, SpvExecutionModeInputLines = 20, SpvExecutionModeInputLinesAdjacency = 21, SpvExecutionModeTriangles = 22, SpvExecutionModeInputTrianglesAdjacency = 23, SpvExecutionModeQuads = 24, SpvExecutionModeIsolines = 25, SpvExecutionModeOutputVertices = 26, SpvExecutionModeOutputPoints = 27, SpvExecutionModeOutputLineStrip = 28, SpvExecutionModeOutputTriangleStrip = 29, SpvExecutionModeVecTypeHint = 30, SpvExecutionModeContractionOff = 31, SpvExecutionModeInitializer = 33, SpvExecutionModeFinalizer = 34, SpvExecutionModeSubgroupSize = 35, SpvExecutionModeSubgroupsPerWorkgroup = 36, SpvExecutionModeSubgroupsPerWorkgroupId = 37, SpvExecutionModeLocalSizeId = 38, SpvExecutionModeLocalSizeHintId = 39, SpvExecutionModePostDepthCoverage = 4446, SpvExecutionModeDenormPreserve = 4459, SpvExecutionModeDenormFlushToZero = 4460, SpvExecutionModeSignedZeroInfNanPreserve = 4461, SpvExecutionModeRoundingModeRTE = 4462, SpvExecutionModeRoundingModeRTZ = 4463, SpvExecutionModeStencilRefReplacingEXT = 5027, SpvExecutionModeOutputLinesNV = 5269, SpvExecutionModeOutputPrimitivesNV = 5270, SpvExecutionModeDerivativeGroupQuadsNV = 5289, SpvExecutionModeDerivativeGroupLinearNV = 5290, SpvExecutionModeOutputTrianglesNV = 5298, SpvExecutionModePixelInterlockOrderedEXT = 5366, SpvExecutionModePixelInterlockUnorderedEXT = 5367, SpvExecutionModeSampleInterlockOrderedEXT = 5368, SpvExecutionModeSampleInterlockUnorderedEXT = 5369, SpvExecutionModeShadingRateInterlockOrderedEXT = 5370, SpvExecutionModeShadingRateInterlockUnorderedEXT = 5371, SpvExecutionModeMaxWorkgroupSizeINTEL = 5893, SpvExecutionModeMaxWorkDimINTEL = 5894, SpvExecutionModeNoGlobalOffsetINTEL = 5895, SpvExecutionModeNumSIMDWorkitemsINTEL = 5896, SpvExecutionModeMax = 0x7fffffff, } SpvExecutionMode; typedef enum SpvStorageClass_ { SpvStorageClassUniformConstant = 0, SpvStorageClassInput = 1, SpvStorageClassUniform = 2, SpvStorageClassOutput = 3, SpvStorageClassWorkgroup = 4, SpvStorageClassCrossWorkgroup = 5, SpvStorageClassPrivate = 6, SpvStorageClassFunction = 7, SpvStorageClassGeneric = 8, SpvStorageClassPushConstant = 9, SpvStorageClassAtomicCounter = 10, SpvStorageClassImage = 11, SpvStorageClassStorageBuffer = 12, SpvStorageClassCallableDataKHR = 5328, SpvStorageClassCallableDataNV = 5328, SpvStorageClassIncomingCallableDataKHR = 5329, SpvStorageClassIncomingCallableDataNV = 5329, SpvStorageClassRayPayloadKHR = 5338, SpvStorageClassRayPayloadNV = 5338, SpvStorageClassHitAttributeKHR = 5339, SpvStorageClassHitAttributeNV = 5339, SpvStorageClassIncomingRayPayloadKHR = 5342, SpvStorageClassIncomingRayPayloadNV = 5342, SpvStorageClassShaderRecordBufferKHR = 5343, SpvStorageClassShaderRecordBufferNV = 5343, SpvStorageClassPhysicalStorageBuffer = 5349, SpvStorageClassPhysicalStorageBufferEXT = 5349, SpvStorageClassCodeSectionINTEL = 5605, SpvStorageClassMax = 0x7fffffff, } SpvStorageClass; typedef enum SpvDim_ { SpvDim1D = 0, SpvDim2D = 1, SpvDim3D = 2, SpvDimCube = 3, SpvDimRect = 4, SpvDimBuffer = 5, SpvDimSubpassData = 6, SpvDimMax = 0x7fffffff, } SpvDim; typedef enum SpvSamplerAddressingMode_ { SpvSamplerAddressingModeNone = 0, SpvSamplerAddressingModeClampToEdge = 1, SpvSamplerAddressingModeClamp = 2, SpvSamplerAddressingModeRepeat = 3, SpvSamplerAddressingModeRepeatMirrored = 4, SpvSamplerAddressingModeMax = 0x7fffffff, } SpvSamplerAddressingMode; typedef enum SpvSamplerFilterMode_ { SpvSamplerFilterModeNearest = 0, SpvSamplerFilterModeLinear = 1, SpvSamplerFilterModeMax = 0x7fffffff, } SpvSamplerFilterMode; typedef enum SpvImageFormat_ { SpvImageFormatUnknown = 0, SpvImageFormatRgba32f = 1, SpvImageFormatRgba16f = 2, SpvImageFormatR32f = 3, SpvImageFormatRgba8 = 4, SpvImageFormatRgba8Snorm = 5, SpvImageFormatRg32f = 6, SpvImageFormatRg16f = 7, SpvImageFormatR11fG11fB10f = 8, SpvImageFormatR16f = 9, SpvImageFormatRgba16 = 10, SpvImageFormatRgb10A2 = 11, SpvImageFormatRg16 = 12, SpvImageFormatRg8 = 13, SpvImageFormatR16 = 14, SpvImageFormatR8 = 15, SpvImageFormatRgba16Snorm = 16, SpvImageFormatRg16Snorm = 17, SpvImageFormatRg8Snorm = 18, SpvImageFormatR16Snorm = 19, SpvImageFormatR8Snorm = 20, SpvImageFormatRgba32i = 21, SpvImageFormatRgba16i = 22, SpvImageFormatRgba8i = 23, SpvImageFormatR32i = 24, SpvImageFormatRg32i = 25, SpvImageFormatRg16i = 26, SpvImageFormatRg8i = 27, SpvImageFormatR16i = 28, SpvImageFormatR8i = 29, SpvImageFormatRgba32ui = 30, SpvImageFormatRgba16ui = 31, SpvImageFormatRgba8ui = 32, SpvImageFormatR32ui = 33, SpvImageFormatRgb10a2ui = 34, SpvImageFormatRg32ui = 35, SpvImageFormatRg16ui = 36, SpvImageFormatRg8ui = 37, SpvImageFormatR16ui = 38, SpvImageFormatR8ui = 39, SpvImageFormatR64ui = 40, SpvImageFormatR64i = 41, SpvImageFormatMax = 0x7fffffff, } SpvImageFormat; typedef enum SpvImageChannelOrder_ { SpvImageChannelOrderR = 0, SpvImageChannelOrderA = 1, SpvImageChannelOrderRG = 2, SpvImageChannelOrderRA = 3, SpvImageChannelOrderRGB = 4, SpvImageChannelOrderRGBA = 5, SpvImageChannelOrderBGRA = 6, SpvImageChannelOrderARGB = 7, SpvImageChannelOrderIntensity = 8, SpvImageChannelOrderLuminance = 9, SpvImageChannelOrderRx = 10, SpvImageChannelOrderRGx = 11, SpvImageChannelOrderRGBx = 12, SpvImageChannelOrderDepth = 13, SpvImageChannelOrderDepthStencil = 14, SpvImageChannelOrdersRGB = 15, SpvImageChannelOrdersRGBx = 16, SpvImageChannelOrdersRGBA = 17, SpvImageChannelOrdersBGRA = 18, SpvImageChannelOrderABGR = 19, SpvImageChannelOrderMax = 0x7fffffff, } SpvImageChannelOrder; typedef enum SpvImageChannelDataType_ { SpvImageChannelDataTypeSnormInt8 = 0, SpvImageChannelDataTypeSnormInt16 = 1, SpvImageChannelDataTypeUnormInt8 = 2, SpvImageChannelDataTypeUnormInt16 = 3, SpvImageChannelDataTypeUnormShort565 = 4, SpvImageChannelDataTypeUnormShort555 = 5, SpvImageChannelDataTypeUnormInt101010 = 6, SpvImageChannelDataTypeSignedInt8 = 7, SpvImageChannelDataTypeSignedInt16 = 8, SpvImageChannelDataTypeSignedInt32 = 9, SpvImageChannelDataTypeUnsignedInt8 = 10, SpvImageChannelDataTypeUnsignedInt16 = 11, SpvImageChannelDataTypeUnsignedInt32 = 12, SpvImageChannelDataTypeHalfFloat = 13, SpvImageChannelDataTypeFloat = 14, SpvImageChannelDataTypeUnormInt24 = 15, SpvImageChannelDataTypeUnormInt101010_2 = 16, SpvImageChannelDataTypeMax = 0x7fffffff, } SpvImageChannelDataType; typedef enum SpvImageOperandsShift_ { SpvImageOperandsBiasShift = 0, SpvImageOperandsLodShift = 1, SpvImageOperandsGradShift = 2, SpvImageOperandsConstOffsetShift = 3, SpvImageOperandsOffsetShift = 4, SpvImageOperandsConstOffsetsShift = 5, SpvImageOperandsSampleShift = 6, SpvImageOperandsMinLodShift = 7, SpvImageOperandsMakeTexelAvailableShift = 8, SpvImageOperandsMakeTexelAvailableKHRShift = 8, SpvImageOperandsMakeTexelVisibleShift = 9, SpvImageOperandsMakeTexelVisibleKHRShift = 9, SpvImageOperandsNonPrivateTexelShift = 10, SpvImageOperandsNonPrivateTexelKHRShift = 10, SpvImageOperandsVolatileTexelShift = 11, SpvImageOperandsVolatileTexelKHRShift = 11, SpvImageOperandsSignExtendShift = 12, SpvImageOperandsZeroExtendShift = 13, SpvImageOperandsMax = 0x7fffffff, } SpvImageOperandsShift; typedef enum SpvImageOperandsMask_ { SpvImageOperandsMaskNone = 0, SpvImageOperandsBiasMask = 0x00000001, SpvImageOperandsLodMask = 0x00000002, SpvImageOperandsGradMask = 0x00000004, SpvImageOperandsConstOffsetMask = 0x00000008, SpvImageOperandsOffsetMask = 0x00000010, SpvImageOperandsConstOffsetsMask = 0x00000020, SpvImageOperandsSampleMask = 0x00000040, SpvImageOperandsMinLodMask = 0x00000080, SpvImageOperandsMakeTexelAvailableMask = 0x00000100, SpvImageOperandsMakeTexelAvailableKHRMask = 0x00000100, SpvImageOperandsMakeTexelVisibleMask = 0x00000200, SpvImageOperandsMakeTexelVisibleKHRMask = 0x00000200, SpvImageOperandsNonPrivateTexelMask = 0x00000400, SpvImageOperandsNonPrivateTexelKHRMask = 0x00000400, SpvImageOperandsVolatileTexelMask = 0x00000800, SpvImageOperandsVolatileTexelKHRMask = 0x00000800, SpvImageOperandsSignExtendMask = 0x00001000, SpvImageOperandsZeroExtendMask = 0x00002000, } SpvImageOperandsMask; typedef enum SpvFPFastMathModeShift_ { SpvFPFastMathModeNotNaNShift = 0, SpvFPFastMathModeNotInfShift = 1, SpvFPFastMathModeNSZShift = 2, SpvFPFastMathModeAllowRecipShift = 3, SpvFPFastMathModeFastShift = 4, SpvFPFastMathModeMax = 0x7fffffff, } SpvFPFastMathModeShift; typedef enum SpvFPFastMathModeMask_ { SpvFPFastMathModeMaskNone = 0, SpvFPFastMathModeNotNaNMask = 0x00000001, SpvFPFastMathModeNotInfMask = 0x00000002, SpvFPFastMathModeNSZMask = 0x00000004, SpvFPFastMathModeAllowRecipMask = 0x00000008, SpvFPFastMathModeFastMask = 0x00000010, } SpvFPFastMathModeMask; typedef enum SpvFPRoundingMode_ { SpvFPRoundingModeRTE = 0, SpvFPRoundingModeRTZ = 1, SpvFPRoundingModeRTP = 2, SpvFPRoundingModeRTN = 3, SpvFPRoundingModeMax = 0x7fffffff, } SpvFPRoundingMode; typedef enum SpvLinkageType_ { SpvLinkageTypeExport = 0, SpvLinkageTypeImport = 1, SpvLinkageTypeMax = 0x7fffffff, } SpvLinkageType; typedef enum SpvAccessQualifier_ { SpvAccessQualifierReadOnly = 0, SpvAccessQualifierWriteOnly = 1, SpvAccessQualifierReadWrite = 2, SpvAccessQualifierMax = 0x7fffffff, } SpvAccessQualifier; typedef enum SpvFunctionParameterAttribute_ { SpvFunctionParameterAttributeZext = 0, SpvFunctionParameterAttributeSext = 1, SpvFunctionParameterAttributeByVal = 2, SpvFunctionParameterAttributeSret = 3, SpvFunctionParameterAttributeNoAlias = 4, SpvFunctionParameterAttributeNoCapture = 5, SpvFunctionParameterAttributeNoWrite = 6, SpvFunctionParameterAttributeNoReadWrite = 7, SpvFunctionParameterAttributeMax = 0x7fffffff, } SpvFunctionParameterAttribute; typedef enum SpvDecoration_ { SpvDecorationRelaxedPrecision = 0, SpvDecorationSpecId = 1, SpvDecorationBlock = 2, SpvDecorationBufferBlock = 3, SpvDecorationRowMajor = 4, SpvDecorationColMajor = 5, SpvDecorationArrayStride = 6, SpvDecorationMatrixStride = 7, SpvDecorationGLSLShared = 8, SpvDecorationGLSLPacked = 9, SpvDecorationCPacked = 10, SpvDecorationBuiltIn = 11, SpvDecorationNoPerspective = 13, SpvDecorationFlat = 14, SpvDecorationPatch = 15, SpvDecorationCentroid = 16, SpvDecorationSample = 17, SpvDecorationInvariant = 18, SpvDecorationRestrict = 19, SpvDecorationAliased = 20, SpvDecorationVolatile = 21, SpvDecorationConstant = 22, SpvDecorationCoherent = 23, SpvDecorationNonWritable = 24, SpvDecorationNonReadable = 25, SpvDecorationUniform = 26, SpvDecorationUniformId = 27, SpvDecorationSaturatedConversion = 28, SpvDecorationStream = 29, SpvDecorationLocation = 30, SpvDecorationComponent = 31, SpvDecorationIndex = 32, SpvDecorationBinding = 33, SpvDecorationDescriptorSet = 34, SpvDecorationOffset = 35, SpvDecorationXfbBuffer = 36, SpvDecorationXfbStride = 37, SpvDecorationFuncParamAttr = 38, SpvDecorationFPRoundingMode = 39, SpvDecorationFPFastMathMode = 40, SpvDecorationLinkageAttributes = 41, SpvDecorationNoContraction = 42, SpvDecorationInputAttachmentIndex = 43, SpvDecorationAlignment = 44, SpvDecorationMaxByteOffset = 45, SpvDecorationAlignmentId = 46, SpvDecorationMaxByteOffsetId = 47, SpvDecorationNoSignedWrap = 4469, SpvDecorationNoUnsignedWrap = 4470, SpvDecorationExplicitInterpAMD = 4999, SpvDecorationOverrideCoverageNV = 5248, SpvDecorationPassthroughNV = 5250, SpvDecorationViewportRelativeNV = 5252, SpvDecorationSecondaryViewportRelativeNV = 5256, SpvDecorationPerPrimitiveNV = 5271, SpvDecorationPerViewNV = 5272, SpvDecorationPerTaskNV = 5273, SpvDecorationPerVertexNV = 5285, SpvDecorationNonUniform = 5300, SpvDecorationNonUniformEXT = 5300, SpvDecorationRestrictPointer = 5355, SpvDecorationRestrictPointerEXT = 5355, SpvDecorationAliasedPointer = 5356, SpvDecorationAliasedPointerEXT = 5356, SpvDecorationReferencedIndirectlyINTEL = 5602, SpvDecorationCounterBuffer = 5634, SpvDecorationHlslCounterBufferGOOGLE = 5634, SpvDecorationHlslSemanticGOOGLE = 5635, SpvDecorationUserSemantic = 5635, SpvDecorationUserTypeGOOGLE = 5636, SpvDecorationRegisterINTEL = 5825, SpvDecorationMemoryINTEL = 5826, SpvDecorationNumbanksINTEL = 5827, SpvDecorationBankwidthINTEL = 5828, SpvDecorationMaxPrivateCopiesINTEL = 5829, SpvDecorationSinglepumpINTEL = 5830, SpvDecorationDoublepumpINTEL = 5831, SpvDecorationMaxReplicatesINTEL = 5832, SpvDecorationSimpleDualPortINTEL = 5833, SpvDecorationMergeINTEL = 5834, SpvDecorationBankBitsINTEL = 5835, SpvDecorationForcePow2DepthINTEL = 5836, SpvDecorationMax = 0x7fffffff, } SpvDecoration; typedef enum SpvBuiltIn_ { SpvBuiltInPosition = 0, SpvBuiltInPointSize = 1, SpvBuiltInClipDistance = 3, SpvBuiltInCullDistance = 4, SpvBuiltInVertexId = 5, SpvBuiltInInstanceId = 6, SpvBuiltInPrimitiveId = 7, SpvBuiltInInvocationId = 8, SpvBuiltInLayer = 9, SpvBuiltInViewportIndex = 10, SpvBuiltInTessLevelOuter = 11, SpvBuiltInTessLevelInner = 12, SpvBuiltInTessCoord = 13, SpvBuiltInPatchVertices = 14, SpvBuiltInFragCoord = 15, SpvBuiltInPointCoord = 16, SpvBuiltInFrontFacing = 17, SpvBuiltInSampleId = 18, SpvBuiltInSamplePosition = 19, SpvBuiltInSampleMask = 20, SpvBuiltInFragDepth = 22, SpvBuiltInHelperInvocation = 23, SpvBuiltInNumWorkgroups = 24, SpvBuiltInWorkgroupSize = 25, SpvBuiltInWorkgroupId = 26, SpvBuiltInLocalInvocationId = 27, SpvBuiltInGlobalInvocationId = 28, SpvBuiltInLocalInvocationIndex = 29, SpvBuiltInWorkDim = 30, SpvBuiltInGlobalSize = 31, SpvBuiltInEnqueuedWorkgroupSize = 32, SpvBuiltInGlobalOffset = 33, SpvBuiltInGlobalLinearId = 34, SpvBuiltInSubgroupSize = 36, SpvBuiltInSubgroupMaxSize = 37, SpvBuiltInNumSubgroups = 38, SpvBuiltInNumEnqueuedSubgroups = 39, SpvBuiltInSubgroupId = 40, SpvBuiltInSubgroupLocalInvocationId = 41, SpvBuiltInVertexIndex = 42, SpvBuiltInInstanceIndex = 43, SpvBuiltInSubgroupEqMask = 4416, SpvBuiltInSubgroupEqMaskKHR = 4416, SpvBuiltInSubgroupGeMask = 4417, SpvBuiltInSubgroupGeMaskKHR = 4417, SpvBuiltInSubgroupGtMask = 4418, SpvBuiltInSubgroupGtMaskKHR = 4418, SpvBuiltInSubgroupLeMask = 4419, SpvBuiltInSubgroupLeMaskKHR = 4419, SpvBuiltInSubgroupLtMask = 4420, SpvBuiltInSubgroupLtMaskKHR = 4420, SpvBuiltInBaseVertex = 4424, SpvBuiltInBaseInstance = 4425, SpvBuiltInDrawIndex = 4426, SpvBuiltInPrimitiveShadingRateKHR = 4432, SpvBuiltInDeviceIndex = 4438, SpvBuiltInViewIndex = 4440, SpvBuiltInShadingRateKHR = 4444, SpvBuiltInBaryCoordNoPerspAMD = 4992, SpvBuiltInBaryCoordNoPerspCentroidAMD = 4993, SpvBuiltInBaryCoordNoPerspSampleAMD = 4994, SpvBuiltInBaryCoordSmoothAMD = 4995, SpvBuiltInBaryCoordSmoothCentroidAMD = 4996, SpvBuiltInBaryCoordSmoothSampleAMD = 4997, SpvBuiltInBaryCoordPullModelAMD = 4998, SpvBuiltInFragStencilRefEXT = 5014, SpvBuiltInViewportMaskNV = 5253, SpvBuiltInSecondaryPositionNV = 5257, SpvBuiltInSecondaryViewportMaskNV = 5258, SpvBuiltInPositionPerViewNV = 5261, SpvBuiltInViewportMaskPerViewNV = 5262, SpvBuiltInFullyCoveredEXT = 5264, SpvBuiltInTaskCountNV = 5274, SpvBuiltInPrimitiveCountNV = 5275, SpvBuiltInPrimitiveIndicesNV = 5276, SpvBuiltInClipDistancePerViewNV = 5277, SpvBuiltInCullDistancePerViewNV = 5278, SpvBuiltInLayerPerViewNV = 5279, SpvBuiltInMeshViewCountNV = 5280, SpvBuiltInMeshViewIndicesNV = 5281, SpvBuiltInBaryCoordNV = 5286, SpvBuiltInBaryCoordNoPerspNV = 5287, SpvBuiltInFragSizeEXT = 5292, SpvBuiltInFragmentSizeNV = 5292, SpvBuiltInFragInvocationCountEXT = 5293, SpvBuiltInInvocationsPerPixelNV = 5293, SpvBuiltInLaunchIdKHR = 5319, SpvBuiltInLaunchIdNV = 5319, SpvBuiltInLaunchSizeKHR = 5320, SpvBuiltInLaunchSizeNV = 5320, SpvBuiltInWorldRayOriginKHR = 5321, SpvBuiltInWorldRayOriginNV = 5321, SpvBuiltInWorldRayDirectionKHR = 5322, SpvBuiltInWorldRayDirectionNV = 5322, SpvBuiltInObjectRayOriginKHR = 5323, SpvBuiltInObjectRayOriginNV = 5323, SpvBuiltInObjectRayDirectionKHR = 5324, SpvBuiltInObjectRayDirectionNV = 5324, SpvBuiltInRayTminKHR = 5325, SpvBuiltInRayTminNV = 5325, SpvBuiltInRayTmaxKHR = 5326, SpvBuiltInRayTmaxNV = 5326, SpvBuiltInInstanceCustomIndexKHR = 5327, SpvBuiltInInstanceCustomIndexNV = 5327, SpvBuiltInObjectToWorldKHR = 5330, SpvBuiltInObjectToWorldNV = 5330, SpvBuiltInWorldToObjectKHR = 5331, SpvBuiltInWorldToObjectNV = 5331, SpvBuiltInHitTNV = 5332, SpvBuiltInHitKindKHR = 5333, SpvBuiltInHitKindNV = 5333, SpvBuiltInIncomingRayFlagsKHR = 5351, SpvBuiltInIncomingRayFlagsNV = 5351, SpvBuiltInRayGeometryIndexKHR = 5352, SpvBuiltInWarpsPerSMNV = 5374, SpvBuiltInSMCountNV = 5375, SpvBuiltInWarpIDNV = 5376, SpvBuiltInSMIDNV = 5377, SpvBuiltInMax = 0x7fffffff, } SpvBuiltIn; typedef enum SpvSelectionControlShift_ { SpvSelectionControlFlattenShift = 0, SpvSelectionControlDontFlattenShift = 1, SpvSelectionControlMax = 0x7fffffff, } SpvSelectionControlShift; typedef enum SpvSelectionControlMask_ { SpvSelectionControlMaskNone = 0, SpvSelectionControlFlattenMask = 0x00000001, SpvSelectionControlDontFlattenMask = 0x00000002, } SpvSelectionControlMask; typedef enum SpvLoopControlShift_ { SpvLoopControlUnrollShift = 0, SpvLoopControlDontUnrollShift = 1, SpvLoopControlDependencyInfiniteShift = 2, SpvLoopControlDependencyLengthShift = 3, SpvLoopControlMinIterationsShift = 4, SpvLoopControlMaxIterationsShift = 5, SpvLoopControlIterationMultipleShift = 6, SpvLoopControlPeelCountShift = 7, SpvLoopControlPartialCountShift = 8, SpvLoopControlInitiationIntervalINTELShift = 16, SpvLoopControlMaxConcurrencyINTELShift = 17, SpvLoopControlDependencyArrayINTELShift = 18, SpvLoopControlPipelineEnableINTELShift = 19, SpvLoopControlLoopCoalesceINTELShift = 20, SpvLoopControlMaxInterleavingINTELShift = 21, SpvLoopControlSpeculatedIterationsINTELShift = 22, SpvLoopControlMax = 0x7fffffff, } SpvLoopControlShift; typedef enum SpvLoopControlMask_ { SpvLoopControlMaskNone = 0, SpvLoopControlUnrollMask = 0x00000001, SpvLoopControlDontUnrollMask = 0x00000002, SpvLoopControlDependencyInfiniteMask = 0x00000004, SpvLoopControlDependencyLengthMask = 0x00000008, SpvLoopControlMinIterationsMask = 0x00000010, SpvLoopControlMaxIterationsMask = 0x00000020, SpvLoopControlIterationMultipleMask = 0x00000040, SpvLoopControlPeelCountMask = 0x00000080, SpvLoopControlPartialCountMask = 0x00000100, SpvLoopControlInitiationIntervalINTELMask = 0x00010000, SpvLoopControlMaxConcurrencyINTELMask = 0x00020000, SpvLoopControlDependencyArrayINTELMask = 0x00040000, SpvLoopControlPipelineEnableINTELMask = 0x00080000, SpvLoopControlLoopCoalesceINTELMask = 0x00100000, SpvLoopControlMaxInterleavingINTELMask = 0x00200000, SpvLoopControlSpeculatedIterationsINTELMask = 0x00400000, } SpvLoopControlMask; typedef enum SpvFunctionControlShift_ { SpvFunctionControlInlineShift = 0, SpvFunctionControlDontInlineShift = 1, SpvFunctionControlPureShift = 2, SpvFunctionControlConstShift = 3, SpvFunctionControlMax = 0x7fffffff, } SpvFunctionControlShift; typedef enum SpvFunctionControlMask_ { SpvFunctionControlMaskNone = 0, SpvFunctionControlInlineMask = 0x00000001, SpvFunctionControlDontInlineMask = 0x00000002, SpvFunctionControlPureMask = 0x00000004, SpvFunctionControlConstMask = 0x00000008, } SpvFunctionControlMask; typedef enum SpvMemorySemanticsShift_ { SpvMemorySemanticsAcquireShift = 1, SpvMemorySemanticsReleaseShift = 2, SpvMemorySemanticsAcquireReleaseShift = 3, SpvMemorySemanticsSequentiallyConsistentShift = 4, SpvMemorySemanticsUniformMemoryShift = 6, SpvMemorySemanticsSubgroupMemoryShift = 7, SpvMemorySemanticsWorkgroupMemoryShift = 8, SpvMemorySemanticsCrossWorkgroupMemoryShift = 9, SpvMemorySemanticsAtomicCounterMemoryShift = 10, SpvMemorySemanticsImageMemoryShift = 11, SpvMemorySemanticsOutputMemoryShift = 12, SpvMemorySemanticsOutputMemoryKHRShift = 12, SpvMemorySemanticsMakeAvailableShift = 13, SpvMemorySemanticsMakeAvailableKHRShift = 13, SpvMemorySemanticsMakeVisibleShift = 14, SpvMemorySemanticsMakeVisibleKHRShift = 14, SpvMemorySemanticsVolatileShift = 15, SpvMemorySemanticsMax = 0x7fffffff, } SpvMemorySemanticsShift; typedef enum SpvMemorySemanticsMask_ { SpvMemorySemanticsMaskNone = 0, SpvMemorySemanticsAcquireMask = 0x00000002, SpvMemorySemanticsReleaseMask = 0x00000004, SpvMemorySemanticsAcquireReleaseMask = 0x00000008, SpvMemorySemanticsSequentiallyConsistentMask = 0x00000010, SpvMemorySemanticsUniformMemoryMask = 0x00000040, SpvMemorySemanticsSubgroupMemoryMask = 0x00000080, SpvMemorySemanticsWorkgroupMemoryMask = 0x00000100, SpvMemorySemanticsCrossWorkgroupMemoryMask = 0x00000200, SpvMemorySemanticsAtomicCounterMemoryMask = 0x00000400, SpvMemorySemanticsImageMemoryMask = 0x00000800, SpvMemorySemanticsOutputMemoryMask = 0x00001000, SpvMemorySemanticsOutputMemoryKHRMask = 0x00001000, SpvMemorySemanticsMakeAvailableMask = 0x00002000, SpvMemorySemanticsMakeAvailableKHRMask = 0x00002000, SpvMemorySemanticsMakeVisibleMask = 0x00004000, SpvMemorySemanticsMakeVisibleKHRMask = 0x00004000, SpvMemorySemanticsVolatileMask = 0x00008000, } SpvMemorySemanticsMask; typedef enum SpvMemoryAccessShift_ { SpvMemoryAccessVolatileShift = 0, SpvMemoryAccessAlignedShift = 1, SpvMemoryAccessNontemporalShift = 2, SpvMemoryAccessMakePointerAvailableShift = 3, SpvMemoryAccessMakePointerAvailableKHRShift = 3, SpvMemoryAccessMakePointerVisibleShift = 4, SpvMemoryAccessMakePointerVisibleKHRShift = 4, SpvMemoryAccessNonPrivatePointerShift = 5, SpvMemoryAccessNonPrivatePointerKHRShift = 5, SpvMemoryAccessMax = 0x7fffffff, } SpvMemoryAccessShift; typedef enum SpvMemoryAccessMask_ { SpvMemoryAccessMaskNone = 0, SpvMemoryAccessVolatileMask = 0x00000001, SpvMemoryAccessAlignedMask = 0x00000002, SpvMemoryAccessNontemporalMask = 0x00000004, SpvMemoryAccessMakePointerAvailableMask = 0x00000008, SpvMemoryAccessMakePointerAvailableKHRMask = 0x00000008, SpvMemoryAccessMakePointerVisibleMask = 0x00000010, SpvMemoryAccessMakePointerVisibleKHRMask = 0x00000010, SpvMemoryAccessNonPrivatePointerMask = 0x00000020, SpvMemoryAccessNonPrivatePointerKHRMask = 0x00000020, } SpvMemoryAccessMask; typedef enum SpvScope_ { SpvScopeCrossDevice = 0, SpvScopeDevice = 1, SpvScopeWorkgroup = 2, SpvScopeSubgroup = 3, SpvScopeInvocation = 4, SpvScopeQueueFamily = 5, SpvScopeQueueFamilyKHR = 5, SpvScopeShaderCallKHR = 6, SpvScopeMax = 0x7fffffff, } SpvScope; typedef enum SpvGroupOperation_ { SpvGroupOperationReduce = 0, SpvGroupOperationInclusiveScan = 1, SpvGroupOperationExclusiveScan = 2, SpvGroupOperationClusteredReduce = 3, SpvGroupOperationPartitionedReduceNV = 6, SpvGroupOperationPartitionedInclusiveScanNV = 7, SpvGroupOperationPartitionedExclusiveScanNV = 8, SpvGroupOperationMax = 0x7fffffff, } SpvGroupOperation; typedef enum SpvKernelEnqueueFlags_ { SpvKernelEnqueueFlagsNoWait = 0, SpvKernelEnqueueFlagsWaitKernel = 1, SpvKernelEnqueueFlagsWaitWorkGroup = 2, SpvKernelEnqueueFlagsMax = 0x7fffffff, } SpvKernelEnqueueFlags; typedef enum SpvKernelProfilingInfoShift_ { SpvKernelProfilingInfoCmdExecTimeShift = 0, SpvKernelProfilingInfoMax = 0x7fffffff, } SpvKernelProfilingInfoShift; typedef enum SpvKernelProfilingInfoMask_ { SpvKernelProfilingInfoMaskNone = 0, SpvKernelProfilingInfoCmdExecTimeMask = 0x00000001, } SpvKernelProfilingInfoMask; typedef enum SpvCapability_ { SpvCapabilityMatrix = 0, SpvCapabilityShader = 1, SpvCapabilityGeometry = 2, SpvCapabilityTessellation = 3, SpvCapabilityAddresses = 4, SpvCapabilityLinkage = 5, SpvCapabilityKernel = 6, SpvCapabilityVector16 = 7, SpvCapabilityFloat16Buffer = 8, SpvCapabilityFloat16 = 9, SpvCapabilityFloat64 = 10, SpvCapabilityInt64 = 11, SpvCapabilityInt64Atomics = 12, SpvCapabilityImageBasic = 13, SpvCapabilityImageReadWrite = 14, SpvCapabilityImageMipmap = 15, SpvCapabilityPipes = 17, SpvCapabilityGroups = 18, SpvCapabilityDeviceEnqueue = 19, SpvCapabilityLiteralSampler = 20, SpvCapabilityAtomicStorage = 21, SpvCapabilityInt16 = 22, SpvCapabilityTessellationPointSize = 23, SpvCapabilityGeometryPointSize = 24, SpvCapabilityImageGatherExtended = 25, SpvCapabilityStorageImageMultisample = 27, SpvCapabilityUniformBufferArrayDynamicIndexing = 28, SpvCapabilitySampledImageArrayDynamicIndexing = 29, SpvCapabilityStorageBufferArrayDynamicIndexing = 30, SpvCapabilityStorageImageArrayDynamicIndexing = 31, SpvCapabilityClipDistance = 32, SpvCapabilityCullDistance = 33, SpvCapabilityImageCubeArray = 34, SpvCapabilitySampleRateShading = 35, SpvCapabilityImageRect = 36, SpvCapabilitySampledRect = 37, SpvCapabilityGenericPointer = 38, SpvCapabilityInt8 = 39, SpvCapabilityInputAttachment = 40, SpvCapabilitySparseResidency = 41, SpvCapabilityMinLod = 42, SpvCapabilitySampled1D = 43, SpvCapabilityImage1D = 44, SpvCapabilitySampledCubeArray = 45, SpvCapabilitySampledBuffer = 46, SpvCapabilityImageBuffer = 47, SpvCapabilityImageMSArray = 48, SpvCapabilityStorageImageExtendedFormats = 49, SpvCapabilityImageQuery = 50, SpvCapabilityDerivativeControl = 51, SpvCapabilityInterpolationFunction = 52, SpvCapabilityTransformFeedback = 53, SpvCapabilityGeometryStreams = 54, SpvCapabilityStorageImageReadWithoutFormat = 55, SpvCapabilityStorageImageWriteWithoutFormat = 56, SpvCapabilityMultiViewport = 57, SpvCapabilitySubgroupDispatch = 58, SpvCapabilityNamedBarrier = 59, SpvCapabilityPipeStorage = 60, SpvCapabilityGroupNonUniform = 61, SpvCapabilityGroupNonUniformVote = 62, SpvCapabilityGroupNonUniformArithmetic = 63, SpvCapabilityGroupNonUniformBallot = 64, SpvCapabilityGroupNonUniformShuffle = 65, SpvCapabilityGroupNonUniformShuffleRelative = 66, SpvCapabilityGroupNonUniformClustered = 67, SpvCapabilityGroupNonUniformQuad = 68, SpvCapabilityShaderLayer = 69, SpvCapabilityShaderViewportIndex = 70, SpvCapabilityFragmentShadingRateKHR = 4422, SpvCapabilitySubgroupBallotKHR = 4423, SpvCapabilityDrawParameters = 4427, SpvCapabilitySubgroupVoteKHR = 4431, SpvCapabilityStorageBuffer16BitAccess = 4433, SpvCapabilityStorageUniformBufferBlock16 = 4433, SpvCapabilityStorageUniform16 = 4434, SpvCapabilityUniformAndStorageBuffer16BitAccess = 4434, SpvCapabilityStoragePushConstant16 = 4435, SpvCapabilityStorageInputOutput16 = 4436, SpvCapabilityDeviceGroup = 4437, SpvCapabilityMultiView = 4439, SpvCapabilityVariablePointersStorageBuffer = 4441, SpvCapabilityVariablePointers = 4442, SpvCapabilityAtomicStorageOps = 4445, SpvCapabilitySampleMaskPostDepthCoverage = 4447, SpvCapabilityStorageBuffer8BitAccess = 4448, SpvCapabilityUniformAndStorageBuffer8BitAccess = 4449, SpvCapabilityStoragePushConstant8 = 4450, SpvCapabilityDenormPreserve = 4464, SpvCapabilityDenormFlushToZero = 4465, SpvCapabilitySignedZeroInfNanPreserve = 4466, SpvCapabilityRoundingModeRTE = 4467, SpvCapabilityRoundingModeRTZ = 4468, SpvCapabilityRayQueryProvisionalKHR = 4471, SpvCapabilityRayQueryKHR = 4472, SpvCapabilityRayTraversalPrimitiveCullingKHR = 4478, SpvCapabilityRayTracingKHR = 4479, SpvCapabilityFloat16ImageAMD = 5008, SpvCapabilityImageGatherBiasLodAMD = 5009, SpvCapabilityFragmentMaskAMD = 5010, SpvCapabilityStencilExportEXT = 5013, SpvCapabilityImageReadWriteLodAMD = 5015, SpvCapabilityInt64ImageEXT = 5016, SpvCapabilityShaderClockKHR = 5055, SpvCapabilitySampleMaskOverrideCoverageNV = 5249, SpvCapabilityGeometryShaderPassthroughNV = 5251, SpvCapabilityShaderViewportIndexLayerEXT = 5254, SpvCapabilityShaderViewportIndexLayerNV = 5254, SpvCapabilityShaderViewportMaskNV = 5255, SpvCapabilityShaderStereoViewNV = 5259, SpvCapabilityPerViewAttributesNV = 5260, SpvCapabilityFragmentFullyCoveredEXT = 5265, SpvCapabilityMeshShadingNV = 5266, SpvCapabilityImageFootprintNV = 5282, SpvCapabilityFragmentBarycentricNV = 5284, SpvCapabilityComputeDerivativeGroupQuadsNV = 5288, SpvCapabilityFragmentDensityEXT = 5291, SpvCapabilityShadingRateNV = 5291, SpvCapabilityGroupNonUniformPartitionedNV = 5297, SpvCapabilityShaderNonUniform = 5301, SpvCapabilityShaderNonUniformEXT = 5301, SpvCapabilityRuntimeDescriptorArray = 5302, SpvCapabilityRuntimeDescriptorArrayEXT = 5302, SpvCapabilityInputAttachmentArrayDynamicIndexing = 5303, SpvCapabilityInputAttachmentArrayDynamicIndexingEXT = 5303, SpvCapabilityUniformTexelBufferArrayDynamicIndexing = 5304, SpvCapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304, SpvCapabilityStorageTexelBufferArrayDynamicIndexing = 5305, SpvCapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305, SpvCapabilityUniformBufferArrayNonUniformIndexing = 5306, SpvCapabilityUniformBufferArrayNonUniformIndexingEXT = 5306, SpvCapabilitySampledImageArrayNonUniformIndexing = 5307, SpvCapabilitySampledImageArrayNonUniformIndexingEXT = 5307, SpvCapabilityStorageBufferArrayNonUniformIndexing = 5308, SpvCapabilityStorageBufferArrayNonUniformIndexingEXT = 5308, SpvCapabilityStorageImageArrayNonUniformIndexing = 5309, SpvCapabilityStorageImageArrayNonUniformIndexingEXT = 5309, SpvCapabilityInputAttachmentArrayNonUniformIndexing = 5310, SpvCapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310, SpvCapabilityUniformTexelBufferArrayNonUniformIndexing = 5311, SpvCapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311, SpvCapabilityStorageTexelBufferArrayNonUniformIndexing = 5312, SpvCapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312, SpvCapabilityRayTracingNV = 5340, SpvCapabilityVulkanMemoryModel = 5345, SpvCapabilityVulkanMemoryModelKHR = 5345, SpvCapabilityVulkanMemoryModelDeviceScope = 5346, SpvCapabilityVulkanMemoryModelDeviceScopeKHR = 5346, SpvCapabilityPhysicalStorageBufferAddresses = 5347, SpvCapabilityPhysicalStorageBufferAddressesEXT = 5347, SpvCapabilityComputeDerivativeGroupLinearNV = 5350, SpvCapabilityRayTracingProvisionalKHR = 5353, SpvCapabilityCooperativeMatrixNV = 5357, SpvCapabilityFragmentShaderSampleInterlockEXT = 5363, SpvCapabilityFragmentShaderShadingRateInterlockEXT = 5372, SpvCapabilityShaderSMBuiltinsNV = 5373, SpvCapabilityFragmentShaderPixelInterlockEXT = 5378, SpvCapabilityDemoteToHelperInvocationEXT = 5379, SpvCapabilitySubgroupShuffleINTEL = 5568, SpvCapabilitySubgroupBufferBlockIOINTEL = 5569, SpvCapabilitySubgroupImageBlockIOINTEL = 5570, SpvCapabilitySubgroupImageMediaBlockIOINTEL = 5579, SpvCapabilityIntegerFunctions2INTEL = 5584, SpvCapabilityFunctionPointersINTEL = 5603, SpvCapabilityIndirectReferencesINTEL = 5604, SpvCapabilitySubgroupAvcMotionEstimationINTEL = 5696, SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697, SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698, SpvCapabilityFPGAMemoryAttributesINTEL = 5824, SpvCapabilityUnstructuredLoopControlsINTEL = 5886, SpvCapabilityFPGALoopControlsINTEL = 5888, SpvCapabilityKernelAttributesINTEL = 5892, SpvCapabilityFPGAKernelAttributesINTEL = 5897, SpvCapabilityBlockingPipesINTEL = 5945, SpvCapabilityFPGARegINTEL = 5948, SpvCapabilityAtomicFloat32AddEXT = 6033, SpvCapabilityAtomicFloat64AddEXT = 6034, SpvCapabilityMax = 0x7fffffff, } SpvCapability; typedef enum SpvRayFlagsShift_ { SpvRayFlagsOpaqueKHRShift = 0, SpvRayFlagsNoOpaqueKHRShift = 1, SpvRayFlagsTerminateOnFirstHitKHRShift = 2, SpvRayFlagsSkipClosestHitShaderKHRShift = 3, SpvRayFlagsCullBackFacingTrianglesKHRShift = 4, SpvRayFlagsCullFrontFacingTrianglesKHRShift = 5, SpvRayFlagsCullOpaqueKHRShift = 6, SpvRayFlagsCullNoOpaqueKHRShift = 7, SpvRayFlagsSkipTrianglesKHRShift = 8, SpvRayFlagsSkipAABBsKHRShift = 9, SpvRayFlagsMax = 0x7fffffff, } SpvRayFlagsShift; typedef enum SpvRayFlagsMask_ { SpvRayFlagsMaskNone = 0, SpvRayFlagsOpaqueKHRMask = 0x00000001, SpvRayFlagsNoOpaqueKHRMask = 0x00000002, SpvRayFlagsTerminateOnFirstHitKHRMask = 0x00000004, SpvRayFlagsSkipClosestHitShaderKHRMask = 0x00000008, SpvRayFlagsCullBackFacingTrianglesKHRMask = 0x00000010, SpvRayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020, SpvRayFlagsCullOpaqueKHRMask = 0x00000040, SpvRayFlagsCullNoOpaqueKHRMask = 0x00000080, SpvRayFlagsSkipTrianglesKHRMask = 0x00000100, SpvRayFlagsSkipAABBsKHRMask = 0x00000200, } SpvRayFlagsMask; typedef enum SpvRayQueryIntersection_ { SpvRayQueryIntersectionRayQueryCandidateIntersectionKHR = 0, SpvRayQueryIntersectionRayQueryCommittedIntersectionKHR = 1, SpvRayQueryIntersectionMax = 0x7fffffff, } SpvRayQueryIntersection; typedef enum SpvRayQueryCommittedIntersectionType_ { SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0, SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1, SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2, SpvRayQueryCommittedIntersectionTypeMax = 0x7fffffff, } SpvRayQueryCommittedIntersectionType; typedef enum SpvRayQueryCandidateIntersectionType_ { SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0, SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1, SpvRayQueryCandidateIntersectionTypeMax = 0x7fffffff, } SpvRayQueryCandidateIntersectionType; typedef enum SpvFragmentShadingRateShift_ { SpvFragmentShadingRateVertical2PixelsShift = 0, SpvFragmentShadingRateVertical4PixelsShift = 1, SpvFragmentShadingRateHorizontal2PixelsShift = 2, SpvFragmentShadingRateHorizontal4PixelsShift = 3, SpvFragmentShadingRateMax = 0x7fffffff, } SpvFragmentShadingRateShift; typedef enum SpvFragmentShadingRateMask_ { SpvFragmentShadingRateMaskNone = 0, SpvFragmentShadingRateVertical2PixelsMask = 0x00000001, SpvFragmentShadingRateVertical4PixelsMask = 0x00000002, SpvFragmentShadingRateHorizontal2PixelsMask = 0x00000004, SpvFragmentShadingRateHorizontal4PixelsMask = 0x00000008, } SpvFragmentShadingRateMask; typedef enum SpvOp_ { SpvOpNop = 0, SpvOpUndef = 1, SpvOpSourceContinued = 2, SpvOpSource = 3, SpvOpSourceExtension = 4, SpvOpName = 5, SpvOpMemberName = 6, SpvOpString = 7, SpvOpLine = 8, SpvOpExtension = 10, SpvOpExtInstImport = 11, SpvOpExtInst = 12, SpvOpMemoryModel = 14, SpvOpEntryPoint = 15, SpvOpExecutionMode = 16, SpvOpCapability = 17, SpvOpTypeVoid = 19, SpvOpTypeBool = 20, SpvOpTypeInt = 21, SpvOpTypeFloat = 22, SpvOpTypeVector = 23, SpvOpTypeMatrix = 24, SpvOpTypeImage = 25, SpvOpTypeSampler = 26, SpvOpTypeSampledImage = 27, SpvOpTypeArray = 28, SpvOpTypeRuntimeArray = 29, SpvOpTypeStruct = 30, SpvOpTypeOpaque = 31, SpvOpTypePointer = 32, SpvOpTypeFunction = 33, SpvOpTypeEvent = 34, SpvOpTypeDeviceEvent = 35, SpvOpTypeReserveId = 36, SpvOpTypeQueue = 37, SpvOpTypePipe = 38, SpvOpTypeForwardPointer = 39, SpvOpConstantTrue = 41, SpvOpConstantFalse = 42, SpvOpConstant = 43, SpvOpConstantComposite = 44, SpvOpConstantSampler = 45, SpvOpConstantNull = 46, SpvOpSpecConstantTrue = 48, SpvOpSpecConstantFalse = 49, SpvOpSpecConstant = 50, SpvOpSpecConstantComposite = 51, SpvOpSpecConstantOp = 52, SpvOpFunction = 54, SpvOpFunctionParameter = 55, SpvOpFunctionEnd = 56, SpvOpFunctionCall = 57, SpvOpVariable = 59, SpvOpImageTexelPointer = 60, SpvOpLoad = 61, SpvOpStore = 62, SpvOpCopyMemory = 63, SpvOpCopyMemorySized = 64, SpvOpAccessChain = 65, SpvOpInBoundsAccessChain = 66, SpvOpPtrAccessChain = 67, SpvOpArrayLength = 68, SpvOpGenericPtrMemSemantics = 69, SpvOpInBoundsPtrAccessChain = 70, SpvOpDecorate = 71, SpvOpMemberDecorate = 72, SpvOpDecorationGroup = 73, SpvOpGroupDecorate = 74, SpvOpGroupMemberDecorate = 75, SpvOpVectorExtractDynamic = 77, SpvOpVectorInsertDynamic = 78, SpvOpVectorShuffle = 79, SpvOpCompositeConstruct = 80, SpvOpCompositeExtract = 81, SpvOpCompositeInsert = 82, SpvOpCopyObject = 83, SpvOpTranspose = 84, SpvOpSampledImage = 86, SpvOpImageSampleImplicitLod = 87, SpvOpImageSampleExplicitLod = 88, SpvOpImageSampleDrefImplicitLod = 89, SpvOpImageSampleDrefExplicitLod = 90, SpvOpImageSampleProjImplicitLod = 91, SpvOpImageSampleProjExplicitLod = 92, SpvOpImageSampleProjDrefImplicitLod = 93, SpvOpImageSampleProjDrefExplicitLod = 94, SpvOpImageFetch = 95, SpvOpImageGather = 96, SpvOpImageDrefGather = 97, SpvOpImageRead = 98, SpvOpImageWrite = 99, SpvOpImage = 100, SpvOpImageQueryFormat = 101, SpvOpImageQueryOrder = 102, SpvOpImageQuerySizeLod = 103, SpvOpImageQuerySize = 104, SpvOpImageQueryLod = 105, SpvOpImageQueryLevels = 106, SpvOpImageQuerySamples = 107, SpvOpConvertFToU = 109, SpvOpConvertFToS = 110, SpvOpConvertSToF = 111, SpvOpConvertUToF = 112, SpvOpUConvert = 113, SpvOpSConvert = 114, SpvOpFConvert = 115, SpvOpQuantizeToF16 = 116, SpvOpConvertPtrToU = 117, SpvOpSatConvertSToU = 118, SpvOpSatConvertUToS = 119, SpvOpConvertUToPtr = 120, SpvOpPtrCastToGeneric = 121, SpvOpGenericCastToPtr = 122, SpvOpGenericCastToPtrExplicit = 123, SpvOpBitcast = 124, SpvOpSNegate = 126, SpvOpFNegate = 127, SpvOpIAdd = 128, SpvOpFAdd = 129, SpvOpISub = 130, SpvOpFSub = 131, SpvOpIMul = 132, SpvOpFMul = 133, SpvOpUDiv = 134, SpvOpSDiv = 135, SpvOpFDiv = 136, SpvOpUMod = 137, SpvOpSRem = 138, SpvOpSMod = 139, SpvOpFRem = 140, SpvOpFMod = 141, SpvOpVectorTimesScalar = 142, SpvOpMatrixTimesScalar = 143, SpvOpVectorTimesMatrix = 144, SpvOpMatrixTimesVector = 145, SpvOpMatrixTimesMatrix = 146, SpvOpOuterProduct = 147, SpvOpDot = 148, SpvOpIAddCarry = 149, SpvOpISubBorrow = 150, SpvOpUMulExtended = 151, SpvOpSMulExtended = 152, SpvOpAny = 154, SpvOpAll = 155, SpvOpIsNan = 156, SpvOpIsInf = 157, SpvOpIsFinite = 158, SpvOpIsNormal = 159, SpvOpSignBitSet = 160, SpvOpLessOrGreater = 161, SpvOpOrdered = 162, SpvOpUnordered = 163, SpvOpLogicalEqual = 164, SpvOpLogicalNotEqual = 165, SpvOpLogicalOr = 166, SpvOpLogicalAnd = 167, SpvOpLogicalNot = 168, SpvOpSelect = 169, SpvOpIEqual = 170, SpvOpINotEqual = 171, SpvOpUGreaterThan = 172, SpvOpSGreaterThan = 173, SpvOpUGreaterThanEqual = 174, SpvOpSGreaterThanEqual = 175, SpvOpULessThan = 176, SpvOpSLessThan = 177, SpvOpULessThanEqual = 178, SpvOpSLessThanEqual = 179, SpvOpFOrdEqual = 180, SpvOpFUnordEqual = 181, SpvOpFOrdNotEqual = 182, SpvOpFUnordNotEqual = 183, SpvOpFOrdLessThan = 184, SpvOpFUnordLessThan = 185, SpvOpFOrdGreaterThan = 186, SpvOpFUnordGreaterThan = 187, SpvOpFOrdLessThanEqual = 188, SpvOpFUnordLessThanEqual = 189, SpvOpFOrdGreaterThanEqual = 190, SpvOpFUnordGreaterThanEqual = 191, SpvOpShiftRightLogical = 194, SpvOpShiftRightArithmetic = 195, SpvOpShiftLeftLogical = 196, SpvOpBitwiseOr = 197, SpvOpBitwiseXor = 198, SpvOpBitwiseAnd = 199, SpvOpNot = 200, SpvOpBitFieldInsert = 201, SpvOpBitFieldSExtract = 202, SpvOpBitFieldUExtract = 203, SpvOpBitReverse = 204, SpvOpBitCount = 205, SpvOpDPdx = 207, SpvOpDPdy = 208, SpvOpFwidth = 209, SpvOpDPdxFine = 210, SpvOpDPdyFine = 211, SpvOpFwidthFine = 212, SpvOpDPdxCoarse = 213, SpvOpDPdyCoarse = 214, SpvOpFwidthCoarse = 215, SpvOpEmitVertex = 218, SpvOpEndPrimitive = 219, SpvOpEmitStreamVertex = 220, SpvOpEndStreamPrimitive = 221, SpvOpControlBarrier = 224, SpvOpMemoryBarrier = 225, SpvOpAtomicLoad = 227, SpvOpAtomicStore = 228, SpvOpAtomicExchange = 229, SpvOpAtomicCompareExchange = 230, SpvOpAtomicCompareExchangeWeak = 231, SpvOpAtomicIIncrement = 232, SpvOpAtomicIDecrement = 233, SpvOpAtomicIAdd = 234, SpvOpAtomicISub = 235, SpvOpAtomicSMin = 236, SpvOpAtomicUMin = 237, SpvOpAtomicSMax = 238, SpvOpAtomicUMax = 239, SpvOpAtomicAnd = 240, SpvOpAtomicOr = 241, SpvOpAtomicXor = 242, SpvOpPhi = 245, SpvOpLoopMerge = 246, SpvOpSelectionMerge = 247, SpvOpLabel = 248, SpvOpBranch = 249, SpvOpBranchConditional = 250, SpvOpSwitch = 251, SpvOpKill = 252, SpvOpReturn = 253, SpvOpReturnValue = 254, SpvOpUnreachable = 255, SpvOpLifetimeStart = 256, SpvOpLifetimeStop = 257, SpvOpGroupAsyncCopy = 259, SpvOpGroupWaitEvents = 260, SpvOpGroupAll = 261, SpvOpGroupAny = 262, SpvOpGroupBroadcast = 263, SpvOpGroupIAdd = 264, SpvOpGroupFAdd = 265, SpvOpGroupFMin = 266, SpvOpGroupUMin = 267, SpvOpGroupSMin = 268, SpvOpGroupFMax = 269, SpvOpGroupUMax = 270, SpvOpGroupSMax = 271, SpvOpReadPipe = 274, SpvOpWritePipe = 275, SpvOpReservedReadPipe = 276, SpvOpReservedWritePipe = 277, SpvOpReserveReadPipePackets = 278, SpvOpReserveWritePipePackets = 279, SpvOpCommitReadPipe = 280, SpvOpCommitWritePipe = 281, SpvOpIsValidReserveId = 282, SpvOpGetNumPipePackets = 283, SpvOpGetMaxPipePackets = 284, SpvOpGroupReserveReadPipePackets = 285, SpvOpGroupReserveWritePipePackets = 286, SpvOpGroupCommitReadPipe = 287, SpvOpGroupCommitWritePipe = 288, SpvOpEnqueueMarker = 291, SpvOpEnqueueKernel = 292, SpvOpGetKernelNDrangeSubGroupCount = 293, SpvOpGetKernelNDrangeMaxSubGroupSize = 294, SpvOpGetKernelWorkGroupSize = 295, SpvOpGetKernelPreferredWorkGroupSizeMultiple = 296, SpvOpRetainEvent = 297, SpvOpReleaseEvent = 298, SpvOpCreateUserEvent = 299, SpvOpIsValidEvent = 300, SpvOpSetUserEventStatus = 301, SpvOpCaptureEventProfilingInfo = 302, SpvOpGetDefaultQueue = 303, SpvOpBuildNDRange = 304, SpvOpImageSparseSampleImplicitLod = 305, SpvOpImageSparseSampleExplicitLod = 306, SpvOpImageSparseSampleDrefImplicitLod = 307, SpvOpImageSparseSampleDrefExplicitLod = 308, SpvOpImageSparseSampleProjImplicitLod = 309, SpvOpImageSparseSampleProjExplicitLod = 310, SpvOpImageSparseSampleProjDrefImplicitLod = 311, SpvOpImageSparseSampleProjDrefExplicitLod = 312, SpvOpImageSparseFetch = 313, SpvOpImageSparseGather = 314, SpvOpImageSparseDrefGather = 315, SpvOpImageSparseTexelsResident = 316, SpvOpNoLine = 317, SpvOpAtomicFlagTestAndSet = 318, SpvOpAtomicFlagClear = 319, SpvOpImageSparseRead = 320, SpvOpSizeOf = 321, SpvOpTypePipeStorage = 322, SpvOpConstantPipeStorage = 323, SpvOpCreatePipeFromPipeStorage = 324, SpvOpGetKernelLocalSizeForSubgroupCount = 325, SpvOpGetKernelMaxNumSubgroups = 326, SpvOpTypeNamedBarrier = 327, SpvOpNamedBarrierInitialize = 328, SpvOpMemoryNamedBarrier = 329, SpvOpModuleProcessed = 330, SpvOpExecutionModeId = 331, SpvOpDecorateId = 332, SpvOpGroupNonUniformElect = 333, SpvOpGroupNonUniformAll = 334, SpvOpGroupNonUniformAny = 335, SpvOpGroupNonUniformAllEqual = 336, SpvOpGroupNonUniformBroadcast = 337, SpvOpGroupNonUniformBroadcastFirst = 338, SpvOpGroupNonUniformBallot = 339, SpvOpGroupNonUniformInverseBallot = 340, SpvOpGroupNonUniformBallotBitExtract = 341, SpvOpGroupNonUniformBallotBitCount = 342, SpvOpGroupNonUniformBallotFindLSB = 343, SpvOpGroupNonUniformBallotFindMSB = 344, SpvOpGroupNonUniformShuffle = 345, SpvOpGroupNonUniformShuffleXor = 346, SpvOpGroupNonUniformShuffleUp = 347, SpvOpGroupNonUniformShuffleDown = 348, SpvOpGroupNonUniformIAdd = 349, SpvOpGroupNonUniformFAdd = 350, SpvOpGroupNonUniformIMul = 351, SpvOpGroupNonUniformFMul = 352, SpvOpGroupNonUniformSMin = 353, SpvOpGroupNonUniformUMin = 354, SpvOpGroupNonUniformFMin = 355, SpvOpGroupNonUniformSMax = 356, SpvOpGroupNonUniformUMax = 357, SpvOpGroupNonUniformFMax = 358, SpvOpGroupNonUniformBitwiseAnd = 359, SpvOpGroupNonUniformBitwiseOr = 360, SpvOpGroupNonUniformBitwiseXor = 361, SpvOpGroupNonUniformLogicalAnd = 362, SpvOpGroupNonUniformLogicalOr = 363, SpvOpGroupNonUniformLogicalXor = 364, SpvOpGroupNonUniformQuadBroadcast = 365, SpvOpGroupNonUniformQuadSwap = 366, SpvOpCopyLogical = 400, SpvOpPtrEqual = 401, SpvOpPtrNotEqual = 402, SpvOpPtrDiff = 403, SpvOpTerminateInvocation = 4416, SpvOpSubgroupBallotKHR = 4421, SpvOpSubgroupFirstInvocationKHR = 4422, SpvOpSubgroupAllKHR = 4428, SpvOpSubgroupAnyKHR = 4429, SpvOpSubgroupAllEqualKHR = 4430, SpvOpSubgroupReadInvocationKHR = 4432, SpvOpTraceRayKHR = 4445, SpvOpExecuteCallableKHR = 4446, SpvOpConvertUToAccelerationStructureKHR = 4447, SpvOpIgnoreIntersectionKHR = 4448, SpvOpTerminateRayKHR = 4449, SpvOpTypeRayQueryKHR = 4472, SpvOpRayQueryInitializeKHR = 4473, SpvOpRayQueryTerminateKHR = 4474, SpvOpRayQueryGenerateIntersectionKHR = 4475, SpvOpRayQueryConfirmIntersectionKHR = 4476, SpvOpRayQueryProceedKHR = 4477, SpvOpRayQueryGetIntersectionTypeKHR = 4479, SpvOpGroupIAddNonUniformAMD = 5000, SpvOpGroupFAddNonUniformAMD = 5001, SpvOpGroupFMinNonUniformAMD = 5002, SpvOpGroupUMinNonUniformAMD = 5003, SpvOpGroupSMinNonUniformAMD = 5004, SpvOpGroupFMaxNonUniformAMD = 5005, SpvOpGroupUMaxNonUniformAMD = 5006, SpvOpGroupSMaxNonUniformAMD = 5007, SpvOpFragmentMaskFetchAMD = 5011, SpvOpFragmentFetchAMD = 5012, SpvOpReadClockKHR = 5056, SpvOpImageSampleFootprintNV = 5283, SpvOpGroupNonUniformPartitionNV = 5296, SpvOpWritePackedPrimitiveIndices4x8NV = 5299, SpvOpReportIntersectionKHR = 5334, SpvOpReportIntersectionNV = 5334, SpvOpIgnoreIntersectionNV = 5335, SpvOpTerminateRayNV = 5336, SpvOpTraceNV = 5337, SpvOpTypeAccelerationStructureKHR = 5341, SpvOpTypeAccelerationStructureNV = 5341, SpvOpExecuteCallableNV = 5344, SpvOpTypeCooperativeMatrixNV = 5358, SpvOpCooperativeMatrixLoadNV = 5359, SpvOpCooperativeMatrixStoreNV = 5360, SpvOpCooperativeMatrixMulAddNV = 5361, SpvOpCooperativeMatrixLengthNV = 5362, SpvOpBeginInvocationInterlockEXT = 5364, SpvOpEndInvocationInterlockEXT = 5365, SpvOpDemoteToHelperInvocationEXT = 5380, SpvOpIsHelperInvocationEXT = 5381, SpvOpSubgroupShuffleINTEL = 5571, SpvOpSubgroupShuffleDownINTEL = 5572, SpvOpSubgroupShuffleUpINTEL = 5573, SpvOpSubgroupShuffleXorINTEL = 5574, SpvOpSubgroupBlockReadINTEL = 5575, SpvOpSubgroupBlockWriteINTEL = 5576, SpvOpSubgroupImageBlockReadINTEL = 5577, SpvOpSubgroupImageBlockWriteINTEL = 5578, SpvOpSubgroupImageMediaBlockReadINTEL = 5580, SpvOpSubgroupImageMediaBlockWriteINTEL = 5581, SpvOpUCountLeadingZerosINTEL = 5585, SpvOpUCountTrailingZerosINTEL = 5586, SpvOpAbsISubINTEL = 5587, SpvOpAbsUSubINTEL = 5588, SpvOpIAddSatINTEL = 5589, SpvOpUAddSatINTEL = 5590, SpvOpIAverageINTEL = 5591, SpvOpUAverageINTEL = 5592, SpvOpIAverageRoundedINTEL = 5593, SpvOpUAverageRoundedINTEL = 5594, SpvOpISubSatINTEL = 5595, SpvOpUSubSatINTEL = 5596, SpvOpIMul32x16INTEL = 5597, SpvOpUMul32x16INTEL = 5598, SpvOpFunctionPointerINTEL = 5600, SpvOpFunctionPointerCallINTEL = 5601, SpvOpDecorateString = 5632, SpvOpDecorateStringGOOGLE = 5632, SpvOpMemberDecorateString = 5633, SpvOpMemberDecorateStringGOOGLE = 5633, SpvOpVmeImageINTEL = 5699, SpvOpTypeVmeImageINTEL = 5700, SpvOpTypeAvcImePayloadINTEL = 5701, SpvOpTypeAvcRefPayloadINTEL = 5702, SpvOpTypeAvcSicPayloadINTEL = 5703, SpvOpTypeAvcMcePayloadINTEL = 5704, SpvOpTypeAvcMceResultINTEL = 5705, SpvOpTypeAvcImeResultINTEL = 5706, SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707, SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708, SpvOpTypeAvcImeSingleReferenceStreaminINTEL = 5709, SpvOpTypeAvcImeDualReferenceStreaminINTEL = 5710, SpvOpTypeAvcRefResultINTEL = 5711, SpvOpTypeAvcSicResultINTEL = 5712, SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713, SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714, SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715, SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716, SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717, SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718, SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719, SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720, SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721, SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722, SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723, SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724, SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725, SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726, SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727, SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728, SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729, SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730, SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731, SpvOpSubgroupAvcMceConvertToImePayloadINTEL = 5732, SpvOpSubgroupAvcMceConvertToImeResultINTEL = 5733, SpvOpSubgroupAvcMceConvertToRefPayloadINTEL = 5734, SpvOpSubgroupAvcMceConvertToRefResultINTEL = 5735, SpvOpSubgroupAvcMceConvertToSicPayloadINTEL = 5736, SpvOpSubgroupAvcMceConvertToSicResultINTEL = 5737, SpvOpSubgroupAvcMceGetMotionVectorsINTEL = 5738, SpvOpSubgroupAvcMceGetInterDistortionsINTEL = 5739, SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740, SpvOpSubgroupAvcMceGetInterMajorShapeINTEL = 5741, SpvOpSubgroupAvcMceGetInterMinorShapeINTEL = 5742, SpvOpSubgroupAvcMceGetInterDirectionsINTEL = 5743, SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744, SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745, SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746, SpvOpSubgroupAvcImeInitializeINTEL = 5747, SpvOpSubgroupAvcImeSetSingleReferenceINTEL = 5748, SpvOpSubgroupAvcImeSetDualReferenceINTEL = 5749, SpvOpSubgroupAvcImeRefWindowSizeINTEL = 5750, SpvOpSubgroupAvcImeAdjustRefOffsetINTEL = 5751, SpvOpSubgroupAvcImeConvertToMcePayloadINTEL = 5752, SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753, SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754, SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755, SpvOpSubgroupAvcImeSetWeightedSadINTEL = 5756, SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757, SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758, SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759, SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760, SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761, SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762, SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763, SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764, SpvOpSubgroupAvcImeConvertToMceResultINTEL = 5765, SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766, SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767, SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768, SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769, SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770, SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771, SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772, SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773, SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774, SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775, SpvOpSubgroupAvcImeGetBorderReachedINTEL = 5776, SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777, SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778, SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779, SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780, SpvOpSubgroupAvcFmeInitializeINTEL = 5781, SpvOpSubgroupAvcBmeInitializeINTEL = 5782, SpvOpSubgroupAvcRefConvertToMcePayloadINTEL = 5783, SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784, SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785, SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786, SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787, SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788, SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789, SpvOpSubgroupAvcRefConvertToMceResultINTEL = 5790, SpvOpSubgroupAvcSicInitializeINTEL = 5791, SpvOpSubgroupAvcSicConfigureSkcINTEL = 5792, SpvOpSubgroupAvcSicConfigureIpeLumaINTEL = 5793, SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794, SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795, SpvOpSubgroupAvcSicConvertToMcePayloadINTEL = 5796, SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797, SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798, SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799, SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800, SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801, SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802, SpvOpSubgroupAvcSicEvaluateIpeINTEL = 5803, SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804, SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805, SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806, SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807, SpvOpSubgroupAvcSicConvertToMceResultINTEL = 5808, SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809, SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810, SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811, SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812, SpvOpSubgroupAvcSicGetIpeChromaModeINTEL = 5813, SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814, SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815, SpvOpSubgroupAvcSicGetInterRawSadsINTEL = 5816, SpvOpLoopControlINTEL = 5887, SpvOpReadPipeBlockingINTEL = 5946, SpvOpWritePipeBlockingINTEL = 5947, SpvOpFPGARegINTEL = 5949, SpvOpRayQueryGetRayTMinKHR = 6016, SpvOpRayQueryGetRayFlagsKHR = 6017, SpvOpRayQueryGetIntersectionTKHR = 6018, SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019, SpvOpRayQueryGetIntersectionInstanceIdKHR = 6020, SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021, SpvOpRayQueryGetIntersectionGeometryIndexKHR = 6022, SpvOpRayQueryGetIntersectionPrimitiveIndexKHR = 6023, SpvOpRayQueryGetIntersectionBarycentricsKHR = 6024, SpvOpRayQueryGetIntersectionFrontFaceKHR = 6025, SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026, SpvOpRayQueryGetIntersectionObjectRayDirectionKHR = 6027, SpvOpRayQueryGetIntersectionObjectRayOriginKHR = 6028, SpvOpRayQueryGetWorldRayDirectionKHR = 6029, SpvOpRayQueryGetWorldRayOriginKHR = 6030, SpvOpRayQueryGetIntersectionObjectToWorldKHR = 6031, SpvOpRayQueryGetIntersectionWorldToObjectKHR = 6032, SpvOpAtomicFAddEXT = 6035, SpvOpMax = 0x7fffffff, } SpvOp; #ifdef SPV_ENABLE_UTILITY_CODE inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultType) { *hasResult = *hasResultType = false; switch (opcode) { default: /* unknown opcode */ break; case SpvOpNop: *hasResult = false; *hasResultType = false; break; case SpvOpUndef: *hasResult = true; *hasResultType = true; break; case SpvOpSourceContinued: *hasResult = false; *hasResultType = false; break; case SpvOpSource: *hasResult = false; *hasResultType = false; break; case SpvOpSourceExtension: *hasResult = false; *hasResultType = false; break; case SpvOpName: *hasResult = false; *hasResultType = false; break; case SpvOpMemberName: *hasResult = false; *hasResultType = false; break; case SpvOpString: *hasResult = true; *hasResultType = false; break; case SpvOpLine: *hasResult = false; *hasResultType = false; break; case SpvOpExtension: *hasResult = false; *hasResultType = false; break; case SpvOpExtInstImport: *hasResult = true; *hasResultType = false; break; case SpvOpExtInst: *hasResult = true; *hasResultType = true; break; case SpvOpMemoryModel: *hasResult = false; *hasResultType = false; break; case SpvOpEntryPoint: *hasResult = false; *hasResultType = false; break; case SpvOpExecutionMode: *hasResult = false; *hasResultType = false; break; case SpvOpCapability: *hasResult = false; *hasResultType = false; break; case SpvOpTypeVoid: *hasResult = true; *hasResultType = false; break; case SpvOpTypeBool: *hasResult = true; *hasResultType = false; break; case SpvOpTypeInt: *hasResult = true; *hasResultType = false; break; case SpvOpTypeFloat: *hasResult = true; *hasResultType = false; break; case SpvOpTypeVector: *hasResult = true; *hasResultType = false; break; case SpvOpTypeMatrix: *hasResult = true; *hasResultType = false; break; case SpvOpTypeImage: *hasResult = true; *hasResultType = false; break; case SpvOpTypeSampler: *hasResult = true; *hasResultType = false; break; case SpvOpTypeSampledImage: *hasResult = true; *hasResultType = false; break; case SpvOpTypeArray: *hasResult = true; *hasResultType = false; break; case SpvOpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break; case SpvOpTypeStruct: *hasResult = true; *hasResultType = false; break; case SpvOpTypeOpaque: *hasResult = true; *hasResultType = false; break; case SpvOpTypePointer: *hasResult = true; *hasResultType = false; break; case SpvOpTypeFunction: *hasResult = true; *hasResultType = false; break; case SpvOpTypeEvent: *hasResult = true; *hasResultType = false; break; case SpvOpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break; case SpvOpTypeReserveId: *hasResult = true; *hasResultType = false; break; case SpvOpTypeQueue: *hasResult = true; *hasResultType = false; break; case SpvOpTypePipe: *hasResult = true; *hasResultType = false; break; case SpvOpTypeForwardPointer: *hasResult = false; *hasResultType = false; break; case SpvOpConstantTrue: *hasResult = true; *hasResultType = true; break; case SpvOpConstantFalse: *hasResult = true; *hasResultType = true; break; case SpvOpConstant: *hasResult = true; *hasResultType = true; break; case SpvOpConstantComposite: *hasResult = true; *hasResultType = true; break; case SpvOpConstantSampler: *hasResult = true; *hasResultType = true; break; case SpvOpConstantNull: *hasResult = true; *hasResultType = true; break; case SpvOpSpecConstantTrue: *hasResult = true; *hasResultType = true; break; case SpvOpSpecConstantFalse: *hasResult = true; *hasResultType = true; break; case SpvOpSpecConstant: *hasResult = true; *hasResultType = true; break; case SpvOpSpecConstantComposite: *hasResult = true; *hasResultType = true; break; case SpvOpSpecConstantOp: *hasResult = true; *hasResultType = true; break; case SpvOpFunction: *hasResult = true; *hasResultType = true; break; case SpvOpFunctionParameter: *hasResult = true; *hasResultType = true; break; case SpvOpFunctionEnd: *hasResult = false; *hasResultType = false; break; case SpvOpFunctionCall: *hasResult = true; *hasResultType = true; break; case SpvOpVariable: *hasResult = true; *hasResultType = true; break; case SpvOpImageTexelPointer: *hasResult = true; *hasResultType = true; break; case SpvOpLoad: *hasResult = true; *hasResultType = true; break; case SpvOpStore: *hasResult = false; *hasResultType = false; break; case SpvOpCopyMemory: *hasResult = false; *hasResultType = false; break; case SpvOpCopyMemorySized: *hasResult = false; *hasResultType = false; break; case SpvOpAccessChain: *hasResult = true; *hasResultType = true; break; case SpvOpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break; case SpvOpPtrAccessChain: *hasResult = true; *hasResultType = true; break; case SpvOpArrayLength: *hasResult = true; *hasResultType = true; break; case SpvOpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break; case SpvOpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break; case SpvOpDecorate: *hasResult = false; *hasResultType = false; break; case SpvOpMemberDecorate: *hasResult = false; *hasResultType = false; break; case SpvOpDecorationGroup: *hasResult = true; *hasResultType = false; break; case SpvOpGroupDecorate: *hasResult = false; *hasResultType = false; break; case SpvOpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break; case SpvOpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break; case SpvOpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break; case SpvOpVectorShuffle: *hasResult = true; *hasResultType = true; break; case SpvOpCompositeConstruct: *hasResult = true; *hasResultType = true; break; case SpvOpCompositeExtract: *hasResult = true; *hasResultType = true; break; case SpvOpCompositeInsert: *hasResult = true; *hasResultType = true; break; case SpvOpCopyObject: *hasResult = true; *hasResultType = true; break; case SpvOpTranspose: *hasResult = true; *hasResultType = true; break; case SpvOpSampledImage: *hasResult = true; *hasResultType = true; break; case SpvOpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageFetch: *hasResult = true; *hasResultType = true; break; case SpvOpImageGather: *hasResult = true; *hasResultType = true; break; case SpvOpImageDrefGather: *hasResult = true; *hasResultType = true; break; case SpvOpImageRead: *hasResult = true; *hasResultType = true; break; case SpvOpImageWrite: *hasResult = false; *hasResultType = false; break; case SpvOpImage: *hasResult = true; *hasResultType = true; break; case SpvOpImageQueryFormat: *hasResult = true; *hasResultType = true; break; case SpvOpImageQueryOrder: *hasResult = true; *hasResultType = true; break; case SpvOpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageQuerySize: *hasResult = true; *hasResultType = true; break; case SpvOpImageQueryLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageQueryLevels: *hasResult = true; *hasResultType = true; break; case SpvOpImageQuerySamples: *hasResult = true; *hasResultType = true; break; case SpvOpConvertFToU: *hasResult = true; *hasResultType = true; break; case SpvOpConvertFToS: *hasResult = true; *hasResultType = true; break; case SpvOpConvertSToF: *hasResult = true; *hasResultType = true; break; case SpvOpConvertUToF: *hasResult = true; *hasResultType = true; break; case SpvOpUConvert: *hasResult = true; *hasResultType = true; break; case SpvOpSConvert: *hasResult = true; *hasResultType = true; break; case SpvOpFConvert: *hasResult = true; *hasResultType = true; break; case SpvOpQuantizeToF16: *hasResult = true; *hasResultType = true; break; case SpvOpConvertPtrToU: *hasResult = true; *hasResultType = true; break; case SpvOpSatConvertSToU: *hasResult = true; *hasResultType = true; break; case SpvOpSatConvertUToS: *hasResult = true; *hasResultType = true; break; case SpvOpConvertUToPtr: *hasResult = true; *hasResultType = true; break; case SpvOpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break; case SpvOpGenericCastToPtr: *hasResult = true; *hasResultType = true; break; case SpvOpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break; case SpvOpBitcast: *hasResult = true; *hasResultType = true; break; case SpvOpSNegate: *hasResult = true; *hasResultType = true; break; case SpvOpFNegate: *hasResult = true; *hasResultType = true; break; case SpvOpIAdd: *hasResult = true; *hasResultType = true; break; case SpvOpFAdd: *hasResult = true; *hasResultType = true; break; case SpvOpISub: *hasResult = true; *hasResultType = true; break; case SpvOpFSub: *hasResult = true; *hasResultType = true; break; case SpvOpIMul: *hasResult = true; *hasResultType = true; break; case SpvOpFMul: *hasResult = true; *hasResultType = true; break; case SpvOpUDiv: *hasResult = true; *hasResultType = true; break; case SpvOpSDiv: *hasResult = true; *hasResultType = true; break; case SpvOpFDiv: *hasResult = true; *hasResultType = true; break; case SpvOpUMod: *hasResult = true; *hasResultType = true; break; case SpvOpSRem: *hasResult = true; *hasResultType = true; break; case SpvOpSMod: *hasResult = true; *hasResultType = true; break; case SpvOpFRem: *hasResult = true; *hasResultType = true; break; case SpvOpFMod: *hasResult = true; *hasResultType = true; break; case SpvOpVectorTimesScalar: *hasResult = true; *hasResultType = true; break; case SpvOpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break; case SpvOpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break; case SpvOpMatrixTimesVector: *hasResult = true; *hasResultType = true; break; case SpvOpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break; case SpvOpOuterProduct: *hasResult = true; *hasResultType = true; break; case SpvOpDot: *hasResult = true; *hasResultType = true; break; case SpvOpIAddCarry: *hasResult = true; *hasResultType = true; break; case SpvOpISubBorrow: *hasResult = true; *hasResultType = true; break; case SpvOpUMulExtended: *hasResult = true; *hasResultType = true; break; case SpvOpSMulExtended: *hasResult = true; *hasResultType = true; break; case SpvOpAny: *hasResult = true; *hasResultType = true; break; case SpvOpAll: *hasResult = true; *hasResultType = true; break; case SpvOpIsNan: *hasResult = true; *hasResultType = true; break; case SpvOpIsInf: *hasResult = true; *hasResultType = true; break; case SpvOpIsFinite: *hasResult = true; *hasResultType = true; break; case SpvOpIsNormal: *hasResult = true; *hasResultType = true; break; case SpvOpSignBitSet: *hasResult = true; *hasResultType = true; break; case SpvOpLessOrGreater: *hasResult = true; *hasResultType = true; break; case SpvOpOrdered: *hasResult = true; *hasResultType = true; break; case SpvOpUnordered: *hasResult = true; *hasResultType = true; break; case SpvOpLogicalEqual: *hasResult = true; *hasResultType = true; break; case SpvOpLogicalNotEqual: *hasResult = true; *hasResultType = true; break; case SpvOpLogicalOr: *hasResult = true; *hasResultType = true; break; case SpvOpLogicalAnd: *hasResult = true; *hasResultType = true; break; case SpvOpLogicalNot: *hasResult = true; *hasResultType = true; break; case SpvOpSelect: *hasResult = true; *hasResultType = true; break; case SpvOpIEqual: *hasResult = true; *hasResultType = true; break; case SpvOpINotEqual: *hasResult = true; *hasResultType = true; break; case SpvOpUGreaterThan: *hasResult = true; *hasResultType = true; break; case SpvOpSGreaterThan: *hasResult = true; *hasResultType = true; break; case SpvOpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break; case SpvOpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break; case SpvOpULessThan: *hasResult = true; *hasResultType = true; break; case SpvOpSLessThan: *hasResult = true; *hasResultType = true; break; case SpvOpULessThanEqual: *hasResult = true; *hasResultType = true; break; case SpvOpSLessThanEqual: *hasResult = true; *hasResultType = true; break; case SpvOpFOrdEqual: *hasResult = true; *hasResultType = true; break; case SpvOpFUnordEqual: *hasResult = true; *hasResultType = true; break; case SpvOpFOrdNotEqual: *hasResult = true; *hasResultType = true; break; case SpvOpFUnordNotEqual: *hasResult = true; *hasResultType = true; break; case SpvOpFOrdLessThan: *hasResult = true; *hasResultType = true; break; case SpvOpFUnordLessThan: *hasResult = true; *hasResultType = true; break; case SpvOpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break; case SpvOpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break; case SpvOpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break; case SpvOpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break; case SpvOpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break; case SpvOpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break; case SpvOpShiftRightLogical: *hasResult = true; *hasResultType = true; break; case SpvOpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break; case SpvOpShiftLeftLogical: *hasResult = true; *hasResultType = true; break; case SpvOpBitwiseOr: *hasResult = true; *hasResultType = true; break; case SpvOpBitwiseXor: *hasResult = true; *hasResultType = true; break; case SpvOpBitwiseAnd: *hasResult = true; *hasResultType = true; break; case SpvOpNot: *hasResult = true; *hasResultType = true; break; case SpvOpBitFieldInsert: *hasResult = true; *hasResultType = true; break; case SpvOpBitFieldSExtract: *hasResult = true; *hasResultType = true; break; case SpvOpBitFieldUExtract: *hasResult = true; *hasResultType = true; break; case SpvOpBitReverse: *hasResult = true; *hasResultType = true; break; case SpvOpBitCount: *hasResult = true; *hasResultType = true; break; case SpvOpDPdx: *hasResult = true; *hasResultType = true; break; case SpvOpDPdy: *hasResult = true; *hasResultType = true; break; case SpvOpFwidth: *hasResult = true; *hasResultType = true; break; case SpvOpDPdxFine: *hasResult = true; *hasResultType = true; break; case SpvOpDPdyFine: *hasResult = true; *hasResultType = true; break; case SpvOpFwidthFine: *hasResult = true; *hasResultType = true; break; case SpvOpDPdxCoarse: *hasResult = true; *hasResultType = true; break; case SpvOpDPdyCoarse: *hasResult = true; *hasResultType = true; break; case SpvOpFwidthCoarse: *hasResult = true; *hasResultType = true; break; case SpvOpEmitVertex: *hasResult = false; *hasResultType = false; break; case SpvOpEndPrimitive: *hasResult = false; *hasResultType = false; break; case SpvOpEmitStreamVertex: *hasResult = false; *hasResultType = false; break; case SpvOpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break; case SpvOpControlBarrier: *hasResult = false; *hasResultType = false; break; case SpvOpMemoryBarrier: *hasResult = false; *hasResultType = false; break; case SpvOpAtomicLoad: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicStore: *hasResult = false; *hasResultType = false; break; case SpvOpAtomicExchange: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicIIncrement: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicIDecrement: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicIAdd: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicISub: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicSMin: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicUMin: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicSMax: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicUMax: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicAnd: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicOr: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicXor: *hasResult = true; *hasResultType = true; break; case SpvOpPhi: *hasResult = true; *hasResultType = true; break; case SpvOpLoopMerge: *hasResult = false; *hasResultType = false; break; case SpvOpSelectionMerge: *hasResult = false; *hasResultType = false; break; case SpvOpLabel: *hasResult = true; *hasResultType = false; break; case SpvOpBranch: *hasResult = false; *hasResultType = false; break; case SpvOpBranchConditional: *hasResult = false; *hasResultType = false; break; case SpvOpSwitch: *hasResult = false; *hasResultType = false; break; case SpvOpKill: *hasResult = false; *hasResultType = false; break; case SpvOpReturn: *hasResult = false; *hasResultType = false; break; case SpvOpReturnValue: *hasResult = false; *hasResultType = false; break; case SpvOpUnreachable: *hasResult = false; *hasResultType = false; break; case SpvOpLifetimeStart: *hasResult = false; *hasResultType = false; break; case SpvOpLifetimeStop: *hasResult = false; *hasResultType = false; break; case SpvOpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break; case SpvOpGroupWaitEvents: *hasResult = false; *hasResultType = false; break; case SpvOpGroupAll: *hasResult = true; *hasResultType = true; break; case SpvOpGroupAny: *hasResult = true; *hasResultType = true; break; case SpvOpGroupBroadcast: *hasResult = true; *hasResultType = true; break; case SpvOpGroupIAdd: *hasResult = true; *hasResultType = true; break; case SpvOpGroupFAdd: *hasResult = true; *hasResultType = true; break; case SpvOpGroupFMin: *hasResult = true; *hasResultType = true; break; case SpvOpGroupUMin: *hasResult = true; *hasResultType = true; break; case SpvOpGroupSMin: *hasResult = true; *hasResultType = true; break; case SpvOpGroupFMax: *hasResult = true; *hasResultType = true; break; case SpvOpGroupUMax: *hasResult = true; *hasResultType = true; break; case SpvOpGroupSMax: *hasResult = true; *hasResultType = true; break; case SpvOpReadPipe: *hasResult = true; *hasResultType = true; break; case SpvOpWritePipe: *hasResult = true; *hasResultType = true; break; case SpvOpReservedReadPipe: *hasResult = true; *hasResultType = true; break; case SpvOpReservedWritePipe: *hasResult = true; *hasResultType = true; break; case SpvOpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; case SpvOpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; case SpvOpCommitReadPipe: *hasResult = false; *hasResultType = false; break; case SpvOpCommitWritePipe: *hasResult = false; *hasResultType = false; break; case SpvOpIsValidReserveId: *hasResult = true; *hasResultType = true; break; case SpvOpGetNumPipePackets: *hasResult = true; *hasResultType = true; break; case SpvOpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break; case SpvOpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; case SpvOpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; case SpvOpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break; case SpvOpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break; case SpvOpEnqueueMarker: *hasResult = true; *hasResultType = true; break; case SpvOpEnqueueKernel: *hasResult = true; *hasResultType = true; break; case SpvOpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break; case SpvOpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break; case SpvOpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break; case SpvOpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break; case SpvOpRetainEvent: *hasResult = false; *hasResultType = false; break; case SpvOpReleaseEvent: *hasResult = false; *hasResultType = false; break; case SpvOpCreateUserEvent: *hasResult = true; *hasResultType = true; break; case SpvOpIsValidEvent: *hasResult = true; *hasResultType = true; break; case SpvOpSetUserEventStatus: *hasResult = false; *hasResultType = false; break; case SpvOpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break; case SpvOpGetDefaultQueue: *hasResult = true; *hasResultType = true; break; case SpvOpBuildNDRange: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseFetch: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseGather: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break; case SpvOpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break; case SpvOpNoLine: *hasResult = false; *hasResultType = false; break; case SpvOpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicFlagClear: *hasResult = false; *hasResultType = false; break; case SpvOpImageSparseRead: *hasResult = true; *hasResultType = true; break; case SpvOpSizeOf: *hasResult = true; *hasResultType = true; break; case SpvOpTypePipeStorage: *hasResult = true; *hasResultType = false; break; case SpvOpConstantPipeStorage: *hasResult = true; *hasResultType = true; break; case SpvOpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break; case SpvOpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break; case SpvOpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break; case SpvOpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break; case SpvOpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break; case SpvOpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break; case SpvOpModuleProcessed: *hasResult = false; *hasResultType = false; break; case SpvOpExecutionModeId: *hasResult = false; *hasResultType = false; break; case SpvOpDecorateId: *hasResult = false; *hasResultType = false; break; case SpvOpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break; case SpvOpCopyLogical: *hasResult = true; *hasResultType = true; break; case SpvOpPtrEqual: *hasResult = true; *hasResultType = true; break; case SpvOpPtrNotEqual: *hasResult = true; *hasResultType = true; break; case SpvOpPtrDiff: *hasResult = true; *hasResultType = true; break; case SpvOpTerminateInvocation: *hasResult = false; *hasResultType = false; break; case SpvOpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; case SpvOpTraceRayKHR: *hasResult = false; *hasResultType = false; break; case SpvOpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break; case SpvOpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break; case SpvOpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break; case SpvOpTerminateRayKHR: *hasResult = false; *hasResultType = false; break; case SpvOpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; case SpvOpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; case SpvOpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; case SpvOpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break; case SpvOpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break; case SpvOpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break; case SpvOpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break; case SpvOpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break; case SpvOpReadClockKHR: *hasResult = true; *hasResultType = true; break; case SpvOpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break; case SpvOpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; case SpvOpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; case SpvOpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; case SpvOpTerminateRayNV: *hasResult = false; *hasResultType = false; break; case SpvOpTraceNV: *hasResult = false; *hasResultType = false; break; case SpvOpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; case SpvOpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; case SpvOpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; case SpvOpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; case SpvOpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break; case SpvOpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break; case SpvOpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break; case SpvOpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; case SpvOpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; case SpvOpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break; case SpvOpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; case SpvOpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; case SpvOpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; case SpvOpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpAbsISubINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpIAddSatINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpUAddSatINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpIAverageINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpUAverageINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpISubSatINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpUSubSatINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break; case SpvOpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break; case SpvOpFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpDecorateString: *hasResult = false; *hasResultType = false; break; case SpvOpMemberDecorateString: *hasResult = false; *hasResultType = false; break; case SpvOpVmeImageINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break; case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpLoopControlINTEL: *hasResult = false; *hasResultType = false; break; case SpvOpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpFPGARegINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break; case SpvOpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break; case SpvOpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break; } } #endif /* SPV_ENABLE_UTILITY_CODE */ #endif spirv-cross-2021.01.15/spirv.hpp000066400000000000000000003202251400026215700162520ustar00rootroot00000000000000// Copyright (c) 2014-2020 The Khronos Group Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and/or associated documentation files (the "Materials"), // to deal in the Materials without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Materials, and to permit persons to whom the // Materials are furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Materials. // // MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS // STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND // HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ // // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS // IN THE MATERIALS. // This header is automatically generated by the same tool that creates // the Binary Section of the SPIR-V specification. // Enumeration tokens for SPIR-V, in various styles: // C, C++, C++11, JSON, Lua, Python, C#, D // // - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL // - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL // - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL // - Lua will use tables, e.g.: spv.SourceLanguage.GLSL // - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL'] // - C# will use enum classes in the Specification class located in the "Spv" namespace, // e.g.: Spv.Specification.SourceLanguage.GLSL // - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL // // Some tokens act like mask values, which can be OR'd together, // while others are mutually exclusive. The mask-like ones have // "Mask" in their name, and a parallel enum that has the shift // amount (1 << x) for each corresponding enumerant. #ifndef spirv_HPP #define spirv_HPP namespace spv { typedef unsigned int Id; #define SPV_VERSION 0x10500 #define SPV_REVISION 4 static const unsigned int MagicNumber = 0x07230203; static const unsigned int Version = 0x00010500; static const unsigned int Revision = 4; static const unsigned int OpCodeMask = 0xffff; static const unsigned int WordCountShift = 16; enum SourceLanguage { SourceLanguageUnknown = 0, SourceLanguageESSL = 1, SourceLanguageGLSL = 2, SourceLanguageOpenCL_C = 3, SourceLanguageOpenCL_CPP = 4, SourceLanguageHLSL = 5, SourceLanguageMax = 0x7fffffff, }; enum ExecutionModel { ExecutionModelVertex = 0, ExecutionModelTessellationControl = 1, ExecutionModelTessellationEvaluation = 2, ExecutionModelGeometry = 3, ExecutionModelFragment = 4, ExecutionModelGLCompute = 5, ExecutionModelKernel = 6, ExecutionModelTaskNV = 5267, ExecutionModelMeshNV = 5268, ExecutionModelRayGenerationKHR = 5313, ExecutionModelRayGenerationNV = 5313, ExecutionModelIntersectionKHR = 5314, ExecutionModelIntersectionNV = 5314, ExecutionModelAnyHitKHR = 5315, ExecutionModelAnyHitNV = 5315, ExecutionModelClosestHitKHR = 5316, ExecutionModelClosestHitNV = 5316, ExecutionModelMissKHR = 5317, ExecutionModelMissNV = 5317, ExecutionModelCallableKHR = 5318, ExecutionModelCallableNV = 5318, ExecutionModelMax = 0x7fffffff, }; enum AddressingModel { AddressingModelLogical = 0, AddressingModelPhysical32 = 1, AddressingModelPhysical64 = 2, AddressingModelPhysicalStorageBuffer64 = 5348, AddressingModelPhysicalStorageBuffer64EXT = 5348, AddressingModelMax = 0x7fffffff, }; enum MemoryModel { MemoryModelSimple = 0, MemoryModelGLSL450 = 1, MemoryModelOpenCL = 2, MemoryModelVulkan = 3, MemoryModelVulkanKHR = 3, MemoryModelMax = 0x7fffffff, }; enum ExecutionMode { ExecutionModeInvocations = 0, ExecutionModeSpacingEqual = 1, ExecutionModeSpacingFractionalEven = 2, ExecutionModeSpacingFractionalOdd = 3, ExecutionModeVertexOrderCw = 4, ExecutionModeVertexOrderCcw = 5, ExecutionModePixelCenterInteger = 6, ExecutionModeOriginUpperLeft = 7, ExecutionModeOriginLowerLeft = 8, ExecutionModeEarlyFragmentTests = 9, ExecutionModePointMode = 10, ExecutionModeXfb = 11, ExecutionModeDepthReplacing = 12, ExecutionModeDepthGreater = 14, ExecutionModeDepthLess = 15, ExecutionModeDepthUnchanged = 16, ExecutionModeLocalSize = 17, ExecutionModeLocalSizeHint = 18, ExecutionModeInputPoints = 19, ExecutionModeInputLines = 20, ExecutionModeInputLinesAdjacency = 21, ExecutionModeTriangles = 22, ExecutionModeInputTrianglesAdjacency = 23, ExecutionModeQuads = 24, ExecutionModeIsolines = 25, ExecutionModeOutputVertices = 26, ExecutionModeOutputPoints = 27, ExecutionModeOutputLineStrip = 28, ExecutionModeOutputTriangleStrip = 29, ExecutionModeVecTypeHint = 30, ExecutionModeContractionOff = 31, ExecutionModeInitializer = 33, ExecutionModeFinalizer = 34, ExecutionModeSubgroupSize = 35, ExecutionModeSubgroupsPerWorkgroup = 36, ExecutionModeSubgroupsPerWorkgroupId = 37, ExecutionModeLocalSizeId = 38, ExecutionModeLocalSizeHintId = 39, ExecutionModePostDepthCoverage = 4446, ExecutionModeDenormPreserve = 4459, ExecutionModeDenormFlushToZero = 4460, ExecutionModeSignedZeroInfNanPreserve = 4461, ExecutionModeRoundingModeRTE = 4462, ExecutionModeRoundingModeRTZ = 4463, ExecutionModeStencilRefReplacingEXT = 5027, ExecutionModeOutputLinesNV = 5269, ExecutionModeOutputPrimitivesNV = 5270, ExecutionModeDerivativeGroupQuadsNV = 5289, ExecutionModeDerivativeGroupLinearNV = 5290, ExecutionModeOutputTrianglesNV = 5298, ExecutionModePixelInterlockOrderedEXT = 5366, ExecutionModePixelInterlockUnorderedEXT = 5367, ExecutionModeSampleInterlockOrderedEXT = 5368, ExecutionModeSampleInterlockUnorderedEXT = 5369, ExecutionModeShadingRateInterlockOrderedEXT = 5370, ExecutionModeShadingRateInterlockUnorderedEXT = 5371, ExecutionModeMaxWorkgroupSizeINTEL = 5893, ExecutionModeMaxWorkDimINTEL = 5894, ExecutionModeNoGlobalOffsetINTEL = 5895, ExecutionModeNumSIMDWorkitemsINTEL = 5896, ExecutionModeMax = 0x7fffffff, }; enum StorageClass { StorageClassUniformConstant = 0, StorageClassInput = 1, StorageClassUniform = 2, StorageClassOutput = 3, StorageClassWorkgroup = 4, StorageClassCrossWorkgroup = 5, StorageClassPrivate = 6, StorageClassFunction = 7, StorageClassGeneric = 8, StorageClassPushConstant = 9, StorageClassAtomicCounter = 10, StorageClassImage = 11, StorageClassStorageBuffer = 12, StorageClassCallableDataKHR = 5328, StorageClassCallableDataNV = 5328, StorageClassIncomingCallableDataKHR = 5329, StorageClassIncomingCallableDataNV = 5329, StorageClassRayPayloadKHR = 5338, StorageClassRayPayloadNV = 5338, StorageClassHitAttributeKHR = 5339, StorageClassHitAttributeNV = 5339, StorageClassIncomingRayPayloadKHR = 5342, StorageClassIncomingRayPayloadNV = 5342, StorageClassShaderRecordBufferKHR = 5343, StorageClassShaderRecordBufferNV = 5343, StorageClassPhysicalStorageBuffer = 5349, StorageClassPhysicalStorageBufferEXT = 5349, StorageClassCodeSectionINTEL = 5605, StorageClassMax = 0x7fffffff, }; enum Dim { Dim1D = 0, Dim2D = 1, Dim3D = 2, DimCube = 3, DimRect = 4, DimBuffer = 5, DimSubpassData = 6, DimMax = 0x7fffffff, }; enum SamplerAddressingMode { SamplerAddressingModeNone = 0, SamplerAddressingModeClampToEdge = 1, SamplerAddressingModeClamp = 2, SamplerAddressingModeRepeat = 3, SamplerAddressingModeRepeatMirrored = 4, SamplerAddressingModeMax = 0x7fffffff, }; enum SamplerFilterMode { SamplerFilterModeNearest = 0, SamplerFilterModeLinear = 1, SamplerFilterModeMax = 0x7fffffff, }; enum ImageFormat { ImageFormatUnknown = 0, ImageFormatRgba32f = 1, ImageFormatRgba16f = 2, ImageFormatR32f = 3, ImageFormatRgba8 = 4, ImageFormatRgba8Snorm = 5, ImageFormatRg32f = 6, ImageFormatRg16f = 7, ImageFormatR11fG11fB10f = 8, ImageFormatR16f = 9, ImageFormatRgba16 = 10, ImageFormatRgb10A2 = 11, ImageFormatRg16 = 12, ImageFormatRg8 = 13, ImageFormatR16 = 14, ImageFormatR8 = 15, ImageFormatRgba16Snorm = 16, ImageFormatRg16Snorm = 17, ImageFormatRg8Snorm = 18, ImageFormatR16Snorm = 19, ImageFormatR8Snorm = 20, ImageFormatRgba32i = 21, ImageFormatRgba16i = 22, ImageFormatRgba8i = 23, ImageFormatR32i = 24, ImageFormatRg32i = 25, ImageFormatRg16i = 26, ImageFormatRg8i = 27, ImageFormatR16i = 28, ImageFormatR8i = 29, ImageFormatRgba32ui = 30, ImageFormatRgba16ui = 31, ImageFormatRgba8ui = 32, ImageFormatR32ui = 33, ImageFormatRgb10a2ui = 34, ImageFormatRg32ui = 35, ImageFormatRg16ui = 36, ImageFormatRg8ui = 37, ImageFormatR16ui = 38, ImageFormatR8ui = 39, ImageFormatR64ui = 40, ImageFormatR64i = 41, ImageFormatMax = 0x7fffffff, }; enum ImageChannelOrder { ImageChannelOrderR = 0, ImageChannelOrderA = 1, ImageChannelOrderRG = 2, ImageChannelOrderRA = 3, ImageChannelOrderRGB = 4, ImageChannelOrderRGBA = 5, ImageChannelOrderBGRA = 6, ImageChannelOrderARGB = 7, ImageChannelOrderIntensity = 8, ImageChannelOrderLuminance = 9, ImageChannelOrderRx = 10, ImageChannelOrderRGx = 11, ImageChannelOrderRGBx = 12, ImageChannelOrderDepth = 13, ImageChannelOrderDepthStencil = 14, ImageChannelOrdersRGB = 15, ImageChannelOrdersRGBx = 16, ImageChannelOrdersRGBA = 17, ImageChannelOrdersBGRA = 18, ImageChannelOrderABGR = 19, ImageChannelOrderMax = 0x7fffffff, }; enum ImageChannelDataType { ImageChannelDataTypeSnormInt8 = 0, ImageChannelDataTypeSnormInt16 = 1, ImageChannelDataTypeUnormInt8 = 2, ImageChannelDataTypeUnormInt16 = 3, ImageChannelDataTypeUnormShort565 = 4, ImageChannelDataTypeUnormShort555 = 5, ImageChannelDataTypeUnormInt101010 = 6, ImageChannelDataTypeSignedInt8 = 7, ImageChannelDataTypeSignedInt16 = 8, ImageChannelDataTypeSignedInt32 = 9, ImageChannelDataTypeUnsignedInt8 = 10, ImageChannelDataTypeUnsignedInt16 = 11, ImageChannelDataTypeUnsignedInt32 = 12, ImageChannelDataTypeHalfFloat = 13, ImageChannelDataTypeFloat = 14, ImageChannelDataTypeUnormInt24 = 15, ImageChannelDataTypeUnormInt101010_2 = 16, ImageChannelDataTypeMax = 0x7fffffff, }; enum ImageOperandsShift { ImageOperandsBiasShift = 0, ImageOperandsLodShift = 1, ImageOperandsGradShift = 2, ImageOperandsConstOffsetShift = 3, ImageOperandsOffsetShift = 4, ImageOperandsConstOffsetsShift = 5, ImageOperandsSampleShift = 6, ImageOperandsMinLodShift = 7, ImageOperandsMakeTexelAvailableShift = 8, ImageOperandsMakeTexelAvailableKHRShift = 8, ImageOperandsMakeTexelVisibleShift = 9, ImageOperandsMakeTexelVisibleKHRShift = 9, ImageOperandsNonPrivateTexelShift = 10, ImageOperandsNonPrivateTexelKHRShift = 10, ImageOperandsVolatileTexelShift = 11, ImageOperandsVolatileTexelKHRShift = 11, ImageOperandsSignExtendShift = 12, ImageOperandsZeroExtendShift = 13, ImageOperandsMax = 0x7fffffff, }; enum ImageOperandsMask { ImageOperandsMaskNone = 0, ImageOperandsBiasMask = 0x00000001, ImageOperandsLodMask = 0x00000002, ImageOperandsGradMask = 0x00000004, ImageOperandsConstOffsetMask = 0x00000008, ImageOperandsOffsetMask = 0x00000010, ImageOperandsConstOffsetsMask = 0x00000020, ImageOperandsSampleMask = 0x00000040, ImageOperandsMinLodMask = 0x00000080, ImageOperandsMakeTexelAvailableMask = 0x00000100, ImageOperandsMakeTexelAvailableKHRMask = 0x00000100, ImageOperandsMakeTexelVisibleMask = 0x00000200, ImageOperandsMakeTexelVisibleKHRMask = 0x00000200, ImageOperandsNonPrivateTexelMask = 0x00000400, ImageOperandsNonPrivateTexelKHRMask = 0x00000400, ImageOperandsVolatileTexelMask = 0x00000800, ImageOperandsVolatileTexelKHRMask = 0x00000800, ImageOperandsSignExtendMask = 0x00001000, ImageOperandsZeroExtendMask = 0x00002000, }; enum FPFastMathModeShift { FPFastMathModeNotNaNShift = 0, FPFastMathModeNotInfShift = 1, FPFastMathModeNSZShift = 2, FPFastMathModeAllowRecipShift = 3, FPFastMathModeFastShift = 4, FPFastMathModeMax = 0x7fffffff, }; enum FPFastMathModeMask { FPFastMathModeMaskNone = 0, FPFastMathModeNotNaNMask = 0x00000001, FPFastMathModeNotInfMask = 0x00000002, FPFastMathModeNSZMask = 0x00000004, FPFastMathModeAllowRecipMask = 0x00000008, FPFastMathModeFastMask = 0x00000010, }; enum FPRoundingMode { FPRoundingModeRTE = 0, FPRoundingModeRTZ = 1, FPRoundingModeRTP = 2, FPRoundingModeRTN = 3, FPRoundingModeMax = 0x7fffffff, }; enum LinkageType { LinkageTypeExport = 0, LinkageTypeImport = 1, LinkageTypeMax = 0x7fffffff, }; enum AccessQualifier { AccessQualifierReadOnly = 0, AccessQualifierWriteOnly = 1, AccessQualifierReadWrite = 2, AccessQualifierMax = 0x7fffffff, }; enum FunctionParameterAttribute { FunctionParameterAttributeZext = 0, FunctionParameterAttributeSext = 1, FunctionParameterAttributeByVal = 2, FunctionParameterAttributeSret = 3, FunctionParameterAttributeNoAlias = 4, FunctionParameterAttributeNoCapture = 5, FunctionParameterAttributeNoWrite = 6, FunctionParameterAttributeNoReadWrite = 7, FunctionParameterAttributeMax = 0x7fffffff, }; enum Decoration { DecorationRelaxedPrecision = 0, DecorationSpecId = 1, DecorationBlock = 2, DecorationBufferBlock = 3, DecorationRowMajor = 4, DecorationColMajor = 5, DecorationArrayStride = 6, DecorationMatrixStride = 7, DecorationGLSLShared = 8, DecorationGLSLPacked = 9, DecorationCPacked = 10, DecorationBuiltIn = 11, DecorationNoPerspective = 13, DecorationFlat = 14, DecorationPatch = 15, DecorationCentroid = 16, DecorationSample = 17, DecorationInvariant = 18, DecorationRestrict = 19, DecorationAliased = 20, DecorationVolatile = 21, DecorationConstant = 22, DecorationCoherent = 23, DecorationNonWritable = 24, DecorationNonReadable = 25, DecorationUniform = 26, DecorationUniformId = 27, DecorationSaturatedConversion = 28, DecorationStream = 29, DecorationLocation = 30, DecorationComponent = 31, DecorationIndex = 32, DecorationBinding = 33, DecorationDescriptorSet = 34, DecorationOffset = 35, DecorationXfbBuffer = 36, DecorationXfbStride = 37, DecorationFuncParamAttr = 38, DecorationFPRoundingMode = 39, DecorationFPFastMathMode = 40, DecorationLinkageAttributes = 41, DecorationNoContraction = 42, DecorationInputAttachmentIndex = 43, DecorationAlignment = 44, DecorationMaxByteOffset = 45, DecorationAlignmentId = 46, DecorationMaxByteOffsetId = 47, DecorationNoSignedWrap = 4469, DecorationNoUnsignedWrap = 4470, DecorationExplicitInterpAMD = 4999, DecorationOverrideCoverageNV = 5248, DecorationPassthroughNV = 5250, DecorationViewportRelativeNV = 5252, DecorationSecondaryViewportRelativeNV = 5256, DecorationPerPrimitiveNV = 5271, DecorationPerViewNV = 5272, DecorationPerTaskNV = 5273, DecorationPerVertexNV = 5285, DecorationNonUniform = 5300, DecorationNonUniformEXT = 5300, DecorationRestrictPointer = 5355, DecorationRestrictPointerEXT = 5355, DecorationAliasedPointer = 5356, DecorationAliasedPointerEXT = 5356, DecorationReferencedIndirectlyINTEL = 5602, DecorationCounterBuffer = 5634, DecorationHlslCounterBufferGOOGLE = 5634, DecorationHlslSemanticGOOGLE = 5635, DecorationUserSemantic = 5635, DecorationUserTypeGOOGLE = 5636, DecorationRegisterINTEL = 5825, DecorationMemoryINTEL = 5826, DecorationNumbanksINTEL = 5827, DecorationBankwidthINTEL = 5828, DecorationMaxPrivateCopiesINTEL = 5829, DecorationSinglepumpINTEL = 5830, DecorationDoublepumpINTEL = 5831, DecorationMaxReplicatesINTEL = 5832, DecorationSimpleDualPortINTEL = 5833, DecorationMergeINTEL = 5834, DecorationBankBitsINTEL = 5835, DecorationForcePow2DepthINTEL = 5836, DecorationMax = 0x7fffffff, }; enum BuiltIn { BuiltInPosition = 0, BuiltInPointSize = 1, BuiltInClipDistance = 3, BuiltInCullDistance = 4, BuiltInVertexId = 5, BuiltInInstanceId = 6, BuiltInPrimitiveId = 7, BuiltInInvocationId = 8, BuiltInLayer = 9, BuiltInViewportIndex = 10, BuiltInTessLevelOuter = 11, BuiltInTessLevelInner = 12, BuiltInTessCoord = 13, BuiltInPatchVertices = 14, BuiltInFragCoord = 15, BuiltInPointCoord = 16, BuiltInFrontFacing = 17, BuiltInSampleId = 18, BuiltInSamplePosition = 19, BuiltInSampleMask = 20, BuiltInFragDepth = 22, BuiltInHelperInvocation = 23, BuiltInNumWorkgroups = 24, BuiltInWorkgroupSize = 25, BuiltInWorkgroupId = 26, BuiltInLocalInvocationId = 27, BuiltInGlobalInvocationId = 28, BuiltInLocalInvocationIndex = 29, BuiltInWorkDim = 30, BuiltInGlobalSize = 31, BuiltInEnqueuedWorkgroupSize = 32, BuiltInGlobalOffset = 33, BuiltInGlobalLinearId = 34, BuiltInSubgroupSize = 36, BuiltInSubgroupMaxSize = 37, BuiltInNumSubgroups = 38, BuiltInNumEnqueuedSubgroups = 39, BuiltInSubgroupId = 40, BuiltInSubgroupLocalInvocationId = 41, BuiltInVertexIndex = 42, BuiltInInstanceIndex = 43, BuiltInSubgroupEqMask = 4416, BuiltInSubgroupEqMaskKHR = 4416, BuiltInSubgroupGeMask = 4417, BuiltInSubgroupGeMaskKHR = 4417, BuiltInSubgroupGtMask = 4418, BuiltInSubgroupGtMaskKHR = 4418, BuiltInSubgroupLeMask = 4419, BuiltInSubgroupLeMaskKHR = 4419, BuiltInSubgroupLtMask = 4420, BuiltInSubgroupLtMaskKHR = 4420, BuiltInBaseVertex = 4424, BuiltInBaseInstance = 4425, BuiltInDrawIndex = 4426, BuiltInPrimitiveShadingRateKHR = 4432, BuiltInDeviceIndex = 4438, BuiltInViewIndex = 4440, BuiltInShadingRateKHR = 4444, BuiltInBaryCoordNoPerspAMD = 4992, BuiltInBaryCoordNoPerspCentroidAMD = 4993, BuiltInBaryCoordNoPerspSampleAMD = 4994, BuiltInBaryCoordSmoothAMD = 4995, BuiltInBaryCoordSmoothCentroidAMD = 4996, BuiltInBaryCoordSmoothSampleAMD = 4997, BuiltInBaryCoordPullModelAMD = 4998, BuiltInFragStencilRefEXT = 5014, BuiltInViewportMaskNV = 5253, BuiltInSecondaryPositionNV = 5257, BuiltInSecondaryViewportMaskNV = 5258, BuiltInPositionPerViewNV = 5261, BuiltInViewportMaskPerViewNV = 5262, BuiltInFullyCoveredEXT = 5264, BuiltInTaskCountNV = 5274, BuiltInPrimitiveCountNV = 5275, BuiltInPrimitiveIndicesNV = 5276, BuiltInClipDistancePerViewNV = 5277, BuiltInCullDistancePerViewNV = 5278, BuiltInLayerPerViewNV = 5279, BuiltInMeshViewCountNV = 5280, BuiltInMeshViewIndicesNV = 5281, BuiltInBaryCoordNV = 5286, BuiltInBaryCoordNoPerspNV = 5287, BuiltInFragSizeEXT = 5292, BuiltInFragmentSizeNV = 5292, BuiltInFragInvocationCountEXT = 5293, BuiltInInvocationsPerPixelNV = 5293, BuiltInLaunchIdKHR = 5319, BuiltInLaunchIdNV = 5319, BuiltInLaunchSizeKHR = 5320, BuiltInLaunchSizeNV = 5320, BuiltInWorldRayOriginKHR = 5321, BuiltInWorldRayOriginNV = 5321, BuiltInWorldRayDirectionKHR = 5322, BuiltInWorldRayDirectionNV = 5322, BuiltInObjectRayOriginKHR = 5323, BuiltInObjectRayOriginNV = 5323, BuiltInObjectRayDirectionKHR = 5324, BuiltInObjectRayDirectionNV = 5324, BuiltInRayTminKHR = 5325, BuiltInRayTminNV = 5325, BuiltInRayTmaxKHR = 5326, BuiltInRayTmaxNV = 5326, BuiltInInstanceCustomIndexKHR = 5327, BuiltInInstanceCustomIndexNV = 5327, BuiltInObjectToWorldKHR = 5330, BuiltInObjectToWorldNV = 5330, BuiltInWorldToObjectKHR = 5331, BuiltInWorldToObjectNV = 5331, BuiltInHitTNV = 5332, BuiltInHitKindKHR = 5333, BuiltInHitKindNV = 5333, BuiltInIncomingRayFlagsKHR = 5351, BuiltInIncomingRayFlagsNV = 5351, BuiltInRayGeometryIndexKHR = 5352, BuiltInWarpsPerSMNV = 5374, BuiltInSMCountNV = 5375, BuiltInWarpIDNV = 5376, BuiltInSMIDNV = 5377, BuiltInMax = 0x7fffffff, }; enum SelectionControlShift { SelectionControlFlattenShift = 0, SelectionControlDontFlattenShift = 1, SelectionControlMax = 0x7fffffff, }; enum SelectionControlMask { SelectionControlMaskNone = 0, SelectionControlFlattenMask = 0x00000001, SelectionControlDontFlattenMask = 0x00000002, }; enum LoopControlShift { LoopControlUnrollShift = 0, LoopControlDontUnrollShift = 1, LoopControlDependencyInfiniteShift = 2, LoopControlDependencyLengthShift = 3, LoopControlMinIterationsShift = 4, LoopControlMaxIterationsShift = 5, LoopControlIterationMultipleShift = 6, LoopControlPeelCountShift = 7, LoopControlPartialCountShift = 8, LoopControlInitiationIntervalINTELShift = 16, LoopControlMaxConcurrencyINTELShift = 17, LoopControlDependencyArrayINTELShift = 18, LoopControlPipelineEnableINTELShift = 19, LoopControlLoopCoalesceINTELShift = 20, LoopControlMaxInterleavingINTELShift = 21, LoopControlSpeculatedIterationsINTELShift = 22, LoopControlMax = 0x7fffffff, }; enum LoopControlMask { LoopControlMaskNone = 0, LoopControlUnrollMask = 0x00000001, LoopControlDontUnrollMask = 0x00000002, LoopControlDependencyInfiniteMask = 0x00000004, LoopControlDependencyLengthMask = 0x00000008, LoopControlMinIterationsMask = 0x00000010, LoopControlMaxIterationsMask = 0x00000020, LoopControlIterationMultipleMask = 0x00000040, LoopControlPeelCountMask = 0x00000080, LoopControlPartialCountMask = 0x00000100, LoopControlInitiationIntervalINTELMask = 0x00010000, LoopControlMaxConcurrencyINTELMask = 0x00020000, LoopControlDependencyArrayINTELMask = 0x00040000, LoopControlPipelineEnableINTELMask = 0x00080000, LoopControlLoopCoalesceINTELMask = 0x00100000, LoopControlMaxInterleavingINTELMask = 0x00200000, LoopControlSpeculatedIterationsINTELMask = 0x00400000, }; enum FunctionControlShift { FunctionControlInlineShift = 0, FunctionControlDontInlineShift = 1, FunctionControlPureShift = 2, FunctionControlConstShift = 3, FunctionControlMax = 0x7fffffff, }; enum FunctionControlMask { FunctionControlMaskNone = 0, FunctionControlInlineMask = 0x00000001, FunctionControlDontInlineMask = 0x00000002, FunctionControlPureMask = 0x00000004, FunctionControlConstMask = 0x00000008, }; enum MemorySemanticsShift { MemorySemanticsAcquireShift = 1, MemorySemanticsReleaseShift = 2, MemorySemanticsAcquireReleaseShift = 3, MemorySemanticsSequentiallyConsistentShift = 4, MemorySemanticsUniformMemoryShift = 6, MemorySemanticsSubgroupMemoryShift = 7, MemorySemanticsWorkgroupMemoryShift = 8, MemorySemanticsCrossWorkgroupMemoryShift = 9, MemorySemanticsAtomicCounterMemoryShift = 10, MemorySemanticsImageMemoryShift = 11, MemorySemanticsOutputMemoryShift = 12, MemorySemanticsOutputMemoryKHRShift = 12, MemorySemanticsMakeAvailableShift = 13, MemorySemanticsMakeAvailableKHRShift = 13, MemorySemanticsMakeVisibleShift = 14, MemorySemanticsMakeVisibleKHRShift = 14, MemorySemanticsVolatileShift = 15, MemorySemanticsMax = 0x7fffffff, }; enum MemorySemanticsMask { MemorySemanticsMaskNone = 0, MemorySemanticsAcquireMask = 0x00000002, MemorySemanticsReleaseMask = 0x00000004, MemorySemanticsAcquireReleaseMask = 0x00000008, MemorySemanticsSequentiallyConsistentMask = 0x00000010, MemorySemanticsUniformMemoryMask = 0x00000040, MemorySemanticsSubgroupMemoryMask = 0x00000080, MemorySemanticsWorkgroupMemoryMask = 0x00000100, MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200, MemorySemanticsAtomicCounterMemoryMask = 0x00000400, MemorySemanticsImageMemoryMask = 0x00000800, MemorySemanticsOutputMemoryMask = 0x00001000, MemorySemanticsOutputMemoryKHRMask = 0x00001000, MemorySemanticsMakeAvailableMask = 0x00002000, MemorySemanticsMakeAvailableKHRMask = 0x00002000, MemorySemanticsMakeVisibleMask = 0x00004000, MemorySemanticsMakeVisibleKHRMask = 0x00004000, MemorySemanticsVolatileMask = 0x00008000, }; enum MemoryAccessShift { MemoryAccessVolatileShift = 0, MemoryAccessAlignedShift = 1, MemoryAccessNontemporalShift = 2, MemoryAccessMakePointerAvailableShift = 3, MemoryAccessMakePointerAvailableKHRShift = 3, MemoryAccessMakePointerVisibleShift = 4, MemoryAccessMakePointerVisibleKHRShift = 4, MemoryAccessNonPrivatePointerShift = 5, MemoryAccessNonPrivatePointerKHRShift = 5, MemoryAccessMax = 0x7fffffff, }; enum MemoryAccessMask { MemoryAccessMaskNone = 0, MemoryAccessVolatileMask = 0x00000001, MemoryAccessAlignedMask = 0x00000002, MemoryAccessNontemporalMask = 0x00000004, MemoryAccessMakePointerAvailableMask = 0x00000008, MemoryAccessMakePointerAvailableKHRMask = 0x00000008, MemoryAccessMakePointerVisibleMask = 0x00000010, MemoryAccessMakePointerVisibleKHRMask = 0x00000010, MemoryAccessNonPrivatePointerMask = 0x00000020, MemoryAccessNonPrivatePointerKHRMask = 0x00000020, }; enum Scope { ScopeCrossDevice = 0, ScopeDevice = 1, ScopeWorkgroup = 2, ScopeSubgroup = 3, ScopeInvocation = 4, ScopeQueueFamily = 5, ScopeQueueFamilyKHR = 5, ScopeShaderCallKHR = 6, ScopeMax = 0x7fffffff, }; enum GroupOperation { GroupOperationReduce = 0, GroupOperationInclusiveScan = 1, GroupOperationExclusiveScan = 2, GroupOperationClusteredReduce = 3, GroupOperationPartitionedReduceNV = 6, GroupOperationPartitionedInclusiveScanNV = 7, GroupOperationPartitionedExclusiveScanNV = 8, GroupOperationMax = 0x7fffffff, }; enum KernelEnqueueFlags { KernelEnqueueFlagsNoWait = 0, KernelEnqueueFlagsWaitKernel = 1, KernelEnqueueFlagsWaitWorkGroup = 2, KernelEnqueueFlagsMax = 0x7fffffff, }; enum KernelProfilingInfoShift { KernelProfilingInfoCmdExecTimeShift = 0, KernelProfilingInfoMax = 0x7fffffff, }; enum KernelProfilingInfoMask { KernelProfilingInfoMaskNone = 0, KernelProfilingInfoCmdExecTimeMask = 0x00000001, }; enum Capability { CapabilityMatrix = 0, CapabilityShader = 1, CapabilityGeometry = 2, CapabilityTessellation = 3, CapabilityAddresses = 4, CapabilityLinkage = 5, CapabilityKernel = 6, CapabilityVector16 = 7, CapabilityFloat16Buffer = 8, CapabilityFloat16 = 9, CapabilityFloat64 = 10, CapabilityInt64 = 11, CapabilityInt64Atomics = 12, CapabilityImageBasic = 13, CapabilityImageReadWrite = 14, CapabilityImageMipmap = 15, CapabilityPipes = 17, CapabilityGroups = 18, CapabilityDeviceEnqueue = 19, CapabilityLiteralSampler = 20, CapabilityAtomicStorage = 21, CapabilityInt16 = 22, CapabilityTessellationPointSize = 23, CapabilityGeometryPointSize = 24, CapabilityImageGatherExtended = 25, CapabilityStorageImageMultisample = 27, CapabilityUniformBufferArrayDynamicIndexing = 28, CapabilitySampledImageArrayDynamicIndexing = 29, CapabilityStorageBufferArrayDynamicIndexing = 30, CapabilityStorageImageArrayDynamicIndexing = 31, CapabilityClipDistance = 32, CapabilityCullDistance = 33, CapabilityImageCubeArray = 34, CapabilitySampleRateShading = 35, CapabilityImageRect = 36, CapabilitySampledRect = 37, CapabilityGenericPointer = 38, CapabilityInt8 = 39, CapabilityInputAttachment = 40, CapabilitySparseResidency = 41, CapabilityMinLod = 42, CapabilitySampled1D = 43, CapabilityImage1D = 44, CapabilitySampledCubeArray = 45, CapabilitySampledBuffer = 46, CapabilityImageBuffer = 47, CapabilityImageMSArray = 48, CapabilityStorageImageExtendedFormats = 49, CapabilityImageQuery = 50, CapabilityDerivativeControl = 51, CapabilityInterpolationFunction = 52, CapabilityTransformFeedback = 53, CapabilityGeometryStreams = 54, CapabilityStorageImageReadWithoutFormat = 55, CapabilityStorageImageWriteWithoutFormat = 56, CapabilityMultiViewport = 57, CapabilitySubgroupDispatch = 58, CapabilityNamedBarrier = 59, CapabilityPipeStorage = 60, CapabilityGroupNonUniform = 61, CapabilityGroupNonUniformVote = 62, CapabilityGroupNonUniformArithmetic = 63, CapabilityGroupNonUniformBallot = 64, CapabilityGroupNonUniformShuffle = 65, CapabilityGroupNonUniformShuffleRelative = 66, CapabilityGroupNonUniformClustered = 67, CapabilityGroupNonUniformQuad = 68, CapabilityShaderLayer = 69, CapabilityShaderViewportIndex = 70, CapabilityFragmentShadingRateKHR = 4422, CapabilitySubgroupBallotKHR = 4423, CapabilityDrawParameters = 4427, CapabilitySubgroupVoteKHR = 4431, CapabilityStorageBuffer16BitAccess = 4433, CapabilityStorageUniformBufferBlock16 = 4433, CapabilityStorageUniform16 = 4434, CapabilityUniformAndStorageBuffer16BitAccess = 4434, CapabilityStoragePushConstant16 = 4435, CapabilityStorageInputOutput16 = 4436, CapabilityDeviceGroup = 4437, CapabilityMultiView = 4439, CapabilityVariablePointersStorageBuffer = 4441, CapabilityVariablePointers = 4442, CapabilityAtomicStorageOps = 4445, CapabilitySampleMaskPostDepthCoverage = 4447, CapabilityStorageBuffer8BitAccess = 4448, CapabilityUniformAndStorageBuffer8BitAccess = 4449, CapabilityStoragePushConstant8 = 4450, CapabilityDenormPreserve = 4464, CapabilityDenormFlushToZero = 4465, CapabilitySignedZeroInfNanPreserve = 4466, CapabilityRoundingModeRTE = 4467, CapabilityRoundingModeRTZ = 4468, CapabilityRayQueryProvisionalKHR = 4471, CapabilityRayQueryKHR = 4472, CapabilityRayTraversalPrimitiveCullingKHR = 4478, CapabilityRayTracingKHR = 4479, CapabilityFloat16ImageAMD = 5008, CapabilityImageGatherBiasLodAMD = 5009, CapabilityFragmentMaskAMD = 5010, CapabilityStencilExportEXT = 5013, CapabilityImageReadWriteLodAMD = 5015, CapabilityInt64ImageEXT = 5016, CapabilityShaderClockKHR = 5055, CapabilitySampleMaskOverrideCoverageNV = 5249, CapabilityGeometryShaderPassthroughNV = 5251, CapabilityShaderViewportIndexLayerEXT = 5254, CapabilityShaderViewportIndexLayerNV = 5254, CapabilityShaderViewportMaskNV = 5255, CapabilityShaderStereoViewNV = 5259, CapabilityPerViewAttributesNV = 5260, CapabilityFragmentFullyCoveredEXT = 5265, CapabilityMeshShadingNV = 5266, CapabilityImageFootprintNV = 5282, CapabilityFragmentBarycentricNV = 5284, CapabilityComputeDerivativeGroupQuadsNV = 5288, CapabilityFragmentDensityEXT = 5291, CapabilityShadingRateNV = 5291, CapabilityGroupNonUniformPartitionedNV = 5297, CapabilityShaderNonUniform = 5301, CapabilityShaderNonUniformEXT = 5301, CapabilityRuntimeDescriptorArray = 5302, CapabilityRuntimeDescriptorArrayEXT = 5302, CapabilityInputAttachmentArrayDynamicIndexing = 5303, CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303, CapabilityUniformTexelBufferArrayDynamicIndexing = 5304, CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304, CapabilityStorageTexelBufferArrayDynamicIndexing = 5305, CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305, CapabilityUniformBufferArrayNonUniformIndexing = 5306, CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306, CapabilitySampledImageArrayNonUniformIndexing = 5307, CapabilitySampledImageArrayNonUniformIndexingEXT = 5307, CapabilityStorageBufferArrayNonUniformIndexing = 5308, CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308, CapabilityStorageImageArrayNonUniformIndexing = 5309, CapabilityStorageImageArrayNonUniformIndexingEXT = 5309, CapabilityInputAttachmentArrayNonUniformIndexing = 5310, CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310, CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311, CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311, CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312, CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312, CapabilityRayTracingNV = 5340, CapabilityVulkanMemoryModel = 5345, CapabilityVulkanMemoryModelKHR = 5345, CapabilityVulkanMemoryModelDeviceScope = 5346, CapabilityVulkanMemoryModelDeviceScopeKHR = 5346, CapabilityPhysicalStorageBufferAddresses = 5347, CapabilityPhysicalStorageBufferAddressesEXT = 5347, CapabilityComputeDerivativeGroupLinearNV = 5350, CapabilityRayTracingProvisionalKHR = 5353, CapabilityCooperativeMatrixNV = 5357, CapabilityFragmentShaderSampleInterlockEXT = 5363, CapabilityFragmentShaderShadingRateInterlockEXT = 5372, CapabilityShaderSMBuiltinsNV = 5373, CapabilityFragmentShaderPixelInterlockEXT = 5378, CapabilityDemoteToHelperInvocationEXT = 5379, CapabilitySubgroupShuffleINTEL = 5568, CapabilitySubgroupBufferBlockIOINTEL = 5569, CapabilitySubgroupImageBlockIOINTEL = 5570, CapabilitySubgroupImageMediaBlockIOINTEL = 5579, CapabilityIntegerFunctions2INTEL = 5584, CapabilityFunctionPointersINTEL = 5603, CapabilityIndirectReferencesINTEL = 5604, CapabilitySubgroupAvcMotionEstimationINTEL = 5696, CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697, CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698, CapabilityFPGAMemoryAttributesINTEL = 5824, CapabilityUnstructuredLoopControlsINTEL = 5886, CapabilityFPGALoopControlsINTEL = 5888, CapabilityKernelAttributesINTEL = 5892, CapabilityFPGAKernelAttributesINTEL = 5897, CapabilityBlockingPipesINTEL = 5945, CapabilityFPGARegINTEL = 5948, CapabilityAtomicFloat32AddEXT = 6033, CapabilityAtomicFloat64AddEXT = 6034, CapabilityMax = 0x7fffffff, }; enum RayFlagsShift { RayFlagsOpaqueKHRShift = 0, RayFlagsNoOpaqueKHRShift = 1, RayFlagsTerminateOnFirstHitKHRShift = 2, RayFlagsSkipClosestHitShaderKHRShift = 3, RayFlagsCullBackFacingTrianglesKHRShift = 4, RayFlagsCullFrontFacingTrianglesKHRShift = 5, RayFlagsCullOpaqueKHRShift = 6, RayFlagsCullNoOpaqueKHRShift = 7, RayFlagsSkipTrianglesKHRShift = 8, RayFlagsSkipAABBsKHRShift = 9, RayFlagsMax = 0x7fffffff, }; enum RayFlagsMask { RayFlagsMaskNone = 0, RayFlagsOpaqueKHRMask = 0x00000001, RayFlagsNoOpaqueKHRMask = 0x00000002, RayFlagsTerminateOnFirstHitKHRMask = 0x00000004, RayFlagsSkipClosestHitShaderKHRMask = 0x00000008, RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010, RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020, RayFlagsCullOpaqueKHRMask = 0x00000040, RayFlagsCullNoOpaqueKHRMask = 0x00000080, RayFlagsSkipTrianglesKHRMask = 0x00000100, RayFlagsSkipAABBsKHRMask = 0x00000200, }; enum RayQueryIntersection { RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0, RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1, RayQueryIntersectionMax = 0x7fffffff, }; enum RayQueryCommittedIntersectionType { RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0, RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1, RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2, RayQueryCommittedIntersectionTypeMax = 0x7fffffff, }; enum RayQueryCandidateIntersectionType { RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0, RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1, RayQueryCandidateIntersectionTypeMax = 0x7fffffff, }; enum FragmentShadingRateShift { FragmentShadingRateVertical2PixelsShift = 0, FragmentShadingRateVertical4PixelsShift = 1, FragmentShadingRateHorizontal2PixelsShift = 2, FragmentShadingRateHorizontal4PixelsShift = 3, FragmentShadingRateMax = 0x7fffffff, }; enum FragmentShadingRateMask { FragmentShadingRateMaskNone = 0, FragmentShadingRateVertical2PixelsMask = 0x00000001, FragmentShadingRateVertical4PixelsMask = 0x00000002, FragmentShadingRateHorizontal2PixelsMask = 0x00000004, FragmentShadingRateHorizontal4PixelsMask = 0x00000008, }; enum Op { OpNop = 0, OpUndef = 1, OpSourceContinued = 2, OpSource = 3, OpSourceExtension = 4, OpName = 5, OpMemberName = 6, OpString = 7, OpLine = 8, OpExtension = 10, OpExtInstImport = 11, OpExtInst = 12, OpMemoryModel = 14, OpEntryPoint = 15, OpExecutionMode = 16, OpCapability = 17, OpTypeVoid = 19, OpTypeBool = 20, OpTypeInt = 21, OpTypeFloat = 22, OpTypeVector = 23, OpTypeMatrix = 24, OpTypeImage = 25, OpTypeSampler = 26, OpTypeSampledImage = 27, OpTypeArray = 28, OpTypeRuntimeArray = 29, OpTypeStruct = 30, OpTypeOpaque = 31, OpTypePointer = 32, OpTypeFunction = 33, OpTypeEvent = 34, OpTypeDeviceEvent = 35, OpTypeReserveId = 36, OpTypeQueue = 37, OpTypePipe = 38, OpTypeForwardPointer = 39, OpConstantTrue = 41, OpConstantFalse = 42, OpConstant = 43, OpConstantComposite = 44, OpConstantSampler = 45, OpConstantNull = 46, OpSpecConstantTrue = 48, OpSpecConstantFalse = 49, OpSpecConstant = 50, OpSpecConstantComposite = 51, OpSpecConstantOp = 52, OpFunction = 54, OpFunctionParameter = 55, OpFunctionEnd = 56, OpFunctionCall = 57, OpVariable = 59, OpImageTexelPointer = 60, OpLoad = 61, OpStore = 62, OpCopyMemory = 63, OpCopyMemorySized = 64, OpAccessChain = 65, OpInBoundsAccessChain = 66, OpPtrAccessChain = 67, OpArrayLength = 68, OpGenericPtrMemSemantics = 69, OpInBoundsPtrAccessChain = 70, OpDecorate = 71, OpMemberDecorate = 72, OpDecorationGroup = 73, OpGroupDecorate = 74, OpGroupMemberDecorate = 75, OpVectorExtractDynamic = 77, OpVectorInsertDynamic = 78, OpVectorShuffle = 79, OpCompositeConstruct = 80, OpCompositeExtract = 81, OpCompositeInsert = 82, OpCopyObject = 83, OpTranspose = 84, OpSampledImage = 86, OpImageSampleImplicitLod = 87, OpImageSampleExplicitLod = 88, OpImageSampleDrefImplicitLod = 89, OpImageSampleDrefExplicitLod = 90, OpImageSampleProjImplicitLod = 91, OpImageSampleProjExplicitLod = 92, OpImageSampleProjDrefImplicitLod = 93, OpImageSampleProjDrefExplicitLod = 94, OpImageFetch = 95, OpImageGather = 96, OpImageDrefGather = 97, OpImageRead = 98, OpImageWrite = 99, OpImage = 100, OpImageQueryFormat = 101, OpImageQueryOrder = 102, OpImageQuerySizeLod = 103, OpImageQuerySize = 104, OpImageQueryLod = 105, OpImageQueryLevels = 106, OpImageQuerySamples = 107, OpConvertFToU = 109, OpConvertFToS = 110, OpConvertSToF = 111, OpConvertUToF = 112, OpUConvert = 113, OpSConvert = 114, OpFConvert = 115, OpQuantizeToF16 = 116, OpConvertPtrToU = 117, OpSatConvertSToU = 118, OpSatConvertUToS = 119, OpConvertUToPtr = 120, OpPtrCastToGeneric = 121, OpGenericCastToPtr = 122, OpGenericCastToPtrExplicit = 123, OpBitcast = 124, OpSNegate = 126, OpFNegate = 127, OpIAdd = 128, OpFAdd = 129, OpISub = 130, OpFSub = 131, OpIMul = 132, OpFMul = 133, OpUDiv = 134, OpSDiv = 135, OpFDiv = 136, OpUMod = 137, OpSRem = 138, OpSMod = 139, OpFRem = 140, OpFMod = 141, OpVectorTimesScalar = 142, OpMatrixTimesScalar = 143, OpVectorTimesMatrix = 144, OpMatrixTimesVector = 145, OpMatrixTimesMatrix = 146, OpOuterProduct = 147, OpDot = 148, OpIAddCarry = 149, OpISubBorrow = 150, OpUMulExtended = 151, OpSMulExtended = 152, OpAny = 154, OpAll = 155, OpIsNan = 156, OpIsInf = 157, OpIsFinite = 158, OpIsNormal = 159, OpSignBitSet = 160, OpLessOrGreater = 161, OpOrdered = 162, OpUnordered = 163, OpLogicalEqual = 164, OpLogicalNotEqual = 165, OpLogicalOr = 166, OpLogicalAnd = 167, OpLogicalNot = 168, OpSelect = 169, OpIEqual = 170, OpINotEqual = 171, OpUGreaterThan = 172, OpSGreaterThan = 173, OpUGreaterThanEqual = 174, OpSGreaterThanEqual = 175, OpULessThan = 176, OpSLessThan = 177, OpULessThanEqual = 178, OpSLessThanEqual = 179, OpFOrdEqual = 180, OpFUnordEqual = 181, OpFOrdNotEqual = 182, OpFUnordNotEqual = 183, OpFOrdLessThan = 184, OpFUnordLessThan = 185, OpFOrdGreaterThan = 186, OpFUnordGreaterThan = 187, OpFOrdLessThanEqual = 188, OpFUnordLessThanEqual = 189, OpFOrdGreaterThanEqual = 190, OpFUnordGreaterThanEqual = 191, OpShiftRightLogical = 194, OpShiftRightArithmetic = 195, OpShiftLeftLogical = 196, OpBitwiseOr = 197, OpBitwiseXor = 198, OpBitwiseAnd = 199, OpNot = 200, OpBitFieldInsert = 201, OpBitFieldSExtract = 202, OpBitFieldUExtract = 203, OpBitReverse = 204, OpBitCount = 205, OpDPdx = 207, OpDPdy = 208, OpFwidth = 209, OpDPdxFine = 210, OpDPdyFine = 211, OpFwidthFine = 212, OpDPdxCoarse = 213, OpDPdyCoarse = 214, OpFwidthCoarse = 215, OpEmitVertex = 218, OpEndPrimitive = 219, OpEmitStreamVertex = 220, OpEndStreamPrimitive = 221, OpControlBarrier = 224, OpMemoryBarrier = 225, OpAtomicLoad = 227, OpAtomicStore = 228, OpAtomicExchange = 229, OpAtomicCompareExchange = 230, OpAtomicCompareExchangeWeak = 231, OpAtomicIIncrement = 232, OpAtomicIDecrement = 233, OpAtomicIAdd = 234, OpAtomicISub = 235, OpAtomicSMin = 236, OpAtomicUMin = 237, OpAtomicSMax = 238, OpAtomicUMax = 239, OpAtomicAnd = 240, OpAtomicOr = 241, OpAtomicXor = 242, OpPhi = 245, OpLoopMerge = 246, OpSelectionMerge = 247, OpLabel = 248, OpBranch = 249, OpBranchConditional = 250, OpSwitch = 251, OpKill = 252, OpReturn = 253, OpReturnValue = 254, OpUnreachable = 255, OpLifetimeStart = 256, OpLifetimeStop = 257, OpGroupAsyncCopy = 259, OpGroupWaitEvents = 260, OpGroupAll = 261, OpGroupAny = 262, OpGroupBroadcast = 263, OpGroupIAdd = 264, OpGroupFAdd = 265, OpGroupFMin = 266, OpGroupUMin = 267, OpGroupSMin = 268, OpGroupFMax = 269, OpGroupUMax = 270, OpGroupSMax = 271, OpReadPipe = 274, OpWritePipe = 275, OpReservedReadPipe = 276, OpReservedWritePipe = 277, OpReserveReadPipePackets = 278, OpReserveWritePipePackets = 279, OpCommitReadPipe = 280, OpCommitWritePipe = 281, OpIsValidReserveId = 282, OpGetNumPipePackets = 283, OpGetMaxPipePackets = 284, OpGroupReserveReadPipePackets = 285, OpGroupReserveWritePipePackets = 286, OpGroupCommitReadPipe = 287, OpGroupCommitWritePipe = 288, OpEnqueueMarker = 291, OpEnqueueKernel = 292, OpGetKernelNDrangeSubGroupCount = 293, OpGetKernelNDrangeMaxSubGroupSize = 294, OpGetKernelWorkGroupSize = 295, OpGetKernelPreferredWorkGroupSizeMultiple = 296, OpRetainEvent = 297, OpReleaseEvent = 298, OpCreateUserEvent = 299, OpIsValidEvent = 300, OpSetUserEventStatus = 301, OpCaptureEventProfilingInfo = 302, OpGetDefaultQueue = 303, OpBuildNDRange = 304, OpImageSparseSampleImplicitLod = 305, OpImageSparseSampleExplicitLod = 306, OpImageSparseSampleDrefImplicitLod = 307, OpImageSparseSampleDrefExplicitLod = 308, OpImageSparseSampleProjImplicitLod = 309, OpImageSparseSampleProjExplicitLod = 310, OpImageSparseSampleProjDrefImplicitLod = 311, OpImageSparseSampleProjDrefExplicitLod = 312, OpImageSparseFetch = 313, OpImageSparseGather = 314, OpImageSparseDrefGather = 315, OpImageSparseTexelsResident = 316, OpNoLine = 317, OpAtomicFlagTestAndSet = 318, OpAtomicFlagClear = 319, OpImageSparseRead = 320, OpSizeOf = 321, OpTypePipeStorage = 322, OpConstantPipeStorage = 323, OpCreatePipeFromPipeStorage = 324, OpGetKernelLocalSizeForSubgroupCount = 325, OpGetKernelMaxNumSubgroups = 326, OpTypeNamedBarrier = 327, OpNamedBarrierInitialize = 328, OpMemoryNamedBarrier = 329, OpModuleProcessed = 330, OpExecutionModeId = 331, OpDecorateId = 332, OpGroupNonUniformElect = 333, OpGroupNonUniformAll = 334, OpGroupNonUniformAny = 335, OpGroupNonUniformAllEqual = 336, OpGroupNonUniformBroadcast = 337, OpGroupNonUniformBroadcastFirst = 338, OpGroupNonUniformBallot = 339, OpGroupNonUniformInverseBallot = 340, OpGroupNonUniformBallotBitExtract = 341, OpGroupNonUniformBallotBitCount = 342, OpGroupNonUniformBallotFindLSB = 343, OpGroupNonUniformBallotFindMSB = 344, OpGroupNonUniformShuffle = 345, OpGroupNonUniformShuffleXor = 346, OpGroupNonUniformShuffleUp = 347, OpGroupNonUniformShuffleDown = 348, OpGroupNonUniformIAdd = 349, OpGroupNonUniformFAdd = 350, OpGroupNonUniformIMul = 351, OpGroupNonUniformFMul = 352, OpGroupNonUniformSMin = 353, OpGroupNonUniformUMin = 354, OpGroupNonUniformFMin = 355, OpGroupNonUniformSMax = 356, OpGroupNonUniformUMax = 357, OpGroupNonUniformFMax = 358, OpGroupNonUniformBitwiseAnd = 359, OpGroupNonUniformBitwiseOr = 360, OpGroupNonUniformBitwiseXor = 361, OpGroupNonUniformLogicalAnd = 362, OpGroupNonUniformLogicalOr = 363, OpGroupNonUniformLogicalXor = 364, OpGroupNonUniformQuadBroadcast = 365, OpGroupNonUniformQuadSwap = 366, OpCopyLogical = 400, OpPtrEqual = 401, OpPtrNotEqual = 402, OpPtrDiff = 403, OpTerminateInvocation = 4416, OpSubgroupBallotKHR = 4421, OpSubgroupFirstInvocationKHR = 4422, OpSubgroupAllKHR = 4428, OpSubgroupAnyKHR = 4429, OpSubgroupAllEqualKHR = 4430, OpSubgroupReadInvocationKHR = 4432, OpTraceRayKHR = 4445, OpExecuteCallableKHR = 4446, OpConvertUToAccelerationStructureKHR = 4447, OpIgnoreIntersectionKHR = 4448, OpTerminateRayKHR = 4449, OpTypeRayQueryKHR = 4472, OpRayQueryInitializeKHR = 4473, OpRayQueryTerminateKHR = 4474, OpRayQueryGenerateIntersectionKHR = 4475, OpRayQueryConfirmIntersectionKHR = 4476, OpRayQueryProceedKHR = 4477, OpRayQueryGetIntersectionTypeKHR = 4479, OpGroupIAddNonUniformAMD = 5000, OpGroupFAddNonUniformAMD = 5001, OpGroupFMinNonUniformAMD = 5002, OpGroupUMinNonUniformAMD = 5003, OpGroupSMinNonUniformAMD = 5004, OpGroupFMaxNonUniformAMD = 5005, OpGroupUMaxNonUniformAMD = 5006, OpGroupSMaxNonUniformAMD = 5007, OpFragmentMaskFetchAMD = 5011, OpFragmentFetchAMD = 5012, OpReadClockKHR = 5056, OpImageSampleFootprintNV = 5283, OpGroupNonUniformPartitionNV = 5296, OpWritePackedPrimitiveIndices4x8NV = 5299, OpReportIntersectionKHR = 5334, OpReportIntersectionNV = 5334, OpIgnoreIntersectionNV = 5335, OpTerminateRayNV = 5336, OpTraceNV = 5337, OpTypeAccelerationStructureKHR = 5341, OpTypeAccelerationStructureNV = 5341, OpExecuteCallableNV = 5344, OpTypeCooperativeMatrixNV = 5358, OpCooperativeMatrixLoadNV = 5359, OpCooperativeMatrixStoreNV = 5360, OpCooperativeMatrixMulAddNV = 5361, OpCooperativeMatrixLengthNV = 5362, OpBeginInvocationInterlockEXT = 5364, OpEndInvocationInterlockEXT = 5365, OpDemoteToHelperInvocationEXT = 5380, OpIsHelperInvocationEXT = 5381, OpSubgroupShuffleINTEL = 5571, OpSubgroupShuffleDownINTEL = 5572, OpSubgroupShuffleUpINTEL = 5573, OpSubgroupShuffleXorINTEL = 5574, OpSubgroupBlockReadINTEL = 5575, OpSubgroupBlockWriteINTEL = 5576, OpSubgroupImageBlockReadINTEL = 5577, OpSubgroupImageBlockWriteINTEL = 5578, OpSubgroupImageMediaBlockReadINTEL = 5580, OpSubgroupImageMediaBlockWriteINTEL = 5581, OpUCountLeadingZerosINTEL = 5585, OpUCountTrailingZerosINTEL = 5586, OpAbsISubINTEL = 5587, OpAbsUSubINTEL = 5588, OpIAddSatINTEL = 5589, OpUAddSatINTEL = 5590, OpIAverageINTEL = 5591, OpUAverageINTEL = 5592, OpIAverageRoundedINTEL = 5593, OpUAverageRoundedINTEL = 5594, OpISubSatINTEL = 5595, OpUSubSatINTEL = 5596, OpIMul32x16INTEL = 5597, OpUMul32x16INTEL = 5598, OpFunctionPointerINTEL = 5600, OpFunctionPointerCallINTEL = 5601, OpDecorateString = 5632, OpDecorateStringGOOGLE = 5632, OpMemberDecorateString = 5633, OpMemberDecorateStringGOOGLE = 5633, OpVmeImageINTEL = 5699, OpTypeVmeImageINTEL = 5700, OpTypeAvcImePayloadINTEL = 5701, OpTypeAvcRefPayloadINTEL = 5702, OpTypeAvcSicPayloadINTEL = 5703, OpTypeAvcMcePayloadINTEL = 5704, OpTypeAvcMceResultINTEL = 5705, OpTypeAvcImeResultINTEL = 5706, OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707, OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708, OpTypeAvcImeSingleReferenceStreaminINTEL = 5709, OpTypeAvcImeDualReferenceStreaminINTEL = 5710, OpTypeAvcRefResultINTEL = 5711, OpTypeAvcSicResultINTEL = 5712, OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713, OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714, OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715, OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716, OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717, OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718, OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719, OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720, OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721, OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722, OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723, OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724, OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725, OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726, OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727, OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728, OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729, OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730, OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731, OpSubgroupAvcMceConvertToImePayloadINTEL = 5732, OpSubgroupAvcMceConvertToImeResultINTEL = 5733, OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734, OpSubgroupAvcMceConvertToRefResultINTEL = 5735, OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736, OpSubgroupAvcMceConvertToSicResultINTEL = 5737, OpSubgroupAvcMceGetMotionVectorsINTEL = 5738, OpSubgroupAvcMceGetInterDistortionsINTEL = 5739, OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740, OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741, OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742, OpSubgroupAvcMceGetInterDirectionsINTEL = 5743, OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744, OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745, OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746, OpSubgroupAvcImeInitializeINTEL = 5747, OpSubgroupAvcImeSetSingleReferenceINTEL = 5748, OpSubgroupAvcImeSetDualReferenceINTEL = 5749, OpSubgroupAvcImeRefWindowSizeINTEL = 5750, OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751, OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752, OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753, OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754, OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755, OpSubgroupAvcImeSetWeightedSadINTEL = 5756, OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757, OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758, OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759, OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760, OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761, OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762, OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763, OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764, OpSubgroupAvcImeConvertToMceResultINTEL = 5765, OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766, OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767, OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768, OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769, OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770, OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771, OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772, OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773, OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774, OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775, OpSubgroupAvcImeGetBorderReachedINTEL = 5776, OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777, OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778, OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779, OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780, OpSubgroupAvcFmeInitializeINTEL = 5781, OpSubgroupAvcBmeInitializeINTEL = 5782, OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783, OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784, OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785, OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786, OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787, OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788, OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789, OpSubgroupAvcRefConvertToMceResultINTEL = 5790, OpSubgroupAvcSicInitializeINTEL = 5791, OpSubgroupAvcSicConfigureSkcINTEL = 5792, OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793, OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794, OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795, OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796, OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797, OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798, OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799, OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800, OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801, OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802, OpSubgroupAvcSicEvaluateIpeINTEL = 5803, OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804, OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805, OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806, OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807, OpSubgroupAvcSicConvertToMceResultINTEL = 5808, OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809, OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810, OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811, OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812, OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813, OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814, OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815, OpSubgroupAvcSicGetInterRawSadsINTEL = 5816, OpLoopControlINTEL = 5887, OpReadPipeBlockingINTEL = 5946, OpWritePipeBlockingINTEL = 5947, OpFPGARegINTEL = 5949, OpRayQueryGetRayTMinKHR = 6016, OpRayQueryGetRayFlagsKHR = 6017, OpRayQueryGetIntersectionTKHR = 6018, OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019, OpRayQueryGetIntersectionInstanceIdKHR = 6020, OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021, OpRayQueryGetIntersectionGeometryIndexKHR = 6022, OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023, OpRayQueryGetIntersectionBarycentricsKHR = 6024, OpRayQueryGetIntersectionFrontFaceKHR = 6025, OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026, OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027, OpRayQueryGetIntersectionObjectRayOriginKHR = 6028, OpRayQueryGetWorldRayDirectionKHR = 6029, OpRayQueryGetWorldRayOriginKHR = 6030, OpRayQueryGetIntersectionObjectToWorldKHR = 6031, OpRayQueryGetIntersectionWorldToObjectKHR = 6032, OpAtomicFAddEXT = 6035, OpMax = 0x7fffffff, }; #ifdef SPV_ENABLE_UTILITY_CODE inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { *hasResult = *hasResultType = false; switch (opcode) { default: /* unknown opcode */ break; case OpNop: *hasResult = false; *hasResultType = false; break; case OpUndef: *hasResult = true; *hasResultType = true; break; case OpSourceContinued: *hasResult = false; *hasResultType = false; break; case OpSource: *hasResult = false; *hasResultType = false; break; case OpSourceExtension: *hasResult = false; *hasResultType = false; break; case OpName: *hasResult = false; *hasResultType = false; break; case OpMemberName: *hasResult = false; *hasResultType = false; break; case OpString: *hasResult = true; *hasResultType = false; break; case OpLine: *hasResult = false; *hasResultType = false; break; case OpExtension: *hasResult = false; *hasResultType = false; break; case OpExtInstImport: *hasResult = true; *hasResultType = false; break; case OpExtInst: *hasResult = true; *hasResultType = true; break; case OpMemoryModel: *hasResult = false; *hasResultType = false; break; case OpEntryPoint: *hasResult = false; *hasResultType = false; break; case OpExecutionMode: *hasResult = false; *hasResultType = false; break; case OpCapability: *hasResult = false; *hasResultType = false; break; case OpTypeVoid: *hasResult = true; *hasResultType = false; break; case OpTypeBool: *hasResult = true; *hasResultType = false; break; case OpTypeInt: *hasResult = true; *hasResultType = false; break; case OpTypeFloat: *hasResult = true; *hasResultType = false; break; case OpTypeVector: *hasResult = true; *hasResultType = false; break; case OpTypeMatrix: *hasResult = true; *hasResultType = false; break; case OpTypeImage: *hasResult = true; *hasResultType = false; break; case OpTypeSampler: *hasResult = true; *hasResultType = false; break; case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break; case OpTypeArray: *hasResult = true; *hasResultType = false; break; case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break; case OpTypeStruct: *hasResult = true; *hasResultType = false; break; case OpTypeOpaque: *hasResult = true; *hasResultType = false; break; case OpTypePointer: *hasResult = true; *hasResultType = false; break; case OpTypeFunction: *hasResult = true; *hasResultType = false; break; case OpTypeEvent: *hasResult = true; *hasResultType = false; break; case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break; case OpTypeReserveId: *hasResult = true; *hasResultType = false; break; case OpTypeQueue: *hasResult = true; *hasResultType = false; break; case OpTypePipe: *hasResult = true; *hasResultType = false; break; case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break; case OpConstantTrue: *hasResult = true; *hasResultType = true; break; case OpConstantFalse: *hasResult = true; *hasResultType = true; break; case OpConstant: *hasResult = true; *hasResultType = true; break; case OpConstantComposite: *hasResult = true; *hasResultType = true; break; case OpConstantSampler: *hasResult = true; *hasResultType = true; break; case OpConstantNull: *hasResult = true; *hasResultType = true; break; case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break; case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break; case OpSpecConstant: *hasResult = true; *hasResultType = true; break; case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break; case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break; case OpFunction: *hasResult = true; *hasResultType = true; break; case OpFunctionParameter: *hasResult = true; *hasResultType = true; break; case OpFunctionEnd: *hasResult = false; *hasResultType = false; break; case OpFunctionCall: *hasResult = true; *hasResultType = true; break; case OpVariable: *hasResult = true; *hasResultType = true; break; case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break; case OpLoad: *hasResult = true; *hasResultType = true; break; case OpStore: *hasResult = false; *hasResultType = false; break; case OpCopyMemory: *hasResult = false; *hasResultType = false; break; case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break; case OpAccessChain: *hasResult = true; *hasResultType = true; break; case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break; case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break; case OpArrayLength: *hasResult = true; *hasResultType = true; break; case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break; case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break; case OpDecorate: *hasResult = false; *hasResultType = false; break; case OpMemberDecorate: *hasResult = false; *hasResultType = false; break; case OpDecorationGroup: *hasResult = true; *hasResultType = false; break; case OpGroupDecorate: *hasResult = false; *hasResultType = false; break; case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break; case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break; case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break; case OpVectorShuffle: *hasResult = true; *hasResultType = true; break; case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break; case OpCompositeExtract: *hasResult = true; *hasResultType = true; break; case OpCompositeInsert: *hasResult = true; *hasResultType = true; break; case OpCopyObject: *hasResult = true; *hasResultType = true; break; case OpTranspose: *hasResult = true; *hasResultType = true; break; case OpSampledImage: *hasResult = true; *hasResultType = true; break; case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageFetch: *hasResult = true; *hasResultType = true; break; case OpImageGather: *hasResult = true; *hasResultType = true; break; case OpImageDrefGather: *hasResult = true; *hasResultType = true; break; case OpImageRead: *hasResult = true; *hasResultType = true; break; case OpImageWrite: *hasResult = false; *hasResultType = false; break; case OpImage: *hasResult = true; *hasResultType = true; break; case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break; case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break; case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break; case OpImageQuerySize: *hasResult = true; *hasResultType = true; break; case OpImageQueryLod: *hasResult = true; *hasResultType = true; break; case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break; case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break; case OpConvertFToU: *hasResult = true; *hasResultType = true; break; case OpConvertFToS: *hasResult = true; *hasResultType = true; break; case OpConvertSToF: *hasResult = true; *hasResultType = true; break; case OpConvertUToF: *hasResult = true; *hasResultType = true; break; case OpUConvert: *hasResult = true; *hasResultType = true; break; case OpSConvert: *hasResult = true; *hasResultType = true; break; case OpFConvert: *hasResult = true; *hasResultType = true; break; case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break; case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break; case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break; case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break; case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break; case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break; case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break; case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break; case OpBitcast: *hasResult = true; *hasResultType = true; break; case OpSNegate: *hasResult = true; *hasResultType = true; break; case OpFNegate: *hasResult = true; *hasResultType = true; break; case OpIAdd: *hasResult = true; *hasResultType = true; break; case OpFAdd: *hasResult = true; *hasResultType = true; break; case OpISub: *hasResult = true; *hasResultType = true; break; case OpFSub: *hasResult = true; *hasResultType = true; break; case OpIMul: *hasResult = true; *hasResultType = true; break; case OpFMul: *hasResult = true; *hasResultType = true; break; case OpUDiv: *hasResult = true; *hasResultType = true; break; case OpSDiv: *hasResult = true; *hasResultType = true; break; case OpFDiv: *hasResult = true; *hasResultType = true; break; case OpUMod: *hasResult = true; *hasResultType = true; break; case OpSRem: *hasResult = true; *hasResultType = true; break; case OpSMod: *hasResult = true; *hasResultType = true; break; case OpFRem: *hasResult = true; *hasResultType = true; break; case OpFMod: *hasResult = true; *hasResultType = true; break; case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break; case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break; case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break; case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break; case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break; case OpOuterProduct: *hasResult = true; *hasResultType = true; break; case OpDot: *hasResult = true; *hasResultType = true; break; case OpIAddCarry: *hasResult = true; *hasResultType = true; break; case OpISubBorrow: *hasResult = true; *hasResultType = true; break; case OpUMulExtended: *hasResult = true; *hasResultType = true; break; case OpSMulExtended: *hasResult = true; *hasResultType = true; break; case OpAny: *hasResult = true; *hasResultType = true; break; case OpAll: *hasResult = true; *hasResultType = true; break; case OpIsNan: *hasResult = true; *hasResultType = true; break; case OpIsInf: *hasResult = true; *hasResultType = true; break; case OpIsFinite: *hasResult = true; *hasResultType = true; break; case OpIsNormal: *hasResult = true; *hasResultType = true; break; case OpSignBitSet: *hasResult = true; *hasResultType = true; break; case OpLessOrGreater: *hasResult = true; *hasResultType = true; break; case OpOrdered: *hasResult = true; *hasResultType = true; break; case OpUnordered: *hasResult = true; *hasResultType = true; break; case OpLogicalEqual: *hasResult = true; *hasResultType = true; break; case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break; case OpLogicalOr: *hasResult = true; *hasResultType = true; break; case OpLogicalAnd: *hasResult = true; *hasResultType = true; break; case OpLogicalNot: *hasResult = true; *hasResultType = true; break; case OpSelect: *hasResult = true; *hasResultType = true; break; case OpIEqual: *hasResult = true; *hasResultType = true; break; case OpINotEqual: *hasResult = true; *hasResultType = true; break; case OpUGreaterThan: *hasResult = true; *hasResultType = true; break; case OpSGreaterThan: *hasResult = true; *hasResultType = true; break; case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break; case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break; case OpULessThan: *hasResult = true; *hasResultType = true; break; case OpSLessThan: *hasResult = true; *hasResultType = true; break; case OpULessThanEqual: *hasResult = true; *hasResultType = true; break; case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break; case OpFOrdEqual: *hasResult = true; *hasResultType = true; break; case OpFUnordEqual: *hasResult = true; *hasResultType = true; break; case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break; case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break; case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break; case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break; case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break; case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break; case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break; case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break; case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break; case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break; case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break; case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break; case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break; case OpBitwiseOr: *hasResult = true; *hasResultType = true; break; case OpBitwiseXor: *hasResult = true; *hasResultType = true; break; case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break; case OpNot: *hasResult = true; *hasResultType = true; break; case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break; case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break; case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break; case OpBitReverse: *hasResult = true; *hasResultType = true; break; case OpBitCount: *hasResult = true; *hasResultType = true; break; case OpDPdx: *hasResult = true; *hasResultType = true; break; case OpDPdy: *hasResult = true; *hasResultType = true; break; case OpFwidth: *hasResult = true; *hasResultType = true; break; case OpDPdxFine: *hasResult = true; *hasResultType = true; break; case OpDPdyFine: *hasResult = true; *hasResultType = true; break; case OpFwidthFine: *hasResult = true; *hasResultType = true; break; case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break; case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break; case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break; case OpEmitVertex: *hasResult = false; *hasResultType = false; break; case OpEndPrimitive: *hasResult = false; *hasResultType = false; break; case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break; case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break; case OpControlBarrier: *hasResult = false; *hasResultType = false; break; case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break; case OpAtomicLoad: *hasResult = true; *hasResultType = true; break; case OpAtomicStore: *hasResult = false; *hasResultType = false; break; case OpAtomicExchange: *hasResult = true; *hasResultType = true; break; case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break; case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break; case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break; case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break; case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break; case OpAtomicISub: *hasResult = true; *hasResultType = true; break; case OpAtomicSMin: *hasResult = true; *hasResultType = true; break; case OpAtomicUMin: *hasResult = true; *hasResultType = true; break; case OpAtomicSMax: *hasResult = true; *hasResultType = true; break; case OpAtomicUMax: *hasResult = true; *hasResultType = true; break; case OpAtomicAnd: *hasResult = true; *hasResultType = true; break; case OpAtomicOr: *hasResult = true; *hasResultType = true; break; case OpAtomicXor: *hasResult = true; *hasResultType = true; break; case OpPhi: *hasResult = true; *hasResultType = true; break; case OpLoopMerge: *hasResult = false; *hasResultType = false; break; case OpSelectionMerge: *hasResult = false; *hasResultType = false; break; case OpLabel: *hasResult = true; *hasResultType = false; break; case OpBranch: *hasResult = false; *hasResultType = false; break; case OpBranchConditional: *hasResult = false; *hasResultType = false; break; case OpSwitch: *hasResult = false; *hasResultType = false; break; case OpKill: *hasResult = false; *hasResultType = false; break; case OpReturn: *hasResult = false; *hasResultType = false; break; case OpReturnValue: *hasResult = false; *hasResultType = false; break; case OpUnreachable: *hasResult = false; *hasResultType = false; break; case OpLifetimeStart: *hasResult = false; *hasResultType = false; break; case OpLifetimeStop: *hasResult = false; *hasResultType = false; break; case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break; case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break; case OpGroupAll: *hasResult = true; *hasResultType = true; break; case OpGroupAny: *hasResult = true; *hasResultType = true; break; case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break; case OpGroupIAdd: *hasResult = true; *hasResultType = true; break; case OpGroupFAdd: *hasResult = true; *hasResultType = true; break; case OpGroupFMin: *hasResult = true; *hasResultType = true; break; case OpGroupUMin: *hasResult = true; *hasResultType = true; break; case OpGroupSMin: *hasResult = true; *hasResultType = true; break; case OpGroupFMax: *hasResult = true; *hasResultType = true; break; case OpGroupUMax: *hasResult = true; *hasResultType = true; break; case OpGroupSMax: *hasResult = true; *hasResultType = true; break; case OpReadPipe: *hasResult = true; *hasResultType = true; break; case OpWritePipe: *hasResult = true; *hasResultType = true; break; case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break; case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break; case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break; case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break; case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break; case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break; case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break; case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break; case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break; case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break; case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break; case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break; case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break; case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break; case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break; case OpRetainEvent: *hasResult = false; *hasResultType = false; break; case OpReleaseEvent: *hasResult = false; *hasResultType = false; break; case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break; case OpIsValidEvent: *hasResult = true; *hasResultType = true; break; case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break; case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break; case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break; case OpBuildNDRange: *hasResult = true; *hasResultType = true; break; case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break; case OpImageSparseGather: *hasResult = true; *hasResultType = true; break; case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break; case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break; case OpNoLine: *hasResult = false; *hasResultType = false; break; case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break; case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break; case OpImageSparseRead: *hasResult = true; *hasResultType = true; break; case OpSizeOf: *hasResult = true; *hasResultType = true; break; case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break; case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break; case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break; case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break; case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break; case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break; case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break; case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break; case OpModuleProcessed: *hasResult = false; *hasResultType = false; break; case OpExecutionModeId: *hasResult = false; *hasResultType = false; break; case OpDecorateId: *hasResult = false; *hasResultType = false; break; case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break; case OpCopyLogical: *hasResult = true; *hasResultType = true; break; case OpPtrEqual: *hasResult = true; *hasResultType = true; break; case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break; case OpPtrDiff: *hasResult = true; *hasResultType = true; break; case OpTerminateInvocation: *hasResult = false; *hasResultType = false; break; case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; case OpTraceRayKHR: *hasResult = false; *hasResultType = false; break; case OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break; case OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break; case OpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break; case OpTerminateRayKHR: *hasResult = false; *hasResultType = false; break; case OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break; case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break; case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break; case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break; case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break; case OpReadClockKHR: *hasResult = true; *hasResultType = true; break; case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break; case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; case OpTraceNV: *hasResult = false; *hasResultType = false; break; case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break; case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break; case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break; case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; case OpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break; case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break; case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break; case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break; case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break; case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break; case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break; case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break; case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break; case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break; case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break; case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break; case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break; case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break; case OpFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break; case OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break; case OpDecorateString: *hasResult = false; *hasResultType = false; break; case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break; case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break; case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break; case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break; case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break; case OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break; case OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break; case OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break; case OpFPGARegINTEL: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break; case OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break; } } #endif /* SPV_ENABLE_UTILITY_CODE */ // Overload operator| for mask bit combining inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); } inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); } inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); } inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); } inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); } inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); } inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); } inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); } inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); } inline FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); } } // end namespace spv #endif // #ifndef spirv_HPP spirv-cross-2021.01.15/spirv_cfg.cpp000066400000000000000000000326161400026215700170700ustar00rootroot00000000000000/* * Copyright 2016-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_cfg.hpp" #include "spirv_cross.hpp" #include #include using namespace std; namespace SPIRV_CROSS_NAMESPACE { CFG::CFG(Compiler &compiler_, const SPIRFunction &func_) : compiler(compiler_) , func(func_) { build_post_order_visit_order(); build_immediate_dominators(); } uint32_t CFG::find_common_dominator(uint32_t a, uint32_t b) const { while (a != b) { if (get_visit_order(a) < get_visit_order(b)) a = get_immediate_dominator(a); else b = get_immediate_dominator(b); } return a; } void CFG::build_immediate_dominators() { // Traverse the post-order in reverse and build up the immediate dominator tree. immediate_dominators.clear(); immediate_dominators[func.entry_block] = func.entry_block; for (auto i = post_order.size(); i; i--) { uint32_t block = post_order[i - 1]; auto &pred = preceding_edges[block]; if (pred.empty()) // This is for the entry block, but we've already set up the dominators. continue; for (auto &edge : pred) { if (immediate_dominators[block]) { assert(immediate_dominators[edge]); immediate_dominators[block] = find_common_dominator(immediate_dominators[block], edge); } else immediate_dominators[block] = edge; } } } bool CFG::is_back_edge(uint32_t to) const { // We have a back edge if the visit order is set with the temporary magic value 0. // Crossing edges will have already been recorded with a visit order. auto itr = visit_order.find(to); return itr != end(visit_order) && itr->second.get() == 0; } bool CFG::has_visited_forward_edge(uint32_t to) const { // If > 0, we have visited the edge already, and this is not a back edge branch. auto itr = visit_order.find(to); return itr != end(visit_order) && itr->second.get() > 0; } bool CFG::post_order_visit(uint32_t block_id) { // If we have already branched to this block (back edge), stop recursion. // If our branches are back-edges, we do not record them. // We have to record crossing edges however. if (has_visited_forward_edge(block_id)) return true; else if (is_back_edge(block_id)) return false; // Block back-edges from recursively revisiting ourselves. visit_order[block_id].get() = 0; auto &block = compiler.get(block_id); // If this is a loop header, add an implied branch to the merge target. // This is needed to avoid annoying cases with do { ... } while(false) loops often generated by inliners. // To the CFG, this is linear control flow, but we risk picking the do/while scope as our dominating block. // This makes sure that if we are accessing a variable outside the do/while, we choose the loop header as dominator. // We could use has_visited_forward_edge, but this break code-gen where the merge block is unreachable in the CFG. // Make a point out of visiting merge target first. This is to make sure that post visit order outside the loop // is lower than inside the loop, which is going to be key for some traversal algorithms like post-dominance analysis. // For selection constructs true/false blocks will end up visiting the merge block directly and it works out fine, // but for loops, only the header might end up actually branching to merge block. if (block.merge == SPIRBlock::MergeLoop && post_order_visit(block.merge_block)) add_branch(block_id, block.merge_block); // First visit our branch targets. switch (block.terminator) { case SPIRBlock::Direct: if (post_order_visit(block.next_block)) add_branch(block_id, block.next_block); break; case SPIRBlock::Select: if (post_order_visit(block.true_block)) add_branch(block_id, block.true_block); if (post_order_visit(block.false_block)) add_branch(block_id, block.false_block); break; case SPIRBlock::MultiSelect: for (auto &target : block.cases) { if (post_order_visit(target.block)) add_branch(block_id, target.block); } if (block.default_block && post_order_visit(block.default_block)) add_branch(block_id, block.default_block); break; default: break; } // If this is a selection merge, add an implied branch to the merge target. // This is needed to avoid cases where an inner branch dominates the outer branch. // This can happen if one of the branches exit early, e.g.: // if (cond) { ...; break; } else { var = 100 } use_var(var); // We can use the variable without a Phi since there is only one possible parent here. // However, in this case, we need to hoist out the inner variable to outside the branch. // Use same strategy as loops. if (block.merge == SPIRBlock::MergeSelection && post_order_visit(block.next_block)) { // If there is only one preceding edge to the merge block and it's not ourselves, we need a fixup. // Add a fake branch so any dominator in either the if (), or else () block, or a lone case statement // will be hoisted out to outside the selection merge. // If size > 1, the variable will be automatically hoisted, so we should not mess with it. // The exception here is switch blocks, where we can have multiple edges to merge block, // all coming from same scope, so be more conservative in this case. // Adding fake branches unconditionally breaks parameter preservation analysis, // which looks at how variables are accessed through the CFG. auto pred_itr = preceding_edges.find(block.next_block); if (pred_itr != end(preceding_edges)) { auto &pred = pred_itr->second; auto succ_itr = succeeding_edges.find(block_id); size_t num_succeeding_edges = 0; if (succ_itr != end(succeeding_edges)) num_succeeding_edges = succ_itr->second.size(); if (block.terminator == SPIRBlock::MultiSelect && num_succeeding_edges == 1) { // Multiple branches can come from the same scope due to "break;", so we need to assume that all branches // come from same case scope in worst case, even if there are multiple preceding edges. // If we have more than one succeeding edge from the block header, it should be impossible // to have a dominator be inside the block. // Only case this can go wrong is if we have 2 or more edges from block header and // 2 or more edges to merge block, and still have dominator be inside a case label. if (!pred.empty()) add_branch(block_id, block.next_block); } else { if (pred.size() == 1 && *pred.begin() != block_id) add_branch(block_id, block.next_block); } } else { // If the merge block does not have any preceding edges, i.e. unreachable, hallucinate it. // We're going to do code-gen for it, and domination analysis requires that we have at least one preceding edge. add_branch(block_id, block.next_block); } } // Then visit ourselves. Start counting at one, to let 0 be a magic value for testing back vs. crossing edges. visit_order[block_id].get() = ++visit_count; post_order.push_back(block_id); return true; } void CFG::build_post_order_visit_order() { uint32_t block = func.entry_block; visit_count = 0; visit_order.clear(); post_order.clear(); post_order_visit(block); } void CFG::add_branch(uint32_t from, uint32_t to) { const auto add_unique = [](SmallVector &l, uint32_t value) { auto itr = find(begin(l), end(l), value); if (itr == end(l)) l.push_back(value); }; add_unique(preceding_edges[to], from); add_unique(succeeding_edges[from], to); } uint32_t CFG::find_loop_dominator(uint32_t block_id) const { while (block_id != SPIRBlock::NoDominator) { auto itr = preceding_edges.find(block_id); if (itr == end(preceding_edges)) return SPIRBlock::NoDominator; if (itr->second.empty()) return SPIRBlock::NoDominator; uint32_t pred_block_id = SPIRBlock::NoDominator; bool ignore_loop_header = false; // If we are a merge block, go directly to the header block. // Only consider a loop dominator if we are branching from inside a block to a loop header. // NOTE: In the CFG we forced an edge from header to merge block always to support variable scopes properly. for (auto &pred : itr->second) { auto &pred_block = compiler.get(pred); if (pred_block.merge == SPIRBlock::MergeLoop && pred_block.merge_block == ID(block_id)) { pred_block_id = pred; ignore_loop_header = true; break; } else if (pred_block.merge == SPIRBlock::MergeSelection && pred_block.next_block == ID(block_id)) { pred_block_id = pred; break; } } // No merge block means we can just pick any edge. Loop headers dominate the inner loop, so any path we // take will lead there. if (pred_block_id == SPIRBlock::NoDominator) pred_block_id = itr->second.front(); block_id = pred_block_id; if (!ignore_loop_header && block_id) { auto &block = compiler.get(block_id); if (block.merge == SPIRBlock::MergeLoop) return block_id; } } return block_id; } bool CFG::node_terminates_control_flow_in_sub_graph(BlockID from, BlockID to) const { // Walk backwards, starting from "to" block. // Only follow pred edges if they have a 1:1 relationship, or a merge relationship. // If we cannot find a path to "from", we must assume that to is inside control flow in some way. auto &from_block = compiler.get(from); BlockID ignore_block_id = 0; if (from_block.merge == SPIRBlock::MergeLoop) ignore_block_id = from_block.merge_block; while (to != from) { auto pred_itr = preceding_edges.find(to); if (pred_itr == end(preceding_edges)) return false; DominatorBuilder builder(*this); for (auto &edge : pred_itr->second) builder.add_block(edge); uint32_t dominator = builder.get_dominator(); if (dominator == 0) return false; auto &dom = compiler.get(dominator); bool true_path_ignore = false; bool false_path_ignore = false; if (ignore_block_id && dom.terminator == SPIRBlock::Select) { auto &true_block = compiler.get(dom.true_block); auto &false_block = compiler.get(dom.false_block); auto &ignore_block = compiler.get(ignore_block_id); true_path_ignore = compiler.execution_is_branchless(true_block, ignore_block); false_path_ignore = compiler.execution_is_branchless(false_block, ignore_block); } if ((dom.merge == SPIRBlock::MergeSelection && dom.next_block == to) || (dom.merge == SPIRBlock::MergeLoop && dom.merge_block == to) || (dom.terminator == SPIRBlock::Direct && dom.next_block == to) || (dom.terminator == SPIRBlock::Select && dom.true_block == to && false_path_ignore) || (dom.terminator == SPIRBlock::Select && dom.false_block == to && true_path_ignore)) { // Allow walking selection constructs if the other branch reaches out of a loop construct. // It cannot be in-scope anymore. to = dominator; } else return false; } return true; } DominatorBuilder::DominatorBuilder(const CFG &cfg_) : cfg(cfg_) { } void DominatorBuilder::add_block(uint32_t block) { if (!cfg.get_immediate_dominator(block)) { // Unreachable block via the CFG, we will never emit this code anyways. return; } if (!dominator) { dominator = block; return; } if (block != dominator) dominator = cfg.find_common_dominator(block, dominator); } void DominatorBuilder::lift_continue_block_dominator() { // It is possible for a continue block to be the dominator of a variable is only accessed inside the while block of a do-while loop. // We cannot safely declare variables inside a continue block, so move any variable declared // in a continue block to the entry block to simplify. // It makes very little sense for a continue block to ever be a dominator, so fall back to the simplest // solution. if (!dominator) return; auto &block = cfg.get_compiler().get(dominator); auto post_order = cfg.get_visit_order(dominator); // If we are branching to a block with a higher post-order traversal index (continue blocks), we have a problem // since we cannot create sensible GLSL code for this, fallback to entry block. bool back_edge_dominator = false; switch (block.terminator) { case SPIRBlock::Direct: if (cfg.get_visit_order(block.next_block) > post_order) back_edge_dominator = true; break; case SPIRBlock::Select: if (cfg.get_visit_order(block.true_block) > post_order) back_edge_dominator = true; if (cfg.get_visit_order(block.false_block) > post_order) back_edge_dominator = true; break; case SPIRBlock::MultiSelect: for (auto &target : block.cases) { if (cfg.get_visit_order(target.block) > post_order) back_edge_dominator = true; } if (block.default_block && cfg.get_visit_order(block.default_block) > post_order) back_edge_dominator = true; break; default: break; } if (back_edge_dominator) dominator = cfg.get_function().entry_block; } } // namespace SPIRV_CROSS_NAMESPACE spirv-cross-2021.01.15/spirv_cfg.hpp000066400000000000000000000072341400026215700170730ustar00rootroot00000000000000/* * Copyright 2016-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_CFG_HPP #define SPIRV_CROSS_CFG_HPP #include "spirv_common.hpp" #include namespace SPIRV_CROSS_NAMESPACE { class Compiler; class CFG { public: CFG(Compiler &compiler, const SPIRFunction &function); Compiler &get_compiler() { return compiler; } const Compiler &get_compiler() const { return compiler; } const SPIRFunction &get_function() const { return func; } uint32_t get_immediate_dominator(uint32_t block) const { auto itr = immediate_dominators.find(block); if (itr != std::end(immediate_dominators)) return itr->second; else return 0; } uint32_t get_visit_order(uint32_t block) const { auto itr = visit_order.find(block); assert(itr != std::end(visit_order)); int v = itr->second.get(); assert(v > 0); return uint32_t(v); } uint32_t find_common_dominator(uint32_t a, uint32_t b) const; const SmallVector &get_preceding_edges(uint32_t block) const { auto itr = preceding_edges.find(block); if (itr != std::end(preceding_edges)) return itr->second; else return empty_vector; } const SmallVector &get_succeeding_edges(uint32_t block) const { auto itr = succeeding_edges.find(block); if (itr != std::end(succeeding_edges)) return itr->second; else return empty_vector; } template void walk_from(std::unordered_set &seen_blocks, uint32_t block, const Op &op) const { if (seen_blocks.count(block)) return; seen_blocks.insert(block); if (op(block)) { for (auto b : get_succeeding_edges(block)) walk_from(seen_blocks, b, op); } } uint32_t find_loop_dominator(uint32_t block) const; bool node_terminates_control_flow_in_sub_graph(BlockID from, BlockID to) const; private: struct VisitOrder { int &get() { return v; } const int &get() const { return v; } int v = -1; }; Compiler &compiler; const SPIRFunction &func; std::unordered_map> preceding_edges; std::unordered_map> succeeding_edges; std::unordered_map immediate_dominators; std::unordered_map visit_order; SmallVector post_order; SmallVector empty_vector; void add_branch(uint32_t from, uint32_t to); void build_post_order_visit_order(); void build_immediate_dominators(); bool post_order_visit(uint32_t block); uint32_t visit_count = 0; bool is_back_edge(uint32_t to) const; bool has_visited_forward_edge(uint32_t to) const; }; class DominatorBuilder { public: DominatorBuilder(const CFG &cfg); void add_block(uint32_t block); uint32_t get_dominator() const { return dominator; } void lift_continue_block_dominator(); private: const CFG &cfg; uint32_t dominator = 0; }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_common.hpp000066400000000000000000001267731400026215700176360ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_COMMON_HPP #define SPIRV_CROSS_COMMON_HPP #include "spirv.hpp" #include "spirv_cross_containers.hpp" #include "spirv_cross_error_handling.hpp" #include // A bit crude, but allows projects which embed SPIRV-Cross statically to // effectively hide all the symbols from other projects. // There is a case where we have: // - Project A links against SPIRV-Cross statically. // - Project A links against Project B statically. // - Project B links against SPIRV-Cross statically (might be a different version). // This leads to a conflict with extremely bizarre results. // By overriding the namespace in one of the project builds, we can work around this. // If SPIRV-Cross is embedded in dynamic libraries, // prefer using -fvisibility=hidden on GCC/Clang instead. #ifdef SPIRV_CROSS_NAMESPACE_OVERRIDE #define SPIRV_CROSS_NAMESPACE SPIRV_CROSS_NAMESPACE_OVERRIDE #else #define SPIRV_CROSS_NAMESPACE spirv_cross #endif namespace SPIRV_CROSS_NAMESPACE { namespace inner { template void join_helper(StringStream<> &stream, T &&t) { stream << std::forward(t); } template void join_helper(StringStream<> &stream, T &&t, Ts &&... ts) { stream << std::forward(t); join_helper(stream, std::forward(ts)...); } } // namespace inner class Bitset { public: Bitset() = default; explicit inline Bitset(uint64_t lower_) : lower(lower_) { } inline bool get(uint32_t bit) const { if (bit < 64) return (lower & (1ull << bit)) != 0; else return higher.count(bit) != 0; } inline void set(uint32_t bit) { if (bit < 64) lower |= 1ull << bit; else higher.insert(bit); } inline void clear(uint32_t bit) { if (bit < 64) lower &= ~(1ull << bit); else higher.erase(bit); } inline uint64_t get_lower() const { return lower; } inline void reset() { lower = 0; higher.clear(); } inline void merge_and(const Bitset &other) { lower &= other.lower; std::unordered_set tmp_set; for (auto &v : higher) if (other.higher.count(v) != 0) tmp_set.insert(v); higher = std::move(tmp_set); } inline void merge_or(const Bitset &other) { lower |= other.lower; for (auto &v : other.higher) higher.insert(v); } inline bool operator==(const Bitset &other) const { if (lower != other.lower) return false; if (higher.size() != other.higher.size()) return false; for (auto &v : higher) if (other.higher.count(v) == 0) return false; return true; } inline bool operator!=(const Bitset &other) const { return !(*this == other); } template void for_each_bit(const Op &op) const { // TODO: Add ctz-based iteration. for (uint32_t i = 0; i < 64; i++) { if (lower & (1ull << i)) op(i); } if (higher.empty()) return; // Need to enforce an order here for reproducible results, // but hitting this path should happen extremely rarely, so having this slow path is fine. SmallVector bits; bits.reserve(higher.size()); for (auto &v : higher) bits.push_back(v); std::sort(std::begin(bits), std::end(bits)); for (auto &v : bits) op(v); } inline bool empty() const { return lower == 0 && higher.empty(); } private: // The most common bits to set are all lower than 64, // so optimize for this case. Bits spilling outside 64 go into a slower data structure. // In almost all cases, higher data structure will not be used. uint64_t lower = 0; std::unordered_set higher; }; // Helper template to avoid lots of nasty string temporary munging. template std::string join(Ts &&... ts) { StringStream<> stream; inner::join_helper(stream, std::forward(ts)...); return stream.str(); } inline std::string merge(const SmallVector &list, const char *between = ", ") { StringStream<> stream; for (auto &elem : list) { stream << elem; if (&elem != &list.back()) stream << between; } return stream.str(); } // Make sure we don't accidentally call this with float or doubles with SFINAE. // Have to use the radix-aware overload. template ::value, int>::type = 0> inline std::string convert_to_string(const T &t) { return std::to_string(t); } // Allow implementations to set a convenient standard precision #ifndef SPIRV_CROSS_FLT_FMT #define SPIRV_CROSS_FLT_FMT "%.32g" #endif // Disable sprintf and strcat warnings. // We cannot rely on snprintf and family existing because, ..., MSVC. #if defined(__clang__) || defined(__GNUC__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #elif defined(_MSC_VER) #pragma warning(push) #pragma warning(disable : 4996) #endif static inline void fixup_radix_point(char *str, char radix_point) { // Setting locales is a very risky business in multi-threaded program, // so just fixup locales instead. We only need to care about the radix point. if (radix_point != '.') { while (*str != '\0') { if (*str == radix_point) *str = '.'; str++; } } } inline std::string convert_to_string(float t, char locale_radix_point) { // std::to_string for floating point values is broken. // Fallback to something more sane. char buf[64]; sprintf(buf, SPIRV_CROSS_FLT_FMT, t); fixup_radix_point(buf, locale_radix_point); // Ensure that the literal is float. if (!strchr(buf, '.') && !strchr(buf, 'e')) strcat(buf, ".0"); return buf; } inline std::string convert_to_string(double t, char locale_radix_point) { // std::to_string for floating point values is broken. // Fallback to something more sane. char buf[64]; sprintf(buf, SPIRV_CROSS_FLT_FMT, t); fixup_radix_point(buf, locale_radix_point); // Ensure that the literal is float. if (!strchr(buf, '.') && !strchr(buf, 'e')) strcat(buf, ".0"); return buf; } template struct ValueSaver { explicit ValueSaver(T ¤t_) : current(current_) , saved(current_) { } void release() { current = saved; } ~ValueSaver() { release(); } T ¤t; T saved; }; #if defined(__clang__) || defined(__GNUC__) #pragma GCC diagnostic pop #elif defined(_MSC_VER) #pragma warning(pop) #endif struct Instruction { uint16_t op = 0; uint16_t count = 0; uint32_t offset = 0; uint32_t length = 0; }; enum Types { TypeNone, TypeType, TypeVariable, TypeConstant, TypeFunction, TypeFunctionPrototype, TypeBlock, TypeExtension, TypeExpression, TypeConstantOp, TypeCombinedImageSampler, TypeAccessChain, TypeUndef, TypeString, TypeCount }; template class TypedID; template <> class TypedID { public: TypedID() = default; TypedID(uint32_t id_) : id(id_) { } template TypedID(const TypedID &other) { *this = other; } template TypedID &operator=(const TypedID &other) { id = uint32_t(other); return *this; } // Implicit conversion to u32 is desired here. // As long as we block implicit conversion between TypedID and TypedID we're good. operator uint32_t() const { return id; } template operator TypedID() const { return TypedID(*this); } private: uint32_t id = 0; }; template class TypedID { public: TypedID() = default; TypedID(uint32_t id_) : id(id_) { } explicit TypedID(const TypedID &other) : id(uint32_t(other)) { } operator uint32_t() const { return id; } private: uint32_t id = 0; }; using VariableID = TypedID; using TypeID = TypedID; using ConstantID = TypedID; using FunctionID = TypedID; using BlockID = TypedID; using ID = TypedID; // Helper for Variant interface. struct IVariant { virtual ~IVariant() = default; virtual IVariant *clone(ObjectPoolBase *pool) = 0; ID self = 0; }; #define SPIRV_CROSS_DECLARE_CLONE(T) \ IVariant *clone(ObjectPoolBase *pool) override \ { \ return static_cast *>(pool)->allocate(*this); \ } struct SPIRUndef : IVariant { enum { type = TypeUndef }; explicit SPIRUndef(TypeID basetype_) : basetype(basetype_) { } TypeID basetype; SPIRV_CROSS_DECLARE_CLONE(SPIRUndef) }; struct SPIRString : IVariant { enum { type = TypeString }; explicit SPIRString(std::string str_) : str(std::move(str_)) { } std::string str; SPIRV_CROSS_DECLARE_CLONE(SPIRString) }; // This type is only used by backends which need to access the combined image and sampler IDs separately after // the OpSampledImage opcode. struct SPIRCombinedImageSampler : IVariant { enum { type = TypeCombinedImageSampler }; SPIRCombinedImageSampler(TypeID type_, VariableID image_, VariableID sampler_) : combined_type(type_) , image(image_) , sampler(sampler_) { } TypeID combined_type; VariableID image; VariableID sampler; SPIRV_CROSS_DECLARE_CLONE(SPIRCombinedImageSampler) }; struct SPIRConstantOp : IVariant { enum { type = TypeConstantOp }; SPIRConstantOp(TypeID result_type, spv::Op op, const uint32_t *args, uint32_t length) : opcode(op) , basetype(result_type) { arguments.reserve(length); for (uint32_t i = 0; i < length; i++) arguments.push_back(args[i]); } spv::Op opcode; SmallVector arguments; TypeID basetype; SPIRV_CROSS_DECLARE_CLONE(SPIRConstantOp) }; struct SPIRType : IVariant { enum { type = TypeType }; enum BaseType { Unknown, Void, Boolean, SByte, UByte, Short, UShort, Int, UInt, Int64, UInt64, AtomicCounter, Half, Float, Double, Struct, Image, SampledImage, Sampler, AccelerationStructure, RayQuery, // Keep internal types at the end. ControlPointArray, Interpolant, Char }; // Scalar/vector/matrix support. BaseType basetype = Unknown; uint32_t width = 0; uint32_t vecsize = 1; uint32_t columns = 1; // Arrays, support array of arrays by having a vector of array sizes. SmallVector array; // Array elements can be either specialization constants or specialization ops. // This array determines how to interpret the array size. // If an element is true, the element is a literal, // otherwise, it's an expression, which must be resolved on demand. // The actual size is not really known until runtime. SmallVector array_size_literal; // Pointers // Keep track of how many pointer layers we have. uint32_t pointer_depth = 0; bool pointer = false; bool forward_pointer = false; spv::StorageClass storage = spv::StorageClassGeneric; SmallVector member_types; // If member order has been rewritten to handle certain scenarios with Offset, // allow codegen to rewrite the index. SmallVector member_type_index_redirection; struct ImageType { TypeID type; spv::Dim dim; bool depth; bool arrayed; bool ms; uint32_t sampled; spv::ImageFormat format; spv::AccessQualifier access; } image; // Structs can be declared multiple times if they are used as part of interface blocks. // We want to detect this so that we only emit the struct definition once. // Since we cannot rely on OpName to be equal, we need to figure out aliases. TypeID type_alias = 0; // Denotes the type which this type is based on. // Allows the backend to traverse how a complex type is built up during access chains. TypeID parent_type = 0; // Used in backends to avoid emitting members with conflicting names. std::unordered_set member_name_cache; SPIRV_CROSS_DECLARE_CLONE(SPIRType) }; struct SPIRExtension : IVariant { enum { type = TypeExtension }; enum Extension { Unsupported, GLSL, SPV_debug_info, SPV_AMD_shader_ballot, SPV_AMD_shader_explicit_vertex_parameter, SPV_AMD_shader_trinary_minmax, SPV_AMD_gcn_shader }; explicit SPIRExtension(Extension ext_) : ext(ext_) { } Extension ext; SPIRV_CROSS_DECLARE_CLONE(SPIRExtension) }; // SPIREntryPoint is not a variant since its IDs are used to decorate OpFunction, // so in order to avoid conflicts, we can't stick them in the ids array. struct SPIREntryPoint { SPIREntryPoint(FunctionID self_, spv::ExecutionModel execution_model, const std::string &entry_name) : self(self_) , name(entry_name) , orig_name(entry_name) , model(execution_model) { } SPIREntryPoint() = default; FunctionID self = 0; std::string name; std::string orig_name; SmallVector interface_variables; Bitset flags; struct WorkgroupSize { uint32_t x = 0, y = 0, z = 0; uint32_t constant = 0; // Workgroup size can be expressed as a constant/spec-constant instead. } workgroup_size; uint32_t invocations = 0; uint32_t output_vertices = 0; spv::ExecutionModel model = spv::ExecutionModelMax; bool geometry_passthrough = false; }; struct SPIRExpression : IVariant { enum { type = TypeExpression }; // Only created by the backend target to avoid creating tons of temporaries. SPIRExpression(std::string expr, TypeID expression_type_, bool immutable_) : expression(move(expr)) , expression_type(expression_type_) , immutable(immutable_) { } // If non-zero, prepend expression with to_expression(base_expression). // Used in amortizing multiple calls to to_expression() // where in certain cases that would quickly force a temporary when not needed. ID base_expression = 0; std::string expression; TypeID expression_type = 0; // If this expression is a forwarded load, // allow us to reference the original variable. ID loaded_from = 0; // If this expression will never change, we can avoid lots of temporaries // in high level source. // An expression being immutable can be speculative, // it is assumed that this is true almost always. bool immutable = false; // Before use, this expression must be transposed. // This is needed for targets which don't support row_major layouts. bool need_transpose = false; // Whether or not this is an access chain expression. bool access_chain = false; // A list of expressions which this expression depends on. SmallVector expression_dependencies; // By reading this expression, we implicitly read these expressions as well. // Used by access chain Store and Load since we read multiple expressions in this case. SmallVector implied_read_expressions; // The expression was emitted at a certain scope. Lets us track when an expression read means multiple reads. uint32_t emitted_loop_level = 0; SPIRV_CROSS_DECLARE_CLONE(SPIRExpression) }; struct SPIRFunctionPrototype : IVariant { enum { type = TypeFunctionPrototype }; explicit SPIRFunctionPrototype(TypeID return_type_) : return_type(return_type_) { } TypeID return_type; SmallVector parameter_types; SPIRV_CROSS_DECLARE_CLONE(SPIRFunctionPrototype) }; struct SPIRBlock : IVariant { enum { type = TypeBlock }; enum Terminator { Unknown, Direct, // Emit next block directly without a particular condition. Select, // Block ends with an if/else block. MultiSelect, // Block ends with switch statement. Return, // Block ends with return. Unreachable, // Noop Kill, // Discard IgnoreIntersection, // Ray Tracing TerminateRay // Ray Tracing }; enum Merge { MergeNone, MergeLoop, MergeSelection }; enum Hints { HintNone, HintUnroll, HintDontUnroll, HintFlatten, HintDontFlatten }; enum Method { MergeToSelectForLoop, MergeToDirectForLoop, MergeToSelectContinueForLoop }; enum ContinueBlockType { ContinueNone, // Continue block is branchless and has at least one instruction. ForLoop, // Noop continue block. WhileLoop, // Continue block is conditional. DoWhileLoop, // Highly unlikely that anything will use this, // since it is really awkward/impossible to express in GLSL. ComplexLoop }; enum : uint32_t { NoDominator = 0xffffffffu }; Terminator terminator = Unknown; Merge merge = MergeNone; Hints hint = HintNone; BlockID next_block = 0; BlockID merge_block = 0; BlockID continue_block = 0; ID return_value = 0; // If 0, return nothing (void). ID condition = 0; BlockID true_block = 0; BlockID false_block = 0; BlockID default_block = 0; SmallVector ops; struct Phi { ID local_variable; // flush local variable ... BlockID parent; // If we're in from_block and want to branch into this block ... VariableID function_variable; // to this function-global "phi" variable first. }; // Before entering this block flush out local variables to magical "phi" variables. SmallVector phi_variables; // Declare these temporaries before beginning the block. // Used for handling complex continue blocks which have side effects. SmallVector> declare_temporary; // Declare these temporaries, but only conditionally if this block turns out to be // a complex loop header. SmallVector> potential_declare_temporary; struct Case { uint32_t value; BlockID block; }; SmallVector cases; // If we have tried to optimize code for this block but failed, // keep track of this. bool disable_block_optimization = false; // If the continue block is complex, fallback to "dumb" for loops. bool complex_continue = false; // Do we need a ladder variable to defer breaking out of a loop construct after a switch block? bool need_ladder_break = false; // If marked, we have explicitly handled Phi from this block, so skip any flushes related to that on a branch. // Used to handle an edge case with switch and case-label fallthrough where fall-through writes to Phi. BlockID ignore_phi_from_block = 0; // The dominating block which this block might be within. // Used in continue; blocks to determine if we really need to write continue. BlockID loop_dominator = 0; // All access to these variables are dominated by this block, // so before branching anywhere we need to make sure that we declare these variables. SmallVector dominated_variables; // These are variables which should be declared in a for loop header, if we // fail to use a classic for-loop, // we remove these variables, and fall back to regular variables outside the loop. SmallVector loop_variables; // Some expressions are control-flow dependent, i.e. any instruction which relies on derivatives or // sub-group-like operations. // Make sure that we only use these expressions in the original block. SmallVector invalidate_expressions; SPIRV_CROSS_DECLARE_CLONE(SPIRBlock) }; struct SPIRFunction : IVariant { enum { type = TypeFunction }; SPIRFunction(TypeID return_type_, TypeID function_type_) : return_type(return_type_) , function_type(function_type_) { } struct Parameter { TypeID type; ID id; uint32_t read_count; uint32_t write_count; // Set to true if this parameter aliases a global variable, // used mostly in Metal where global variables // have to be passed down to functions as regular arguments. // However, for this kind of variable, we should not care about // read and write counts as access to the function arguments // is not local to the function in question. bool alias_global_variable; }; // When calling a function, and we're remapping separate image samplers, // resolve these arguments into combined image samplers and pass them // as additional arguments in this order. // It gets more complicated as functions can pull in their own globals // and combine them with parameters, // so we need to distinguish if something is local parameter index // or a global ID. struct CombinedImageSamplerParameter { VariableID id; VariableID image_id; VariableID sampler_id; bool global_image; bool global_sampler; bool depth; }; TypeID return_type; TypeID function_type; SmallVector arguments; // Can be used by backends to add magic arguments. // Currently used by combined image/sampler implementation. SmallVector shadow_arguments; SmallVector local_variables; BlockID entry_block = 0; SmallVector blocks; SmallVector combined_parameters; struct EntryLine { uint32_t file_id = 0; uint32_t line_literal = 0; }; EntryLine entry_line; void add_local_variable(VariableID id) { local_variables.push_back(id); } void add_parameter(TypeID parameter_type, ID id, bool alias_global_variable = false) { // Arguments are read-only until proven otherwise. arguments.push_back({ parameter_type, id, 0u, 0u, alias_global_variable }); } // Hooks to be run when the function returns. // Mostly used for lowering internal data structures onto flattened structures. // Need to defer this, because they might rely on things which change during compilation. // Intentionally not a small vector, this one is rare, and std::function can be large. Vector> fixup_hooks_out; // Hooks to be run when the function begins. // Mostly used for populating internal data structures from flattened structures. // Need to defer this, because they might rely on things which change during compilation. // Intentionally not a small vector, this one is rare, and std::function can be large. Vector> fixup_hooks_in; // On function entry, make sure to copy a constant array into thread addr space to work around // the case where we are passing a constant array by value to a function on backends which do not // consider arrays value types. SmallVector constant_arrays_needed_on_stack; bool active = false; bool flush_undeclared = true; bool do_combined_parameters = true; SPIRV_CROSS_DECLARE_CLONE(SPIRFunction) }; struct SPIRAccessChain : IVariant { enum { type = TypeAccessChain }; SPIRAccessChain(TypeID basetype_, spv::StorageClass storage_, std::string base_, std::string dynamic_index_, int32_t static_index_) : basetype(basetype_) , storage(storage_) , base(std::move(base_)) , dynamic_index(std::move(dynamic_index_)) , static_index(static_index_) { } // The access chain represents an offset into a buffer. // Some backends need more complicated handling of access chains to be able to use buffers, like HLSL // which has no usable buffer type ala GLSL SSBOs. // StructuredBuffer is too limited, so our only option is to deal with ByteAddressBuffer which works with raw addresses. TypeID basetype; spv::StorageClass storage; std::string base; std::string dynamic_index; int32_t static_index; VariableID loaded_from = 0; uint32_t matrix_stride = 0; uint32_t array_stride = 0; bool row_major_matrix = false; bool immutable = false; // By reading this expression, we implicitly read these expressions as well. // Used by access chain Store and Load since we read multiple expressions in this case. SmallVector implied_read_expressions; SPIRV_CROSS_DECLARE_CLONE(SPIRAccessChain) }; struct SPIRVariable : IVariant { enum { type = TypeVariable }; SPIRVariable() = default; SPIRVariable(TypeID basetype_, spv::StorageClass storage_, ID initializer_ = 0, VariableID basevariable_ = 0) : basetype(basetype_) , storage(storage_) , initializer(initializer_) , basevariable(basevariable_) { } TypeID basetype = 0; spv::StorageClass storage = spv::StorageClassGeneric; uint32_t decoration = 0; ID initializer = 0; VariableID basevariable = 0; SmallVector dereference_chain; bool compat_builtin = false; // If a variable is shadowed, we only statically assign to it // and never actually emit a statement for it. // When we read the variable as an expression, just forward // shadowed_id as the expression. bool statically_assigned = false; ID static_expression = 0; // Temporaries which can remain forwarded as long as this variable is not modified. SmallVector dependees; bool forwardable = true; bool deferred_declaration = false; bool phi_variable = false; // Used to deal with Phi variable flushes. See flush_phi(). bool allocate_temporary_copy = false; bool remapped_variable = false; uint32_t remapped_components = 0; // The block which dominates all access to this variable. BlockID dominator = 0; // If true, this variable is a loop variable, when accessing the variable // outside a loop, // we should statically forward it. bool loop_variable = false; // Set to true while we're inside the for loop. bool loop_variable_enable = false; SPIRFunction::Parameter *parameter = nullptr; SPIRV_CROSS_DECLARE_CLONE(SPIRVariable) }; struct SPIRConstant : IVariant { enum { type = TypeConstant }; union Constant { uint32_t u32; int32_t i32; float f32; uint64_t u64; int64_t i64; double f64; }; struct ConstantVector { Constant r[4]; // If != 0, this element is a specialization constant, and we should keep track of it as such. ID id[4]; uint32_t vecsize = 1; ConstantVector() { memset(r, 0, sizeof(r)); } }; struct ConstantMatrix { ConstantVector c[4]; // If != 0, this column is a specialization constant, and we should keep track of it as such. ID id[4]; uint32_t columns = 1; }; static inline float f16_to_f32(uint16_t u16_value) { // Based on the GLM implementation. int s = (u16_value >> 15) & 0x1; int e = (u16_value >> 10) & 0x1f; int m = (u16_value >> 0) & 0x3ff; union { float f32; uint32_t u32; } u; if (e == 0) { if (m == 0) { u.u32 = uint32_t(s) << 31; return u.f32; } else { while ((m & 0x400) == 0) { m <<= 1; e--; } e++; m &= ~0x400; } } else if (e == 31) { if (m == 0) { u.u32 = (uint32_t(s) << 31) | 0x7f800000u; return u.f32; } else { u.u32 = (uint32_t(s) << 31) | 0x7f800000u | (m << 13); return u.f32; } } e += 127 - 15; m <<= 13; u.u32 = (uint32_t(s) << 31) | (e << 23) | m; return u.f32; } inline uint32_t specialization_constant_id(uint32_t col, uint32_t row) const { return m.c[col].id[row]; } inline uint32_t specialization_constant_id(uint32_t col) const { return m.id[col]; } inline uint32_t scalar(uint32_t col = 0, uint32_t row = 0) const { return m.c[col].r[row].u32; } inline int16_t scalar_i16(uint32_t col = 0, uint32_t row = 0) const { return int16_t(m.c[col].r[row].u32 & 0xffffu); } inline uint16_t scalar_u16(uint32_t col = 0, uint32_t row = 0) const { return uint16_t(m.c[col].r[row].u32 & 0xffffu); } inline int8_t scalar_i8(uint32_t col = 0, uint32_t row = 0) const { return int8_t(m.c[col].r[row].u32 & 0xffu); } inline uint8_t scalar_u8(uint32_t col = 0, uint32_t row = 0) const { return uint8_t(m.c[col].r[row].u32 & 0xffu); } inline float scalar_f16(uint32_t col = 0, uint32_t row = 0) const { return f16_to_f32(scalar_u16(col, row)); } inline float scalar_f32(uint32_t col = 0, uint32_t row = 0) const { return m.c[col].r[row].f32; } inline int32_t scalar_i32(uint32_t col = 0, uint32_t row = 0) const { return m.c[col].r[row].i32; } inline double scalar_f64(uint32_t col = 0, uint32_t row = 0) const { return m.c[col].r[row].f64; } inline int64_t scalar_i64(uint32_t col = 0, uint32_t row = 0) const { return m.c[col].r[row].i64; } inline uint64_t scalar_u64(uint32_t col = 0, uint32_t row = 0) const { return m.c[col].r[row].u64; } inline const ConstantVector &vector() const { return m.c[0]; } inline uint32_t vector_size() const { return m.c[0].vecsize; } inline uint32_t columns() const { return m.columns; } inline void make_null(const SPIRType &constant_type_) { m = {}; m.columns = constant_type_.columns; for (auto &c : m.c) c.vecsize = constant_type_.vecsize; } inline bool constant_is_null() const { if (specialization) return false; if (!subconstants.empty()) return false; for (uint32_t col = 0; col < columns(); col++) for (uint32_t row = 0; row < vector_size(); row++) if (scalar_u64(col, row) != 0) return false; return true; } explicit SPIRConstant(uint32_t constant_type_) : constant_type(constant_type_) { } SPIRConstant() = default; SPIRConstant(TypeID constant_type_, const uint32_t *elements, uint32_t num_elements, bool specialized) : constant_type(constant_type_) , specialization(specialized) { subconstants.reserve(num_elements); for (uint32_t i = 0; i < num_elements; i++) subconstants.push_back(elements[i]); specialization = specialized; } // Construct scalar (32-bit). SPIRConstant(TypeID constant_type_, uint32_t v0, bool specialized) : constant_type(constant_type_) , specialization(specialized) { m.c[0].r[0].u32 = v0; m.c[0].vecsize = 1; m.columns = 1; } // Construct scalar (64-bit). SPIRConstant(TypeID constant_type_, uint64_t v0, bool specialized) : constant_type(constant_type_) , specialization(specialized) { m.c[0].r[0].u64 = v0; m.c[0].vecsize = 1; m.columns = 1; } // Construct vectors and matrices. SPIRConstant(TypeID constant_type_, const SPIRConstant *const *vector_elements, uint32_t num_elements, bool specialized) : constant_type(constant_type_) , specialization(specialized) { bool matrix = vector_elements[0]->m.c[0].vecsize > 1; if (matrix) { m.columns = num_elements; for (uint32_t i = 0; i < num_elements; i++) { m.c[i] = vector_elements[i]->m.c[0]; if (vector_elements[i]->specialization) m.id[i] = vector_elements[i]->self; } } else { m.c[0].vecsize = num_elements; m.columns = 1; for (uint32_t i = 0; i < num_elements; i++) { m.c[0].r[i] = vector_elements[i]->m.c[0].r[0]; if (vector_elements[i]->specialization) m.c[0].id[i] = vector_elements[i]->self; } } } TypeID constant_type = 0; ConstantMatrix m; // If this constant is a specialization constant (i.e. created with OpSpecConstant*). bool specialization = false; // If this constant is used as an array length which creates specialization restrictions on some backends. bool is_used_as_array_length = false; // If true, this is a LUT, and should always be declared in the outer scope. bool is_used_as_lut = false; // For composites which are constant arrays, etc. SmallVector subconstants; // Non-Vulkan GLSL, HLSL and sometimes MSL emits defines for each specialization constant, // and uses them to initialize the constant. This allows the user // to still be able to specialize the value by supplying corresponding // preprocessor directives before compiling the shader. std::string specialization_constant_macro_name; SPIRV_CROSS_DECLARE_CLONE(SPIRConstant) }; // Variants have a very specific allocation scheme. struct ObjectPoolGroup { std::unique_ptr pools[TypeCount]; }; class Variant { public: explicit Variant(ObjectPoolGroup *group_) : group(group_) { } ~Variant() { if (holder) group->pools[type]->free_opaque(holder); } // Marking custom move constructor as noexcept is important. Variant(Variant &&other) SPIRV_CROSS_NOEXCEPT { *this = std::move(other); } // We cannot copy from other variant without our own pool group. // Have to explicitly copy. Variant(const Variant &variant) = delete; // Marking custom move constructor as noexcept is important. Variant &operator=(Variant &&other) SPIRV_CROSS_NOEXCEPT { if (this != &other) { if (holder) group->pools[type]->free_opaque(holder); holder = other.holder; group = other.group; type = other.type; allow_type_rewrite = other.allow_type_rewrite; other.holder = nullptr; other.type = TypeNone; } return *this; } // This copy/clone should only be called in the Compiler constructor. // If this is called inside ::compile(), we invalidate any references we took higher in the stack. // This should never happen. Variant &operator=(const Variant &other) { //#define SPIRV_CROSS_COPY_CONSTRUCTOR_SANITIZE #ifdef SPIRV_CROSS_COPY_CONSTRUCTOR_SANITIZE abort(); #endif if (this != &other) { if (holder) group->pools[type]->free_opaque(holder); if (other.holder) holder = other.holder->clone(group->pools[other.type].get()); else holder = nullptr; type = other.type; allow_type_rewrite = other.allow_type_rewrite; } return *this; } void set(IVariant *val, Types new_type) { if (holder) group->pools[type]->free_opaque(holder); holder = nullptr; if (!allow_type_rewrite && type != TypeNone && type != new_type) { if (val) group->pools[new_type]->free_opaque(val); SPIRV_CROSS_THROW("Overwriting a variant with new type."); } holder = val; type = new_type; allow_type_rewrite = false; } template T *allocate_and_set(Types new_type, Ts &&... ts) { T *val = static_cast &>(*group->pools[new_type]).allocate(std::forward(ts)...); set(val, new_type); return val; } template T &get() { if (!holder) SPIRV_CROSS_THROW("nullptr"); if (static_cast(T::type) != type) SPIRV_CROSS_THROW("Bad cast"); return *static_cast(holder); } template const T &get() const { if (!holder) SPIRV_CROSS_THROW("nullptr"); if (static_cast(T::type) != type) SPIRV_CROSS_THROW("Bad cast"); return *static_cast(holder); } Types get_type() const { return type; } ID get_id() const { return holder ? holder->self : ID(0); } bool empty() const { return !holder; } void reset() { if (holder) group->pools[type]->free_opaque(holder); holder = nullptr; type = TypeNone; } void set_allow_type_rewrite() { allow_type_rewrite = true; } private: ObjectPoolGroup *group = nullptr; IVariant *holder = nullptr; Types type = TypeNone; bool allow_type_rewrite = false; }; template T &variant_get(Variant &var) { return var.get(); } template const T &variant_get(const Variant &var) { return var.get(); } template T &variant_set(Variant &var, P &&... args) { auto *ptr = var.allocate_and_set(static_cast(T::type), std::forward

(args)...); return *ptr; } struct AccessChainMeta { uint32_t storage_physical_type = 0; bool need_transpose = false; bool storage_is_packed = false; bool storage_is_invariant = false; bool flattened_struct = false; }; enum ExtendedDecorations { // Marks if a buffer block is re-packed, i.e. member declaration might be subject to PhysicalTypeID remapping and padding. SPIRVCrossDecorationBufferBlockRepacked = 0, // A type in a buffer block might be declared with a different physical type than the logical type. // If this is not set, PhysicalTypeID == the SPIR-V type as declared. SPIRVCrossDecorationPhysicalTypeID, // Marks if the physical type is to be declared with tight packing rules, i.e. packed_floatN on MSL and friends. // If this is set, PhysicalTypeID might also be set. It can be set to same as logical type if all we're doing // is converting float3 to packed_float3 for example. // If this is marked on a struct, it means the struct itself must use only Packed types for all its members. SPIRVCrossDecorationPhysicalTypePacked, // The padding in bytes before declaring this struct member. // If used on a struct type, marks the target size of a struct. SPIRVCrossDecorationPaddingTarget, SPIRVCrossDecorationInterfaceMemberIndex, SPIRVCrossDecorationInterfaceOrigID, SPIRVCrossDecorationResourceIndexPrimary, // Used for decorations like resource indices for samplers when part of combined image samplers. // A variable might need to hold two resource indices in this case. SPIRVCrossDecorationResourceIndexSecondary, // Used for resource indices for multiplanar images when part of combined image samplers. SPIRVCrossDecorationResourceIndexTertiary, SPIRVCrossDecorationResourceIndexQuaternary, // Marks a buffer block for using explicit offsets (GLSL/HLSL). SPIRVCrossDecorationExplicitOffset, // Apply to a variable in the Input storage class; marks it as holding the base group passed to vkCmdDispatchBase(), // or the base vertex and instance indices passed to vkCmdDrawIndexed(). // In MSL, this is used to adjust the WorkgroupId and GlobalInvocationId variables in compute shaders, // and to hold the BaseVertex and BaseInstance variables in vertex shaders. SPIRVCrossDecorationBuiltInDispatchBase, // Apply to a variable that is a function parameter; marks it as being a "dynamic" // combined image-sampler. In MSL, this is used when a function parameter might hold // either a regular combined image-sampler or one that has an attached sampler // Y'CbCr conversion. SPIRVCrossDecorationDynamicImageSampler, // Apply to a variable in the Input storage class; marks it as holding the size of the stage // input grid. // In MSL, this is used to hold the vertex and instance counts in a tessellation pipeline // vertex shader. SPIRVCrossDecorationBuiltInStageInputSize, // Apply to any access chain of a tessellation I/O variable; stores the type of the sub-object // that was chained to, as recorded in the input variable itself. This is used in case the pointer // is itself used as the base of an access chain, to calculate the original type of the sub-object // chained to, in case a swizzle needs to be applied. This should not happen normally with valid // SPIR-V, but the MSL backend can change the type of input variables, necessitating the // addition of swizzles to keep the generated code compiling. SPIRVCrossDecorationTessIOOriginalInputTypeID, // Apply to any access chain of an interface variable used with pull-model interpolation, where the variable is a // vector but the resulting pointer is a scalar; stores the component index that is to be accessed by the chain. // This is used when emitting calls to interpolation functions on the chain in MSL: in this case, the component // must be applied to the result, since pull-model interpolants in MSL cannot be swizzled directly, but the // results of interpolation can. SPIRVCrossDecorationInterpolantComponentExpr, SPIRVCrossDecorationCount }; struct Meta { struct Decoration { std::string alias; std::string qualified_alias; std::string hlsl_semantic; Bitset decoration_flags; spv::BuiltIn builtin_type = spv::BuiltInMax; uint32_t location = 0; uint32_t component = 0; uint32_t set = 0; uint32_t binding = 0; uint32_t offset = 0; uint32_t xfb_buffer = 0; uint32_t xfb_stride = 0; uint32_t stream = 0; uint32_t array_stride = 0; uint32_t matrix_stride = 0; uint32_t input_attachment = 0; uint32_t spec_id = 0; uint32_t index = 0; spv::FPRoundingMode fp_rounding_mode = spv::FPRoundingModeMax; bool builtin = false; struct Extended { Extended() { // MSVC 2013 workaround to init like this. for (auto &v : values) v = 0; } Bitset flags; uint32_t values[SPIRVCrossDecorationCount]; } extended; }; Decoration decoration; // Intentionally not a SmallVector. Decoration is large and somewhat rare. Vector members; std::unordered_map decoration_word_offset; // For SPV_GOOGLE_hlsl_functionality1. bool hlsl_is_magic_counter_buffer = false; // ID for the sibling counter buffer. uint32_t hlsl_magic_counter_buffer = 0; }; // A user callback that remaps the type of any variable. // var_name is the declared name of the variable. // name_of_type is the textual name of the type which will be used in the code unless written to by the callback. using VariableTypeRemapCallback = std::function; class Hasher { public: inline void u32(uint32_t value) { h = (h * 0x100000001b3ull) ^ value; } inline uint64_t get() const { return h; } private: uint64_t h = 0xcbf29ce484222325ull; }; static inline bool type_is_floating_point(const SPIRType &type) { return type.basetype == SPIRType::Half || type.basetype == SPIRType::Float || type.basetype == SPIRType::Double; } static inline bool type_is_integral(const SPIRType &type) { return type.basetype == SPIRType::SByte || type.basetype == SPIRType::UByte || type.basetype == SPIRType::Short || type.basetype == SPIRType::UShort || type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt || type.basetype == SPIRType::Int64 || type.basetype == SPIRType::UInt64; } static inline SPIRType::BaseType to_signed_basetype(uint32_t width) { switch (width) { case 8: return SPIRType::SByte; case 16: return SPIRType::Short; case 32: return SPIRType::Int; case 64: return SPIRType::Int64; default: SPIRV_CROSS_THROW("Invalid bit width."); } } static inline SPIRType::BaseType to_unsigned_basetype(uint32_t width) { switch (width) { case 8: return SPIRType::UByte; case 16: return SPIRType::UShort; case 32: return SPIRType::UInt; case 64: return SPIRType::UInt64; default: SPIRV_CROSS_THROW("Invalid bit width."); } } // Returns true if an arithmetic operation does not change behavior depending on signedness. static inline bool opcode_is_sign_invariant(spv::Op opcode) { switch (opcode) { case spv::OpIEqual: case spv::OpINotEqual: case spv::OpISub: case spv::OpIAdd: case spv::OpIMul: case spv::OpShiftLeftLogical: case spv::OpBitwiseOr: case spv::OpBitwiseXor: case spv::OpBitwiseAnd: return true; default: return false; } } struct SetBindingPair { uint32_t desc_set; uint32_t binding; inline bool operator==(const SetBindingPair &other) const { return desc_set == other.desc_set && binding == other.binding; } inline bool operator<(const SetBindingPair &other) const { return desc_set < other.desc_set || (desc_set == other.desc_set && binding < other.binding); } }; struct StageSetBinding { spv::ExecutionModel model; uint32_t desc_set; uint32_t binding; inline bool operator==(const StageSetBinding &other) const { return model == other.model && desc_set == other.desc_set && binding == other.binding; } }; struct InternalHasher { inline size_t operator()(const SetBindingPair &value) const { // Quality of hash doesn't really matter here. auto hash_set = std::hash()(value.desc_set); auto hash_binding = std::hash()(value.binding); return (hash_set * 0x10001b31) ^ hash_binding; } inline size_t operator()(const StageSetBinding &value) const { // Quality of hash doesn't really matter here. auto hash_model = std::hash()(value.model); auto hash_set = std::hash()(value.desc_set); auto tmp_hash = (hash_model * 0x10001b31) ^ hash_set; return (tmp_hash * 0x10001b31) ^ value.binding; } }; // Special constant used in a {MSL,HLSL}ResourceBinding desc_set // element to indicate the bindings for the push constants. static const uint32_t ResourceBindingPushConstantDescriptorSet = ~(0u); // Special constant used in a {MSL,HLSL}ResourceBinding binding // element to indicate the bindings for the push constants. static const uint32_t ResourceBindingPushConstantBinding = 0; } // namespace SPIRV_CROSS_NAMESPACE namespace std { template struct hash> { size_t operator()(const SPIRV_CROSS_NAMESPACE::TypedID &value) const { return std::hash()(value); } }; } // namespace std #endif spirv-cross-2021.01.15/spirv_cpp.cpp000066400000000000000000000373761400026215700171230ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_cpp.hpp" using namespace spv; using namespace SPIRV_CROSS_NAMESPACE; using namespace std; void CompilerCPP::emit_buffer_block(const SPIRVariable &var) { add_resource_name(var.self); auto &type = get(var.basetype); auto instance_name = to_name(var.self); uint32_t descriptor_set = ir.meta[var.self].decoration.set; uint32_t binding = ir.meta[var.self].decoration.binding; emit_block_struct(type); auto buffer_name = to_name(type.self); statement("internal::Resource<", buffer_name, type_to_array_glsl(type), "> ", instance_name, "__;"); statement_no_indent("#define ", instance_name, " __res->", instance_name, "__.get()"); resource_registrations.push_back( join("s.register_resource(", instance_name, "__", ", ", descriptor_set, ", ", binding, ");")); statement(""); } void CompilerCPP::emit_interface_block(const SPIRVariable &var) { add_resource_name(var.self); auto &type = get(var.basetype); const char *qual = var.storage == StorageClassInput ? "StageInput" : "StageOutput"; const char *lowerqual = var.storage == StorageClassInput ? "stage_input" : "stage_output"; auto instance_name = to_name(var.self); uint32_t location = ir.meta[var.self].decoration.location; string buffer_name; auto flags = ir.meta[type.self].decoration.decoration_flags; if (flags.get(DecorationBlock)) { emit_block_struct(type); buffer_name = to_name(type.self); } else buffer_name = type_to_glsl(type); statement("internal::", qual, "<", buffer_name, type_to_array_glsl(type), "> ", instance_name, "__;"); statement_no_indent("#define ", instance_name, " __res->", instance_name, "__.get()"); resource_registrations.push_back(join("s.register_", lowerqual, "(", instance_name, "__", ", ", location, ");")); statement(""); } void CompilerCPP::emit_shared(const SPIRVariable &var) { add_resource_name(var.self); auto instance_name = to_name(var.self); statement(CompilerGLSL::variable_decl(var), ";"); statement_no_indent("#define ", instance_name, " __res->", instance_name); } void CompilerCPP::emit_uniform(const SPIRVariable &var) { add_resource_name(var.self); auto &type = get(var.basetype); auto instance_name = to_name(var.self); uint32_t descriptor_set = ir.meta[var.self].decoration.set; uint32_t binding = ir.meta[var.self].decoration.binding; uint32_t location = ir.meta[var.self].decoration.location; string type_name = type_to_glsl(type); remap_variable_type_name(type, instance_name, type_name); if (type.basetype == SPIRType::Image || type.basetype == SPIRType::SampledImage || type.basetype == SPIRType::AtomicCounter) { statement("internal::Resource<", type_name, type_to_array_glsl(type), "> ", instance_name, "__;"); statement_no_indent("#define ", instance_name, " __res->", instance_name, "__.get()"); resource_registrations.push_back( join("s.register_resource(", instance_name, "__", ", ", descriptor_set, ", ", binding, ");")); } else { statement("internal::UniformConstant<", type_name, type_to_array_glsl(type), "> ", instance_name, "__;"); statement_no_indent("#define ", instance_name, " __res->", instance_name, "__.get()"); resource_registrations.push_back( join("s.register_uniform_constant(", instance_name, "__", ", ", location, ");")); } statement(""); } void CompilerCPP::emit_push_constant_block(const SPIRVariable &var) { add_resource_name(var.self); auto &type = get(var.basetype); auto &flags = ir.meta[var.self].decoration.decoration_flags; if (flags.get(DecorationBinding) || flags.get(DecorationDescriptorSet)) SPIRV_CROSS_THROW("Push constant blocks cannot be compiled to GLSL with Binding or Set syntax. " "Remap to location with reflection API first or disable these decorations."); emit_block_struct(type); auto buffer_name = to_name(type.self); auto instance_name = to_name(var.self); statement("internal::PushConstant<", buffer_name, type_to_array_glsl(type), "> ", instance_name, ";"); statement_no_indent("#define ", instance_name, " __res->", instance_name, ".get()"); resource_registrations.push_back(join("s.register_push_constant(", instance_name, "__", ");")); statement(""); } void CompilerCPP::emit_block_struct(SPIRType &type) { // C++ can't do interface blocks, so we fake it by emitting a separate struct. // However, these structs are not allowed to alias anything, so remove it before // emitting the struct. // // The type we have here needs to be resolved to the non-pointer type so we can remove aliases. auto &self = get(type.self); self.type_alias = 0; emit_struct(self); } void CompilerCPP::emit_resources() { for (auto &id : ir.ids) { if (id.get_type() == TypeConstant) { auto &c = id.get(); bool needs_declaration = c.specialization || c.is_used_as_lut; if (needs_declaration) { if (!options.vulkan_semantics && c.specialization) { c.specialization_constant_macro_name = constant_value_macro_name(get_decoration(c.self, DecorationSpecId)); } emit_constant(c); } } else if (id.get_type() == TypeConstantOp) { emit_specialization_constant_op(id.get()); } } // Output all basic struct types which are not Block or BufferBlock as these are declared inplace // when such variables are instantiated. for (auto &id : ir.ids) { if (id.get_type() == TypeType) { auto &type = id.get(); if (type.basetype == SPIRType::Struct && type.array.empty() && !type.pointer && (!ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) && !ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock))) { emit_struct(type); } } } statement("struct Resources : ", resource_type); begin_scope(); // Output UBOs and SSBOs for (auto &id : ir.ids) { if (id.get_type() == TypeVariable) { auto &var = id.get(); auto &type = get(var.basetype); if (var.storage != StorageClassFunction && type.pointer && type.storage == StorageClassUniform && !is_hidden_variable(var) && (ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) || ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock))) { emit_buffer_block(var); } } } // Output push constant blocks for (auto &id : ir.ids) { if (id.get_type() == TypeVariable) { auto &var = id.get(); auto &type = get(var.basetype); if (!is_hidden_variable(var) && var.storage != StorageClassFunction && type.pointer && type.storage == StorageClassPushConstant) { emit_push_constant_block(var); } } } // Output in/out interfaces. for (auto &id : ir.ids) { if (id.get_type() == TypeVariable) { auto &var = id.get(); auto &type = get(var.basetype); if (var.storage != StorageClassFunction && !is_hidden_variable(var) && type.pointer && (var.storage == StorageClassInput || var.storage == StorageClassOutput) && interface_variable_exists_in_entry_point(var.self)) { emit_interface_block(var); } } } // Output Uniform Constants (values, samplers, images, etc). for (auto &id : ir.ids) { if (id.get_type() == TypeVariable) { auto &var = id.get(); auto &type = get(var.basetype); if (var.storage != StorageClassFunction && !is_hidden_variable(var) && type.pointer && (type.storage == StorageClassUniformConstant || type.storage == StorageClassAtomicCounter)) { emit_uniform(var); } } } // Global variables. bool emitted = false; for (auto global : global_variables) { auto &var = get(global); if (var.storage == StorageClassWorkgroup) { emit_shared(var); emitted = true; } } if (emitted) statement(""); declare_undefined_values(); statement("inline void init(spirv_cross_shader& s)"); begin_scope(); statement(resource_type, "::init(s);"); for (auto ® : resource_registrations) statement(reg); end_scope(); resource_registrations.clear(); end_scope_decl(); statement(""); statement("Resources* __res;"); if (get_entry_point().model == ExecutionModelGLCompute) statement("ComputePrivateResources __priv_res;"); statement(""); // Emit regular globals which are allocated per invocation. emitted = false; for (auto global : global_variables) { auto &var = get(global); if (var.storage == StorageClassPrivate) { if (var.storage == StorageClassWorkgroup) emit_shared(var); else statement(CompilerGLSL::variable_decl(var), ";"); emitted = true; } } if (emitted) statement(""); } string CompilerCPP::compile() { ir.fixup_reserved_names(); // Do not deal with ES-isms like precision, older extensions and such. options.es = false; options.version = 450; backend.float_literal_suffix = true; backend.double_literal_suffix = false; backend.long_long_literal_suffix = true; backend.uint32_t_literal_suffix = true; backend.basic_int_type = "int32_t"; backend.basic_uint_type = "uint32_t"; backend.swizzle_is_function = true; backend.shared_is_implied = true; backend.unsized_array_supported = false; backend.explicit_struct_type = true; backend.use_initializer_list = true; fixup_type_alias(); reorder_type_alias(); build_function_control_flow_graphs_and_analyze(); update_active_builtins(); uint32_t pass_count = 0; do { if (pass_count >= 3) SPIRV_CROSS_THROW("Over 3 compilation loops detected. Must be a bug!"); resource_registrations.clear(); reset(); // Move constructor for this type is broken on GCC 4.9 ... buffer.reset(); emit_header(); emit_resources(); emit_function(get(ir.default_entry_point), Bitset()); pass_count++; } while (is_forcing_recompilation()); // Match opening scope of emit_header(). end_scope_decl(); // namespace end_scope(); // Emit C entry points emit_c_linkage(); // Entry point in CPP is always main() for the time being. get_entry_point().name = "main"; return buffer.str(); } void CompilerCPP::emit_c_linkage() { statement(""); statement("spirv_cross_shader_t *spirv_cross_construct(void)"); begin_scope(); statement("return new ", impl_type, "();"); end_scope(); statement(""); statement("void spirv_cross_destruct(spirv_cross_shader_t *shader)"); begin_scope(); statement("delete static_cast<", impl_type, "*>(shader);"); end_scope(); statement(""); statement("void spirv_cross_invoke(spirv_cross_shader_t *shader)"); begin_scope(); statement("static_cast<", impl_type, "*>(shader)->invoke();"); end_scope(); statement(""); statement("static const struct spirv_cross_interface vtable ="); begin_scope(); statement("spirv_cross_construct,"); statement("spirv_cross_destruct,"); statement("spirv_cross_invoke,"); end_scope_decl(); statement(""); statement("const struct spirv_cross_interface *", interface_name.empty() ? string("spirv_cross_get_interface") : interface_name, "(void)"); begin_scope(); statement("return &vtable;"); end_scope(); } void CompilerCPP::emit_function_prototype(SPIRFunction &func, const Bitset &) { if (func.self != ir.default_entry_point) add_function_overload(func); local_variable_names = resource_names; string decl; auto &type = get(func.return_type); decl += "inline "; decl += type_to_glsl(type); decl += " "; if (func.self == ir.default_entry_point) { decl += "main"; processing_entry_point = true; } else decl += to_name(func.self); decl += "("; for (auto &arg : func.arguments) { add_local_variable_name(arg.id); decl += argument_decl(arg); if (&arg != &func.arguments.back()) decl += ", "; // Hold a pointer to the parameter so we can invalidate the readonly field if needed. auto *var = maybe_get(arg.id); if (var) var->parameter = &arg; } decl += ")"; statement(decl); } string CompilerCPP::argument_decl(const SPIRFunction::Parameter &arg) { auto &type = expression_type(arg.id); bool constref = !type.pointer || arg.write_count == 0; auto &var = get(arg.id); string base = type_to_glsl(type); string variable_name = to_name(var.self); remap_variable_type_name(type, variable_name, base); for (uint32_t i = 0; i < type.array.size(); i++) base = join("std::array<", base, ", ", to_array_size(type, i), ">"); return join(constref ? "const " : "", base, " &", variable_name); } string CompilerCPP::variable_decl(const SPIRType &type, const string &name, uint32_t /* id */) { string base = type_to_glsl(type); remap_variable_type_name(type, name, base); bool runtime = false; for (uint32_t i = 0; i < type.array.size(); i++) { auto &array = type.array[i]; if (!array && type.array_size_literal[i]) { // Avoid using runtime arrays with std::array since this is undefined. // Runtime arrays cannot be passed around as values, so this is fine. runtime = true; } else base = join("std::array<", base, ", ", to_array_size(type, i), ">"); } base += ' '; return base + name + (runtime ? "[1]" : ""); } void CompilerCPP::emit_header() { auto &execution = get_entry_point(); statement("// This C++ shader is autogenerated by spirv-cross."); statement("#include \"spirv_cross/internal_interface.hpp\""); statement("#include \"spirv_cross/external_interface.h\""); // Needed to properly implement GLSL-style arrays. statement("#include "); statement("#include "); statement(""); statement("using namespace spirv_cross;"); statement("using namespace glm;"); statement(""); statement("namespace Impl"); begin_scope(); switch (execution.model) { case ExecutionModelGeometry: case ExecutionModelTessellationControl: case ExecutionModelTessellationEvaluation: case ExecutionModelGLCompute: case ExecutionModelFragment: case ExecutionModelVertex: statement("struct Shader"); begin_scope(); break; default: SPIRV_CROSS_THROW("Unsupported execution model."); } switch (execution.model) { case ExecutionModelGeometry: impl_type = "GeometryShader"; resource_type = "GeometryResources"; break; case ExecutionModelVertex: impl_type = "VertexShader"; resource_type = "VertexResources"; break; case ExecutionModelFragment: impl_type = "FragmentShader"; resource_type = "FragmentResources"; break; case ExecutionModelGLCompute: impl_type = join("ComputeShader"); resource_type = "ComputeResources"; break; case ExecutionModelTessellationControl: impl_type = "TessControlShader"; resource_type = "TessControlResources"; break; case ExecutionModelTessellationEvaluation: impl_type = "TessEvaluationShader"; resource_type = "TessEvaluationResources"; break; default: SPIRV_CROSS_THROW("Unsupported execution model."); } } spirv-cross-2021.01.15/spirv_cpp.hpp000066400000000000000000000051161400026215700171130ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_CPP_HPP #define SPIRV_CROSS_CPP_HPP #include "spirv_glsl.hpp" #include namespace SPIRV_CROSS_NAMESPACE { class CompilerCPP : public CompilerGLSL { public: explicit CompilerCPP(std::vector spirv_) : CompilerGLSL(std::move(spirv_)) { } CompilerCPP(const uint32_t *ir_, size_t word_count) : CompilerGLSL(ir_, word_count) { } explicit CompilerCPP(const ParsedIR &ir_) : CompilerGLSL(ir_) { } explicit CompilerCPP(ParsedIR &&ir_) : CompilerGLSL(std::move(ir_)) { } std::string compile() override; // Sets a custom symbol name that can override // spirv_cross_get_interface. // // Useful when several shader interfaces are linked // statically into the same binary. void set_interface_name(std::string name) { interface_name = std::move(name); } private: void emit_header() override; void emit_c_linkage(); void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override; void emit_resources(); void emit_buffer_block(const SPIRVariable &type) override; void emit_push_constant_block(const SPIRVariable &var) override; void emit_interface_block(const SPIRVariable &type); void emit_block_chain(SPIRBlock &block); void emit_uniform(const SPIRVariable &var) override; void emit_shared(const SPIRVariable &var); void emit_block_struct(SPIRType &type); std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id) override; std::string argument_decl(const SPIRFunction::Parameter &arg); SmallVector resource_registrations; std::string impl_type; std::string resource_type; uint32_t shared_counter = 0; std::string interface_name; }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_cross.cpp000066400000000000000000004341731400026215700174660ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_cross.hpp" #include "GLSL.std.450.h" #include "spirv_cfg.hpp" #include "spirv_common.hpp" #include "spirv_parser.hpp" #include #include #include using namespace std; using namespace spv; using namespace SPIRV_CROSS_NAMESPACE; Compiler::Compiler(vector ir_) { Parser parser(move(ir_)); parser.parse(); set_ir(move(parser.get_parsed_ir())); } Compiler::Compiler(const uint32_t *ir_, size_t word_count) { Parser parser(ir_, word_count); parser.parse(); set_ir(move(parser.get_parsed_ir())); } Compiler::Compiler(const ParsedIR &ir_) { set_ir(ir_); } Compiler::Compiler(ParsedIR &&ir_) { set_ir(move(ir_)); } void Compiler::set_ir(ParsedIR &&ir_) { ir = move(ir_); parse_fixup(); } void Compiler::set_ir(const ParsedIR &ir_) { ir = ir_; parse_fixup(); } string Compiler::compile() { return ""; } bool Compiler::variable_storage_is_aliased(const SPIRVariable &v) { auto &type = get(v.basetype); bool ssbo = v.storage == StorageClassStorageBuffer || ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock); bool image = type.basetype == SPIRType::Image; bool counter = type.basetype == SPIRType::AtomicCounter; bool buffer_reference = type.storage == StorageClassPhysicalStorageBufferEXT; bool is_restrict; if (ssbo) is_restrict = ir.get_buffer_block_flags(v).get(DecorationRestrict); else is_restrict = has_decoration(v.self, DecorationRestrict); return !is_restrict && (ssbo || image || counter || buffer_reference); } bool Compiler::block_is_pure(const SPIRBlock &block) { // This is a global side effect of the function. if (block.terminator == SPIRBlock::Kill || block.terminator == SPIRBlock::TerminateRay || block.terminator == SPIRBlock::IgnoreIntersection) return false; for (auto &i : block.ops) { auto ops = stream(i); auto op = static_cast(i.op); switch (op) { case OpFunctionCall: { uint32_t func = ops[2]; if (!function_is_pure(get(func))) return false; break; } case OpCopyMemory: case OpStore: { auto &type = expression_type(ops[0]); if (type.storage != StorageClassFunction) return false; break; } case OpImageWrite: return false; // Atomics are impure. case OpAtomicLoad: case OpAtomicStore: case OpAtomicExchange: case OpAtomicCompareExchange: case OpAtomicCompareExchangeWeak: case OpAtomicIIncrement: case OpAtomicIDecrement: case OpAtomicIAdd: case OpAtomicISub: case OpAtomicSMin: case OpAtomicUMin: case OpAtomicSMax: case OpAtomicUMax: case OpAtomicAnd: case OpAtomicOr: case OpAtomicXor: return false; // Geometry shader builtins modify global state. case OpEndPrimitive: case OpEmitStreamVertex: case OpEndStreamPrimitive: case OpEmitVertex: return false; // Barriers disallow any reordering, so we should treat blocks with barrier as writing. case OpControlBarrier: case OpMemoryBarrier: return false; // Ray tracing builtins are impure. case OpReportIntersectionKHR: case OpIgnoreIntersectionNV: case OpTerminateRayNV: case OpTraceNV: case OpTraceRayKHR: case OpExecuteCallableNV: case OpExecuteCallableKHR: return false; // OpExtInst is potentially impure depending on extension, but GLSL builtins are at least pure. case OpDemoteToHelperInvocationEXT: // This is a global side effect of the function. return false; default: break; } } return true; } string Compiler::to_name(uint32_t id, bool allow_alias) const { if (allow_alias && ir.ids[id].get_type() == TypeType) { // If this type is a simple alias, emit the // name of the original type instead. // We don't want to override the meta alias // as that can be overridden by the reflection APIs after parse. auto &type = get(id); if (type.type_alias) { // If the alias master has been specially packed, we will have emitted a clean variant as well, // so skip the name aliasing here. if (!has_extended_decoration(type.type_alias, SPIRVCrossDecorationBufferBlockRepacked)) return to_name(type.type_alias); } } auto &alias = ir.get_name(id); if (alias.empty()) return join("_", id); else return alias; } bool Compiler::function_is_pure(const SPIRFunction &func) { for (auto block : func.blocks) { if (!block_is_pure(get(block))) { //fprintf(stderr, "Function %s is impure!\n", to_name(func.self).c_str()); return false; } } //fprintf(stderr, "Function %s is pure!\n", to_name(func.self).c_str()); return true; } void Compiler::register_global_read_dependencies(const SPIRBlock &block, uint32_t id) { for (auto &i : block.ops) { auto ops = stream(i); auto op = static_cast(i.op); switch (op) { case OpFunctionCall: { uint32_t func = ops[2]; register_global_read_dependencies(get(func), id); break; } case OpLoad: case OpImageRead: { // If we're in a storage class which does not get invalidated, adding dependencies here is no big deal. auto *var = maybe_get_backing_variable(ops[2]); if (var && var->storage != StorageClassFunction) { auto &type = get(var->basetype); // InputTargets are immutable. if (type.basetype != SPIRType::Image && type.image.dim != DimSubpassData) var->dependees.push_back(id); } break; } default: break; } } } void Compiler::register_global_read_dependencies(const SPIRFunction &func, uint32_t id) { for (auto block : func.blocks) register_global_read_dependencies(get(block), id); } SPIRVariable *Compiler::maybe_get_backing_variable(uint32_t chain) { auto *var = maybe_get(chain); if (!var) { auto *cexpr = maybe_get(chain); if (cexpr) var = maybe_get(cexpr->loaded_from); auto *access_chain = maybe_get(chain); if (access_chain) var = maybe_get(access_chain->loaded_from); } return var; } StorageClass Compiler::get_expression_effective_storage_class(uint32_t ptr) { auto *var = maybe_get_backing_variable(ptr); // If the expression has been lowered to a temporary, we need to use the Generic storage class. // We're looking for the effective storage class of a given expression. // An access chain or forwarded OpLoads from such access chains // will generally have the storage class of the underlying variable, but if the load was not forwarded // we have lost any address space qualifiers. bool forced_temporary = ir.ids[ptr].get_type() == TypeExpression && !get(ptr).access_chain && (forced_temporaries.count(ptr) != 0 || forwarded_temporaries.count(ptr) == 0); if (var && !forced_temporary) { // Normalize SSBOs to StorageBuffer here. if (var->storage == StorageClassUniform && has_decoration(get(var->basetype).self, DecorationBufferBlock)) return StorageClassStorageBuffer; else return var->storage; } else return expression_type(ptr).storage; } void Compiler::register_read(uint32_t expr, uint32_t chain, bool forwarded) { auto &e = get(expr); auto *var = maybe_get_backing_variable(chain); if (var) { e.loaded_from = var->self; // If the backing variable is immutable, we do not need to depend on the variable. if (forwarded && !is_immutable(var->self)) var->dependees.push_back(e.self); // If we load from a parameter, make sure we create "inout" if we also write to the parameter. // The default is "in" however, so we never invalidate our compilation by reading. if (var && var->parameter) var->parameter->read_count++; } } void Compiler::register_write(uint32_t chain) { auto *var = maybe_get(chain); if (!var) { // If we're storing through an access chain, invalidate the backing variable instead. auto *expr = maybe_get(chain); if (expr && expr->loaded_from) var = maybe_get(expr->loaded_from); auto *access_chain = maybe_get(chain); if (access_chain && access_chain->loaded_from) var = maybe_get(access_chain->loaded_from); } auto &chain_type = expression_type(chain); if (var) { bool check_argument_storage_qualifier = true; auto &type = expression_type(chain); // If our variable is in a storage class which can alias with other buffers, // invalidate all variables which depend on aliased variables. And if this is a // variable pointer, then invalidate all variables regardless. if (get_variable_data_type(*var).pointer) { flush_all_active_variables(); if (type.pointer_depth == 1) { // We have a backing variable which is a pointer-to-pointer type. // We are storing some data through a pointer acquired through that variable, // but we are not writing to the value of the variable itself, // i.e., we are not modifying the pointer directly. // If we are storing a non-pointer type (pointer_depth == 1), // we know that we are storing some unrelated data. // A case here would be // void foo(Foo * const *arg) { // Foo *bar = *arg; // bar->unrelated = 42; // } // arg, the argument is constant. check_argument_storage_qualifier = false; } } if (type.storage == StorageClassPhysicalStorageBufferEXT || variable_storage_is_aliased(*var)) flush_all_aliased_variables(); else if (var) flush_dependees(*var); // We tried to write to a parameter which is not marked with out qualifier, force a recompile. if (check_argument_storage_qualifier && var->parameter && var->parameter->write_count == 0) { var->parameter->write_count++; force_recompile(); } } else if (chain_type.pointer) { // If we stored through a variable pointer, then we don't know which // variable we stored to. So *all* expressions after this point need to // be invalidated. // FIXME: If we can prove that the variable pointer will point to // only certain variables, we can invalidate only those. flush_all_active_variables(); } // If chain_type.pointer is false, we're not writing to memory backed variables, but temporaries instead. // This can happen in copy_logical_type where we unroll complex reads and writes to temporaries. } void Compiler::flush_dependees(SPIRVariable &var) { for (auto expr : var.dependees) invalid_expressions.insert(expr); var.dependees.clear(); } void Compiler::flush_all_aliased_variables() { for (auto aliased : aliased_variables) flush_dependees(get(aliased)); } void Compiler::flush_all_atomic_capable_variables() { for (auto global : global_variables) flush_dependees(get(global)); flush_all_aliased_variables(); } void Compiler::flush_control_dependent_expressions(uint32_t block_id) { auto &block = get(block_id); for (auto &expr : block.invalidate_expressions) invalid_expressions.insert(expr); block.invalidate_expressions.clear(); } void Compiler::flush_all_active_variables() { // Invalidate all temporaries we read from variables in this block since they were forwarded. // Invalidate all temporaries we read from globals. for (auto &v : current_function->local_variables) flush_dependees(get(v)); for (auto &arg : current_function->arguments) flush_dependees(get(arg.id)); for (auto global : global_variables) flush_dependees(get(global)); flush_all_aliased_variables(); } uint32_t Compiler::expression_type_id(uint32_t id) const { switch (ir.ids[id].get_type()) { case TypeVariable: return get(id).basetype; case TypeExpression: return get(id).expression_type; case TypeConstant: return get(id).constant_type; case TypeConstantOp: return get(id).basetype; case TypeUndef: return get(id).basetype; case TypeCombinedImageSampler: return get(id).combined_type; case TypeAccessChain: return get(id).basetype; default: SPIRV_CROSS_THROW("Cannot resolve expression type."); } } const SPIRType &Compiler::expression_type(uint32_t id) const { return get(expression_type_id(id)); } bool Compiler::expression_is_lvalue(uint32_t id) const { auto &type = expression_type(id); switch (type.basetype) { case SPIRType::SampledImage: case SPIRType::Image: case SPIRType::Sampler: return false; default: return true; } } bool Compiler::is_immutable(uint32_t id) const { if (ir.ids[id].get_type() == TypeVariable) { auto &var = get(id); // Anything we load from the UniformConstant address space is guaranteed to be immutable. bool pointer_to_const = var.storage == StorageClassUniformConstant; return pointer_to_const || var.phi_variable || !expression_is_lvalue(id); } else if (ir.ids[id].get_type() == TypeAccessChain) return get(id).immutable; else if (ir.ids[id].get_type() == TypeExpression) return get(id).immutable; else if (ir.ids[id].get_type() == TypeConstant || ir.ids[id].get_type() == TypeConstantOp || ir.ids[id].get_type() == TypeUndef) return true; else return false; } static inline bool storage_class_is_interface(spv::StorageClass storage) { switch (storage) { case StorageClassInput: case StorageClassOutput: case StorageClassUniform: case StorageClassUniformConstant: case StorageClassAtomicCounter: case StorageClassPushConstant: case StorageClassStorageBuffer: return true; default: return false; } } bool Compiler::is_hidden_variable(const SPIRVariable &var, bool include_builtins) const { if ((is_builtin_variable(var) && !include_builtins) || var.remapped_variable) return true; // Combined image samplers are always considered active as they are "magic" variables. if (find_if(begin(combined_image_samplers), end(combined_image_samplers), [&var](const CombinedImageSampler &samp) { return samp.combined_id == var.self; }) != end(combined_image_samplers)) { return false; } bool hidden = false; if (check_active_interface_variables && storage_class_is_interface(var.storage)) hidden = active_interface_variables.find(var.self) == end(active_interface_variables); return hidden; } bool Compiler::is_builtin_type(const SPIRType &type) const { auto *type_meta = ir.find_meta(type.self); // We can have builtin structs as well. If one member of a struct is builtin, the struct must also be builtin. if (type_meta) for (auto &m : type_meta->members) if (m.builtin) return true; return false; } bool Compiler::is_builtin_variable(const SPIRVariable &var) const { auto *m = ir.find_meta(var.self); if (var.compat_builtin || (m && m->decoration.builtin)) return true; else return is_builtin_type(get(var.basetype)); } bool Compiler::is_member_builtin(const SPIRType &type, uint32_t index, BuiltIn *builtin) const { auto *type_meta = ir.find_meta(type.self); if (type_meta) { auto &memb = type_meta->members; if (index < memb.size() && memb[index].builtin) { if (builtin) *builtin = memb[index].builtin_type; return true; } } return false; } bool Compiler::is_scalar(const SPIRType &type) const { return type.basetype != SPIRType::Struct && type.vecsize == 1 && type.columns == 1; } bool Compiler::is_vector(const SPIRType &type) const { return type.vecsize > 1 && type.columns == 1; } bool Compiler::is_matrix(const SPIRType &type) const { return type.vecsize > 1 && type.columns > 1; } bool Compiler::is_array(const SPIRType &type) const { return !type.array.empty(); } ShaderResources Compiler::get_shader_resources() const { return get_shader_resources(nullptr); } ShaderResources Compiler::get_shader_resources(const unordered_set &active_variables) const { return get_shader_resources(&active_variables); } bool Compiler::InterfaceVariableAccessHandler::handle(Op opcode, const uint32_t *args, uint32_t length) { uint32_t variable = 0; switch (opcode) { // Need this first, otherwise, GCC complains about unhandled switch statements. default: break; case OpFunctionCall: { // Invalid SPIR-V. if (length < 3) return false; uint32_t count = length - 3; args += 3; for (uint32_t i = 0; i < count; i++) { auto *var = compiler.maybe_get(args[i]); if (var && storage_class_is_interface(var->storage)) variables.insert(args[i]); } break; } case OpSelect: { // Invalid SPIR-V. if (length < 5) return false; uint32_t count = length - 3; args += 3; for (uint32_t i = 0; i < count; i++) { auto *var = compiler.maybe_get(args[i]); if (var && storage_class_is_interface(var->storage)) variables.insert(args[i]); } break; } case OpPhi: { // Invalid SPIR-V. if (length < 2) return false; uint32_t count = length - 2; args += 2; for (uint32_t i = 0; i < count; i += 2) { auto *var = compiler.maybe_get(args[i]); if (var && storage_class_is_interface(var->storage)) variables.insert(args[i]); } break; } case OpAtomicStore: case OpStore: // Invalid SPIR-V. if (length < 1) return false; variable = args[0]; break; case OpCopyMemory: { if (length < 2) return false; auto *var = compiler.maybe_get(args[0]); if (var && storage_class_is_interface(var->storage)) variables.insert(args[0]); var = compiler.maybe_get(args[1]); if (var && storage_class_is_interface(var->storage)) variables.insert(args[1]); break; } case OpExtInst: { if (length < 5) return false; auto &extension_set = compiler.get(args[2]); switch (extension_set.ext) { case SPIRExtension::GLSL: { auto op = static_cast(args[3]); switch (op) { case GLSLstd450InterpolateAtCentroid: case GLSLstd450InterpolateAtSample: case GLSLstd450InterpolateAtOffset: { auto *var = compiler.maybe_get(args[4]); if (var && storage_class_is_interface(var->storage)) variables.insert(args[4]); break; } default: break; } break; } case SPIRExtension::SPV_AMD_shader_explicit_vertex_parameter: { enum AMDShaderExplicitVertexParameter { InterpolateAtVertexAMD = 1 }; auto op = static_cast(args[3]); switch (op) { case InterpolateAtVertexAMD: { auto *var = compiler.maybe_get(args[4]); if (var && storage_class_is_interface(var->storage)) variables.insert(args[4]); break; } default: break; } break; } default: break; } break; } case OpAccessChain: case OpInBoundsAccessChain: case OpPtrAccessChain: case OpLoad: case OpCopyObject: case OpImageTexelPointer: case OpAtomicLoad: case OpAtomicExchange: case OpAtomicCompareExchange: case OpAtomicCompareExchangeWeak: case OpAtomicIIncrement: case OpAtomicIDecrement: case OpAtomicIAdd: case OpAtomicISub: case OpAtomicSMin: case OpAtomicUMin: case OpAtomicSMax: case OpAtomicUMax: case OpAtomicAnd: case OpAtomicOr: case OpAtomicXor: case OpArrayLength: // Invalid SPIR-V. if (length < 3) return false; variable = args[2]; break; } if (variable) { auto *var = compiler.maybe_get(variable); if (var && storage_class_is_interface(var->storage)) variables.insert(variable); } return true; } unordered_set Compiler::get_active_interface_variables() const { // Traverse the call graph and find all interface variables which are in use. unordered_set variables; InterfaceVariableAccessHandler handler(*this, variables); traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); ir.for_each_typed_id([&](uint32_t, const SPIRVariable &var) { if (var.storage != StorageClassOutput) return; if (!interface_variable_exists_in_entry_point(var.self)) return; // An output variable which is just declared (but uninitialized) might be read by subsequent stages // so we should force-enable these outputs, // since compilation will fail if a subsequent stage attempts to read from the variable in question. // Also, make sure we preserve output variables which are only initialized, but never accessed by any code. if (var.initializer != ID(0) || get_execution_model() != ExecutionModelFragment) variables.insert(var.self); }); // If we needed to create one, we'll need it. if (dummy_sampler_id) variables.insert(dummy_sampler_id); return variables; } void Compiler::set_enabled_interface_variables(std::unordered_set active_variables) { active_interface_variables = move(active_variables); check_active_interface_variables = true; } ShaderResources Compiler::get_shader_resources(const unordered_set *active_variables) const { ShaderResources res; bool ssbo_instance_name = reflection_ssbo_instance_name_is_significant(); ir.for_each_typed_id([&](uint32_t, const SPIRVariable &var) { auto &type = this->get(var.basetype); // It is possible for uniform storage classes to be passed as function parameters, so detect // that. To detect function parameters, check of StorageClass of variable is function scope. if (var.storage == StorageClassFunction || !type.pointer || is_builtin_variable(var)) return; if (active_variables && active_variables->find(var.self) == end(*active_variables)) return; // Input if (var.storage == StorageClassInput && interface_variable_exists_in_entry_point(var.self)) { if (has_decoration(type.self, DecorationBlock)) { res.stage_inputs.push_back( { var.self, var.basetype, type.self, get_remapped_declared_block_name(var.self, false) }); } else res.stage_inputs.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } // Subpass inputs else if (var.storage == StorageClassUniformConstant && type.image.dim == DimSubpassData) { res.subpass_inputs.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } // Outputs else if (var.storage == StorageClassOutput && interface_variable_exists_in_entry_point(var.self)) { if (has_decoration(type.self, DecorationBlock)) { res.stage_outputs.push_back( { var.self, var.basetype, type.self, get_remapped_declared_block_name(var.self, false) }); } else res.stage_outputs.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } // UBOs else if (type.storage == StorageClassUniform && has_decoration(type.self, DecorationBlock)) { res.uniform_buffers.push_back( { var.self, var.basetype, type.self, get_remapped_declared_block_name(var.self, false) }); } // Old way to declare SSBOs. else if (type.storage == StorageClassUniform && has_decoration(type.self, DecorationBufferBlock)) { res.storage_buffers.push_back( { var.self, var.basetype, type.self, get_remapped_declared_block_name(var.self, ssbo_instance_name) }); } // Modern way to declare SSBOs. else if (type.storage == StorageClassStorageBuffer) { res.storage_buffers.push_back( { var.self, var.basetype, type.self, get_remapped_declared_block_name(var.self, ssbo_instance_name) }); } // Push constant blocks else if (type.storage == StorageClassPushConstant) { // There can only be one push constant block, but keep the vector in case this restriction is lifted // in the future. res.push_constant_buffers.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } // Images else if (type.storage == StorageClassUniformConstant && type.basetype == SPIRType::Image && type.image.sampled == 2) { res.storage_images.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } // Separate images else if (type.storage == StorageClassUniformConstant && type.basetype == SPIRType::Image && type.image.sampled == 1) { res.separate_images.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } // Separate samplers else if (type.storage == StorageClassUniformConstant && type.basetype == SPIRType::Sampler) { res.separate_samplers.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } // Textures else if (type.storage == StorageClassUniformConstant && type.basetype == SPIRType::SampledImage) { res.sampled_images.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } // Atomic counters else if (type.storage == StorageClassAtomicCounter) { res.atomic_counters.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } // Acceleration structures else if (type.storage == StorageClassUniformConstant && type.basetype == SPIRType::AccelerationStructure) { res.acceleration_structures.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } }); return res; } bool Compiler::type_is_block_like(const SPIRType &type) const { if (type.basetype != SPIRType::Struct) return false; if (has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock)) { return true; } // Block-like types may have Offset decorations. for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++) if (has_member_decoration(type.self, i, DecorationOffset)) return true; return false; } void Compiler::parse_fixup() { // Figure out specialization constants for work group sizes. for (auto id_ : ir.ids_for_constant_or_variable) { auto &id = ir.ids[id_]; if (id.get_type() == TypeConstant) { auto &c = id.get(); if (ir.meta[c.self].decoration.builtin && ir.meta[c.self].decoration.builtin_type == BuiltInWorkgroupSize) { // In current SPIR-V, there can be just one constant like this. // All entry points will receive the constant value. for (auto &entry : ir.entry_points) { entry.second.workgroup_size.constant = c.self; entry.second.workgroup_size.x = c.scalar(0, 0); entry.second.workgroup_size.y = c.scalar(0, 1); entry.second.workgroup_size.z = c.scalar(0, 2); } } } else if (id.get_type() == TypeVariable) { auto &var = id.get(); if (var.storage == StorageClassPrivate || var.storage == StorageClassWorkgroup || var.storage == StorageClassOutput) global_variables.push_back(var.self); if (variable_storage_is_aliased(var)) aliased_variables.push_back(var.self); } } } void Compiler::update_name_cache(unordered_set &cache_primary, const unordered_set &cache_secondary, string &name) { if (name.empty()) return; const auto find_name = [&](const string &n) -> bool { if (cache_primary.find(n) != end(cache_primary)) return true; if (&cache_primary != &cache_secondary) if (cache_secondary.find(n) != end(cache_secondary)) return true; return false; }; const auto insert_name = [&](const string &n) { cache_primary.insert(n); }; if (!find_name(name)) { insert_name(name); return; } uint32_t counter = 0; auto tmpname = name; bool use_linked_underscore = true; if (tmpname == "_") { // We cannot just append numbers, as we will end up creating internally reserved names. // Make it like _0_ instead. tmpname += "0"; } else if (tmpname.back() == '_') { // The last_character is an underscore, so we don't need to link in underscore. // This would violate double underscore rules. use_linked_underscore = false; } // If there is a collision (very rare), // keep tacking on extra identifier until it's unique. do { counter++; name = tmpname + (use_linked_underscore ? "_" : "") + convert_to_string(counter); } while (find_name(name)); insert_name(name); } void Compiler::update_name_cache(unordered_set &cache, string &name) { update_name_cache(cache, cache, name); } void Compiler::set_name(ID id, const std::string &name) { ir.set_name(id, name); } const SPIRType &Compiler::get_type(TypeID id) const { return get(id); } const SPIRType &Compiler::get_type_from_variable(VariableID id) const { return get(get(id).basetype); } uint32_t Compiler::get_pointee_type_id(uint32_t type_id) const { auto *p_type = &get(type_id); if (p_type->pointer) { assert(p_type->parent_type); type_id = p_type->parent_type; } return type_id; } const SPIRType &Compiler::get_pointee_type(const SPIRType &type) const { auto *p_type = &type; if (p_type->pointer) { assert(p_type->parent_type); p_type = &get(p_type->parent_type); } return *p_type; } const SPIRType &Compiler::get_pointee_type(uint32_t type_id) const { return get_pointee_type(get(type_id)); } uint32_t Compiler::get_variable_data_type_id(const SPIRVariable &var) const { if (var.phi_variable) return var.basetype; return get_pointee_type_id(var.basetype); } SPIRType &Compiler::get_variable_data_type(const SPIRVariable &var) { return get(get_variable_data_type_id(var)); } const SPIRType &Compiler::get_variable_data_type(const SPIRVariable &var) const { return get(get_variable_data_type_id(var)); } SPIRType &Compiler::get_variable_element_type(const SPIRVariable &var) { SPIRType *type = &get_variable_data_type(var); if (is_array(*type)) type = &get(type->parent_type); return *type; } const SPIRType &Compiler::get_variable_element_type(const SPIRVariable &var) const { const SPIRType *type = &get_variable_data_type(var); if (is_array(*type)) type = &get(type->parent_type); return *type; } bool Compiler::is_sampled_image_type(const SPIRType &type) { return (type.basetype == SPIRType::Image || type.basetype == SPIRType::SampledImage) && type.image.sampled == 1 && type.image.dim != DimBuffer; } void Compiler::set_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration, const std::string &argument) { ir.set_member_decoration_string(id, index, decoration, argument); } void Compiler::set_member_decoration(TypeID id, uint32_t index, Decoration decoration, uint32_t argument) { ir.set_member_decoration(id, index, decoration, argument); } void Compiler::set_member_name(TypeID id, uint32_t index, const std::string &name) { ir.set_member_name(id, index, name); } const std::string &Compiler::get_member_name(TypeID id, uint32_t index) const { return ir.get_member_name(id, index); } void Compiler::set_qualified_name(uint32_t id, const string &name) { ir.meta[id].decoration.qualified_alias = name; } void Compiler::set_member_qualified_name(uint32_t type_id, uint32_t index, const std::string &name) { ir.meta[type_id].members.resize(max(ir.meta[type_id].members.size(), size_t(index) + 1)); ir.meta[type_id].members[index].qualified_alias = name; } const string &Compiler::get_member_qualified_name(TypeID type_id, uint32_t index) const { auto *m = ir.find_meta(type_id); if (m && index < m->members.size()) return m->members[index].qualified_alias; else return ir.get_empty_string(); } uint32_t Compiler::get_member_decoration(TypeID id, uint32_t index, Decoration decoration) const { return ir.get_member_decoration(id, index, decoration); } const Bitset &Compiler::get_member_decoration_bitset(TypeID id, uint32_t index) const { return ir.get_member_decoration_bitset(id, index); } bool Compiler::has_member_decoration(TypeID id, uint32_t index, Decoration decoration) const { return ir.has_member_decoration(id, index, decoration); } void Compiler::unset_member_decoration(TypeID id, uint32_t index, Decoration decoration) { ir.unset_member_decoration(id, index, decoration); } void Compiler::set_decoration_string(ID id, spv::Decoration decoration, const std::string &argument) { ir.set_decoration_string(id, decoration, argument); } void Compiler::set_decoration(ID id, Decoration decoration, uint32_t argument) { ir.set_decoration(id, decoration, argument); } void Compiler::set_extended_decoration(uint32_t id, ExtendedDecorations decoration, uint32_t value) { auto &dec = ir.meta[id].decoration; dec.extended.flags.set(decoration); dec.extended.values[decoration] = value; } void Compiler::set_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration, uint32_t value) { ir.meta[type].members.resize(max(ir.meta[type].members.size(), size_t(index) + 1)); auto &dec = ir.meta[type].members[index]; dec.extended.flags.set(decoration); dec.extended.values[decoration] = value; } static uint32_t get_default_extended_decoration(ExtendedDecorations decoration) { switch (decoration) { case SPIRVCrossDecorationResourceIndexPrimary: case SPIRVCrossDecorationResourceIndexSecondary: case SPIRVCrossDecorationResourceIndexTertiary: case SPIRVCrossDecorationResourceIndexQuaternary: case SPIRVCrossDecorationInterfaceMemberIndex: return ~(0u); default: return 0; } } uint32_t Compiler::get_extended_decoration(uint32_t id, ExtendedDecorations decoration) const { auto *m = ir.find_meta(id); if (!m) return 0; auto &dec = m->decoration; if (!dec.extended.flags.get(decoration)) return get_default_extended_decoration(decoration); return dec.extended.values[decoration]; } uint32_t Compiler::get_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) const { auto *m = ir.find_meta(type); if (!m) return 0; if (index >= m->members.size()) return 0; auto &dec = m->members[index]; if (!dec.extended.flags.get(decoration)) return get_default_extended_decoration(decoration); return dec.extended.values[decoration]; } bool Compiler::has_extended_decoration(uint32_t id, ExtendedDecorations decoration) const { auto *m = ir.find_meta(id); if (!m) return false; auto &dec = m->decoration; return dec.extended.flags.get(decoration); } bool Compiler::has_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) const { auto *m = ir.find_meta(type); if (!m) return false; if (index >= m->members.size()) return false; auto &dec = m->members[index]; return dec.extended.flags.get(decoration); } void Compiler::unset_extended_decoration(uint32_t id, ExtendedDecorations decoration) { auto &dec = ir.meta[id].decoration; dec.extended.flags.clear(decoration); dec.extended.values[decoration] = 0; } void Compiler::unset_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) { ir.meta[type].members.resize(max(ir.meta[type].members.size(), size_t(index) + 1)); auto &dec = ir.meta[type].members[index]; dec.extended.flags.clear(decoration); dec.extended.values[decoration] = 0; } StorageClass Compiler::get_storage_class(VariableID id) const { return get(id).storage; } const std::string &Compiler::get_name(ID id) const { return ir.get_name(id); } const std::string Compiler::get_fallback_name(ID id) const { return join("_", id); } const std::string Compiler::get_block_fallback_name(VariableID id) const { auto &var = get(id); if (get_name(id).empty()) return join("_", get(var.basetype).self, "_", id); else return get_name(id); } const Bitset &Compiler::get_decoration_bitset(ID id) const { return ir.get_decoration_bitset(id); } bool Compiler::has_decoration(ID id, Decoration decoration) const { return ir.has_decoration(id, decoration); } const string &Compiler::get_decoration_string(ID id, Decoration decoration) const { return ir.get_decoration_string(id, decoration); } const string &Compiler::get_member_decoration_string(TypeID id, uint32_t index, Decoration decoration) const { return ir.get_member_decoration_string(id, index, decoration); } uint32_t Compiler::get_decoration(ID id, Decoration decoration) const { return ir.get_decoration(id, decoration); } void Compiler::unset_decoration(ID id, Decoration decoration) { ir.unset_decoration(id, decoration); } bool Compiler::get_binary_offset_for_decoration(VariableID id, spv::Decoration decoration, uint32_t &word_offset) const { auto *m = ir.find_meta(id); if (!m) return false; auto &word_offsets = m->decoration_word_offset; auto itr = word_offsets.find(decoration); if (itr == end(word_offsets)) return false; word_offset = itr->second; return true; } bool Compiler::block_is_loop_candidate(const SPIRBlock &block, SPIRBlock::Method method) const { // Tried and failed. if (block.disable_block_optimization || block.complex_continue) return false; if (method == SPIRBlock::MergeToSelectForLoop || method == SPIRBlock::MergeToSelectContinueForLoop) { // Try to detect common for loop pattern // which the code backend can use to create cleaner code. // for(;;) { if (cond) { some_body; } else { break; } } // is the pattern we're looking for. const auto *false_block = maybe_get(block.false_block); const auto *true_block = maybe_get(block.true_block); const auto *merge_block = maybe_get(block.merge_block); bool false_block_is_merge = block.false_block == block.merge_block || (false_block && merge_block && execution_is_noop(*false_block, *merge_block)); bool true_block_is_merge = block.true_block == block.merge_block || (true_block && merge_block && execution_is_noop(*true_block, *merge_block)); bool positive_candidate = block.true_block != block.merge_block && block.true_block != block.self && false_block_is_merge; bool negative_candidate = block.false_block != block.merge_block && block.false_block != block.self && true_block_is_merge; bool ret = block.terminator == SPIRBlock::Select && block.merge == SPIRBlock::MergeLoop && (positive_candidate || negative_candidate); if (ret && positive_candidate && method == SPIRBlock::MergeToSelectContinueForLoop) ret = block.true_block == block.continue_block; else if (ret && negative_candidate && method == SPIRBlock::MergeToSelectContinueForLoop) ret = block.false_block == block.continue_block; // If we have OpPhi which depends on branches which came from our own block, // we need to flush phi variables in else block instead of a trivial break, // so we cannot assume this is a for loop candidate. if (ret) { for (auto &phi : block.phi_variables) if (phi.parent == block.self) return false; auto *merge = maybe_get(block.merge_block); if (merge) for (auto &phi : merge->phi_variables) if (phi.parent == block.self) return false; } return ret; } else if (method == SPIRBlock::MergeToDirectForLoop) { // Empty loop header that just sets up merge target // and branches to loop body. bool ret = block.terminator == SPIRBlock::Direct && block.merge == SPIRBlock::MergeLoop && block.ops.empty(); if (!ret) return false; auto &child = get(block.next_block); const auto *false_block = maybe_get(child.false_block); const auto *true_block = maybe_get(child.true_block); const auto *merge_block = maybe_get(block.merge_block); bool false_block_is_merge = child.false_block == block.merge_block || (false_block && merge_block && execution_is_noop(*false_block, *merge_block)); bool true_block_is_merge = child.true_block == block.merge_block || (true_block && merge_block && execution_is_noop(*true_block, *merge_block)); bool positive_candidate = child.true_block != block.merge_block && child.true_block != block.self && false_block_is_merge; bool negative_candidate = child.false_block != block.merge_block && child.false_block != block.self && true_block_is_merge; ret = child.terminator == SPIRBlock::Select && child.merge == SPIRBlock::MergeNone && (positive_candidate || negative_candidate); // If we have OpPhi which depends on branches which came from our own block, // we need to flush phi variables in else block instead of a trivial break, // so we cannot assume this is a for loop candidate. if (ret) { for (auto &phi : block.phi_variables) if (phi.parent == block.self || phi.parent == child.self) return false; for (auto &phi : child.phi_variables) if (phi.parent == block.self) return false; auto *merge = maybe_get(block.merge_block); if (merge) for (auto &phi : merge->phi_variables) if (phi.parent == block.self || phi.parent == child.false_block) return false; } return ret; } else return false; } bool Compiler::execution_is_noop(const SPIRBlock &from, const SPIRBlock &to) const { if (!execution_is_branchless(from, to)) return false; auto *start = &from; for (;;) { if (start->self == to.self) return true; if (!start->ops.empty()) return false; auto &next = get(start->next_block); // Flushing phi variables does not count as noop. for (auto &phi : next.phi_variables) if (phi.parent == start->self) return false; start = &next; } } bool Compiler::execution_is_branchless(const SPIRBlock &from, const SPIRBlock &to) const { auto *start = &from; for (;;) { if (start->self == to.self) return true; if (start->terminator == SPIRBlock::Direct && start->merge == SPIRBlock::MergeNone) start = &get(start->next_block); else return false; } } bool Compiler::execution_is_direct_branch(const SPIRBlock &from, const SPIRBlock &to) const { return from.terminator == SPIRBlock::Direct && from.merge == SPIRBlock::MergeNone && from.next_block == to.self; } SPIRBlock::ContinueBlockType Compiler::continue_block_type(const SPIRBlock &block) const { // The block was deemed too complex during code emit, pick conservative fallback paths. if (block.complex_continue) return SPIRBlock::ComplexLoop; // In older glslang output continue block can be equal to the loop header. // In this case, execution is clearly branchless, so just assume a while loop header here. if (block.merge == SPIRBlock::MergeLoop) return SPIRBlock::WhileLoop; if (block.loop_dominator == BlockID(SPIRBlock::NoDominator)) { // Continue block is never reached from CFG. return SPIRBlock::ComplexLoop; } auto &dominator = get(block.loop_dominator); if (execution_is_noop(block, dominator)) return SPIRBlock::WhileLoop; else if (execution_is_branchless(block, dominator)) return SPIRBlock::ForLoop; else { const auto *false_block = maybe_get(block.false_block); const auto *true_block = maybe_get(block.true_block); const auto *merge_block = maybe_get(dominator.merge_block); // If we need to flush Phi in this block, we cannot have a DoWhile loop. bool flush_phi_to_false = false_block && flush_phi_required(block.self, block.false_block); bool flush_phi_to_true = true_block && flush_phi_required(block.self, block.true_block); if (flush_phi_to_false || flush_phi_to_true) return SPIRBlock::ComplexLoop; bool positive_do_while = block.true_block == dominator.self && (block.false_block == dominator.merge_block || (false_block && merge_block && execution_is_noop(*false_block, *merge_block))); bool negative_do_while = block.false_block == dominator.self && (block.true_block == dominator.merge_block || (true_block && merge_block && execution_is_noop(*true_block, *merge_block))); if (block.merge == SPIRBlock::MergeNone && block.terminator == SPIRBlock::Select && (positive_do_while || negative_do_while)) { return SPIRBlock::DoWhileLoop; } else return SPIRBlock::ComplexLoop; } } bool Compiler::traverse_all_reachable_opcodes(const SPIRBlock &block, OpcodeHandler &handler) const { handler.set_current_block(block); handler.rearm_current_block(block); // Ideally, perhaps traverse the CFG instead of all blocks in order to eliminate dead blocks, // but this shouldn't be a problem in practice unless the SPIR-V is doing insane things like recursing // inside dead blocks ... for (auto &i : block.ops) { auto ops = stream(i); auto op = static_cast(i.op); if (!handler.handle(op, ops, i.length)) return false; if (op == OpFunctionCall) { auto &func = get(ops[2]); if (handler.follow_function_call(func)) { if (!handler.begin_function_scope(ops, i.length)) return false; if (!traverse_all_reachable_opcodes(get(ops[2]), handler)) return false; if (!handler.end_function_scope(ops, i.length)) return false; handler.rearm_current_block(block); } } } return true; } bool Compiler::traverse_all_reachable_opcodes(const SPIRFunction &func, OpcodeHandler &handler) const { for (auto block : func.blocks) if (!traverse_all_reachable_opcodes(get(block), handler)) return false; return true; } uint32_t Compiler::type_struct_member_offset(const SPIRType &type, uint32_t index) const { auto *type_meta = ir.find_meta(type.self); if (type_meta) { // Decoration must be set in valid SPIR-V, otherwise throw. auto &dec = type_meta->members[index]; if (dec.decoration_flags.get(DecorationOffset)) return dec.offset; else SPIRV_CROSS_THROW("Struct member does not have Offset set."); } else SPIRV_CROSS_THROW("Struct member does not have Offset set."); } uint32_t Compiler::type_struct_member_array_stride(const SPIRType &type, uint32_t index) const { auto *type_meta = ir.find_meta(type.member_types[index]); if (type_meta) { // Decoration must be set in valid SPIR-V, otherwise throw. // ArrayStride is part of the array type not OpMemberDecorate. auto &dec = type_meta->decoration; if (dec.decoration_flags.get(DecorationArrayStride)) return dec.array_stride; else SPIRV_CROSS_THROW("Struct member does not have ArrayStride set."); } else SPIRV_CROSS_THROW("Struct member does not have ArrayStride set."); } uint32_t Compiler::type_struct_member_matrix_stride(const SPIRType &type, uint32_t index) const { auto *type_meta = ir.find_meta(type.self); if (type_meta) { // Decoration must be set in valid SPIR-V, otherwise throw. // MatrixStride is part of OpMemberDecorate. auto &dec = type_meta->members[index]; if (dec.decoration_flags.get(DecorationMatrixStride)) return dec.matrix_stride; else SPIRV_CROSS_THROW("Struct member does not have MatrixStride set."); } else SPIRV_CROSS_THROW("Struct member does not have MatrixStride set."); } size_t Compiler::get_declared_struct_size(const SPIRType &type) const { if (type.member_types.empty()) SPIRV_CROSS_THROW("Declared struct in block cannot be empty."); uint32_t last = uint32_t(type.member_types.size() - 1); size_t offset = type_struct_member_offset(type, last); size_t size = get_declared_struct_member_size(type, last); return offset + size; } size_t Compiler::get_declared_struct_size_runtime_array(const SPIRType &type, size_t array_size) const { if (type.member_types.empty()) SPIRV_CROSS_THROW("Declared struct in block cannot be empty."); size_t size = get_declared_struct_size(type); auto &last_type = get(type.member_types.back()); if (!last_type.array.empty() && last_type.array_size_literal[0] && last_type.array[0] == 0) // Runtime array size += array_size * type_struct_member_array_stride(type, uint32_t(type.member_types.size() - 1)); return size; } uint32_t Compiler::evaluate_spec_constant_u32(const SPIRConstantOp &spec) const { auto &result_type = get(spec.basetype); if (result_type.basetype != SPIRType::UInt && result_type.basetype != SPIRType::Int && result_type.basetype != SPIRType::Boolean) { SPIRV_CROSS_THROW( "Only 32-bit integers and booleans are currently supported when evaluating specialization constants.\n"); } if (!is_scalar(result_type)) SPIRV_CROSS_THROW("Spec constant evaluation must be a scalar.\n"); uint32_t value = 0; const auto eval_u32 = [&](uint32_t id) -> uint32_t { auto &type = expression_type(id); if (type.basetype != SPIRType::UInt && type.basetype != SPIRType::Int && type.basetype != SPIRType::Boolean) { SPIRV_CROSS_THROW("Only 32-bit integers and booleans are currently supported when evaluating " "specialization constants.\n"); } if (!is_scalar(type)) SPIRV_CROSS_THROW("Spec constant evaluation must be a scalar.\n"); if (const auto *c = this->maybe_get(id)) return c->scalar(); else return evaluate_spec_constant_u32(this->get(id)); }; #define binary_spec_op(op, binary_op) \ case Op##op: \ value = eval_u32(spec.arguments[0]) binary_op eval_u32(spec.arguments[1]); \ break #define binary_spec_op_cast(op, binary_op, type) \ case Op##op: \ value = uint32_t(type(eval_u32(spec.arguments[0])) binary_op type(eval_u32(spec.arguments[1]))); \ break // Support the basic opcodes which are typically used when computing array sizes. switch (spec.opcode) { binary_spec_op(IAdd, +); binary_spec_op(ISub, -); binary_spec_op(IMul, *); binary_spec_op(BitwiseAnd, &); binary_spec_op(BitwiseOr, |); binary_spec_op(BitwiseXor, ^); binary_spec_op(LogicalAnd, &); binary_spec_op(LogicalOr, |); binary_spec_op(ShiftLeftLogical, <<); binary_spec_op(ShiftRightLogical, >>); binary_spec_op_cast(ShiftRightArithmetic, >>, int32_t); binary_spec_op(LogicalEqual, ==); binary_spec_op(LogicalNotEqual, !=); binary_spec_op(IEqual, ==); binary_spec_op(INotEqual, !=); binary_spec_op(ULessThan, <); binary_spec_op(ULessThanEqual, <=); binary_spec_op(UGreaterThan, >); binary_spec_op(UGreaterThanEqual, >=); binary_spec_op_cast(SLessThan, <, int32_t); binary_spec_op_cast(SLessThanEqual, <=, int32_t); binary_spec_op_cast(SGreaterThan, >, int32_t); binary_spec_op_cast(SGreaterThanEqual, >=, int32_t); #undef binary_spec_op #undef binary_spec_op_cast case OpLogicalNot: value = uint32_t(!eval_u32(spec.arguments[0])); break; case OpNot: value = ~eval_u32(spec.arguments[0]); break; case OpSNegate: value = uint32_t(-int32_t(eval_u32(spec.arguments[0]))); break; case OpSelect: value = eval_u32(spec.arguments[0]) ? eval_u32(spec.arguments[1]) : eval_u32(spec.arguments[2]); break; case OpUMod: { uint32_t a = eval_u32(spec.arguments[0]); uint32_t b = eval_u32(spec.arguments[1]); if (b == 0) SPIRV_CROSS_THROW("Undefined behavior in UMod, b == 0.\n"); value = a % b; break; } case OpSRem: { auto a = int32_t(eval_u32(spec.arguments[0])); auto b = int32_t(eval_u32(spec.arguments[1])); if (b == 0) SPIRV_CROSS_THROW("Undefined behavior in SRem, b == 0.\n"); value = a % b; break; } case OpSMod: { auto a = int32_t(eval_u32(spec.arguments[0])); auto b = int32_t(eval_u32(spec.arguments[1])); if (b == 0) SPIRV_CROSS_THROW("Undefined behavior in SMod, b == 0.\n"); auto v = a % b; // Makes sure we match the sign of b, not a. if ((b < 0 && v > 0) || (b > 0 && v < 0)) v += b; value = v; break; } case OpUDiv: { uint32_t a = eval_u32(spec.arguments[0]); uint32_t b = eval_u32(spec.arguments[1]); if (b == 0) SPIRV_CROSS_THROW("Undefined behavior in UDiv, b == 0.\n"); value = a / b; break; } case OpSDiv: { auto a = int32_t(eval_u32(spec.arguments[0])); auto b = int32_t(eval_u32(spec.arguments[1])); if (b == 0) SPIRV_CROSS_THROW("Undefined behavior in SDiv, b == 0.\n"); value = a / b; break; } default: SPIRV_CROSS_THROW("Unsupported spec constant opcode for evaluation.\n"); } return value; } uint32_t Compiler::evaluate_constant_u32(uint32_t id) const { if (const auto *c = maybe_get(id)) return c->scalar(); else return evaluate_spec_constant_u32(get(id)); } size_t Compiler::get_declared_struct_member_size(const SPIRType &struct_type, uint32_t index) const { if (struct_type.member_types.empty()) SPIRV_CROSS_THROW("Declared struct in block cannot be empty."); auto &flags = get_member_decoration_bitset(struct_type.self, index); auto &type = get(struct_type.member_types[index]); switch (type.basetype) { case SPIRType::Unknown: case SPIRType::Void: case SPIRType::Boolean: // Bools are purely logical, and cannot be used for externally visible types. case SPIRType::AtomicCounter: case SPIRType::Image: case SPIRType::SampledImage: case SPIRType::Sampler: SPIRV_CROSS_THROW("Querying size for object with opaque size."); default: break; } if (type.pointer && type.storage == StorageClassPhysicalStorageBuffer) { // Check if this is a top-level pointer type, and not an array of pointers. if (type.pointer_depth > get(type.parent_type).pointer_depth) return 8; } if (!type.array.empty()) { // For arrays, we can use ArrayStride to get an easy check. bool array_size_literal = type.array_size_literal.back(); uint32_t array_size = array_size_literal ? type.array.back() : evaluate_constant_u32(type.array.back()); return type_struct_member_array_stride(struct_type, index) * array_size; } else if (type.basetype == SPIRType::Struct) { return get_declared_struct_size(type); } else { unsigned vecsize = type.vecsize; unsigned columns = type.columns; // Vectors. if (columns == 1) { size_t component_size = type.width / 8; return vecsize * component_size; } else { uint32_t matrix_stride = type_struct_member_matrix_stride(struct_type, index); // Per SPIR-V spec, matrices must be tightly packed and aligned up for vec3 accesses. if (flags.get(DecorationRowMajor)) return matrix_stride * vecsize; else if (flags.get(DecorationColMajor)) return matrix_stride * columns; else SPIRV_CROSS_THROW("Either row-major or column-major must be declared for matrices."); } } } bool Compiler::BufferAccessHandler::handle(Op opcode, const uint32_t *args, uint32_t length) { if (opcode != OpAccessChain && opcode != OpInBoundsAccessChain && opcode != OpPtrAccessChain) return true; bool ptr_chain = (opcode == OpPtrAccessChain); // Invalid SPIR-V. if (length < (ptr_chain ? 5u : 4u)) return false; if (args[2] != id) return true; // Don't bother traversing the entire access chain tree yet. // If we access a struct member, assume we access the entire member. uint32_t index = compiler.get(args[ptr_chain ? 4 : 3]).scalar(); // Seen this index already. if (seen.find(index) != end(seen)) return true; seen.insert(index); auto &type = compiler.expression_type(id); uint32_t offset = compiler.type_struct_member_offset(type, index); size_t range; // If we have another member in the struct, deduce the range by looking at the next member. // This is okay since structs in SPIR-V can have padding, but Offset decoration must be // monotonically increasing. // Of course, this doesn't take into account if the SPIR-V for some reason decided to add // very large amounts of padding, but that's not really a big deal. if (index + 1 < type.member_types.size()) { range = compiler.type_struct_member_offset(type, index + 1) - offset; } else { // No padding, so just deduce it from the size of the member directly. range = compiler.get_declared_struct_member_size(type, index); } ranges.push_back({ index, offset, range }); return true; } SmallVector Compiler::get_active_buffer_ranges(VariableID id) const { SmallVector ranges; BufferAccessHandler handler(*this, ranges, id); traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); return ranges; } bool Compiler::types_are_logically_equivalent(const SPIRType &a, const SPIRType &b) const { if (a.basetype != b.basetype) return false; if (a.width != b.width) return false; if (a.vecsize != b.vecsize) return false; if (a.columns != b.columns) return false; if (a.array.size() != b.array.size()) return false; size_t array_count = a.array.size(); if (array_count && memcmp(a.array.data(), b.array.data(), array_count * sizeof(uint32_t)) != 0) return false; if (a.basetype == SPIRType::Image || a.basetype == SPIRType::SampledImage) { if (memcmp(&a.image, &b.image, sizeof(SPIRType::Image)) != 0) return false; } if (a.member_types.size() != b.member_types.size()) return false; size_t member_types = a.member_types.size(); for (size_t i = 0; i < member_types; i++) { if (!types_are_logically_equivalent(get(a.member_types[i]), get(b.member_types[i]))) return false; } return true; } const Bitset &Compiler::get_execution_mode_bitset() const { return get_entry_point().flags; } void Compiler::set_execution_mode(ExecutionMode mode, uint32_t arg0, uint32_t arg1, uint32_t arg2) { auto &execution = get_entry_point(); execution.flags.set(mode); switch (mode) { case ExecutionModeLocalSize: execution.workgroup_size.x = arg0; execution.workgroup_size.y = arg1; execution.workgroup_size.z = arg2; break; case ExecutionModeInvocations: execution.invocations = arg0; break; case ExecutionModeOutputVertices: execution.output_vertices = arg0; break; default: break; } } void Compiler::unset_execution_mode(ExecutionMode mode) { auto &execution = get_entry_point(); execution.flags.clear(mode); } uint32_t Compiler::get_work_group_size_specialization_constants(SpecializationConstant &x, SpecializationConstant &y, SpecializationConstant &z) const { auto &execution = get_entry_point(); x = { 0, 0 }; y = { 0, 0 }; z = { 0, 0 }; if (execution.workgroup_size.constant != 0) { auto &c = get(execution.workgroup_size.constant); if (c.m.c[0].id[0] != ID(0)) { x.id = c.m.c[0].id[0]; x.constant_id = get_decoration(c.m.c[0].id[0], DecorationSpecId); } if (c.m.c[0].id[1] != ID(0)) { y.id = c.m.c[0].id[1]; y.constant_id = get_decoration(c.m.c[0].id[1], DecorationSpecId); } if (c.m.c[0].id[2] != ID(0)) { z.id = c.m.c[0].id[2]; z.constant_id = get_decoration(c.m.c[0].id[2], DecorationSpecId); } } return execution.workgroup_size.constant; } uint32_t Compiler::get_execution_mode_argument(spv::ExecutionMode mode, uint32_t index) const { auto &execution = get_entry_point(); switch (mode) { case ExecutionModeLocalSize: switch (index) { case 0: return execution.workgroup_size.x; case 1: return execution.workgroup_size.y; case 2: return execution.workgroup_size.z; default: return 0; } case ExecutionModeInvocations: return execution.invocations; case ExecutionModeOutputVertices: return execution.output_vertices; default: return 0; } } ExecutionModel Compiler::get_execution_model() const { auto &execution = get_entry_point(); return execution.model; } bool Compiler::is_tessellation_shader(ExecutionModel model) { return model == ExecutionModelTessellationControl || model == ExecutionModelTessellationEvaluation; } bool Compiler::is_vertex_like_shader() const { auto model = get_execution_model(); return model == ExecutionModelVertex || model == ExecutionModelGeometry || model == ExecutionModelTessellationControl || model == ExecutionModelTessellationEvaluation; } bool Compiler::is_tessellation_shader() const { return is_tessellation_shader(get_execution_model()); } void Compiler::set_remapped_variable_state(VariableID id, bool remap_enable) { get(id).remapped_variable = remap_enable; } bool Compiler::get_remapped_variable_state(VariableID id) const { return get(id).remapped_variable; } void Compiler::set_subpass_input_remapped_components(VariableID id, uint32_t components) { get(id).remapped_components = components; } uint32_t Compiler::get_subpass_input_remapped_components(VariableID id) const { return get(id).remapped_components; } void Compiler::add_implied_read_expression(SPIRExpression &e, uint32_t source) { auto itr = find(begin(e.implied_read_expressions), end(e.implied_read_expressions), ID(source)); if (itr == end(e.implied_read_expressions)) e.implied_read_expressions.push_back(source); } void Compiler::add_implied_read_expression(SPIRAccessChain &e, uint32_t source) { auto itr = find(begin(e.implied_read_expressions), end(e.implied_read_expressions), ID(source)); if (itr == end(e.implied_read_expressions)) e.implied_read_expressions.push_back(source); } void Compiler::inherit_expression_dependencies(uint32_t dst, uint32_t source_expression) { // Don't inherit any expression dependencies if the expression in dst // is not a forwarded temporary. if (forwarded_temporaries.find(dst) == end(forwarded_temporaries) || forced_temporaries.find(dst) != end(forced_temporaries)) { return; } auto &e = get(dst); auto *phi = maybe_get(source_expression); if (phi && phi->phi_variable) { // We have used a phi variable, which can change at the end of the block, // so make sure we take a dependency on this phi variable. phi->dependees.push_back(dst); } auto *s = maybe_get(source_expression); if (!s) return; auto &e_deps = e.expression_dependencies; auto &s_deps = s->expression_dependencies; // If we depend on a expression, we also depend on all sub-dependencies from source. e_deps.push_back(source_expression); e_deps.insert(end(e_deps), begin(s_deps), end(s_deps)); // Eliminate duplicated dependencies. sort(begin(e_deps), end(e_deps)); e_deps.erase(unique(begin(e_deps), end(e_deps)), end(e_deps)); } SmallVector Compiler::get_entry_points_and_stages() const { SmallVector entries; for (auto &entry : ir.entry_points) entries.push_back({ entry.second.orig_name, entry.second.model }); return entries; } void Compiler::rename_entry_point(const std::string &old_name, const std::string &new_name, spv::ExecutionModel model) { auto &entry = get_entry_point(old_name, model); entry.orig_name = new_name; entry.name = new_name; } void Compiler::set_entry_point(const std::string &name, spv::ExecutionModel model) { auto &entry = get_entry_point(name, model); ir.default_entry_point = entry.self; } SPIREntryPoint &Compiler::get_first_entry_point(const std::string &name) { auto itr = find_if( begin(ir.entry_points), end(ir.entry_points), [&](const std::pair &entry) -> bool { return entry.second.orig_name == name; }); if (itr == end(ir.entry_points)) SPIRV_CROSS_THROW("Entry point does not exist."); return itr->second; } const SPIREntryPoint &Compiler::get_first_entry_point(const std::string &name) const { auto itr = find_if( begin(ir.entry_points), end(ir.entry_points), [&](const std::pair &entry) -> bool { return entry.second.orig_name == name; }); if (itr == end(ir.entry_points)) SPIRV_CROSS_THROW("Entry point does not exist."); return itr->second; } SPIREntryPoint &Compiler::get_entry_point(const std::string &name, ExecutionModel model) { auto itr = find_if(begin(ir.entry_points), end(ir.entry_points), [&](const std::pair &entry) -> bool { return entry.second.orig_name == name && entry.second.model == model; }); if (itr == end(ir.entry_points)) SPIRV_CROSS_THROW("Entry point does not exist."); return itr->second; } const SPIREntryPoint &Compiler::get_entry_point(const std::string &name, ExecutionModel model) const { auto itr = find_if(begin(ir.entry_points), end(ir.entry_points), [&](const std::pair &entry) -> bool { return entry.second.orig_name == name && entry.second.model == model; }); if (itr == end(ir.entry_points)) SPIRV_CROSS_THROW("Entry point does not exist."); return itr->second; } const string &Compiler::get_cleansed_entry_point_name(const std::string &name, ExecutionModel model) const { return get_entry_point(name, model).name; } const SPIREntryPoint &Compiler::get_entry_point() const { return ir.entry_points.find(ir.default_entry_point)->second; } SPIREntryPoint &Compiler::get_entry_point() { return ir.entry_points.find(ir.default_entry_point)->second; } bool Compiler::interface_variable_exists_in_entry_point(uint32_t id) const { auto &var = get(id); if (ir.get_spirv_version() < 0x10400) { if (var.storage != StorageClassInput && var.storage != StorageClassOutput && var.storage != StorageClassUniformConstant) SPIRV_CROSS_THROW("Only Input, Output variables and Uniform constants are part of a shader linking interface."); // This is to avoid potential problems with very old glslang versions which did // not emit input/output interfaces properly. // We can assume they only had a single entry point, and single entry point // shaders could easily be assumed to use every interface variable anyways. if (ir.entry_points.size() <= 1) return true; } // In SPIR-V 1.4 and later, all global resource variables must be present. auto &execution = get_entry_point(); return find(begin(execution.interface_variables), end(execution.interface_variables), VariableID(id)) != end(execution.interface_variables); } void Compiler::CombinedImageSamplerHandler::push_remap_parameters(const SPIRFunction &func, const uint32_t *args, uint32_t length) { // If possible, pipe through a remapping table so that parameters know // which variables they actually bind to in this scope. unordered_map remapping; for (uint32_t i = 0; i < length; i++) remapping[func.arguments[i].id] = remap_parameter(args[i]); parameter_remapping.push(move(remapping)); } void Compiler::CombinedImageSamplerHandler::pop_remap_parameters() { parameter_remapping.pop(); } uint32_t Compiler::CombinedImageSamplerHandler::remap_parameter(uint32_t id) { auto *var = compiler.maybe_get_backing_variable(id); if (var) id = var->self; if (parameter_remapping.empty()) return id; auto &remapping = parameter_remapping.top(); auto itr = remapping.find(id); if (itr != end(remapping)) return itr->second; else return id; } bool Compiler::CombinedImageSamplerHandler::begin_function_scope(const uint32_t *args, uint32_t length) { if (length < 3) return false; auto &callee = compiler.get(args[2]); args += 3; length -= 3; push_remap_parameters(callee, args, length); functions.push(&callee); return true; } bool Compiler::CombinedImageSamplerHandler::end_function_scope(const uint32_t *args, uint32_t length) { if (length < 3) return false; auto &callee = compiler.get(args[2]); args += 3; // There are two types of cases we have to handle, // a callee might call sampler2D(texture2D, sampler) directly where // one or more parameters originate from parameters. // Alternatively, we need to provide combined image samplers to our callees, // and in this case we need to add those as well. pop_remap_parameters(); // Our callee has now been processed at least once. // No point in doing it again. callee.do_combined_parameters = false; auto ¶ms = functions.top()->combined_parameters; functions.pop(); if (functions.empty()) return true; auto &caller = *functions.top(); if (caller.do_combined_parameters) { for (auto ¶m : params) { VariableID image_id = param.global_image ? param.image_id : VariableID(args[param.image_id]); VariableID sampler_id = param.global_sampler ? param.sampler_id : VariableID(args[param.sampler_id]); auto *i = compiler.maybe_get_backing_variable(image_id); auto *s = compiler.maybe_get_backing_variable(sampler_id); if (i) image_id = i->self; if (s) sampler_id = s->self; register_combined_image_sampler(caller, 0, image_id, sampler_id, param.depth); } } return true; } void Compiler::CombinedImageSamplerHandler::register_combined_image_sampler(SPIRFunction &caller, VariableID combined_module_id, VariableID image_id, VariableID sampler_id, bool depth) { // We now have a texture ID and a sampler ID which will either be found as a global // or a parameter in our own function. If both are global, they will not need a parameter, // otherwise, add it to our list. SPIRFunction::CombinedImageSamplerParameter param = { 0u, image_id, sampler_id, true, true, depth, }; auto texture_itr = find_if(begin(caller.arguments), end(caller.arguments), [image_id](const SPIRFunction::Parameter &p) { return p.id == image_id; }); auto sampler_itr = find_if(begin(caller.arguments), end(caller.arguments), [sampler_id](const SPIRFunction::Parameter &p) { return p.id == sampler_id; }); if (texture_itr != end(caller.arguments)) { param.global_image = false; param.image_id = uint32_t(texture_itr - begin(caller.arguments)); } if (sampler_itr != end(caller.arguments)) { param.global_sampler = false; param.sampler_id = uint32_t(sampler_itr - begin(caller.arguments)); } if (param.global_image && param.global_sampler) return; auto itr = find_if(begin(caller.combined_parameters), end(caller.combined_parameters), [¶m](const SPIRFunction::CombinedImageSamplerParameter &p) { return param.image_id == p.image_id && param.sampler_id == p.sampler_id && param.global_image == p.global_image && param.global_sampler == p.global_sampler; }); if (itr == end(caller.combined_parameters)) { uint32_t id = compiler.ir.increase_bound_by(3); auto type_id = id + 0; auto ptr_type_id = id + 1; auto combined_id = id + 2; auto &base = compiler.expression_type(image_id); auto &type = compiler.set(type_id); auto &ptr_type = compiler.set(ptr_type_id); type = base; type.self = type_id; type.basetype = SPIRType::SampledImage; type.pointer = false; type.storage = StorageClassGeneric; type.image.depth = depth; ptr_type = type; ptr_type.pointer = true; ptr_type.storage = StorageClassUniformConstant; ptr_type.parent_type = type_id; // Build new variable. compiler.set(combined_id, ptr_type_id, StorageClassFunction, 0); // Inherit RelaxedPrecision. // If any of OpSampledImage, underlying image or sampler are marked, inherit the decoration. bool relaxed_precision = compiler.has_decoration(sampler_id, DecorationRelaxedPrecision) || compiler.has_decoration(image_id, DecorationRelaxedPrecision) || (combined_module_id && compiler.has_decoration(combined_module_id, DecorationRelaxedPrecision)); if (relaxed_precision) compiler.set_decoration(combined_id, DecorationRelaxedPrecision); param.id = combined_id; compiler.set_name(combined_id, join("SPIRV_Cross_Combined", compiler.to_name(image_id), compiler.to_name(sampler_id))); caller.combined_parameters.push_back(param); caller.shadow_arguments.push_back({ ptr_type_id, combined_id, 0u, 0u, true }); } } bool Compiler::DummySamplerForCombinedImageHandler::handle(Op opcode, const uint32_t *args, uint32_t length) { if (need_dummy_sampler) { // No need to traverse further, we know the result. return false; } switch (opcode) { case OpLoad: { if (length < 3) return false; uint32_t result_type = args[0]; auto &type = compiler.get(result_type); bool separate_image = type.basetype == SPIRType::Image && type.image.sampled == 1 && type.image.dim != DimBuffer; // If not separate image, don't bother. if (!separate_image) return true; uint32_t id = args[1]; uint32_t ptr = args[2]; compiler.set(id, "", result_type, true); compiler.register_read(id, ptr, true); break; } case OpImageFetch: case OpImageQuerySizeLod: case OpImageQuerySize: case OpImageQueryLevels: case OpImageQuerySamples: { // If we are fetching or querying LOD from a plain OpTypeImage, we must pre-combine with our dummy sampler. auto *var = compiler.maybe_get_backing_variable(args[2]); if (var) { auto &type = compiler.get(var->basetype); if (type.basetype == SPIRType::Image && type.image.sampled == 1 && type.image.dim != DimBuffer) need_dummy_sampler = true; } break; } case OpInBoundsAccessChain: case OpAccessChain: case OpPtrAccessChain: { if (length < 3) return false; uint32_t result_type = args[0]; auto &type = compiler.get(result_type); bool separate_image = type.basetype == SPIRType::Image && type.image.sampled == 1 && type.image.dim != DimBuffer; if (!separate_image) return true; uint32_t id = args[1]; uint32_t ptr = args[2]; compiler.set(id, "", result_type, true); compiler.register_read(id, ptr, true); // Other backends might use SPIRAccessChain for this later. compiler.ir.ids[id].set_allow_type_rewrite(); break; } default: break; } return true; } bool Compiler::CombinedImageSamplerHandler::handle(Op opcode, const uint32_t *args, uint32_t length) { // We need to figure out where samplers and images are loaded from, so do only the bare bones compilation we need. bool is_fetch = false; switch (opcode) { case OpLoad: { if (length < 3) return false; uint32_t result_type = args[0]; auto &type = compiler.get(result_type); bool separate_image = type.basetype == SPIRType::Image && type.image.sampled == 1; bool separate_sampler = type.basetype == SPIRType::Sampler; // If not separate image or sampler, don't bother. if (!separate_image && !separate_sampler) return true; uint32_t id = args[1]; uint32_t ptr = args[2]; compiler.set(id, "", result_type, true); compiler.register_read(id, ptr, true); return true; } case OpInBoundsAccessChain: case OpAccessChain: case OpPtrAccessChain: { if (length < 3) return false; // Technically, it is possible to have arrays of textures and arrays of samplers and combine them, but this becomes essentially // impossible to implement, since we don't know which concrete sampler we are accessing. // One potential way is to create a combinatorial explosion where N textures and M samplers are combined into N * M sampler2Ds, // but this seems ridiculously complicated for a problem which is easy to work around. // Checking access chains like this assumes we don't have samplers or textures inside uniform structs, but this makes no sense. uint32_t result_type = args[0]; auto &type = compiler.get(result_type); bool separate_image = type.basetype == SPIRType::Image && type.image.sampled == 1; bool separate_sampler = type.basetype == SPIRType::Sampler; if (separate_sampler) SPIRV_CROSS_THROW( "Attempting to use arrays or structs of separate samplers. This is not possible to statically " "remap to plain GLSL."); if (separate_image) { uint32_t id = args[1]; uint32_t ptr = args[2]; compiler.set(id, "", result_type, true); compiler.register_read(id, ptr, true); } return true; } case OpImageFetch: case OpImageQuerySizeLod: case OpImageQuerySize: case OpImageQueryLevels: case OpImageQuerySamples: { // If we are fetching from a plain OpTypeImage or querying LOD, we must pre-combine with our dummy sampler. auto *var = compiler.maybe_get_backing_variable(args[2]); if (!var) return true; auto &type = compiler.get(var->basetype); if (type.basetype == SPIRType::Image && type.image.sampled == 1 && type.image.dim != DimBuffer) { if (compiler.dummy_sampler_id == 0) SPIRV_CROSS_THROW("texelFetch without sampler was found, but no dummy sampler has been created with " "build_dummy_sampler_for_combined_images()."); // Do it outside. is_fetch = true; break; } return true; } case OpSampledImage: // Do it outside. break; default: return true; } // Registers sampler2D calls used in case they are parameters so // that their callees know which combined image samplers to propagate down the call stack. if (!functions.empty()) { auto &callee = *functions.top(); if (callee.do_combined_parameters) { uint32_t image_id = args[2]; auto *image = compiler.maybe_get_backing_variable(image_id); if (image) image_id = image->self; uint32_t sampler_id = is_fetch ? compiler.dummy_sampler_id : args[3]; auto *sampler = compiler.maybe_get_backing_variable(sampler_id); if (sampler) sampler_id = sampler->self; uint32_t combined_id = args[1]; auto &combined_type = compiler.get(args[0]); register_combined_image_sampler(callee, combined_id, image_id, sampler_id, combined_type.image.depth); } } // For function calls, we need to remap IDs which are function parameters into global variables. // This information is statically known from the current place in the call stack. // Function parameters are not necessarily pointers, so if we don't have a backing variable, remapping will know // which backing variable the image/sample came from. VariableID image_id = remap_parameter(args[2]); VariableID sampler_id = is_fetch ? compiler.dummy_sampler_id : remap_parameter(args[3]); auto itr = find_if(begin(compiler.combined_image_samplers), end(compiler.combined_image_samplers), [image_id, sampler_id](const CombinedImageSampler &combined) { return combined.image_id == image_id && combined.sampler_id == sampler_id; }); if (itr == end(compiler.combined_image_samplers)) { uint32_t sampled_type; uint32_t combined_module_id; if (is_fetch) { // Have to invent the sampled image type. sampled_type = compiler.ir.increase_bound_by(1); auto &type = compiler.set(sampled_type); type = compiler.expression_type(args[2]); type.self = sampled_type; type.basetype = SPIRType::SampledImage; type.image.depth = false; combined_module_id = 0; } else { sampled_type = args[0]; combined_module_id = args[1]; } auto id = compiler.ir.increase_bound_by(2); auto type_id = id + 0; auto combined_id = id + 1; // Make a new type, pointer to OpTypeSampledImage, so we can make a variable of this type. // We will probably have this type lying around, but it doesn't hurt to make duplicates for internal purposes. auto &type = compiler.set(type_id); auto &base = compiler.get(sampled_type); type = base; type.pointer = true; type.storage = StorageClassUniformConstant; type.parent_type = type_id; // Build new variable. compiler.set(combined_id, type_id, StorageClassUniformConstant, 0); // Inherit RelaxedPrecision (and potentially other useful flags if deemed relevant). // If any of OpSampledImage, underlying image or sampler are marked, inherit the decoration. bool relaxed_precision = (sampler_id && compiler.has_decoration(sampler_id, DecorationRelaxedPrecision)) || (image_id && compiler.has_decoration(image_id, DecorationRelaxedPrecision)) || (combined_module_id && compiler.has_decoration(combined_module_id, DecorationRelaxedPrecision)); if (relaxed_precision) compiler.set_decoration(combined_id, DecorationRelaxedPrecision); // Propagate the array type for the original image as well. auto *var = compiler.maybe_get_backing_variable(image_id); if (var) { auto &parent_type = compiler.get(var->basetype); type.array = parent_type.array; type.array_size_literal = parent_type.array_size_literal; } compiler.combined_image_samplers.push_back({ combined_id, image_id, sampler_id }); } return true; } VariableID Compiler::build_dummy_sampler_for_combined_images() { DummySamplerForCombinedImageHandler handler(*this); traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); if (handler.need_dummy_sampler) { uint32_t offset = ir.increase_bound_by(3); auto type_id = offset + 0; auto ptr_type_id = offset + 1; auto var_id = offset + 2; SPIRType sampler_type; auto &sampler = set(type_id); sampler.basetype = SPIRType::Sampler; auto &ptr_sampler = set(ptr_type_id); ptr_sampler = sampler; ptr_sampler.self = type_id; ptr_sampler.storage = StorageClassUniformConstant; ptr_sampler.pointer = true; ptr_sampler.parent_type = type_id; set(var_id, ptr_type_id, StorageClassUniformConstant, 0); set_name(var_id, "SPIRV_Cross_DummySampler"); dummy_sampler_id = var_id; return var_id; } else return 0; } void Compiler::build_combined_image_samplers() { ir.for_each_typed_id([&](uint32_t, SPIRFunction &func) { func.combined_parameters.clear(); func.shadow_arguments.clear(); func.do_combined_parameters = true; }); combined_image_samplers.clear(); CombinedImageSamplerHandler handler(*this); traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); } SmallVector Compiler::get_specialization_constants() const { SmallVector spec_consts; ir.for_each_typed_id([&](uint32_t, const SPIRConstant &c) { if (c.specialization && has_decoration(c.self, DecorationSpecId)) spec_consts.push_back({ c.self, get_decoration(c.self, DecorationSpecId) }); }); return spec_consts; } SPIRConstant &Compiler::get_constant(ConstantID id) { return get(id); } const SPIRConstant &Compiler::get_constant(ConstantID id) const { return get(id); } static bool exists_unaccessed_path_to_return(const CFG &cfg, uint32_t block, const unordered_set &blocks, unordered_set &visit_cache) { // This block accesses the variable. if (blocks.find(block) != end(blocks)) return false; // We are at the end of the CFG. if (cfg.get_succeeding_edges(block).empty()) return true; // If any of our successors have a path to the end, there exists a path from block. for (auto &succ : cfg.get_succeeding_edges(block)) { if (visit_cache.count(succ) == 0) { if (exists_unaccessed_path_to_return(cfg, succ, blocks, visit_cache)) return true; visit_cache.insert(succ); } } return false; } void Compiler::analyze_parameter_preservation( SPIRFunction &entry, const CFG &cfg, const unordered_map> &variable_to_blocks, const unordered_map> &complete_write_blocks) { for (auto &arg : entry.arguments) { // Non-pointers are always inputs. auto &type = get(arg.type); if (!type.pointer) continue; // Opaque argument types are always in bool potential_preserve; switch (type.basetype) { case SPIRType::Sampler: case SPIRType::Image: case SPIRType::SampledImage: case SPIRType::AtomicCounter: potential_preserve = false; break; default: potential_preserve = true; break; } if (!potential_preserve) continue; auto itr = variable_to_blocks.find(arg.id); if (itr == end(variable_to_blocks)) { // Variable is never accessed. continue; } // We have accessed a variable, but there was no complete writes to that variable. // We deduce that we must preserve the argument. itr = complete_write_blocks.find(arg.id); if (itr == end(complete_write_blocks)) { arg.read_count++; continue; } // If there is a path through the CFG where no block completely writes to the variable, the variable will be in an undefined state // when the function returns. We therefore need to implicitly preserve the variable in case there are writers in the function. // Major case here is if a function is // void foo(int &var) { if (cond) var = 10; } // Using read/write counts, we will think it's just an out variable, but it really needs to be inout, // because if we don't write anything whatever we put into the function must return back to the caller. unordered_set visit_cache; if (exists_unaccessed_path_to_return(cfg, entry.entry_block, itr->second, visit_cache)) arg.read_count++; } } Compiler::AnalyzeVariableScopeAccessHandler::AnalyzeVariableScopeAccessHandler(Compiler &compiler_, SPIRFunction &entry_) : compiler(compiler_) , entry(entry_) { } bool Compiler::AnalyzeVariableScopeAccessHandler::follow_function_call(const SPIRFunction &) { // Only analyze within this function. return false; } void Compiler::AnalyzeVariableScopeAccessHandler::set_current_block(const SPIRBlock &block) { current_block = █ // If we're branching to a block which uses OpPhi, in GLSL // this will be a variable write when we branch, // so we need to track access to these variables as well to // have a complete picture. const auto test_phi = [this, &block](uint32_t to) { auto &next = compiler.get(to); for (auto &phi : next.phi_variables) { if (phi.parent == block.self) { accessed_variables_to_block[phi.function_variable].insert(block.self); // Phi variables are also accessed in our target branch block. accessed_variables_to_block[phi.function_variable].insert(next.self); notify_variable_access(phi.local_variable, block.self); } } }; switch (block.terminator) { case SPIRBlock::Direct: notify_variable_access(block.condition, block.self); test_phi(block.next_block); break; case SPIRBlock::Select: notify_variable_access(block.condition, block.self); test_phi(block.true_block); test_phi(block.false_block); break; case SPIRBlock::MultiSelect: notify_variable_access(block.condition, block.self); for (auto &target : block.cases) test_phi(target.block); if (block.default_block) test_phi(block.default_block); break; default: break; } } void Compiler::AnalyzeVariableScopeAccessHandler::notify_variable_access(uint32_t id, uint32_t block) { if (id == 0) return; // Access chains used in multiple blocks mean hoisting all the variables used to construct the access chain as not all backends can use pointers. auto itr = access_chain_children.find(id); if (itr != end(access_chain_children)) for (auto child_id : itr->second) notify_variable_access(child_id, block); if (id_is_phi_variable(id)) accessed_variables_to_block[id].insert(block); else if (id_is_potential_temporary(id)) accessed_temporaries_to_block[id].insert(block); } bool Compiler::AnalyzeVariableScopeAccessHandler::id_is_phi_variable(uint32_t id) const { if (id >= compiler.get_current_id_bound()) return false; auto *var = compiler.maybe_get(id); return var && var->phi_variable; } bool Compiler::AnalyzeVariableScopeAccessHandler::id_is_potential_temporary(uint32_t id) const { if (id >= compiler.get_current_id_bound()) return false; // Temporaries are not created before we start emitting code. return compiler.ir.ids[id].empty() || (compiler.ir.ids[id].get_type() == TypeExpression); } bool Compiler::AnalyzeVariableScopeAccessHandler::handle(spv::Op op, const uint32_t *args, uint32_t length) { // Keep track of the types of temporaries, so we can hoist them out as necessary. uint32_t result_type, result_id; if (compiler.instruction_to_result_type(result_type, result_id, op, args, length)) result_id_to_type[result_id] = result_type; switch (op) { case OpStore: { if (length < 2) return false; ID ptr = args[0]; auto *var = compiler.maybe_get_backing_variable(ptr); // If we store through an access chain, we have a partial write. if (var) { accessed_variables_to_block[var->self].insert(current_block->self); if (var->self == ptr) complete_write_variables_to_block[var->self].insert(current_block->self); else partial_write_variables_to_block[var->self].insert(current_block->self); } // args[0] might be an access chain we have to track use of. notify_variable_access(args[0], current_block->self); // Might try to store a Phi variable here. notify_variable_access(args[1], current_block->self); break; } case OpAccessChain: case OpInBoundsAccessChain: case OpPtrAccessChain: { if (length < 3) return false; // Access chains used in multiple blocks mean hoisting all the variables used to construct the access chain as not all backends can use pointers. uint32_t ptr = args[2]; auto *var = compiler.maybe_get(ptr); if (var) { accessed_variables_to_block[var->self].insert(current_block->self); access_chain_children[args[1]].insert(var->self); } // args[2] might be another access chain we have to track use of. for (uint32_t i = 2; i < length; i++) { notify_variable_access(args[i], current_block->self); access_chain_children[args[1]].insert(args[i]); } // Also keep track of the access chain pointer itself. // In exceptionally rare cases, we can end up with a case where // the access chain is generated in the loop body, but is consumed in continue block. // This means we need complex loop workarounds, and we must detect this via CFG analysis. notify_variable_access(args[1], current_block->self); // The result of an access chain is a fixed expression and is not really considered a temporary. auto &e = compiler.set(args[1], "", args[0], true); auto *backing_variable = compiler.maybe_get_backing_variable(ptr); e.loaded_from = backing_variable ? VariableID(backing_variable->self) : VariableID(0); // Other backends might use SPIRAccessChain for this later. compiler.ir.ids[args[1]].set_allow_type_rewrite(); access_chain_expressions.insert(args[1]); break; } case OpCopyMemory: { if (length < 2) return false; ID lhs = args[0]; ID rhs = args[1]; auto *var = compiler.maybe_get_backing_variable(lhs); // If we store through an access chain, we have a partial write. if (var) { accessed_variables_to_block[var->self].insert(current_block->self); if (var->self == lhs) complete_write_variables_to_block[var->self].insert(current_block->self); else partial_write_variables_to_block[var->self].insert(current_block->self); } // args[0:1] might be access chains we have to track use of. for (uint32_t i = 0; i < 2; i++) notify_variable_access(args[i], current_block->self); var = compiler.maybe_get_backing_variable(rhs); if (var) accessed_variables_to_block[var->self].insert(current_block->self); break; } case OpCopyObject: { if (length < 3) return false; auto *var = compiler.maybe_get_backing_variable(args[2]); if (var) accessed_variables_to_block[var->self].insert(current_block->self); // Might be an access chain which we have to keep track of. notify_variable_access(args[1], current_block->self); if (access_chain_expressions.count(args[2])) access_chain_expressions.insert(args[1]); // Might try to copy a Phi variable here. notify_variable_access(args[2], current_block->self); break; } case OpLoad: { if (length < 3) return false; uint32_t ptr = args[2]; auto *var = compiler.maybe_get_backing_variable(ptr); if (var) accessed_variables_to_block[var->self].insert(current_block->self); // Loaded value is a temporary. notify_variable_access(args[1], current_block->self); // Might be an access chain we have to track use of. notify_variable_access(args[2], current_block->self); break; } case OpFunctionCall: { if (length < 3) return false; // Return value may be a temporary. if (compiler.get_type(args[0]).basetype != SPIRType::Void) notify_variable_access(args[1], current_block->self); length -= 3; args += 3; for (uint32_t i = 0; i < length; i++) { auto *var = compiler.maybe_get_backing_variable(args[i]); if (var) { accessed_variables_to_block[var->self].insert(current_block->self); // Assume we can get partial writes to this variable. partial_write_variables_to_block[var->self].insert(current_block->self); } // Cannot easily prove if argument we pass to a function is completely written. // Usually, functions write to a dummy variable, // which is then copied to in full to the real argument. // Might try to copy a Phi variable here. notify_variable_access(args[i], current_block->self); } break; } case OpExtInst: { for (uint32_t i = 4; i < length; i++) notify_variable_access(args[i], current_block->self); notify_variable_access(args[1], current_block->self); break; } case OpArrayLength: case OpLine: case OpNoLine: // Uses literals, but cannot be a phi variable or temporary, so ignore. break; // Atomics shouldn't be able to access function-local variables. // Some GLSL builtins access a pointer. case OpCompositeInsert: case OpVectorShuffle: // Specialize for opcode which contains literals. for (uint32_t i = 1; i < 4; i++) notify_variable_access(args[i], current_block->self); break; case OpCompositeExtract: // Specialize for opcode which contains literals. for (uint32_t i = 1; i < 3; i++) notify_variable_access(args[i], current_block->self); break; case OpImageWrite: for (uint32_t i = 0; i < length; i++) { // Argument 3 is a literal. if (i != 3) notify_variable_access(args[i], current_block->self); } break; case OpImageSampleImplicitLod: case OpImageSampleExplicitLod: case OpImageSparseSampleImplicitLod: case OpImageSparseSampleExplicitLod: case OpImageSampleProjImplicitLod: case OpImageSampleProjExplicitLod: case OpImageSparseSampleProjImplicitLod: case OpImageSparseSampleProjExplicitLod: case OpImageFetch: case OpImageSparseFetch: case OpImageRead: case OpImageSparseRead: for (uint32_t i = 1; i < length; i++) { // Argument 4 is a literal. if (i != 4) notify_variable_access(args[i], current_block->self); } break; case OpImageSampleDrefImplicitLod: case OpImageSampleDrefExplicitLod: case OpImageSparseSampleDrefImplicitLod: case OpImageSparseSampleDrefExplicitLod: case OpImageSampleProjDrefImplicitLod: case OpImageSampleProjDrefExplicitLod: case OpImageSparseSampleProjDrefImplicitLod: case OpImageSparseSampleProjDrefExplicitLod: case OpImageGather: case OpImageSparseGather: case OpImageDrefGather: case OpImageSparseDrefGather: for (uint32_t i = 1; i < length; i++) { // Argument 5 is a literal. if (i != 5) notify_variable_access(args[i], current_block->self); } break; default: { // Rather dirty way of figuring out where Phi variables are used. // As long as only IDs are used, we can scan through instructions and try to find any evidence that // the ID of a variable has been used. // There are potential false positives here where a literal is used in-place of an ID, // but worst case, it does not affect the correctness of the compile. // Exhaustive analysis would be better here, but it's not worth it for now. for (uint32_t i = 0; i < length; i++) notify_variable_access(args[i], current_block->self); break; } } return true; } Compiler::StaticExpressionAccessHandler::StaticExpressionAccessHandler(Compiler &compiler_, uint32_t variable_id_) : compiler(compiler_) , variable_id(variable_id_) { } bool Compiler::StaticExpressionAccessHandler::follow_function_call(const SPIRFunction &) { return false; } bool Compiler::StaticExpressionAccessHandler::handle(spv::Op op, const uint32_t *args, uint32_t length) { switch (op) { case OpStore: if (length < 2) return false; if (args[0] == variable_id) { static_expression = args[1]; write_count++; } break; case OpLoad: if (length < 3) return false; if (args[2] == variable_id && static_expression == 0) // Tried to read from variable before it was initialized. return false; break; case OpAccessChain: case OpInBoundsAccessChain: case OpPtrAccessChain: if (length < 3) return false; if (args[2] == variable_id) // If we try to access chain our candidate variable before we store to it, bail. return false; break; default: break; } return true; } void Compiler::find_function_local_luts(SPIRFunction &entry, const AnalyzeVariableScopeAccessHandler &handler, bool single_function) { auto &cfg = *function_cfgs.find(entry.self)->second; // For each variable which is statically accessed. for (auto &accessed_var : handler.accessed_variables_to_block) { auto &blocks = accessed_var.second; auto &var = get(accessed_var.first); auto &type = expression_type(accessed_var.first); // Only consider function local variables here. // If we only have a single function in our CFG, private storage is also fine, // since it behaves like a function local variable. bool allow_lut = var.storage == StorageClassFunction || (single_function && var.storage == StorageClassPrivate); if (!allow_lut) continue; // We cannot be a phi variable. if (var.phi_variable) continue; // Only consider arrays here. if (type.array.empty()) continue; // If the variable has an initializer, make sure it is a constant expression. uint32_t static_constant_expression = 0; if (var.initializer) { if (ir.ids[var.initializer].get_type() != TypeConstant) continue; static_constant_expression = var.initializer; // There can be no stores to this variable, we have now proved we have a LUT. if (handler.complete_write_variables_to_block.count(var.self) != 0 || handler.partial_write_variables_to_block.count(var.self) != 0) continue; } else { // We can have one, and only one write to the variable, and that write needs to be a constant. // No partial writes allowed. if (handler.partial_write_variables_to_block.count(var.self) != 0) continue; auto itr = handler.complete_write_variables_to_block.find(var.self); // No writes? if (itr == end(handler.complete_write_variables_to_block)) continue; // We write to the variable in more than one block. auto &write_blocks = itr->second; if (write_blocks.size() != 1) continue; // The write needs to happen in the dominating block. DominatorBuilder builder(cfg); for (auto &block : blocks) builder.add_block(block); uint32_t dominator = builder.get_dominator(); // The complete write happened in a branch or similar, cannot deduce static expression. if (write_blocks.count(dominator) == 0) continue; // Find the static expression for this variable. StaticExpressionAccessHandler static_expression_handler(*this, var.self); traverse_all_reachable_opcodes(get(dominator), static_expression_handler); // We want one, and exactly one write if (static_expression_handler.write_count != 1 || static_expression_handler.static_expression == 0) continue; // Is it a constant expression? if (ir.ids[static_expression_handler.static_expression].get_type() != TypeConstant) continue; // We found a LUT! static_constant_expression = static_expression_handler.static_expression; } get(static_constant_expression).is_used_as_lut = true; var.static_expression = static_constant_expression; var.statically_assigned = true; var.remapped_variable = true; } } void Compiler::analyze_variable_scope(SPIRFunction &entry, AnalyzeVariableScopeAccessHandler &handler) { // First, we map out all variable access within a function. // Essentially a map of block -> { variables accessed in the basic block } traverse_all_reachable_opcodes(entry, handler); auto &cfg = *function_cfgs.find(entry.self)->second; // Analyze if there are parameters which need to be implicitly preserved with an "in" qualifier. analyze_parameter_preservation(entry, cfg, handler.accessed_variables_to_block, handler.complete_write_variables_to_block); unordered_map potential_loop_variables; // Find the loop dominator block for each block. for (auto &block_id : entry.blocks) { auto &block = get(block_id); auto itr = ir.continue_block_to_loop_header.find(block_id); if (itr != end(ir.continue_block_to_loop_header) && itr->second != block_id) { // Continue block might be unreachable in the CFG, but we still like to know the loop dominator. // Edge case is when continue block is also the loop header, don't set the dominator in this case. block.loop_dominator = itr->second; } else { uint32_t loop_dominator = cfg.find_loop_dominator(block_id); if (loop_dominator != block_id) block.loop_dominator = loop_dominator; else block.loop_dominator = SPIRBlock::NoDominator; } } // For each variable which is statically accessed. for (auto &var : handler.accessed_variables_to_block) { // Only deal with variables which are considered local variables in this function. if (find(begin(entry.local_variables), end(entry.local_variables), VariableID(var.first)) == end(entry.local_variables)) continue; DominatorBuilder builder(cfg); auto &blocks = var.second; auto &type = expression_type(var.first); // Figure out which block is dominating all accesses of those variables. for (auto &block : blocks) { // If we're accessing a variable inside a continue block, this variable might be a loop variable. // We can only use loop variables with scalars, as we cannot track static expressions for vectors. if (is_continue(block)) { // Potentially awkward case to check for. // We might have a variable inside a loop, which is touched by the continue block, // but is not actually a loop variable. // The continue block is dominated by the inner part of the loop, which does not make sense in high-level // language output because it will be declared before the body, // so we will have to lift the dominator up to the relevant loop header instead. builder.add_block(ir.continue_block_to_loop_header[block]); // Arrays or structs cannot be loop variables. if (type.vecsize == 1 && type.columns == 1 && type.basetype != SPIRType::Struct && type.array.empty()) { // The variable is used in multiple continue blocks, this is not a loop // candidate, signal that by setting block to -1u. auto &potential = potential_loop_variables[var.first]; if (potential == 0) potential = block; else potential = ~(0u); } } builder.add_block(block); } builder.lift_continue_block_dominator(); // Add it to a per-block list of variables. BlockID dominating_block = builder.get_dominator(); // For variables whose dominating block is inside a loop, there is a risk that these variables // actually need to be preserved across loop iterations. We can express this by adding // a "read" access to the loop header. // In the dominating block, we must see an OpStore or equivalent as the first access of an OpVariable. // Should that fail, we look for the outermost loop header and tack on an access there. // Phi nodes cannot have this problem. if (dominating_block) { auto &variable = get(var.first); if (!variable.phi_variable) { auto *block = &get(dominating_block); bool preserve = may_read_undefined_variable_in_block(*block, var.first); if (preserve) { // Find the outermost loop scope. while (block->loop_dominator != BlockID(SPIRBlock::NoDominator)) block = &get(block->loop_dominator); if (block->self != dominating_block) { builder.add_block(block->self); dominating_block = builder.get_dominator(); } } } } // If all blocks here are dead code, this will be 0, so the variable in question // will be completely eliminated. if (dominating_block) { auto &block = get(dominating_block); block.dominated_variables.push_back(var.first); get(var.first).dominator = dominating_block; } } for (auto &var : handler.accessed_temporaries_to_block) { auto itr = handler.result_id_to_type.find(var.first); if (itr == end(handler.result_id_to_type)) { // We found a false positive ID being used, ignore. // This should probably be an assert. continue; } // There is no point in doing domination analysis for opaque types. auto &type = get(itr->second); if (type_is_opaque_value(type)) continue; DominatorBuilder builder(cfg); bool force_temporary = false; bool used_in_header_hoisted_continue_block = false; // Figure out which block is dominating all accesses of those temporaries. auto &blocks = var.second; for (auto &block : blocks) { builder.add_block(block); if (blocks.size() != 1 && is_continue(block)) { // The risk here is that inner loop can dominate the continue block. // Any temporary we access in the continue block must be declared before the loop. // This is moot for complex loops however. auto &loop_header_block = get(ir.continue_block_to_loop_header[block]); assert(loop_header_block.merge == SPIRBlock::MergeLoop); builder.add_block(loop_header_block.self); used_in_header_hoisted_continue_block = true; } } uint32_t dominating_block = builder.get_dominator(); if (blocks.size() != 1 && is_single_block_loop(dominating_block)) { // Awkward case, because the loop header is also the continue block, // so hoisting to loop header does not help. force_temporary = true; } if (dominating_block) { // If we touch a variable in the dominating block, this is the expected setup. // SPIR-V normally mandates this, but we have extra cases for temporary use inside loops. bool first_use_is_dominator = blocks.count(dominating_block) != 0; if (!first_use_is_dominator || force_temporary) { if (handler.access_chain_expressions.count(var.first)) { // Exceptionally rare case. // We cannot declare temporaries of access chains (except on MSL perhaps with pointers). // Rather than do that, we force the indexing expressions to be declared in the right scope by // tracking their usage to that end. There is no temporary to hoist. // However, we still need to observe declaration order of the access chain. if (used_in_header_hoisted_continue_block) { // For this scenario, we used an access chain inside a continue block where we also registered an access to header block. // This is a problem as we need to declare an access chain properly first with full definition. // We cannot use temporaries for these expressions, // so we must make sure the access chain is declared ahead of time. // Force a complex for loop to deal with this. // TODO: Out-of-order declaring for loops where continue blocks are emitted last might be another option. auto &loop_header_block = get(dominating_block); assert(loop_header_block.merge == SPIRBlock::MergeLoop); loop_header_block.complex_continue = true; } } else { // This should be very rare, but if we try to declare a temporary inside a loop, // and that temporary is used outside the loop as well (spirv-opt inliner likes this) // we should actually emit the temporary outside the loop. hoisted_temporaries.insert(var.first); forced_temporaries.insert(var.first); auto &block_temporaries = get(dominating_block).declare_temporary; block_temporaries.emplace_back(handler.result_id_to_type[var.first], var.first); } } else if (blocks.size() > 1) { // Keep track of the temporary as we might have to declare this temporary. // This can happen if the loop header dominates a temporary, but we have a complex fallback loop. // In this case, the header is actually inside the for (;;) {} block, and we have problems. // What we need to do is hoist the temporaries outside the for (;;) {} block in case the header block // declares the temporary. auto &block_temporaries = get(dominating_block).potential_declare_temporary; block_temporaries.emplace_back(handler.result_id_to_type[var.first], var.first); } } } unordered_set seen_blocks; // Now, try to analyze whether or not these variables are actually loop variables. for (auto &loop_variable : potential_loop_variables) { auto &var = get(loop_variable.first); auto dominator = var.dominator; BlockID block = loop_variable.second; // The variable was accessed in multiple continue blocks, ignore. if (block == BlockID(~(0u)) || block == BlockID(0)) continue; // Dead code. if (dominator == ID(0)) continue; BlockID header = 0; // Find the loop header for this block if we are a continue block. { auto itr = ir.continue_block_to_loop_header.find(block); if (itr != end(ir.continue_block_to_loop_header)) { header = itr->second; } else if (get(block).continue_block == block) { // Also check for self-referential continue block. header = block; } } assert(header); auto &header_block = get(header); auto &blocks = handler.accessed_variables_to_block[loop_variable.first]; // If a loop variable is not used before the loop, it's probably not a loop variable. bool has_accessed_variable = blocks.count(header) != 0; // Now, there are two conditions we need to meet for the variable to be a loop variable. // 1. The dominating block must have a branch-free path to the loop header, // this way we statically know which expression should be part of the loop variable initializer. // Walk from the dominator, if there is one straight edge connecting // dominator and loop header, we statically know the loop initializer. bool static_loop_init = true; while (dominator != header) { if (blocks.count(dominator) != 0) has_accessed_variable = true; auto &succ = cfg.get_succeeding_edges(dominator); if (succ.size() != 1) { static_loop_init = false; break; } auto &pred = cfg.get_preceding_edges(succ.front()); if (pred.size() != 1 || pred.front() != dominator) { static_loop_init = false; break; } dominator = succ.front(); } if (!static_loop_init || !has_accessed_variable) continue; // The second condition we need to meet is that no access after the loop // merge can occur. Walk the CFG to see if we find anything. seen_blocks.clear(); cfg.walk_from(seen_blocks, header_block.merge_block, [&](uint32_t walk_block) -> bool { // We found a block which accesses the variable outside the loop. if (blocks.find(walk_block) != end(blocks)) static_loop_init = false; return true; }); if (!static_loop_init) continue; // We have a loop variable. header_block.loop_variables.push_back(loop_variable.first); // Need to sort here as variables come from an unordered container, and pushing stuff in wrong order // will break reproducability in regression runs. sort(begin(header_block.loop_variables), end(header_block.loop_variables)); get(loop_variable.first).loop_variable = true; } } bool Compiler::may_read_undefined_variable_in_block(const SPIRBlock &block, uint32_t var) { for (auto &op : block.ops) { auto *ops = stream(op); switch (op.op) { case OpStore: case OpCopyMemory: if (ops[0] == var) return false; break; case OpAccessChain: case OpInBoundsAccessChain: case OpPtrAccessChain: // Access chains are generally used to partially read and write. It's too hard to analyze // if all constituents are written fully before continuing, so just assume it's preserved. // This is the same as the parameter preservation analysis. if (ops[2] == var) return true; break; case OpSelect: // Variable pointers. // We might read before writing. if (ops[3] == var || ops[4] == var) return true; break; case OpPhi: { // Variable pointers. // We might read before writing. if (op.length < 2) break; uint32_t count = op.length - 2; for (uint32_t i = 0; i < count; i += 2) if (ops[i + 2] == var) return true; break; } case OpCopyObject: case OpLoad: if (ops[2] == var) return true; break; case OpFunctionCall: { if (op.length < 3) break; // May read before writing. uint32_t count = op.length - 3; for (uint32_t i = 0; i < count; i++) if (ops[i + 3] == var) return true; break; } default: break; } } // Not accessed somehow, at least not in a usual fashion. // It's likely accessed in a branch, so assume we must preserve. return true; } Bitset Compiler::get_buffer_block_flags(VariableID id) const { return ir.get_buffer_block_flags(get(id)); } bool Compiler::get_common_basic_type(const SPIRType &type, SPIRType::BaseType &base_type) { if (type.basetype == SPIRType::Struct) { base_type = SPIRType::Unknown; for (auto &member_type : type.member_types) { SPIRType::BaseType member_base; if (!get_common_basic_type(get(member_type), member_base)) return false; if (base_type == SPIRType::Unknown) base_type = member_base; else if (base_type != member_base) return false; } return true; } else { base_type = type.basetype; return true; } } void Compiler::ActiveBuiltinHandler::handle_builtin(const SPIRType &type, BuiltIn builtin, const Bitset &decoration_flags) { // If used, we will need to explicitly declare a new array size for these builtins. if (builtin == BuiltInClipDistance) { if (!type.array_size_literal[0]) SPIRV_CROSS_THROW("Array size for ClipDistance must be a literal."); uint32_t array_size = type.array[0]; if (array_size == 0) SPIRV_CROSS_THROW("Array size for ClipDistance must not be unsized."); compiler.clip_distance_count = array_size; } else if (builtin == BuiltInCullDistance) { if (!type.array_size_literal[0]) SPIRV_CROSS_THROW("Array size for CullDistance must be a literal."); uint32_t array_size = type.array[0]; if (array_size == 0) SPIRV_CROSS_THROW("Array size for CullDistance must not be unsized."); compiler.cull_distance_count = array_size; } else if (builtin == BuiltInPosition) { if (decoration_flags.get(DecorationInvariant)) compiler.position_invariant = true; } } void Compiler::ActiveBuiltinHandler::add_if_builtin(uint32_t id, bool allow_blocks) { // Only handle plain variables here. // Builtins which are part of a block are handled in AccessChain. // If allow_blocks is used however, this is to handle initializers of blocks, // which implies that all members are written to. auto *var = compiler.maybe_get(id); auto *m = compiler.ir.find_meta(id); if (var && m) { auto &type = compiler.get(var->basetype); auto &decorations = m->decoration; auto &flags = type.storage == StorageClassInput ? compiler.active_input_builtins : compiler.active_output_builtins; if (decorations.builtin) { flags.set(decorations.builtin_type); handle_builtin(type, decorations.builtin_type, decorations.decoration_flags); } else if (allow_blocks && compiler.has_decoration(type.self, DecorationBlock)) { uint32_t member_count = uint32_t(type.member_types.size()); for (uint32_t i = 0; i < member_count; i++) { if (compiler.has_member_decoration(type.self, i, DecorationBuiltIn)) { auto &member_type = compiler.get(type.member_types[i]); BuiltIn builtin = BuiltIn(compiler.get_member_decoration(type.self, i, DecorationBuiltIn)); flags.set(builtin); handle_builtin(member_type, builtin, compiler.get_member_decoration_bitset(type.self, i)); } } } } } void Compiler::ActiveBuiltinHandler::add_if_builtin(uint32_t id) { add_if_builtin(id, false); } void Compiler::ActiveBuiltinHandler::add_if_builtin_or_block(uint32_t id) { add_if_builtin(id, true); } bool Compiler::ActiveBuiltinHandler::handle(spv::Op opcode, const uint32_t *args, uint32_t length) { switch (opcode) { case OpStore: if (length < 1) return false; add_if_builtin(args[0]); break; case OpCopyMemory: if (length < 2) return false; add_if_builtin(args[0]); add_if_builtin(args[1]); break; case OpCopyObject: case OpLoad: if (length < 3) return false; add_if_builtin(args[2]); break; case OpSelect: if (length < 5) return false; add_if_builtin(args[3]); add_if_builtin(args[4]); break; case OpPhi: { if (length < 2) return false; uint32_t count = length - 2; args += 2; for (uint32_t i = 0; i < count; i += 2) add_if_builtin(args[i]); break; } case OpFunctionCall: { if (length < 3) return false; uint32_t count = length - 3; args += 3; for (uint32_t i = 0; i < count; i++) add_if_builtin(args[i]); break; } case OpAccessChain: case OpInBoundsAccessChain: case OpPtrAccessChain: { if (length < 4) return false; // Only consider global variables, cannot consider variables in functions yet, or other // access chains as they have not been created yet. auto *var = compiler.maybe_get(args[2]); if (!var) break; // Required if we access chain into builtins like gl_GlobalInvocationID. add_if_builtin(args[2]); // Start traversing type hierarchy at the proper non-pointer types. auto *type = &compiler.get_variable_data_type(*var); auto &flags = var->storage == StorageClassInput ? compiler.active_input_builtins : compiler.active_output_builtins; uint32_t count = length - 3; args += 3; for (uint32_t i = 0; i < count; i++) { // Pointers if (opcode == OpPtrAccessChain && i == 0) { type = &compiler.get(type->parent_type); continue; } // Arrays if (!type->array.empty()) { type = &compiler.get(type->parent_type); } // Structs else if (type->basetype == SPIRType::Struct) { uint32_t index = compiler.get(args[i]).scalar(); if (index < uint32_t(compiler.ir.meta[type->self].members.size())) { auto &decorations = compiler.ir.meta[type->self].members[index]; if (decorations.builtin) { flags.set(decorations.builtin_type); handle_builtin(compiler.get(type->member_types[index]), decorations.builtin_type, decorations.decoration_flags); } } type = &compiler.get(type->member_types[index]); } else { // No point in traversing further. We won't find any extra builtins. break; } } break; } default: break; } return true; } void Compiler::update_active_builtins() { active_input_builtins.reset(); active_output_builtins.reset(); cull_distance_count = 0; clip_distance_count = 0; ActiveBuiltinHandler handler(*this); traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); ir.for_each_typed_id([&](uint32_t, const SPIRVariable &var) { if (var.storage != StorageClassOutput) return; if (!interface_variable_exists_in_entry_point(var.self)) return; // Also, make sure we preserve output variables which are only initialized, but never accessed by any code. if (var.initializer != ID(0)) handler.add_if_builtin_or_block(var.self); }); } // Returns whether this shader uses a builtin of the storage class bool Compiler::has_active_builtin(BuiltIn builtin, StorageClass storage) { const Bitset *flags; switch (storage) { case StorageClassInput: flags = &active_input_builtins; break; case StorageClassOutput: flags = &active_output_builtins; break; default: return false; } return flags->get(builtin); } void Compiler::analyze_image_and_sampler_usage() { CombinedImageSamplerDrefHandler dref_handler(*this); traverse_all_reachable_opcodes(get(ir.default_entry_point), dref_handler); CombinedImageSamplerUsageHandler handler(*this, dref_handler.dref_combined_samplers); traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); // Need to run this traversal twice. First time, we propagate any comparison sampler usage from leaf functions // down to main(). // In the second pass, we can propagate up forced depth state coming from main() up into leaf functions. handler.dependency_hierarchy.clear(); traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); comparison_ids = move(handler.comparison_ids); need_subpass_input = handler.need_subpass_input; // Forward information from separate images and samplers into combined image samplers. for (auto &combined : combined_image_samplers) if (comparison_ids.count(combined.sampler_id)) comparison_ids.insert(combined.combined_id); } bool Compiler::CombinedImageSamplerDrefHandler::handle(spv::Op opcode, const uint32_t *args, uint32_t) { // Mark all sampled images which are used with Dref. switch (opcode) { case OpImageSampleDrefExplicitLod: case OpImageSampleDrefImplicitLod: case OpImageSampleProjDrefExplicitLod: case OpImageSampleProjDrefImplicitLod: case OpImageSparseSampleProjDrefImplicitLod: case OpImageSparseSampleDrefImplicitLod: case OpImageSparseSampleProjDrefExplicitLod: case OpImageSparseSampleDrefExplicitLod: case OpImageDrefGather: case OpImageSparseDrefGather: dref_combined_samplers.insert(args[2]); return true; default: break; } return true; } const CFG &Compiler::get_cfg_for_current_function() const { assert(current_function); return get_cfg_for_function(current_function->self); } const CFG &Compiler::get_cfg_for_function(uint32_t id) const { auto cfg_itr = function_cfgs.find(id); assert(cfg_itr != end(function_cfgs)); assert(cfg_itr->second); return *cfg_itr->second; } void Compiler::build_function_control_flow_graphs_and_analyze() { CFGBuilder handler(*this); handler.function_cfgs[ir.default_entry_point].reset(new CFG(*this, get(ir.default_entry_point))); traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); function_cfgs = move(handler.function_cfgs); bool single_function = function_cfgs.size() <= 1; for (auto &f : function_cfgs) { auto &func = get(f.first); AnalyzeVariableScopeAccessHandler scope_handler(*this, func); analyze_variable_scope(func, scope_handler); find_function_local_luts(func, scope_handler, single_function); // Check if we can actually use the loop variables we found in analyze_variable_scope. // To use multiple initializers, we need the same type and qualifiers. for (auto block : func.blocks) { auto &b = get(block); if (b.loop_variables.size() < 2) continue; auto &flags = get_decoration_bitset(b.loop_variables.front()); uint32_t type = get(b.loop_variables.front()).basetype; bool invalid_initializers = false; for (auto loop_variable : b.loop_variables) { if (flags != get_decoration_bitset(loop_variable) || type != get(b.loop_variables.front()).basetype) { invalid_initializers = true; break; } } if (invalid_initializers) { for (auto loop_variable : b.loop_variables) get(loop_variable).loop_variable = false; b.loop_variables.clear(); } } } } Compiler::CFGBuilder::CFGBuilder(Compiler &compiler_) : compiler(compiler_) { } bool Compiler::CFGBuilder::handle(spv::Op, const uint32_t *, uint32_t) { return true; } bool Compiler::CFGBuilder::follow_function_call(const SPIRFunction &func) { if (function_cfgs.find(func.self) == end(function_cfgs)) { function_cfgs[func.self].reset(new CFG(compiler, func)); return true; } else return false; } void Compiler::CombinedImageSamplerUsageHandler::add_dependency(uint32_t dst, uint32_t src) { dependency_hierarchy[dst].insert(src); // Propagate up any comparison state if we're loading from one such variable. if (comparison_ids.count(src)) comparison_ids.insert(dst); } bool Compiler::CombinedImageSamplerUsageHandler::begin_function_scope(const uint32_t *args, uint32_t length) { if (length < 3) return false; auto &func = compiler.get(args[2]); const auto *arg = &args[3]; length -= 3; for (uint32_t i = 0; i < length; i++) { auto &argument = func.arguments[i]; add_dependency(argument.id, arg[i]); } return true; } void Compiler::CombinedImageSamplerUsageHandler::add_hierarchy_to_comparison_ids(uint32_t id) { // Traverse the variable dependency hierarchy and tag everything in its path with comparison ids. comparison_ids.insert(id); for (auto &dep_id : dependency_hierarchy[id]) add_hierarchy_to_comparison_ids(dep_id); } bool Compiler::CombinedImageSamplerUsageHandler::handle(Op opcode, const uint32_t *args, uint32_t length) { switch (opcode) { case OpAccessChain: case OpInBoundsAccessChain: case OpPtrAccessChain: case OpLoad: { if (length < 3) return false; add_dependency(args[1], args[2]); // Ideally defer this to OpImageRead, but then we'd need to track loaded IDs. // If we load an image, we're going to use it and there is little harm in declaring an unused gl_FragCoord. auto &type = compiler.get(args[0]); if (type.image.dim == DimSubpassData) need_subpass_input = true; // If we load a SampledImage and it will be used with Dref, propagate the state up. if (dref_combined_samplers.count(args[1]) != 0) add_hierarchy_to_comparison_ids(args[1]); break; } case OpSampledImage: { if (length < 4) return false; uint32_t result_type = args[0]; uint32_t result_id = args[1]; auto &type = compiler.get(result_type); // If the underlying resource has been used for comparison then duplicate loads of that resource must be too. // This image must be a depth image. uint32_t image = args[2]; uint32_t sampler = args[3]; if (type.image.depth || dref_combined_samplers.count(result_id) != 0) { add_hierarchy_to_comparison_ids(image); // This sampler must be a SamplerComparisonState, and not a regular SamplerState. add_hierarchy_to_comparison_ids(sampler); // Mark the OpSampledImage itself as being comparison state. comparison_ids.insert(result_id); } return true; } default: break; } return true; } bool Compiler::buffer_is_hlsl_counter_buffer(VariableID id) const { auto *m = ir.find_meta(id); return m && m->hlsl_is_magic_counter_buffer; } bool Compiler::buffer_get_hlsl_counter_buffer(VariableID id, uint32_t &counter_id) const { auto *m = ir.find_meta(id); // First, check for the proper decoration. if (m && m->hlsl_magic_counter_buffer != 0) { counter_id = m->hlsl_magic_counter_buffer; return true; } else return false; } void Compiler::make_constant_null(uint32_t id, uint32_t type) { auto &constant_type = get(type); if (constant_type.pointer) { auto &constant = set(id, type); constant.make_null(constant_type); } else if (!constant_type.array.empty()) { assert(constant_type.parent_type); uint32_t parent_id = ir.increase_bound_by(1); make_constant_null(parent_id, constant_type.parent_type); if (!constant_type.array_size_literal.back()) SPIRV_CROSS_THROW("Array size of OpConstantNull must be a literal."); SmallVector elements(constant_type.array.back()); for (uint32_t i = 0; i < constant_type.array.back(); i++) elements[i] = parent_id; set(id, type, elements.data(), uint32_t(elements.size()), false); } else if (!constant_type.member_types.empty()) { uint32_t member_ids = ir.increase_bound_by(uint32_t(constant_type.member_types.size())); SmallVector elements(constant_type.member_types.size()); for (uint32_t i = 0; i < constant_type.member_types.size(); i++) { make_constant_null(member_ids + i, constant_type.member_types[i]); elements[i] = member_ids + i; } set(id, type, elements.data(), uint32_t(elements.size()), false); } else { auto &constant = set(id, type); constant.make_null(constant_type); } } const SmallVector &Compiler::get_declared_capabilities() const { return ir.declared_capabilities; } const SmallVector &Compiler::get_declared_extensions() const { return ir.declared_extensions; } std::string Compiler::get_remapped_declared_block_name(VariableID id) const { return get_remapped_declared_block_name(id, false); } std::string Compiler::get_remapped_declared_block_name(uint32_t id, bool fallback_prefer_instance_name) const { auto itr = declared_block_names.find(id); if (itr != end(declared_block_names)) { return itr->second; } else { auto &var = get(id); if (fallback_prefer_instance_name) { return to_name(var.self); } else { auto &type = get(var.basetype); auto *type_meta = ir.find_meta(type.self); auto *block_name = type_meta ? &type_meta->decoration.alias : nullptr; return (!block_name || block_name->empty()) ? get_block_fallback_name(id) : *block_name; } } } bool Compiler::reflection_ssbo_instance_name_is_significant() const { if (ir.source.known) { // UAVs from HLSL source tend to be declared in a way where the type is reused // but the instance name is significant, and that's the name we should report. // For GLSL, SSBOs each have their own block type as that's how GLSL is written. return ir.source.hlsl; } unordered_set ssbo_type_ids; bool aliased_ssbo_types = false; // If we don't have any OpSource information, we need to perform some shaky heuristics. ir.for_each_typed_id([&](uint32_t, const SPIRVariable &var) { auto &type = this->get(var.basetype); if (!type.pointer || var.storage == StorageClassFunction) return; bool ssbo = var.storage == StorageClassStorageBuffer || (var.storage == StorageClassUniform && has_decoration(type.self, DecorationBufferBlock)); if (ssbo) { if (ssbo_type_ids.count(type.self)) aliased_ssbo_types = true; else ssbo_type_ids.insert(type.self); } }); // If the block name is aliased, assume we have HLSL-style UAV declarations. return aliased_ssbo_types; } bool Compiler::instruction_to_result_type(uint32_t &result_type, uint32_t &result_id, spv::Op op, const uint32_t *args, uint32_t length) { // Most instructions follow the pattern of . // There are some exceptions. switch (op) { case OpStore: case OpCopyMemory: case OpCopyMemorySized: case OpImageWrite: case OpAtomicStore: case OpAtomicFlagClear: case OpEmitStreamVertex: case OpEndStreamPrimitive: case OpControlBarrier: case OpMemoryBarrier: case OpGroupWaitEvents: case OpRetainEvent: case OpReleaseEvent: case OpSetUserEventStatus: case OpCaptureEventProfilingInfo: case OpCommitReadPipe: case OpCommitWritePipe: case OpGroupCommitReadPipe: case OpGroupCommitWritePipe: case OpLine: case OpNoLine: return false; default: if (length > 1 && maybe_get(args[0]) != nullptr) { result_type = args[0]; result_id = args[1]; return true; } else return false; } } Bitset Compiler::combined_decoration_for_member(const SPIRType &type, uint32_t index) const { Bitset flags; auto *type_meta = ir.find_meta(type.self); if (type_meta) { auto &members = type_meta->members; if (index >= members.size()) return flags; auto &dec = members[index]; flags.merge_or(dec.decoration_flags); auto &member_type = get(type.member_types[index]); // If our member type is a struct, traverse all the child members as well recursively. auto &member_childs = member_type.member_types; for (uint32_t i = 0; i < member_childs.size(); i++) { auto &child_member_type = get(member_childs[i]); if (!child_member_type.pointer) flags.merge_or(combined_decoration_for_member(member_type, i)); } } return flags; } bool Compiler::is_desktop_only_format(spv::ImageFormat format) { switch (format) { // Desktop-only formats case ImageFormatR11fG11fB10f: case ImageFormatR16f: case ImageFormatRgb10A2: case ImageFormatR8: case ImageFormatRg8: case ImageFormatR16: case ImageFormatRg16: case ImageFormatRgba16: case ImageFormatR16Snorm: case ImageFormatRg16Snorm: case ImageFormatRgba16Snorm: case ImageFormatR8Snorm: case ImageFormatRg8Snorm: case ImageFormatR8ui: case ImageFormatRg8ui: case ImageFormatR16ui: case ImageFormatRgb10a2ui: case ImageFormatR8i: case ImageFormatRg8i: case ImageFormatR16i: return true; default: break; } return false; } bool Compiler::image_is_comparison(const SPIRType &type, uint32_t id) const { return type.image.depth || (comparison_ids.count(id) != 0); } bool Compiler::type_is_opaque_value(const SPIRType &type) const { return !type.pointer && (type.basetype == SPIRType::SampledImage || type.basetype == SPIRType::Image || type.basetype == SPIRType::Sampler); } // Make these member functions so we can easily break on any force_recompile events. void Compiler::force_recompile() { is_force_recompile = true; } bool Compiler::is_forcing_recompilation() const { return is_force_recompile; } void Compiler::clear_force_recompile() { is_force_recompile = false; } Compiler::PhysicalStorageBufferPointerHandler::PhysicalStorageBufferPointerHandler(Compiler &compiler_) : compiler(compiler_) { } bool Compiler::PhysicalStorageBufferPointerHandler::handle(Op op, const uint32_t *args, uint32_t) { if (op == OpConvertUToPtr || op == OpBitcast) { auto &type = compiler.get(args[0]); if (type.storage == StorageClassPhysicalStorageBufferEXT && type.pointer && type.pointer_depth == 1) { // If we need to cast to a pointer type which is not a block, we might need to synthesize ourselves // a block type which wraps this POD type. if (type.basetype != SPIRType::Struct) types.insert(args[0]); } } return true; } void Compiler::analyze_non_block_pointer_types() { PhysicalStorageBufferPointerHandler handler(*this); traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); physical_storage_non_block_pointer_types.reserve(handler.types.size()); for (auto type : handler.types) physical_storage_non_block_pointer_types.push_back(type); sort(begin(physical_storage_non_block_pointer_types), end(physical_storage_non_block_pointer_types)); } bool Compiler::InterlockedResourceAccessPrepassHandler::handle(Op op, const uint32_t *, uint32_t) { if (op == OpBeginInvocationInterlockEXT || op == OpEndInvocationInterlockEXT) { if (interlock_function_id != 0 && interlock_function_id != call_stack.back()) { // Most complex case, we have no sensible way of dealing with this // other than taking the 100% conservative approach, exit early. split_function_case = true; return false; } else { interlock_function_id = call_stack.back(); // If this call is performed inside control flow we have a problem. auto &cfg = compiler.get_cfg_for_function(interlock_function_id); uint32_t from_block_id = compiler.get(interlock_function_id).entry_block; bool outside_control_flow = cfg.node_terminates_control_flow_in_sub_graph(from_block_id, current_block_id); if (!outside_control_flow) control_flow_interlock = true; } } return true; } void Compiler::InterlockedResourceAccessPrepassHandler::rearm_current_block(const SPIRBlock &block) { current_block_id = block.self; } bool Compiler::InterlockedResourceAccessPrepassHandler::begin_function_scope(const uint32_t *args, uint32_t length) { if (length < 3) return false; call_stack.push_back(args[2]); return true; } bool Compiler::InterlockedResourceAccessPrepassHandler::end_function_scope(const uint32_t *, uint32_t) { call_stack.pop_back(); return true; } bool Compiler::InterlockedResourceAccessHandler::begin_function_scope(const uint32_t *args, uint32_t length) { if (length < 3) return false; if (args[2] == interlock_function_id) call_stack_is_interlocked = true; call_stack.push_back(args[2]); return true; } bool Compiler::InterlockedResourceAccessHandler::end_function_scope(const uint32_t *, uint32_t) { if (call_stack.back() == interlock_function_id) call_stack_is_interlocked = false; call_stack.pop_back(); return true; } void Compiler::InterlockedResourceAccessHandler::access_potential_resource(uint32_t id) { if ((use_critical_section && in_crit_sec) || (control_flow_interlock && call_stack_is_interlocked) || split_function_case) { compiler.interlocked_resources.insert(id); } } bool Compiler::InterlockedResourceAccessHandler::handle(Op opcode, const uint32_t *args, uint32_t length) { // Only care about critical section analysis if we have simple case. if (use_critical_section) { if (opcode == OpBeginInvocationInterlockEXT) { in_crit_sec = true; return true; } if (opcode == OpEndInvocationInterlockEXT) { // End critical section--nothing more to do. return false; } } // We need to figure out where images and buffers are loaded from, so do only the bare bones compilation we need. switch (opcode) { case OpLoad: { if (length < 3) return false; uint32_t ptr = args[2]; auto *var = compiler.maybe_get_backing_variable(ptr); // We're only concerned with buffer and image memory here. if (!var) break; switch (var->storage) { default: break; case StorageClassUniformConstant: { uint32_t result_type = args[0]; uint32_t id = args[1]; compiler.set(id, "", result_type, true); compiler.register_read(id, ptr, true); break; } case StorageClassUniform: // Must have BufferBlock; we only care about SSBOs. if (!compiler.has_decoration(compiler.get(var->basetype).self, DecorationBufferBlock)) break; // fallthrough case StorageClassStorageBuffer: access_potential_resource(var->self); break; } break; } case OpInBoundsAccessChain: case OpAccessChain: case OpPtrAccessChain: { if (length < 3) return false; uint32_t result_type = args[0]; auto &type = compiler.get(result_type); if (type.storage == StorageClassUniform || type.storage == StorageClassUniformConstant || type.storage == StorageClassStorageBuffer) { uint32_t id = args[1]; uint32_t ptr = args[2]; compiler.set(id, "", result_type, true); compiler.register_read(id, ptr, true); compiler.ir.ids[id].set_allow_type_rewrite(); } break; } case OpImageTexelPointer: { if (length < 3) return false; uint32_t result_type = args[0]; uint32_t id = args[1]; uint32_t ptr = args[2]; auto &e = compiler.set(id, "", result_type, true); auto *var = compiler.maybe_get_backing_variable(ptr); if (var) e.loaded_from = var->self; break; } case OpStore: case OpImageWrite: case OpAtomicStore: { if (length < 1) return false; uint32_t ptr = args[0]; auto *var = compiler.maybe_get_backing_variable(ptr); if (var && (var->storage == StorageClassUniform || var->storage == StorageClassUniformConstant || var->storage == StorageClassStorageBuffer)) { access_potential_resource(var->self); } break; } case OpCopyMemory: { if (length < 2) return false; uint32_t dst = args[0]; uint32_t src = args[1]; auto *dst_var = compiler.maybe_get_backing_variable(dst); auto *src_var = compiler.maybe_get_backing_variable(src); if (dst_var && (dst_var->storage == StorageClassUniform || dst_var->storage == StorageClassStorageBuffer)) access_potential_resource(dst_var->self); if (src_var) { if (src_var->storage != StorageClassUniform && src_var->storage != StorageClassStorageBuffer) break; if (src_var->storage == StorageClassUniform && !compiler.has_decoration(compiler.get(src_var->basetype).self, DecorationBufferBlock)) { break; } access_potential_resource(src_var->self); } break; } case OpImageRead: case OpAtomicLoad: { if (length < 3) return false; uint32_t ptr = args[2]; auto *var = compiler.maybe_get_backing_variable(ptr); // We're only concerned with buffer and image memory here. if (!var) break; switch (var->storage) { default: break; case StorageClassUniform: // Must have BufferBlock; we only care about SSBOs. if (!compiler.has_decoration(compiler.get(var->basetype).self, DecorationBufferBlock)) break; // fallthrough case StorageClassUniformConstant: case StorageClassStorageBuffer: access_potential_resource(var->self); break; } break; } case OpAtomicExchange: case OpAtomicCompareExchange: case OpAtomicIIncrement: case OpAtomicIDecrement: case OpAtomicIAdd: case OpAtomicISub: case OpAtomicSMin: case OpAtomicUMin: case OpAtomicSMax: case OpAtomicUMax: case OpAtomicAnd: case OpAtomicOr: case OpAtomicXor: { if (length < 3) return false; uint32_t ptr = args[2]; auto *var = compiler.maybe_get_backing_variable(ptr); if (var && (var->storage == StorageClassUniform || var->storage == StorageClassUniformConstant || var->storage == StorageClassStorageBuffer)) { access_potential_resource(var->self); } break; } default: break; } return true; } void Compiler::analyze_interlocked_resource_usage() { if (get_execution_model() == ExecutionModelFragment && (get_entry_point().flags.get(ExecutionModePixelInterlockOrderedEXT) || get_entry_point().flags.get(ExecutionModePixelInterlockUnorderedEXT) || get_entry_point().flags.get(ExecutionModeSampleInterlockOrderedEXT) || get_entry_point().flags.get(ExecutionModeSampleInterlockUnorderedEXT))) { InterlockedResourceAccessPrepassHandler prepass_handler(*this, ir.default_entry_point); traverse_all_reachable_opcodes(get(ir.default_entry_point), prepass_handler); InterlockedResourceAccessHandler handler(*this, ir.default_entry_point); handler.interlock_function_id = prepass_handler.interlock_function_id; handler.split_function_case = prepass_handler.split_function_case; handler.control_flow_interlock = prepass_handler.control_flow_interlock; handler.use_critical_section = !handler.split_function_case && !handler.control_flow_interlock; traverse_all_reachable_opcodes(get(ir.default_entry_point), handler); // For GLSL. If we hit any of these cases, we have to fall back to conservative approach. interlocked_is_complex = !handler.use_critical_section || handler.interlock_function_id != ir.default_entry_point; } } bool Compiler::type_is_array_of_pointers(const SPIRType &type) const { if (!type.pointer) return false; // If parent type has same pointer depth, we must have an array of pointers. return type.pointer_depth == get(type.parent_type).pointer_depth; } bool Compiler::type_is_top_level_physical_pointer(const SPIRType &type) const { return type.pointer && type.storage == StorageClassPhysicalStorageBuffer && type.pointer_depth > get(type.parent_type).pointer_depth; } bool Compiler::flush_phi_required(BlockID from, BlockID to) const { auto &child = get(to); for (auto &phi : child.phi_variables) if (phi.parent == from) return true; return false; } void Compiler::add_loop_level() { current_loop_level++; } spirv-cross-2021.01.15/spirv_cross.hpp000066400000000000000000001343631400026215700174710ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_HPP #define SPIRV_CROSS_HPP #include "spirv.hpp" #include "spirv_cfg.hpp" #include "spirv_cross_parsed_ir.hpp" namespace SPIRV_CROSS_NAMESPACE { struct Resource { // Resources are identified with their SPIR-V ID. // This is the ID of the OpVariable. ID id; // The type ID of the variable which includes arrays and all type modifications. // This type ID is not suitable for parsing OpMemberDecoration of a struct and other decorations in general // since these modifications typically happen on the base_type_id. TypeID type_id; // The base type of the declared resource. // This type is the base type which ignores pointers and arrays of the type_id. // This is mostly useful to parse decorations of the underlying type. // base_type_id can also be obtained with get_type(get_type(type_id).self). TypeID base_type_id; // The declared name (OpName) of the resource. // For Buffer blocks, the name actually reflects the externally // visible Block name. // // This name can be retrieved again by using either // get_name(id) or get_name(base_type_id) depending if it's a buffer block or not. // // This name can be an empty string in which case get_fallback_name(id) can be // used which obtains a suitable fallback identifier for an ID. std::string name; }; struct ShaderResources { SmallVector uniform_buffers; SmallVector storage_buffers; SmallVector stage_inputs; SmallVector stage_outputs; SmallVector subpass_inputs; SmallVector storage_images; SmallVector sampled_images; SmallVector atomic_counters; SmallVector acceleration_structures; // There can only be one push constant block, // but keep the vector in case this restriction is lifted in the future. SmallVector push_constant_buffers; // For Vulkan GLSL and HLSL source, // these correspond to separate texture2D and samplers respectively. SmallVector separate_images; SmallVector separate_samplers; }; struct CombinedImageSampler { // The ID of the sampler2D variable. VariableID combined_id; // The ID of the texture2D variable. VariableID image_id; // The ID of the sampler variable. VariableID sampler_id; }; struct SpecializationConstant { // The ID of the specialization constant. ConstantID id; // The constant ID of the constant, used in Vulkan during pipeline creation. uint32_t constant_id; }; struct BufferRange { unsigned index; size_t offset; size_t range; }; enum BufferPackingStandard { BufferPackingStd140, BufferPackingStd430, BufferPackingStd140EnhancedLayout, BufferPackingStd430EnhancedLayout, BufferPackingHLSLCbuffer, BufferPackingHLSLCbufferPackOffset, BufferPackingScalar, BufferPackingScalarEnhancedLayout }; struct EntryPoint { std::string name; spv::ExecutionModel execution_model; }; class Compiler { public: friend class CFG; friend class DominatorBuilder; // The constructor takes a buffer of SPIR-V words and parses it. // It will create its own parser, parse the SPIR-V and move the parsed IR // as if you had called the constructors taking ParsedIR directly. explicit Compiler(std::vector ir); Compiler(const uint32_t *ir, size_t word_count); // This is more modular. We can also consume a ParsedIR structure directly, either as a move, or copy. // With copy, we can reuse the same parsed IR for multiple Compiler instances. explicit Compiler(const ParsedIR &ir); explicit Compiler(ParsedIR &&ir); virtual ~Compiler() = default; // After parsing, API users can modify the SPIR-V via reflection and call this // to disassemble the SPIR-V into the desired langauage. // Sub-classes actually implement this. virtual std::string compile(); // Gets the identifier (OpName) of an ID. If not defined, an empty string will be returned. const std::string &get_name(ID id) const; // Applies a decoration to an ID. Effectively injects OpDecorate. void set_decoration(ID id, spv::Decoration decoration, uint32_t argument = 0); void set_decoration_string(ID id, spv::Decoration decoration, const std::string &argument); // Overrides the identifier OpName of an ID. // Identifiers beginning with underscores or identifiers which contain double underscores // are reserved by the implementation. void set_name(ID id, const std::string &name); // Gets a bitmask for the decorations which are applied to ID. // I.e. (1ull << spv::DecorationFoo) | (1ull << spv::DecorationBar) const Bitset &get_decoration_bitset(ID id) const; // Returns whether the decoration has been applied to the ID. bool has_decoration(ID id, spv::Decoration decoration) const; // Gets the value for decorations which take arguments. // If the decoration is a boolean (i.e. spv::DecorationNonWritable), // 1 will be returned. // If decoration doesn't exist or decoration is not recognized, // 0 will be returned. uint32_t get_decoration(ID id, spv::Decoration decoration) const; const std::string &get_decoration_string(ID id, spv::Decoration decoration) const; // Removes the decoration for an ID. void unset_decoration(ID id, spv::Decoration decoration); // Gets the SPIR-V type associated with ID. // Mostly used with Resource::type_id and Resource::base_type_id to parse the underlying type of a resource. const SPIRType &get_type(TypeID id) const; // Gets the SPIR-V type of a variable. const SPIRType &get_type_from_variable(VariableID id) const; // Gets the underlying storage class for an OpVariable. spv::StorageClass get_storage_class(VariableID id) const; // If get_name() is an empty string, get the fallback name which will be used // instead in the disassembled source. virtual const std::string get_fallback_name(ID id) const; // If get_name() of a Block struct is an empty string, get the fallback name. // This needs to be per-variable as multiple variables can use the same block type. virtual const std::string get_block_fallback_name(VariableID id) const; // Given an OpTypeStruct in ID, obtain the identifier for member number "index". // This may be an empty string. const std::string &get_member_name(TypeID id, uint32_t index) const; // Given an OpTypeStruct in ID, obtain the OpMemberDecoration for member number "index". uint32_t get_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const; const std::string &get_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration) const; // Sets the member identifier for OpTypeStruct ID, member number "index". void set_member_name(TypeID id, uint32_t index, const std::string &name); // Returns the qualified member identifier for OpTypeStruct ID, member number "index", // or an empty string if no qualified alias exists const std::string &get_member_qualified_name(TypeID type_id, uint32_t index) const; // Gets the decoration mask for a member of a struct, similar to get_decoration_mask. const Bitset &get_member_decoration_bitset(TypeID id, uint32_t index) const; // Returns whether the decoration has been applied to a member of a struct. bool has_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const; // Similar to set_decoration, but for struct members. void set_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration, uint32_t argument = 0); void set_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration, const std::string &argument); // Unsets a member decoration, similar to unset_decoration. void unset_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration); // Gets the fallback name for a member, similar to get_fallback_name. virtual const std::string get_fallback_member_name(uint32_t index) const { return join("_", index); } // Returns a vector of which members of a struct are potentially in use by a // SPIR-V shader. The granularity of this analysis is per-member of a struct. // This can be used for Buffer (UBO), BufferBlock/StorageBuffer (SSBO) and PushConstant blocks. // ID is the Resource::id obtained from get_shader_resources(). SmallVector get_active_buffer_ranges(VariableID id) const; // Returns the effective size of a buffer block. size_t get_declared_struct_size(const SPIRType &struct_type) const; // Returns the effective size of a buffer block, with a given array size // for a runtime array. // SSBOs are typically declared as runtime arrays. get_declared_struct_size() will return 0 for the size. // This is not very helpful for applications which might need to know the array stride of its last member. // This can be done through the API, but it is not very intuitive how to accomplish this, so here we provide a helper function // to query the size of the buffer, assuming that the last member has a certain size. // If the buffer does not contain a runtime array, array_size is ignored, and the function will behave as // get_declared_struct_size(). // To get the array stride of the last member, something like: // get_declared_struct_size_runtime_array(type, 1) - get_declared_struct_size_runtime_array(type, 0) will work. size_t get_declared_struct_size_runtime_array(const SPIRType &struct_type, size_t array_size) const; // Returns the effective size of a buffer block struct member. size_t get_declared_struct_member_size(const SPIRType &struct_type, uint32_t index) const; // Returns a set of all global variables which are statically accessed // by the control flow graph from the current entry point. // Only variables which change the interface for a shader are returned, that is, // variables with storage class of Input, Output, Uniform, UniformConstant, PushConstant and AtomicCounter // storage classes are returned. // // To use the returned set as the filter for which variables are used during compilation, // this set can be moved to set_enabled_interface_variables(). std::unordered_set get_active_interface_variables() const; // Sets the interface variables which are used during compilation. // By default, all variables are used. // Once set, compile() will only consider the set in active_variables. void set_enabled_interface_variables(std::unordered_set active_variables); // Query shader resources, use ids with reflection interface to modify or query binding points, etc. ShaderResources get_shader_resources() const; // Query shader resources, but only return the variables which are part of active_variables. // E.g.: get_shader_resources(get_active_variables()) to only return the variables which are statically // accessed. ShaderResources get_shader_resources(const std::unordered_set &active_variables) const; // Remapped variables are considered built-in variables and a backend will // not emit a declaration for this variable. // This is mostly useful for making use of builtins which are dependent on extensions. void set_remapped_variable_state(VariableID id, bool remap_enable); bool get_remapped_variable_state(VariableID id) const; // For subpassInput variables which are remapped to plain variables, // the number of components in the remapped // variable must be specified as the backing type of subpass inputs are opaque. void set_subpass_input_remapped_components(VariableID id, uint32_t components); uint32_t get_subpass_input_remapped_components(VariableID id) const; // All operations work on the current entry point. // Entry points can be swapped out with set_entry_point(). // Entry points should be set right after the constructor completes as some reflection functions traverse the graph from the entry point. // Resource reflection also depends on the entry point. // By default, the current entry point is set to the first OpEntryPoint which appears in the SPIR-V module. // Some shader languages restrict the names that can be given to entry points, and the // corresponding backend will automatically rename an entry point name, during the call // to compile() if it is illegal. For example, the common entry point name main() is // illegal in MSL, and is renamed to an alternate name by the MSL backend. // Given the original entry point name contained in the SPIR-V, this function returns // the name, as updated by the backend during the call to compile(). If the name is not // illegal, and has not been renamed, or if this function is called before compile(), // this function will simply return the same name. // New variants of entry point query and reflection. // Names for entry points in the SPIR-V module may alias if they belong to different execution models. // To disambiguate, we must pass along with the entry point names the execution model. SmallVector get_entry_points_and_stages() const; void set_entry_point(const std::string &entry, spv::ExecutionModel execution_model); // Renames an entry point from old_name to new_name. // If old_name is currently selected as the current entry point, it will continue to be the current entry point, // albeit with a new name. // get_entry_points() is essentially invalidated at this point. void rename_entry_point(const std::string &old_name, const std::string &new_name, spv::ExecutionModel execution_model); const SPIREntryPoint &get_entry_point(const std::string &name, spv::ExecutionModel execution_model) const; SPIREntryPoint &get_entry_point(const std::string &name, spv::ExecutionModel execution_model); const std::string &get_cleansed_entry_point_name(const std::string &name, spv::ExecutionModel execution_model) const; // Traverses all reachable opcodes and sets active_builtins to a bitmask of all builtin variables which are accessed in the shader. void update_active_builtins(); bool has_active_builtin(spv::BuiltIn builtin, spv::StorageClass storage); // Query and modify OpExecutionMode. const Bitset &get_execution_mode_bitset() const; void unset_execution_mode(spv::ExecutionMode mode); void set_execution_mode(spv::ExecutionMode mode, uint32_t arg0 = 0, uint32_t arg1 = 0, uint32_t arg2 = 0); // Gets argument for an execution mode (LocalSize, Invocations, OutputVertices). // For LocalSize, the index argument is used to select the dimension (X = 0, Y = 1, Z = 2). // For execution modes which do not have arguments, 0 is returned. uint32_t get_execution_mode_argument(spv::ExecutionMode mode, uint32_t index = 0) const; spv::ExecutionModel get_execution_model() const; bool is_tessellation_shader() const; // In SPIR-V, the compute work group size can be represented by a constant vector, in which case // the LocalSize execution mode is ignored. // // This constant vector can be a constant vector, specialization constant vector, or partly specialized constant vector. // To modify and query work group dimensions which are specialization constants, SPIRConstant values must be modified // directly via get_constant() rather than using LocalSize directly. This function will return which constants should be modified. // // To modify dimensions which are *not* specialization constants, set_execution_mode should be used directly. // Arguments to set_execution_mode which are specialization constants are effectively ignored during compilation. // NOTE: This is somewhat different from how SPIR-V works. In SPIR-V, the constant vector will completely replace LocalSize, // while in this interface, LocalSize is only ignored for specialization constants. // // The specialization constant will be written to x, y and z arguments. // If the component is not a specialization constant, a zeroed out struct will be written. // The return value is the constant ID of the builtin WorkGroupSize, but this is not expected to be useful // for most use cases. uint32_t get_work_group_size_specialization_constants(SpecializationConstant &x, SpecializationConstant &y, SpecializationConstant &z) const; // Analyzes all OpImageFetch (texelFetch) opcodes and checks if there are instances where // said instruction is used without a combined image sampler. // GLSL targets do not support the use of texelFetch without a sampler. // To workaround this, we must inject a dummy sampler which can be used to form a sampler2D at the call-site of // texelFetch as necessary. // // This must be called before build_combined_image_samplers(). // build_combined_image_samplers() may refer to the ID returned by this method if the returned ID is non-zero. // The return value will be the ID of a sampler object if a dummy sampler is necessary, or 0 if no sampler object // is required. // // If the returned ID is non-zero, it can be decorated with set/bindings as desired before calling compile(). // Calling this function also invalidates get_active_interface_variables(), so this should be called // before that function. VariableID build_dummy_sampler_for_combined_images(); // Analyzes all separate image and samplers used from the currently selected entry point, // and re-routes them all to a combined image sampler instead. // This is required to "support" separate image samplers in targets which do not natively support // this feature, like GLSL/ESSL. // // This must be called before compile() if such remapping is desired. // This call will add new sampled images to the SPIR-V, // so it will appear in reflection if get_shader_resources() is called after build_combined_image_samplers. // // If any image/sampler remapping was found, no separate image/samplers will appear in the decompiled output, // but will still appear in reflection. // // The resulting samplers will be void of any decorations like name, descriptor sets and binding points, // so this can be added before compile() if desired. // // Combined image samplers originating from this set are always considered active variables. // Arrays of separate samplers are not supported, but arrays of separate images are supported. // Array of images + sampler -> Array of combined image samplers. void build_combined_image_samplers(); // Gets a remapping for the combined image samplers. const SmallVector &get_combined_image_samplers() const { return combined_image_samplers; } // Set a new variable type remap callback. // The type remapping is designed to allow global interface variable to assume more special types. // A typical example here is to remap sampler2D into samplerExternalOES, which currently isn't supported // directly by SPIR-V. // // In compile() while emitting code, // for every variable that is declared, including function parameters, the callback will be called // and the API user has a chance to change the textual representation of the type used to declare the variable. // The API user can detect special patterns in names to guide the remapping. void set_variable_type_remap_callback(VariableTypeRemapCallback cb) { variable_remap_callback = std::move(cb); } // API for querying which specialization constants exist. // To modify a specialization constant before compile(), use get_constant(constant.id), // then update constants directly in the SPIRConstant data structure. // For composite types, the subconstants can be iterated over and modified. // constant_type is the SPIRType for the specialization constant, // which can be queried to determine which fields in the unions should be poked at. SmallVector get_specialization_constants() const; SPIRConstant &get_constant(ConstantID id); const SPIRConstant &get_constant(ConstantID id) const; uint32_t get_current_id_bound() const { return uint32_t(ir.ids.size()); } // API for querying buffer objects. // The type passed in here should be the base type of a resource, i.e. // get_type(resource.base_type_id) // as decorations are set in the basic Block type. // The type passed in here must have these decorations set, or an exception is raised. // Only UBOs and SSBOs or sub-structs which are part of these buffer types will have these decorations set. uint32_t type_struct_member_offset(const SPIRType &type, uint32_t index) const; uint32_t type_struct_member_array_stride(const SPIRType &type, uint32_t index) const; uint32_t type_struct_member_matrix_stride(const SPIRType &type, uint32_t index) const; // Gets the offset in SPIR-V words (uint32_t) for a decoration which was originally declared in the SPIR-V binary. // The offset will point to one or more uint32_t literals which can be modified in-place before using the SPIR-V binary. // Note that adding or removing decorations using the reflection API will not change the behavior of this function. // If the decoration was declared, sets the word_offset to an offset into the provided SPIR-V binary buffer and returns true, // otherwise, returns false. // If the decoration does not have any value attached to it (e.g. DecorationRelaxedPrecision), this function will also return false. bool get_binary_offset_for_decoration(VariableID id, spv::Decoration decoration, uint32_t &word_offset) const; // HLSL counter buffer reflection interface. // Append/Consume/Increment/Decrement in HLSL is implemented as two "neighbor" buffer objects where // one buffer implements the storage, and a single buffer containing just a lone "int" implements the counter. // To SPIR-V these will be exposed as two separate buffers, but glslang HLSL frontend emits a special indentifier // which lets us link the two buffers together. // Queries if a variable ID is a counter buffer which "belongs" to a regular buffer object. // If SPV_GOOGLE_hlsl_functionality1 is used, this can be used even with a stripped SPIR-V module. // Otherwise, this query is purely based on OpName identifiers as found in the SPIR-V module, and will // only return true if OpSource was reported HLSL. // To rely on this functionality, ensure that the SPIR-V module is not stripped. bool buffer_is_hlsl_counter_buffer(VariableID id) const; // Queries if a buffer object has a neighbor "counter" buffer. // If so, the ID of that counter buffer will be returned in counter_id. // If SPV_GOOGLE_hlsl_functionality1 is used, this can be used even with a stripped SPIR-V module. // Otherwise, this query is purely based on OpName identifiers as found in the SPIR-V module, and will // only return true if OpSource was reported HLSL. // To rely on this functionality, ensure that the SPIR-V module is not stripped. bool buffer_get_hlsl_counter_buffer(VariableID id, uint32_t &counter_id) const; // Gets the list of all SPIR-V Capabilities which were declared in the SPIR-V module. const SmallVector &get_declared_capabilities() const; // Gets the list of all SPIR-V extensions which were declared in the SPIR-V module. const SmallVector &get_declared_extensions() const; // When declaring buffer blocks in GLSL, the name declared in the GLSL source // might not be the same as the name declared in the SPIR-V module due to naming conflicts. // In this case, SPIRV-Cross needs to find a fallback-name, and it might only // be possible to know this name after compiling to GLSL. // This is particularly important for HLSL input and UAVs which tends to reuse the same block type // for multiple distinct blocks. For these cases it is not possible to modify the name of the type itself // because it might be unique. Instead, you can use this interface to check after compilation which // name was actually used if your input SPIR-V tends to have this problem. // For other names like remapped names for variables, etc, it's generally enough to query the name of the variables // after compiling, block names are an exception to this rule. // ID is the name of a variable as returned by Resource::id, and must be a variable with a Block-like type. // // This also applies to HLSL cbuffers. std::string get_remapped_declared_block_name(VariableID id) const; // For buffer block variables, get the decorations for that variable. // Sometimes, decorations for buffer blocks are found in member decorations instead // of direct decorations on the variable itself. // The most common use here is to check if a buffer is readonly or writeonly. Bitset get_buffer_block_flags(VariableID id) const; protected: const uint32_t *stream(const Instruction &instr) const { // If we're not going to use any arguments, just return nullptr. // We want to avoid case where we return an out of range pointer // that trips debug assertions on some platforms. if (!instr.length) return nullptr; if (instr.offset + instr.length > ir.spirv.size()) SPIRV_CROSS_THROW("Compiler::stream() out of range."); return &ir.spirv[instr.offset]; } ParsedIR ir; // Marks variables which have global scope and variables which can alias with other variables // (SSBO, image load store, etc) SmallVector global_variables; SmallVector aliased_variables; SPIRFunction *current_function = nullptr; SPIRBlock *current_block = nullptr; uint32_t current_loop_level = 0; std::unordered_set active_interface_variables; bool check_active_interface_variables = false; void add_loop_level(); void set_initializers(SPIRExpression &e) { e.emitted_loop_level = current_loop_level; } template void set_initializers(const T &) { } // If our IDs are out of range here as part of opcodes, throw instead of // undefined behavior. template T &set(uint32_t id, P &&... args) { ir.add_typed_id(static_cast(T::type), id); auto &var = variant_set(ir.ids[id], std::forward

(args)...); var.self = id; set_initializers(var); return var; } template T &get(uint32_t id) { return variant_get(ir.ids[id]); } template T *maybe_get(uint32_t id) { if (id >= ir.ids.size()) return nullptr; else if (ir.ids[id].get_type() == static_cast(T::type)) return &get(id); else return nullptr; } template const T &get(uint32_t id) const { return variant_get(ir.ids[id]); } template const T *maybe_get(uint32_t id) const { if (id >= ir.ids.size()) return nullptr; else if (ir.ids[id].get_type() == static_cast(T::type)) return &get(id); else return nullptr; } // Gets the id of SPIR-V type underlying the given type_id, which might be a pointer. uint32_t get_pointee_type_id(uint32_t type_id) const; // Gets the SPIR-V type underlying the given type, which might be a pointer. const SPIRType &get_pointee_type(const SPIRType &type) const; // Gets the SPIR-V type underlying the given type_id, which might be a pointer. const SPIRType &get_pointee_type(uint32_t type_id) const; // Gets the ID of the SPIR-V type underlying a variable. uint32_t get_variable_data_type_id(const SPIRVariable &var) const; // Gets the SPIR-V type underlying a variable. SPIRType &get_variable_data_type(const SPIRVariable &var); // Gets the SPIR-V type underlying a variable. const SPIRType &get_variable_data_type(const SPIRVariable &var) const; // Gets the SPIR-V element type underlying an array variable. SPIRType &get_variable_element_type(const SPIRVariable &var); // Gets the SPIR-V element type underlying an array variable. const SPIRType &get_variable_element_type(const SPIRVariable &var) const; // Sets the qualified member identifier for OpTypeStruct ID, member number "index". void set_member_qualified_name(uint32_t type_id, uint32_t index, const std::string &name); void set_qualified_name(uint32_t id, const std::string &name); // Returns if the given type refers to a sampled image. bool is_sampled_image_type(const SPIRType &type); const SPIREntryPoint &get_entry_point() const; SPIREntryPoint &get_entry_point(); static bool is_tessellation_shader(spv::ExecutionModel model); virtual std::string to_name(uint32_t id, bool allow_alias = true) const; bool is_builtin_variable(const SPIRVariable &var) const; bool is_builtin_type(const SPIRType &type) const; bool is_hidden_variable(const SPIRVariable &var, bool include_builtins = false) const; bool is_immutable(uint32_t id) const; bool is_member_builtin(const SPIRType &type, uint32_t index, spv::BuiltIn *builtin) const; bool is_scalar(const SPIRType &type) const; bool is_vector(const SPIRType &type) const; bool is_matrix(const SPIRType &type) const; bool is_array(const SPIRType &type) const; uint32_t expression_type_id(uint32_t id) const; const SPIRType &expression_type(uint32_t id) const; bool expression_is_lvalue(uint32_t id) const; bool variable_storage_is_aliased(const SPIRVariable &var); SPIRVariable *maybe_get_backing_variable(uint32_t chain); spv::StorageClass get_expression_effective_storage_class(uint32_t ptr); void register_read(uint32_t expr, uint32_t chain, bool forwarded); void register_write(uint32_t chain); inline bool is_continue(uint32_t next) const { return (ir.block_meta[next] & ParsedIR::BLOCK_META_CONTINUE_BIT) != 0; } inline bool is_single_block_loop(uint32_t next) const { auto &block = get(next); return block.merge == SPIRBlock::MergeLoop && block.continue_block == ID(next); } inline bool is_break(uint32_t next) const { return (ir.block_meta[next] & (ParsedIR::BLOCK_META_LOOP_MERGE_BIT | ParsedIR::BLOCK_META_MULTISELECT_MERGE_BIT)) != 0; } inline bool is_loop_break(uint32_t next) const { return (ir.block_meta[next] & ParsedIR::BLOCK_META_LOOP_MERGE_BIT) != 0; } inline bool is_conditional(uint32_t next) const { return (ir.block_meta[next] & (ParsedIR::BLOCK_META_SELECTION_MERGE_BIT | ParsedIR::BLOCK_META_MULTISELECT_MERGE_BIT)) != 0; } // Dependency tracking for temporaries read from variables. void flush_dependees(SPIRVariable &var); void flush_all_active_variables(); void flush_control_dependent_expressions(uint32_t block); void flush_all_atomic_capable_variables(); void flush_all_aliased_variables(); void register_global_read_dependencies(const SPIRBlock &func, uint32_t id); void register_global_read_dependencies(const SPIRFunction &func, uint32_t id); std::unordered_set invalid_expressions; void update_name_cache(std::unordered_set &cache, std::string &name); // A variant which takes two sets of names. The secondary is only used to verify there are no collisions, // but the set is not updated when we have found a new name. // Used primarily when adding block interface names. void update_name_cache(std::unordered_set &cache_primary, const std::unordered_set &cache_secondary, std::string &name); bool function_is_pure(const SPIRFunction &func); bool block_is_pure(const SPIRBlock &block); bool execution_is_branchless(const SPIRBlock &from, const SPIRBlock &to) const; bool execution_is_direct_branch(const SPIRBlock &from, const SPIRBlock &to) const; bool execution_is_noop(const SPIRBlock &from, const SPIRBlock &to) const; SPIRBlock::ContinueBlockType continue_block_type(const SPIRBlock &continue_block) const; void force_recompile(); void clear_force_recompile(); bool is_forcing_recompilation() const; bool is_force_recompile = false; bool block_is_loop_candidate(const SPIRBlock &block, SPIRBlock::Method method) const; bool types_are_logically_equivalent(const SPIRType &a, const SPIRType &b) const; void inherit_expression_dependencies(uint32_t dst, uint32_t source); void add_implied_read_expression(SPIRExpression &e, uint32_t source); void add_implied_read_expression(SPIRAccessChain &e, uint32_t source); // For proper multiple entry point support, allow querying if an Input or Output // variable is part of that entry points interface. bool interface_variable_exists_in_entry_point(uint32_t id) const; SmallVector combined_image_samplers; void remap_variable_type_name(const SPIRType &type, const std::string &var_name, std::string &type_name) const { if (variable_remap_callback) variable_remap_callback(type, var_name, type_name); } void set_ir(const ParsedIR &parsed); void set_ir(ParsedIR &&parsed); void parse_fixup(); // Used internally to implement various traversals for queries. struct OpcodeHandler { virtual ~OpcodeHandler() = default; // Return true if traversal should continue. // If false, traversal will end immediately. virtual bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) = 0; virtual bool follow_function_call(const SPIRFunction &) { return true; } virtual void set_current_block(const SPIRBlock &) { } // Called after returning from a function or when entering a block, // can be called multiple times per block, // while set_current_block is only called on block entry. virtual void rearm_current_block(const SPIRBlock &) { } virtual bool begin_function_scope(const uint32_t *, uint32_t) { return true; } virtual bool end_function_scope(const uint32_t *, uint32_t) { return true; } }; struct BufferAccessHandler : OpcodeHandler { BufferAccessHandler(const Compiler &compiler_, SmallVector &ranges_, uint32_t id_) : compiler(compiler_) , ranges(ranges_) , id(id_) { } bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; const Compiler &compiler; SmallVector &ranges; uint32_t id; std::unordered_set seen; }; struct InterfaceVariableAccessHandler : OpcodeHandler { InterfaceVariableAccessHandler(const Compiler &compiler_, std::unordered_set &variables_) : compiler(compiler_) , variables(variables_) { } bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; const Compiler &compiler; std::unordered_set &variables; }; struct CombinedImageSamplerHandler : OpcodeHandler { CombinedImageSamplerHandler(Compiler &compiler_) : compiler(compiler_) { } bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; bool begin_function_scope(const uint32_t *args, uint32_t length) override; bool end_function_scope(const uint32_t *args, uint32_t length) override; Compiler &compiler; // Each function in the call stack needs its own remapping for parameters so we can deduce which global variable each texture/sampler the parameter is statically bound to. std::stack> parameter_remapping; std::stack functions; uint32_t remap_parameter(uint32_t id); void push_remap_parameters(const SPIRFunction &func, const uint32_t *args, uint32_t length); void pop_remap_parameters(); void register_combined_image_sampler(SPIRFunction &caller, VariableID combined_id, VariableID texture_id, VariableID sampler_id, bool depth); }; struct DummySamplerForCombinedImageHandler : OpcodeHandler { DummySamplerForCombinedImageHandler(Compiler &compiler_) : compiler(compiler_) { } bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; Compiler &compiler; bool need_dummy_sampler = false; }; struct ActiveBuiltinHandler : OpcodeHandler { ActiveBuiltinHandler(Compiler &compiler_) : compiler(compiler_) { } bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; Compiler &compiler; void handle_builtin(const SPIRType &type, spv::BuiltIn builtin, const Bitset &decoration_flags); void add_if_builtin(uint32_t id); void add_if_builtin_or_block(uint32_t id); void add_if_builtin(uint32_t id, bool allow_blocks); }; bool traverse_all_reachable_opcodes(const SPIRBlock &block, OpcodeHandler &handler) const; bool traverse_all_reachable_opcodes(const SPIRFunction &block, OpcodeHandler &handler) const; // This must be an ordered data structure so we always pick the same type aliases. SmallVector global_struct_cache; ShaderResources get_shader_resources(const std::unordered_set *active_variables) const; VariableTypeRemapCallback variable_remap_callback; bool get_common_basic_type(const SPIRType &type, SPIRType::BaseType &base_type); std::unordered_set forced_temporaries; std::unordered_set forwarded_temporaries; std::unordered_set suppressed_usage_tracking; std::unordered_set hoisted_temporaries; std::unordered_set forced_invariant_temporaries; Bitset active_input_builtins; Bitset active_output_builtins; uint32_t clip_distance_count = 0; uint32_t cull_distance_count = 0; bool position_invariant = false; void analyze_parameter_preservation( SPIRFunction &entry, const CFG &cfg, const std::unordered_map> &variable_to_blocks, const std::unordered_map> &complete_write_blocks); // If a variable ID or parameter ID is found in this set, a sampler is actually a shadow/comparison sampler. // SPIR-V does not support this distinction, so we must keep track of this information outside the type system. // There might be unrelated IDs found in this set which do not correspond to actual variables. // This set should only be queried for the existence of samplers which are already known to be variables or parameter IDs. // Similar is implemented for images, as well as if subpass inputs are needed. std::unordered_set comparison_ids; bool need_subpass_input = false; // In certain backends, we will need to use a dummy sampler to be able to emit code. // GLSL does not support texelFetch on texture2D objects, but SPIR-V does, // so we need to workaround by having the application inject a dummy sampler. uint32_t dummy_sampler_id = 0; void analyze_image_and_sampler_usage(); struct CombinedImageSamplerDrefHandler : OpcodeHandler { CombinedImageSamplerDrefHandler(Compiler &compiler_) : compiler(compiler_) { } bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; Compiler &compiler; std::unordered_set dref_combined_samplers; }; struct CombinedImageSamplerUsageHandler : OpcodeHandler { CombinedImageSamplerUsageHandler(Compiler &compiler_, const std::unordered_set &dref_combined_samplers_) : compiler(compiler_) , dref_combined_samplers(dref_combined_samplers_) { } bool begin_function_scope(const uint32_t *args, uint32_t length) override; bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; Compiler &compiler; const std::unordered_set &dref_combined_samplers; std::unordered_map> dependency_hierarchy; std::unordered_set comparison_ids; void add_hierarchy_to_comparison_ids(uint32_t ids); bool need_subpass_input = false; void add_dependency(uint32_t dst, uint32_t src); }; void build_function_control_flow_graphs_and_analyze(); std::unordered_map> function_cfgs; const CFG &get_cfg_for_current_function() const; const CFG &get_cfg_for_function(uint32_t id) const; struct CFGBuilder : OpcodeHandler { explicit CFGBuilder(Compiler &compiler_); bool follow_function_call(const SPIRFunction &func) override; bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; Compiler &compiler; std::unordered_map> function_cfgs; }; struct AnalyzeVariableScopeAccessHandler : OpcodeHandler { AnalyzeVariableScopeAccessHandler(Compiler &compiler_, SPIRFunction &entry_); bool follow_function_call(const SPIRFunction &) override; void set_current_block(const SPIRBlock &block) override; void notify_variable_access(uint32_t id, uint32_t block); bool id_is_phi_variable(uint32_t id) const; bool id_is_potential_temporary(uint32_t id) const; bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; Compiler &compiler; SPIRFunction &entry; std::unordered_map> accessed_variables_to_block; std::unordered_map> accessed_temporaries_to_block; std::unordered_map result_id_to_type; std::unordered_map> complete_write_variables_to_block; std::unordered_map> partial_write_variables_to_block; std::unordered_set access_chain_expressions; // Access chains used in multiple blocks mean hoisting all the variables used to construct the access chain as not all backends can use pointers. std::unordered_map> access_chain_children; const SPIRBlock *current_block = nullptr; }; struct StaticExpressionAccessHandler : OpcodeHandler { StaticExpressionAccessHandler(Compiler &compiler_, uint32_t variable_id_); bool follow_function_call(const SPIRFunction &) override; bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; Compiler &compiler; uint32_t variable_id; uint32_t static_expression = 0; uint32_t write_count = 0; }; struct PhysicalStorageBufferPointerHandler : OpcodeHandler { explicit PhysicalStorageBufferPointerHandler(Compiler &compiler_); bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; Compiler &compiler; std::unordered_set types; }; void analyze_non_block_pointer_types(); SmallVector physical_storage_non_block_pointer_types; void analyze_variable_scope(SPIRFunction &function, AnalyzeVariableScopeAccessHandler &handler); void find_function_local_luts(SPIRFunction &function, const AnalyzeVariableScopeAccessHandler &handler, bool single_function); bool may_read_undefined_variable_in_block(const SPIRBlock &block, uint32_t var); // Finds all resources that are written to from inside the critical section, if present. // The critical section is delimited by OpBeginInvocationInterlockEXT and // OpEndInvocationInterlockEXT instructions. In MSL and HLSL, any resources written // while inside the critical section must be placed in a raster order group. struct InterlockedResourceAccessHandler : OpcodeHandler { InterlockedResourceAccessHandler(Compiler &compiler_, uint32_t entry_point_id) : compiler(compiler_) { call_stack.push_back(entry_point_id); } bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; bool begin_function_scope(const uint32_t *args, uint32_t length) override; bool end_function_scope(const uint32_t *args, uint32_t length) override; Compiler &compiler; bool in_crit_sec = false; uint32_t interlock_function_id = 0; bool split_function_case = false; bool control_flow_interlock = false; bool use_critical_section = false; bool call_stack_is_interlocked = false; SmallVector call_stack; void access_potential_resource(uint32_t id); }; struct InterlockedResourceAccessPrepassHandler : OpcodeHandler { InterlockedResourceAccessPrepassHandler(Compiler &compiler_, uint32_t entry_point_id) : compiler(compiler_) { call_stack.push_back(entry_point_id); } void rearm_current_block(const SPIRBlock &block) override; bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; bool begin_function_scope(const uint32_t *args, uint32_t length) override; bool end_function_scope(const uint32_t *args, uint32_t length) override; Compiler &compiler; uint32_t interlock_function_id = 0; uint32_t current_block_id = 0; bool split_function_case = false; bool control_flow_interlock = false; SmallVector call_stack; }; void analyze_interlocked_resource_usage(); // The set of all resources written while inside the critical section, if present. std::unordered_set interlocked_resources; bool interlocked_is_complex = false; void make_constant_null(uint32_t id, uint32_t type); std::unordered_map declared_block_names; bool instruction_to_result_type(uint32_t &result_type, uint32_t &result_id, spv::Op op, const uint32_t *args, uint32_t length); Bitset combined_decoration_for_member(const SPIRType &type, uint32_t index) const; static bool is_desktop_only_format(spv::ImageFormat format); bool image_is_comparison(const SPIRType &type, uint32_t id) const; void set_extended_decoration(uint32_t id, ExtendedDecorations decoration, uint32_t value = 0); uint32_t get_extended_decoration(uint32_t id, ExtendedDecorations decoration) const; bool has_extended_decoration(uint32_t id, ExtendedDecorations decoration) const; void unset_extended_decoration(uint32_t id, ExtendedDecorations decoration); void set_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration, uint32_t value = 0); uint32_t get_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) const; bool has_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) const; void unset_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration); bool type_is_array_of_pointers(const SPIRType &type) const; bool type_is_top_level_physical_pointer(const SPIRType &type) const; bool type_is_block_like(const SPIRType &type) const; bool type_is_opaque_value(const SPIRType &type) const; bool reflection_ssbo_instance_name_is_significant() const; std::string get_remapped_declared_block_name(uint32_t id, bool fallback_prefer_instance_name) const; bool flush_phi_required(BlockID from, BlockID to) const; uint32_t evaluate_spec_constant_u32(const SPIRConstantOp &spec) const; uint32_t evaluate_constant_u32(uint32_t id) const; bool is_vertex_like_shader() const; private: // Used only to implement the old deprecated get_entry_point() interface. const SPIREntryPoint &get_first_entry_point(const std::string &name) const; SPIREntryPoint &get_first_entry_point(const std::string &name); }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_cross_c.cpp000066400000000000000000002356651400026215700177750ustar00rootroot00000000000000/* * Copyright 2019-2021 Hans-Kristian Arntzen * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_cross_c.h" #if SPIRV_CROSS_C_API_CPP #include "spirv_cpp.hpp" #endif #if SPIRV_CROSS_C_API_GLSL #include "spirv_glsl.hpp" #else #include "spirv_cross.hpp" #endif #if SPIRV_CROSS_C_API_HLSL #include "spirv_hlsl.hpp" #endif #if SPIRV_CROSS_C_API_MSL #include "spirv_msl.hpp" #endif #if SPIRV_CROSS_C_API_REFLECT #include "spirv_reflect.hpp" #endif #ifdef HAVE_SPIRV_CROSS_GIT_VERSION #include "gitversion.h" #endif #include "spirv_parser.hpp" #include #include #include // clang-format off #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) #endif #ifndef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS #define SPVC_BEGIN_SAFE_SCOPE try #else #define SPVC_BEGIN_SAFE_SCOPE #endif #ifndef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS #define SPVC_END_SAFE_SCOPE(context, error) \ catch (const std::exception &e) \ { \ (context)->report_error(e.what()); \ return (error); \ } #else #define SPVC_END_SAFE_SCOPE(context, error) #endif using namespace std; using namespace SPIRV_CROSS_NAMESPACE; struct ScratchMemoryAllocation { virtual ~ScratchMemoryAllocation() = default; }; struct StringAllocation : ScratchMemoryAllocation { explicit StringAllocation(const char *name) : str(name) { } explicit StringAllocation(std::string name) : str(std::move(name)) { } std::string str; }; template struct TemporaryBuffer : ScratchMemoryAllocation { SmallVector buffer; }; template static inline std::unique_ptr spvc_allocate(Ts &&... ts) { return std::unique_ptr(new T(std::forward(ts)...)); } struct spvc_context_s { string last_error; SmallVector> allocations; const char *allocate_name(const std::string &name); spvc_error_callback callback = nullptr; void *callback_userdata = nullptr; void report_error(std::string msg); }; void spvc_context_s::report_error(std::string msg) { last_error = std::move(msg); if (callback) callback(callback_userdata, last_error.c_str()); } const char *spvc_context_s::allocate_name(const std::string &name) { SPVC_BEGIN_SAFE_SCOPE { auto alloc = spvc_allocate(name); auto *ret = alloc->str.c_str(); allocations.emplace_back(std::move(alloc)); return ret; } SPVC_END_SAFE_SCOPE(this, nullptr) } struct spvc_parsed_ir_s : ScratchMemoryAllocation { spvc_context context = nullptr; ParsedIR parsed; }; struct spvc_compiler_s : ScratchMemoryAllocation { spvc_context context = nullptr; unique_ptr compiler; spvc_backend backend = SPVC_BACKEND_NONE; }; struct spvc_compiler_options_s : ScratchMemoryAllocation { spvc_context context = nullptr; uint32_t backend_flags = 0; #if SPIRV_CROSS_C_API_GLSL CompilerGLSL::Options glsl; #endif #if SPIRV_CROSS_C_API_MSL CompilerMSL::Options msl; #endif #if SPIRV_CROSS_C_API_HLSL CompilerHLSL::Options hlsl; #endif }; struct spvc_set_s : ScratchMemoryAllocation { std::unordered_set set; }; // Dummy-inherit to we can keep our opaque type handle type safe in C-land as well, // and avoid just throwing void * around. struct spvc_type_s : SPIRType { }; struct spvc_constant_s : SPIRConstant { }; struct spvc_resources_s : ScratchMemoryAllocation { spvc_context context = nullptr; SmallVector uniform_buffers; SmallVector storage_buffers; SmallVector stage_inputs; SmallVector stage_outputs; SmallVector subpass_inputs; SmallVector storage_images; SmallVector sampled_images; SmallVector atomic_counters; SmallVector push_constant_buffers; SmallVector separate_images; SmallVector separate_samplers; SmallVector acceleration_structures; bool copy_resources(SmallVector &outputs, const SmallVector &inputs); bool copy_resources(const ShaderResources &resources); }; spvc_result spvc_context_create(spvc_context *context) { auto *ctx = new (std::nothrow) spvc_context_s; if (!ctx) return SPVC_ERROR_OUT_OF_MEMORY; *context = ctx; return SPVC_SUCCESS; } void spvc_context_destroy(spvc_context context) { delete context; } void spvc_context_release_allocations(spvc_context context) { context->allocations.clear(); } const char *spvc_context_get_last_error_string(spvc_context context) { return context->last_error.c_str(); } SPVC_PUBLIC_API void spvc_context_set_error_callback(spvc_context context, spvc_error_callback cb, void *userdata) { context->callback = cb; context->callback_userdata = userdata; } spvc_result spvc_context_parse_spirv(spvc_context context, const SpvId *spirv, size_t word_count, spvc_parsed_ir *parsed_ir) { SPVC_BEGIN_SAFE_SCOPE { std::unique_ptr pir(new (std::nothrow) spvc_parsed_ir_s); if (!pir) { context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } pir->context = context; Parser parser(spirv, word_count); parser.parse(); pir->parsed = move(parser.get_parsed_ir()); *parsed_ir = pir.get(); context->allocations.push_back(std::move(pir)); } SPVC_END_SAFE_SCOPE(context, SPVC_ERROR_INVALID_SPIRV) return SPVC_SUCCESS; } spvc_result spvc_context_create_compiler(spvc_context context, spvc_backend backend, spvc_parsed_ir parsed_ir, spvc_capture_mode mode, spvc_compiler *compiler) { SPVC_BEGIN_SAFE_SCOPE { std::unique_ptr comp(new (std::nothrow) spvc_compiler_s); if (!comp) { context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } comp->backend = backend; comp->context = context; if (mode != SPVC_CAPTURE_MODE_COPY && mode != SPVC_CAPTURE_MODE_TAKE_OWNERSHIP) { context->report_error("Invalid argument for capture mode."); return SPVC_ERROR_INVALID_ARGUMENT; } switch (backend) { case SPVC_BACKEND_NONE: if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP) comp->compiler.reset(new Compiler(move(parsed_ir->parsed))); else if (mode == SPVC_CAPTURE_MODE_COPY) comp->compiler.reset(new Compiler(parsed_ir->parsed)); break; #if SPIRV_CROSS_C_API_GLSL case SPVC_BACKEND_GLSL: if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP) comp->compiler.reset(new CompilerGLSL(move(parsed_ir->parsed))); else if (mode == SPVC_CAPTURE_MODE_COPY) comp->compiler.reset(new CompilerGLSL(parsed_ir->parsed)); break; #endif #if SPIRV_CROSS_C_API_HLSL case SPVC_BACKEND_HLSL: if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP) comp->compiler.reset(new CompilerHLSL(move(parsed_ir->parsed))); else if (mode == SPVC_CAPTURE_MODE_COPY) comp->compiler.reset(new CompilerHLSL(parsed_ir->parsed)); break; #endif #if SPIRV_CROSS_C_API_MSL case SPVC_BACKEND_MSL: if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP) comp->compiler.reset(new CompilerMSL(move(parsed_ir->parsed))); else if (mode == SPVC_CAPTURE_MODE_COPY) comp->compiler.reset(new CompilerMSL(parsed_ir->parsed)); break; #endif #if SPIRV_CROSS_C_API_CPP case SPVC_BACKEND_CPP: if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP) comp->compiler.reset(new CompilerCPP(move(parsed_ir->parsed))); else if (mode == SPVC_CAPTURE_MODE_COPY) comp->compiler.reset(new CompilerCPP(parsed_ir->parsed)); break; #endif #if SPIRV_CROSS_C_API_REFLECT case SPVC_BACKEND_JSON: if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP) comp->compiler.reset(new CompilerReflection(move(parsed_ir->parsed))); else if (mode == SPVC_CAPTURE_MODE_COPY) comp->compiler.reset(new CompilerReflection(parsed_ir->parsed)); break; #endif default: context->report_error("Invalid backend."); return SPVC_ERROR_INVALID_ARGUMENT; } *compiler = comp.get(); context->allocations.push_back(std::move(comp)); } SPVC_END_SAFE_SCOPE(context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } spvc_result spvc_compiler_create_compiler_options(spvc_compiler compiler, spvc_compiler_options *options) { SPVC_BEGIN_SAFE_SCOPE { std::unique_ptr opt(new (std::nothrow) spvc_compiler_options_s); if (!opt) { compiler->context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } opt->context = compiler->context; opt->backend_flags = 0; switch (compiler->backend) { #if SPIRV_CROSS_C_API_MSL case SPVC_BACKEND_MSL: opt->backend_flags |= SPVC_COMPILER_OPTION_MSL_BIT | SPVC_COMPILER_OPTION_COMMON_BIT; opt->glsl = static_cast(compiler->compiler.get())->get_common_options(); opt->msl = static_cast(compiler->compiler.get())->get_msl_options(); break; #endif #if SPIRV_CROSS_C_API_HLSL case SPVC_BACKEND_HLSL: opt->backend_flags |= SPVC_COMPILER_OPTION_HLSL_BIT | SPVC_COMPILER_OPTION_COMMON_BIT; opt->glsl = static_cast(compiler->compiler.get())->get_common_options(); opt->hlsl = static_cast(compiler->compiler.get())->get_hlsl_options(); break; #endif #if SPIRV_CROSS_C_API_GLSL case SPVC_BACKEND_GLSL: opt->backend_flags |= SPVC_COMPILER_OPTION_GLSL_BIT | SPVC_COMPILER_OPTION_COMMON_BIT; opt->glsl = static_cast(compiler->compiler.get())->get_common_options(); break; #endif default: break; } *options = opt.get(); compiler->context->allocations.push_back(std::move(opt)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } spvc_result spvc_compiler_options_set_bool(spvc_compiler_options options, spvc_compiler_option option, spvc_bool value) { return spvc_compiler_options_set_uint(options, option, value ? 1 : 0); } spvc_result spvc_compiler_options_set_uint(spvc_compiler_options options, spvc_compiler_option option, unsigned value) { (void)value; (void)option; uint32_t supported_mask = options->backend_flags; uint32_t required_mask = option & SPVC_COMPILER_OPTION_LANG_BITS; if ((required_mask | supported_mask) != supported_mask) { options->context->report_error("Option is not supported by current backend."); return SPVC_ERROR_INVALID_ARGUMENT; } switch (option) { #if SPIRV_CROSS_C_API_GLSL case SPVC_COMPILER_OPTION_FORCE_TEMPORARY: options->glsl.force_temporary = value != 0; break; case SPVC_COMPILER_OPTION_FLATTEN_MULTIDIMENSIONAL_ARRAYS: options->glsl.flatten_multidimensional_arrays = value != 0; break; case SPVC_COMPILER_OPTION_FIXUP_DEPTH_CONVENTION: options->glsl.vertex.fixup_clipspace = value != 0; break; case SPVC_COMPILER_OPTION_FLIP_VERTEX_Y: options->glsl.vertex.flip_vert_y = value != 0; break; case SPVC_COMPILER_OPTION_EMIT_LINE_DIRECTIVES: options->glsl.emit_line_directives = value != 0; break; case SPVC_COMPILER_OPTION_ENABLE_STORAGE_IMAGE_QUALIFIER_DEDUCTION: options->glsl.enable_storage_image_qualifier_deduction = value != 0; break; case SPVC_COMPILER_OPTION_FORCE_ZERO_INITIALIZED_VARIABLES: options->glsl.force_zero_initialized_variables = value != 0; break; case SPVC_COMPILER_OPTION_GLSL_SUPPORT_NONZERO_BASE_INSTANCE: options->glsl.vertex.support_nonzero_base_instance = value != 0; break; case SPVC_COMPILER_OPTION_GLSL_SEPARATE_SHADER_OBJECTS: options->glsl.separate_shader_objects = value != 0; break; case SPVC_COMPILER_OPTION_GLSL_ENABLE_420PACK_EXTENSION: options->glsl.enable_420pack_extension = value != 0; break; case SPVC_COMPILER_OPTION_GLSL_VERSION: options->glsl.version = value; break; case SPVC_COMPILER_OPTION_GLSL_ES: options->glsl.es = value != 0; break; case SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS: options->glsl.vulkan_semantics = value != 0; break; case SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_FLOAT_PRECISION_HIGHP: options->glsl.fragment.default_float_precision = value != 0 ? CompilerGLSL::Options::Precision::Highp : CompilerGLSL::Options::Precision::Mediump; break; case SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_INT_PRECISION_HIGHP: options->glsl.fragment.default_int_precision = value != 0 ? CompilerGLSL::Options::Precision::Highp : CompilerGLSL::Options::Precision::Mediump; break; case SPVC_COMPILER_OPTION_GLSL_EMIT_PUSH_CONSTANT_AS_UNIFORM_BUFFER: options->glsl.emit_push_constant_as_uniform_buffer = value != 0; break; case SPVC_COMPILER_OPTION_GLSL_EMIT_UNIFORM_BUFFER_AS_PLAIN_UNIFORMS: options->glsl.emit_uniform_buffer_as_plain_uniforms = value != 0; break; case SPVC_COMPILER_OPTION_GLSL_FORCE_FLATTENED_IO_BLOCKS: options->glsl.force_flattened_io_blocks = value != 0; break; #endif #if SPIRV_CROSS_C_API_HLSL case SPVC_COMPILER_OPTION_HLSL_SHADER_MODEL: options->hlsl.shader_model = value; break; case SPVC_COMPILER_OPTION_HLSL_POINT_SIZE_COMPAT: options->hlsl.point_size_compat = value != 0; break; case SPVC_COMPILER_OPTION_HLSL_POINT_COORD_COMPAT: options->hlsl.point_coord_compat = value != 0; break; case SPVC_COMPILER_OPTION_HLSL_SUPPORT_NONZERO_BASE_VERTEX_BASE_INSTANCE: options->hlsl.support_nonzero_base_vertex_base_instance = value != 0; break; case SPVC_COMPILER_OPTION_HLSL_FORCE_STORAGE_BUFFER_AS_UAV: options->hlsl.force_storage_buffer_as_uav = value != 0; break; case SPVC_COMPILER_OPTION_HLSL_NONWRITABLE_UAV_TEXTURE_AS_SRV: options->hlsl.nonwritable_uav_texture_as_srv = value != 0; break; case SPVC_COMPILER_OPTION_HLSL_ENABLE_16BIT_TYPES: options->hlsl.enable_16bit_types = value != 0; break; case SPVC_COMPILER_OPTION_HLSL_FLATTEN_MATRIX_VERTEX_INPUT_SEMANTICS: options->hlsl.flatten_matrix_vertex_input_semantics = value != 0; break; #endif #if SPIRV_CROSS_C_API_MSL case SPVC_COMPILER_OPTION_MSL_VERSION: options->msl.msl_version = value; break; case SPVC_COMPILER_OPTION_MSL_TEXEL_BUFFER_TEXTURE_WIDTH: options->msl.texel_buffer_texture_width = value; break; case SPVC_COMPILER_OPTION_MSL_SWIZZLE_BUFFER_INDEX: options->msl.swizzle_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_INDIRECT_PARAMS_BUFFER_INDEX: options->msl.indirect_params_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_SHADER_OUTPUT_BUFFER_INDEX: options->msl.shader_output_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_SHADER_PATCH_OUTPUT_BUFFER_INDEX: options->msl.shader_patch_output_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_SHADER_TESS_FACTOR_OUTPUT_BUFFER_INDEX: options->msl.shader_tess_factor_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_WORKGROUP_INDEX: options->msl.shader_input_wg_index = value; break; case SPVC_COMPILER_OPTION_MSL_ENABLE_POINT_SIZE_BUILTIN: options->msl.enable_point_size_builtin = value != 0; break; case SPVC_COMPILER_OPTION_MSL_DISABLE_RASTERIZATION: options->msl.disable_rasterization = value != 0; break; case SPVC_COMPILER_OPTION_MSL_CAPTURE_OUTPUT_TO_BUFFER: options->msl.capture_output_to_buffer = value != 0; break; case SPVC_COMPILER_OPTION_MSL_SWIZZLE_TEXTURE_SAMPLES: options->msl.swizzle_texture_samples = value != 0; break; case SPVC_COMPILER_OPTION_MSL_PAD_FRAGMENT_OUTPUT_COMPONENTS: options->msl.pad_fragment_output_components = value != 0; break; case SPVC_COMPILER_OPTION_MSL_TESS_DOMAIN_ORIGIN_LOWER_LEFT: options->msl.tess_domain_origin_lower_left = value != 0; break; case SPVC_COMPILER_OPTION_MSL_PLATFORM: options->msl.platform = static_cast(value); break; case SPVC_COMPILER_OPTION_MSL_ARGUMENT_BUFFERS: options->msl.argument_buffers = value != 0; break; case SPVC_COMPILER_OPTION_MSL_TEXTURE_BUFFER_NATIVE: options->msl.texture_buffer_native = value != 0; break; case SPVC_COMPILER_OPTION_MSL_BUFFER_SIZE_BUFFER_INDEX: options->msl.buffer_size_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_MULTIVIEW: options->msl.multiview = value != 0; break; case SPVC_COMPILER_OPTION_MSL_VIEW_MASK_BUFFER_INDEX: options->msl.view_mask_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_DEVICE_INDEX: options->msl.device_index = value; break; case SPVC_COMPILER_OPTION_MSL_VIEW_INDEX_FROM_DEVICE_INDEX: options->msl.view_index_from_device_index = value != 0; break; case SPVC_COMPILER_OPTION_MSL_DISPATCH_BASE: options->msl.dispatch_base = value != 0; break; case SPVC_COMPILER_OPTION_MSL_DYNAMIC_OFFSETS_BUFFER_INDEX: options->msl.dynamic_offsets_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_TEXTURE_1D_AS_2D: options->msl.texture_1D_as_2D = value != 0; break; case SPVC_COMPILER_OPTION_MSL_ENABLE_BASE_INDEX_ZERO: options->msl.enable_base_index_zero = value != 0; break; case SPVC_COMPILER_OPTION_MSL_FRAMEBUFFER_FETCH_SUBPASS: options->msl.use_framebuffer_fetch_subpasses = value != 0; break; case SPVC_COMPILER_OPTION_MSL_INVARIANT_FP_MATH: options->msl.invariant_float_math = value != 0; break; case SPVC_COMPILER_OPTION_MSL_EMULATE_CUBEMAP_ARRAY: options->msl.emulate_cube_array = value != 0; break; case SPVC_COMPILER_OPTION_MSL_ENABLE_DECORATION_BINDING: options->msl.enable_decoration_binding = value != 0; break; case SPVC_COMPILER_OPTION_MSL_FORCE_ACTIVE_ARGUMENT_BUFFER_RESOURCES: options->msl.force_active_argument_buffer_resources = value != 0; break; case SPVC_COMPILER_OPTION_MSL_FORCE_NATIVE_ARRAYS: options->msl.force_native_arrays = value != 0; break; case SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_OUTPUT_MASK: options->msl.enable_frag_output_mask = value; break; case SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_DEPTH_BUILTIN: options->msl.enable_frag_depth_builtin = value != 0; break; case SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_STENCIL_REF_BUILTIN: options->msl.enable_frag_stencil_ref_builtin = value != 0; break; case SPVC_COMPILER_OPTION_MSL_ENABLE_CLIP_DISTANCE_USER_VARYING: options->msl.enable_clip_distance_user_varying = value != 0; break; case SPVC_COMPILER_OPTION_MSL_MULTI_PATCH_WORKGROUP: options->msl.multi_patch_workgroup = value != 0; break; case SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_BUFFER_INDEX: options->msl.shader_input_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_SHADER_INDEX_BUFFER_INDEX: options->msl.shader_index_buffer_index = value; break; case SPVC_COMPILER_OPTION_MSL_VERTEX_FOR_TESSELLATION: options->msl.vertex_for_tessellation = value != 0; break; case SPVC_COMPILER_OPTION_MSL_VERTEX_INDEX_TYPE: options->msl.vertex_index_type = static_cast(value); break; case SPVC_COMPILER_OPTION_MSL_MULTIVIEW_LAYERED_RENDERING: options->msl.multiview_layered_rendering = value != 0; break; case SPVC_COMPILER_OPTION_MSL_ARRAYED_SUBPASS_INPUT: options->msl.arrayed_subpass_input = value != 0; break; case SPVC_COMPILER_OPTION_MSL_R32UI_LINEAR_TEXTURE_ALIGNMENT: options->msl.r32ui_linear_texture_alignment = value; break; case SPVC_COMPILER_OPTION_MSL_R32UI_ALIGNMENT_CONSTANT_ID: options->msl.r32ui_alignment_constant_id = value; break; case SPVC_COMPILER_OPTION_MSL_IOS_USE_SIMDGROUP_FUNCTIONS: options->msl.ios_use_simdgroup_functions = value != 0; break; case SPVC_COMPILER_OPTION_MSL_EMULATE_SUBGROUPS: options->msl.emulate_subgroups = value != 0; break; case SPVC_COMPILER_OPTION_MSL_FIXED_SUBGROUP_SIZE: options->msl.fixed_subgroup_size = value; break; case SPVC_COMPILER_OPTION_MSL_FORCE_SAMPLE_RATE_SHADING: options->msl.force_sample_rate_shading = value != 0; break; #endif default: options->context->report_error("Unknown option."); return SPVC_ERROR_INVALID_ARGUMENT; } return SPVC_SUCCESS; } spvc_result spvc_compiler_install_compiler_options(spvc_compiler compiler, spvc_compiler_options options) { (void)options; switch (compiler->backend) { #if SPIRV_CROSS_C_API_GLSL case SPVC_BACKEND_GLSL: static_cast(*compiler->compiler).set_common_options(options->glsl); break; #endif #if SPIRV_CROSS_C_API_HLSL case SPVC_BACKEND_HLSL: static_cast(*compiler->compiler).set_common_options(options->glsl); static_cast(*compiler->compiler).set_hlsl_options(options->hlsl); break; #endif #if SPIRV_CROSS_C_API_MSL case SPVC_BACKEND_MSL: static_cast(*compiler->compiler).set_common_options(options->glsl); static_cast(*compiler->compiler).set_msl_options(options->msl); break; #endif default: break; } return SPVC_SUCCESS; } spvc_result spvc_compiler_add_header_line(spvc_compiler compiler, const char *line) { #if SPIRV_CROSS_C_API_GLSL if (compiler->backend == SPVC_BACKEND_NONE) { compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection."); return SPVC_ERROR_INVALID_ARGUMENT; } static_cast(compiler->compiler.get())->add_header_line(line); return SPVC_SUCCESS; #else (void)line; compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_require_extension(spvc_compiler compiler, const char *line) { #if SPIRV_CROSS_C_API_GLSL if (compiler->backend == SPVC_BACKEND_NONE) { compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection."); return SPVC_ERROR_INVALID_ARGUMENT; } static_cast(compiler->compiler.get())->require_extension(line); return SPVC_SUCCESS; #else (void)line; compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_flatten_buffer_block(spvc_compiler compiler, spvc_variable_id id) { #if SPIRV_CROSS_C_API_GLSL if (compiler->backend == SPVC_BACKEND_NONE) { compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection."); return SPVC_ERROR_INVALID_ARGUMENT; } static_cast(compiler->compiler.get())->flatten_buffer_block(id); return SPVC_SUCCESS; #else (void)id; compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_bool spvc_compiler_variable_is_depth_or_compare(spvc_compiler compiler, spvc_variable_id id) { #if SPIRV_CROSS_C_API_GLSL if (compiler->backend == SPVC_BACKEND_NONE) { compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection."); return SPVC_ERROR_INVALID_ARGUMENT; } return static_cast(compiler->compiler.get())->variable_is_depth_or_compare(id) ? SPVC_TRUE : SPVC_FALSE; #else (void)id; compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection."); return SPVC_FALSE; #endif } spvc_result spvc_compiler_hlsl_set_root_constants_layout(spvc_compiler compiler, const spvc_hlsl_root_constants *constant_info, size_t count) { #if SPIRV_CROSS_C_API_HLSL if (compiler->backend != SPVC_BACKEND_HLSL) { compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &hlsl = *static_cast(compiler->compiler.get()); vector roots; roots.reserve(count); for (size_t i = 0; i < count; i++) { RootConstants root; root.binding = constant_info[i].binding; root.space = constant_info[i].space; root.start = constant_info[i].start; root.end = constant_info[i].end; roots.push_back(root); } hlsl.set_root_constant_layouts(std::move(roots)); return SPVC_SUCCESS; #else (void)constant_info; (void)count; compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_hlsl_add_vertex_attribute_remap(spvc_compiler compiler, const spvc_hlsl_vertex_attribute_remap *remap, size_t count) { #if SPIRV_CROSS_C_API_HLSL if (compiler->backend != SPVC_BACKEND_HLSL) { compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } HLSLVertexAttributeRemap re; auto &hlsl = *static_cast(compiler->compiler.get()); for (size_t i = 0; i < count; i++) { re.location = remap[i].location; re.semantic = remap[i].semantic; hlsl.add_vertex_attribute_remap(re); } return SPVC_SUCCESS; #else (void)remap; (void)count; compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_variable_id spvc_compiler_hlsl_remap_num_workgroups_builtin(spvc_compiler compiler) { #if SPIRV_CROSS_C_API_HLSL if (compiler->backend != SPVC_BACKEND_HLSL) { compiler->context->report_error("HLSL function used on a non-HLSL backend."); return 0; } auto &hlsl = *static_cast(compiler->compiler.get()); return hlsl.remap_num_workgroups_builtin(); #else compiler->context->report_error("HLSL function used on a non-HLSL backend."); return 0; #endif } spvc_result spvc_compiler_hlsl_set_resource_binding_flags(spvc_compiler compiler, spvc_hlsl_binding_flags flags) { #if SPIRV_CROSS_C_API_HLSL if (compiler->backend != SPVC_BACKEND_HLSL) { compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &hlsl = *static_cast(compiler->compiler.get()); hlsl.set_resource_binding_flags(flags); return SPVC_SUCCESS; #else (void)flags; compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_hlsl_add_resource_binding(spvc_compiler compiler, const spvc_hlsl_resource_binding *binding) { #if SPIRV_CROSS_C_API_HLSL if (compiler->backend != SPVC_BACKEND_HLSL) { compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &hlsl = *static_cast(compiler->compiler.get()); HLSLResourceBinding bind; bind.binding = binding->binding; bind.desc_set = binding->desc_set; bind.stage = static_cast(binding->stage); bind.cbv.register_binding = binding->cbv.register_binding; bind.cbv.register_space = binding->cbv.register_space; bind.uav.register_binding = binding->uav.register_binding; bind.uav.register_space = binding->uav.register_space; bind.srv.register_binding = binding->srv.register_binding; bind.srv.register_space = binding->srv.register_space; bind.sampler.register_binding = binding->sampler.register_binding; bind.sampler.register_space = binding->sampler.register_space; hlsl.add_hlsl_resource_binding(bind); return SPVC_SUCCESS; #else (void)binding; compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_bool spvc_compiler_hlsl_is_resource_used(spvc_compiler compiler, SpvExecutionModel model, unsigned set, unsigned binding) { #if SPIRV_CROSS_C_API_HLSL if (compiler->backend != SPVC_BACKEND_HLSL) { compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_FALSE; } auto &hlsl = *static_cast(compiler->compiler.get()); return hlsl.is_hlsl_resource_binding_used(static_cast(model), set, binding) ? SPVC_TRUE : SPVC_FALSE; #else (void)model; (void)set; (void)binding; compiler->context->report_error("HLSL function used on a non-HLSL backend."); return SPVC_FALSE; #endif } spvc_bool spvc_compiler_msl_is_rasterization_disabled(spvc_compiler compiler) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; } auto &msl = *static_cast(compiler->compiler.get()); return msl.get_is_rasterization_disabled() ? SPVC_TRUE : SPVC_FALSE; #else compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; #endif } spvc_bool spvc_compiler_msl_needs_swizzle_buffer(spvc_compiler compiler) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; } auto &msl = *static_cast(compiler->compiler.get()); return msl.needs_swizzle_buffer() ? SPVC_TRUE : SPVC_FALSE; #else compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; #endif } spvc_bool spvc_compiler_msl_needs_buffer_size_buffer(spvc_compiler compiler) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; } auto &msl = *static_cast(compiler->compiler.get()); return msl.needs_buffer_size_buffer() ? SPVC_TRUE : SPVC_FALSE; #else compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; #endif } spvc_bool spvc_compiler_msl_needs_aux_buffer(spvc_compiler compiler) { return spvc_compiler_msl_needs_swizzle_buffer(compiler); } spvc_bool spvc_compiler_msl_needs_output_buffer(spvc_compiler compiler) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; } auto &msl = *static_cast(compiler->compiler.get()); return msl.needs_output_buffer() ? SPVC_TRUE : SPVC_FALSE; #else compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; #endif } spvc_bool spvc_compiler_msl_needs_patch_output_buffer(spvc_compiler compiler) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; } auto &msl = *static_cast(compiler->compiler.get()); return msl.needs_patch_output_buffer() ? SPVC_TRUE : SPVC_FALSE; #else compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; #endif } spvc_bool spvc_compiler_msl_needs_input_threadgroup_mem(spvc_compiler compiler) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; } auto &msl = *static_cast(compiler->compiler.get()); return msl.needs_input_threadgroup_mem() ? SPVC_TRUE : SPVC_FALSE; #else compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; #endif } spvc_result spvc_compiler_msl_add_vertex_attribute(spvc_compiler compiler, const spvc_msl_vertex_attribute *va) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); MSLShaderInput attr; attr.location = va->location; attr.format = static_cast(va->format); attr.builtin = static_cast(va->builtin); msl.add_msl_shader_input(attr); return SPVC_SUCCESS; #else (void)va; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_add_shader_input(spvc_compiler compiler, const spvc_msl_shader_input *si) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); MSLShaderInput input; input.location = si->location; input.format = static_cast(si->format); input.builtin = static_cast(si->builtin); input.vecsize = si->vecsize; msl.add_msl_shader_input(input); return SPVC_SUCCESS; #else (void)si; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_add_resource_binding(spvc_compiler compiler, const spvc_msl_resource_binding *binding) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); MSLResourceBinding bind; bind.binding = binding->binding; bind.desc_set = binding->desc_set; bind.stage = static_cast(binding->stage); bind.msl_buffer = binding->msl_buffer; bind.msl_texture = binding->msl_texture; bind.msl_sampler = binding->msl_sampler; msl.add_msl_resource_binding(bind); return SPVC_SUCCESS; #else (void)binding; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_add_dynamic_buffer(spvc_compiler compiler, unsigned desc_set, unsigned binding, unsigned index) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); msl.add_dynamic_buffer(desc_set, binding, index); return SPVC_SUCCESS; #else (void)binding; (void)desc_set; (void)index; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_add_inline_uniform_block(spvc_compiler compiler, unsigned desc_set, unsigned binding) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); msl.add_inline_uniform_block(desc_set, binding); return SPVC_SUCCESS; #else (void)binding; (void)desc_set; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_add_discrete_descriptor_set(spvc_compiler compiler, unsigned desc_set) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); msl.add_discrete_descriptor_set(desc_set); return SPVC_SUCCESS; #else (void)desc_set; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_set_argument_buffer_device_address_space(spvc_compiler compiler, unsigned desc_set, spvc_bool device_address) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); msl.set_argument_buffer_device_address_space(desc_set, bool(device_address)); return SPVC_SUCCESS; #else (void)desc_set; (void)device_address; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_bool spvc_compiler_msl_is_shader_input_used(spvc_compiler compiler, unsigned location) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; } auto &msl = *static_cast(compiler->compiler.get()); return msl.is_msl_shader_input_used(location) ? SPVC_TRUE : SPVC_FALSE; #else (void)location; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; #endif } spvc_bool spvc_compiler_msl_is_vertex_attribute_used(spvc_compiler compiler, unsigned location) { return spvc_compiler_msl_is_shader_input_used(compiler, location); } spvc_bool spvc_compiler_msl_is_resource_used(spvc_compiler compiler, SpvExecutionModel model, unsigned set, unsigned binding) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; } auto &msl = *static_cast(compiler->compiler.get()); return msl.is_msl_resource_binding_used(static_cast(model), set, binding) ? SPVC_TRUE : SPVC_FALSE; #else (void)model; (void)set; (void)binding; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_FALSE; #endif } spvc_result spvc_compiler_msl_set_combined_sampler_suffix(spvc_compiler compiler, const char *suffix) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); msl.set_combined_sampler_suffix(suffix); return SPVC_SUCCESS; #else (void)suffix; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } const char *spvc_compiler_msl_get_combined_sampler_suffix(spvc_compiler compiler) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return ""; } auto &msl = *static_cast(compiler->compiler.get()); return msl.get_combined_sampler_suffix(); #else compiler->context->report_error("MSL function used on a non-MSL backend."); return ""; #endif } #if SPIRV_CROSS_C_API_MSL static void spvc_convert_msl_sampler(MSLConstexprSampler &samp, const spvc_msl_constexpr_sampler *sampler) { samp.s_address = static_cast(sampler->s_address); samp.t_address = static_cast(sampler->t_address); samp.r_address = static_cast(sampler->r_address); samp.lod_clamp_min = sampler->lod_clamp_min; samp.lod_clamp_max = sampler->lod_clamp_max; samp.lod_clamp_enable = sampler->lod_clamp_enable != 0; samp.min_filter = static_cast(sampler->min_filter); samp.mag_filter = static_cast(sampler->mag_filter); samp.mip_filter = static_cast(sampler->mip_filter); samp.compare_enable = sampler->compare_enable != 0; samp.anisotropy_enable = sampler->anisotropy_enable != 0; samp.max_anisotropy = sampler->max_anisotropy; samp.compare_func = static_cast(sampler->compare_func); samp.coord = static_cast(sampler->coord); samp.border_color = static_cast(sampler->border_color); } static void spvc_convert_msl_sampler_ycbcr_conversion(MSLConstexprSampler &samp, const spvc_msl_sampler_ycbcr_conversion *conv) { samp.ycbcr_conversion_enable = conv != nullptr; if (conv == nullptr) return; samp.planes = conv->planes; samp.resolution = static_cast(conv->resolution); samp.chroma_filter = static_cast(conv->chroma_filter); samp.x_chroma_offset = static_cast(conv->x_chroma_offset); samp.y_chroma_offset = static_cast(conv->y_chroma_offset); for (int i = 0; i < 4; i++) samp.swizzle[i] = static_cast(conv->swizzle[i]); samp.ycbcr_model = static_cast(conv->ycbcr_model); samp.ycbcr_range = static_cast(conv->ycbcr_range); samp.bpc = conv->bpc; } #endif spvc_result spvc_compiler_msl_remap_constexpr_sampler(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); MSLConstexprSampler samp; spvc_convert_msl_sampler(samp, sampler); msl.remap_constexpr_sampler(id, samp); return SPVC_SUCCESS; #else (void)id; (void)sampler; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); MSLConstexprSampler samp; spvc_convert_msl_sampler(samp, sampler); msl.remap_constexpr_sampler_by_binding(desc_set, binding, samp); return SPVC_SUCCESS; #else (void)desc_set; (void)binding; (void)sampler; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_remap_constexpr_sampler_ycbcr(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); MSLConstexprSampler samp; spvc_convert_msl_sampler(samp, sampler); spvc_convert_msl_sampler_ycbcr_conversion(samp, conv); msl.remap_constexpr_sampler(id, samp); return SPVC_SUCCESS; #else (void)id; (void)sampler; (void)conv; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); MSLConstexprSampler samp; spvc_convert_msl_sampler(samp, sampler); spvc_convert_msl_sampler_ycbcr_conversion(samp, conv); msl.remap_constexpr_sampler_by_binding(desc_set, binding, samp); return SPVC_SUCCESS; #else (void)desc_set; (void)binding; (void)sampler; (void)conv; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } spvc_result spvc_compiler_msl_set_fragment_output_components(spvc_compiler compiler, unsigned location, unsigned components) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; } auto &msl = *static_cast(compiler->compiler.get()); msl.set_fragment_output_components(location, components); return SPVC_SUCCESS; #else (void)location; (void)components; compiler->context->report_error("MSL function used on a non-MSL backend."); return SPVC_ERROR_INVALID_ARGUMENT; #endif } unsigned spvc_compiler_msl_get_automatic_resource_binding(spvc_compiler compiler, spvc_variable_id id) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return uint32_t(-1); } auto &msl = *static_cast(compiler->compiler.get()); return msl.get_automatic_msl_resource_binding(id); #else (void)id; compiler->context->report_error("MSL function used on a non-MSL backend."); return uint32_t(-1); #endif } unsigned spvc_compiler_msl_get_automatic_resource_binding_secondary(spvc_compiler compiler, spvc_variable_id id) { #if SPIRV_CROSS_C_API_MSL if (compiler->backend != SPVC_BACKEND_MSL) { compiler->context->report_error("MSL function used on a non-MSL backend."); return uint32_t(-1); } auto &msl = *static_cast(compiler->compiler.get()); return msl.get_automatic_msl_resource_binding_secondary(id); #else (void)id; compiler->context->report_error("MSL function used on a non-MSL backend."); return uint32_t(-1); #endif } spvc_result spvc_compiler_compile(spvc_compiler compiler, const char **source) { SPVC_BEGIN_SAFE_SCOPE { auto result = compiler->compiler->compile(); if (result.empty()) { compiler->context->report_error("Unsupported SPIR-V."); return SPVC_ERROR_UNSUPPORTED_SPIRV; } *source = compiler->context->allocate_name(result); if (!*source) { compiler->context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } return SPVC_SUCCESS; } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_UNSUPPORTED_SPIRV) } bool spvc_resources_s::copy_resources(SmallVector &outputs, const SmallVector &inputs) { for (auto &i : inputs) { spvc_reflected_resource r; r.base_type_id = i.base_type_id; r.type_id = i.type_id; r.id = i.id; r.name = context->allocate_name(i.name); if (!r.name) return false; outputs.push_back(r); } return true; } bool spvc_resources_s::copy_resources(const ShaderResources &resources) { if (!copy_resources(uniform_buffers, resources.uniform_buffers)) return false; if (!copy_resources(storage_buffers, resources.storage_buffers)) return false; if (!copy_resources(stage_inputs, resources.stage_inputs)) return false; if (!copy_resources(stage_outputs, resources.stage_outputs)) return false; if (!copy_resources(subpass_inputs, resources.subpass_inputs)) return false; if (!copy_resources(storage_images, resources.storage_images)) return false; if (!copy_resources(sampled_images, resources.sampled_images)) return false; if (!copy_resources(atomic_counters, resources.atomic_counters)) return false; if (!copy_resources(push_constant_buffers, resources.push_constant_buffers)) return false; if (!copy_resources(separate_images, resources.separate_images)) return false; if (!copy_resources(separate_samplers, resources.separate_samplers)) return false; if (!copy_resources(acceleration_structures, resources.acceleration_structures)) return false; return true; } spvc_result spvc_compiler_get_active_interface_variables(spvc_compiler compiler, spvc_set *set) { SPVC_BEGIN_SAFE_SCOPE { std::unique_ptr ptr(new (std::nothrow) spvc_set_s); if (!ptr) { compiler->context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } auto active = compiler->compiler->get_active_interface_variables(); ptr->set = std::move(active); *set = ptr.get(); compiler->context->allocations.push_back(std::move(ptr)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } spvc_result spvc_compiler_set_enabled_interface_variables(spvc_compiler compiler, spvc_set set) { SPVC_BEGIN_SAFE_SCOPE { compiler->compiler->set_enabled_interface_variables(set->set); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } spvc_result spvc_compiler_create_shader_resources_for_active_variables(spvc_compiler compiler, spvc_resources *resources, spvc_set set) { SPVC_BEGIN_SAFE_SCOPE { std::unique_ptr res(new (std::nothrow) spvc_resources_s); if (!res) { compiler->context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } res->context = compiler->context; auto accessed_resources = compiler->compiler->get_shader_resources(set->set); if (!res->copy_resources(accessed_resources)) { res->context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } *resources = res.get(); compiler->context->allocations.push_back(std::move(res)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } spvc_result spvc_compiler_create_shader_resources(spvc_compiler compiler, spvc_resources *resources) { SPVC_BEGIN_SAFE_SCOPE { std::unique_ptr res(new (std::nothrow) spvc_resources_s); if (!res) { compiler->context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } res->context = compiler->context; auto accessed_resources = compiler->compiler->get_shader_resources(); if (!res->copy_resources(accessed_resources)) { res->context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } *resources = res.get(); compiler->context->allocations.push_back(std::move(res)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } spvc_result spvc_resources_get_resource_list_for_type(spvc_resources resources, spvc_resource_type type, const spvc_reflected_resource **resource_list, size_t *resource_size) { const SmallVector *list = nullptr; switch (type) { case SPVC_RESOURCE_TYPE_UNIFORM_BUFFER: list = &resources->uniform_buffers; break; case SPVC_RESOURCE_TYPE_STORAGE_BUFFER: list = &resources->storage_buffers; break; case SPVC_RESOURCE_TYPE_STAGE_INPUT: list = &resources->stage_inputs; break; case SPVC_RESOURCE_TYPE_STAGE_OUTPUT: list = &resources->stage_outputs; break; case SPVC_RESOURCE_TYPE_SUBPASS_INPUT: list = &resources->subpass_inputs; break; case SPVC_RESOURCE_TYPE_STORAGE_IMAGE: list = &resources->storage_images; break; case SPVC_RESOURCE_TYPE_SAMPLED_IMAGE: list = &resources->sampled_images; break; case SPVC_RESOURCE_TYPE_ATOMIC_COUNTER: list = &resources->atomic_counters; break; case SPVC_RESOURCE_TYPE_PUSH_CONSTANT: list = &resources->push_constant_buffers; break; case SPVC_RESOURCE_TYPE_SEPARATE_IMAGE: list = &resources->separate_images; break; case SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS: list = &resources->separate_samplers; break; case SPVC_RESOURCE_TYPE_ACCELERATION_STRUCTURE: list = &resources->acceleration_structures; break; default: break; } if (!list) { resources->context->report_error("Invalid argument."); return SPVC_ERROR_INVALID_ARGUMENT; } *resource_size = list->size(); *resource_list = list->data(); return SPVC_SUCCESS; } void spvc_compiler_set_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration, unsigned argument) { compiler->compiler->set_decoration(id, static_cast(decoration), argument); } void spvc_compiler_set_decoration_string(spvc_compiler compiler, SpvId id, SpvDecoration decoration, const char *argument) { compiler->compiler->set_decoration_string(id, static_cast(decoration), argument); } void spvc_compiler_set_name(spvc_compiler compiler, SpvId id, const char *argument) { compiler->compiler->set_name(id, argument); } void spvc_compiler_set_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration, unsigned argument) { compiler->compiler->set_member_decoration(id, member_index, static_cast(decoration), argument); } void spvc_compiler_set_member_decoration_string(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration, const char *argument) { compiler->compiler->set_member_decoration_string(id, member_index, static_cast(decoration), argument); } void spvc_compiler_set_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index, const char *argument) { compiler->compiler->set_member_name(id, member_index, argument); } void spvc_compiler_unset_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration) { compiler->compiler->unset_decoration(id, static_cast(decoration)); } void spvc_compiler_unset_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration) { compiler->compiler->unset_member_decoration(id, member_index, static_cast(decoration)); } spvc_bool spvc_compiler_has_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration) { return compiler->compiler->has_decoration(id, static_cast(decoration)) ? SPVC_TRUE : SPVC_FALSE; } spvc_bool spvc_compiler_has_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration) { return compiler->compiler->has_member_decoration(id, member_index, static_cast(decoration)) ? SPVC_TRUE : SPVC_FALSE; } const char *spvc_compiler_get_name(spvc_compiler compiler, SpvId id) { return compiler->compiler->get_name(id).c_str(); } unsigned spvc_compiler_get_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration) { return compiler->compiler->get_decoration(id, static_cast(decoration)); } const char *spvc_compiler_get_decoration_string(spvc_compiler compiler, SpvId id, SpvDecoration decoration) { return compiler->compiler->get_decoration_string(id, static_cast(decoration)).c_str(); } unsigned spvc_compiler_get_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration) { return compiler->compiler->get_member_decoration(id, member_index, static_cast(decoration)); } const char *spvc_compiler_get_member_decoration_string(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration) { return compiler->compiler->get_member_decoration_string(id, member_index, static_cast(decoration)) .c_str(); } const char *spvc_compiler_get_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index) { return compiler->compiler->get_member_name(id, member_index).c_str(); } spvc_result spvc_compiler_get_entry_points(spvc_compiler compiler, const spvc_entry_point **entry_points, size_t *num_entry_points) { SPVC_BEGIN_SAFE_SCOPE { auto entries = compiler->compiler->get_entry_points_and_stages(); SmallVector translated; translated.reserve(entries.size()); for (auto &entry : entries) { spvc_entry_point new_entry; new_entry.execution_model = static_cast(entry.execution_model); new_entry.name = compiler->context->allocate_name(entry.name); if (!new_entry.name) { compiler->context->report_error("Out of memory."); return SPVC_ERROR_OUT_OF_MEMORY; } translated.push_back(new_entry); } auto ptr = spvc_allocate>(); ptr->buffer = std::move(translated); *entry_points = ptr->buffer.data(); *num_entry_points = ptr->buffer.size(); compiler->context->allocations.push_back(std::move(ptr)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } spvc_result spvc_compiler_set_entry_point(spvc_compiler compiler, const char *name, SpvExecutionModel model) { compiler->compiler->set_entry_point(name, static_cast(model)); return SPVC_SUCCESS; } spvc_result spvc_compiler_rename_entry_point(spvc_compiler compiler, const char *old_name, const char *new_name, SpvExecutionModel model) { SPVC_BEGIN_SAFE_SCOPE { compiler->compiler->rename_entry_point(old_name, new_name, static_cast(model)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } const char *spvc_compiler_get_cleansed_entry_point_name(spvc_compiler compiler, const char *name, SpvExecutionModel model) { SPVC_BEGIN_SAFE_SCOPE { auto cleansed_name = compiler->compiler->get_cleansed_entry_point_name(name, static_cast(model)); return compiler->context->allocate_name(cleansed_name); } SPVC_END_SAFE_SCOPE(compiler->context, nullptr) } void spvc_compiler_set_execution_mode(spvc_compiler compiler, SpvExecutionMode mode) { compiler->compiler->set_execution_mode(static_cast(mode)); } void spvc_compiler_set_execution_mode_with_arguments(spvc_compiler compiler, SpvExecutionMode mode, unsigned arg0, unsigned arg1, unsigned arg2) { compiler->compiler->set_execution_mode(static_cast(mode), arg0, arg1, arg2); } void spvc_compiler_unset_execution_mode(spvc_compiler compiler, SpvExecutionMode mode) { compiler->compiler->unset_execution_mode(static_cast(mode)); } spvc_result spvc_compiler_get_execution_modes(spvc_compiler compiler, const SpvExecutionMode **modes, size_t *num_modes) { SPVC_BEGIN_SAFE_SCOPE { auto ptr = spvc_allocate>(); compiler->compiler->get_execution_mode_bitset().for_each_bit( [&](uint32_t bit) { ptr->buffer.push_back(static_cast(bit)); }); *modes = ptr->buffer.data(); *num_modes = ptr->buffer.size(); compiler->context->allocations.push_back(std::move(ptr)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } unsigned spvc_compiler_get_execution_mode_argument(spvc_compiler compiler, SpvExecutionMode mode) { return compiler->compiler->get_execution_mode_argument(static_cast(mode)); } unsigned spvc_compiler_get_execution_mode_argument_by_index(spvc_compiler compiler, SpvExecutionMode mode, unsigned index) { return compiler->compiler->get_execution_mode_argument(static_cast(mode), index); } SpvExecutionModel spvc_compiler_get_execution_model(spvc_compiler compiler) { return static_cast(compiler->compiler->get_execution_model()); } spvc_type spvc_compiler_get_type_handle(spvc_compiler compiler, spvc_type_id id) { // Should only throw if an intentionally garbage ID is passed, but the IDs are not type-safe. SPVC_BEGIN_SAFE_SCOPE { return static_cast(&compiler->compiler->get_type(id)); } SPVC_END_SAFE_SCOPE(compiler->context, nullptr) } spvc_type_id spvc_type_get_base_type_id(spvc_type type) { return type->self; } static spvc_basetype convert_basetype(SPIRType::BaseType type) { // For now the enums match up. return static_cast(type); } spvc_basetype spvc_type_get_basetype(spvc_type type) { return convert_basetype(type->basetype); } unsigned spvc_type_get_bit_width(spvc_type type) { return type->width; } unsigned spvc_type_get_vector_size(spvc_type type) { return type->vecsize; } unsigned spvc_type_get_columns(spvc_type type) { return type->columns; } unsigned spvc_type_get_num_array_dimensions(spvc_type type) { return unsigned(type->array.size()); } spvc_bool spvc_type_array_dimension_is_literal(spvc_type type, unsigned dimension) { return type->array_size_literal[dimension] ? SPVC_TRUE : SPVC_FALSE; } SpvId spvc_type_get_array_dimension(spvc_type type, unsigned dimension) { return type->array[dimension]; } unsigned spvc_type_get_num_member_types(spvc_type type) { return unsigned(type->member_types.size()); } spvc_type_id spvc_type_get_member_type(spvc_type type, unsigned index) { return type->member_types[index]; } SpvStorageClass spvc_type_get_storage_class(spvc_type type) { return static_cast(type->storage); } // Image type query. spvc_type_id spvc_type_get_image_sampled_type(spvc_type type) { return type->image.type; } SpvDim spvc_type_get_image_dimension(spvc_type type) { return static_cast(type->image.dim); } spvc_bool spvc_type_get_image_is_depth(spvc_type type) { return type->image.depth ? SPVC_TRUE : SPVC_FALSE; } spvc_bool spvc_type_get_image_arrayed(spvc_type type) { return type->image.arrayed ? SPVC_TRUE : SPVC_FALSE; } spvc_bool spvc_type_get_image_multisampled(spvc_type type) { return type->image.ms ? SPVC_TRUE : SPVC_FALSE; } spvc_bool spvc_type_get_image_is_storage(spvc_type type) { return type->image.sampled == 2 ? SPVC_TRUE : SPVC_FALSE; } SpvImageFormat spvc_type_get_image_storage_format(spvc_type type) { return static_cast(static_cast(type)->image.format); } SpvAccessQualifier spvc_type_get_image_access_qualifier(spvc_type type) { return static_cast(static_cast(type)->image.access); } spvc_result spvc_compiler_get_declared_struct_size(spvc_compiler compiler, spvc_type struct_type, size_t *size) { SPVC_BEGIN_SAFE_SCOPE { *size = compiler->compiler->get_declared_struct_size(*static_cast(struct_type)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } spvc_result spvc_compiler_get_declared_struct_size_runtime_array(spvc_compiler compiler, spvc_type struct_type, size_t array_size, size_t *size) { SPVC_BEGIN_SAFE_SCOPE { *size = compiler->compiler->get_declared_struct_size_runtime_array(*static_cast(struct_type), array_size); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } spvc_result spvc_compiler_get_declared_struct_member_size(spvc_compiler compiler, spvc_type struct_type, unsigned index, size_t *size) { SPVC_BEGIN_SAFE_SCOPE { *size = compiler->compiler->get_declared_struct_member_size(*static_cast(struct_type), index); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } spvc_result spvc_compiler_type_struct_member_offset(spvc_compiler compiler, spvc_type type, unsigned index, unsigned *offset) { SPVC_BEGIN_SAFE_SCOPE { *offset = compiler->compiler->type_struct_member_offset(*static_cast(type), index); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } spvc_result spvc_compiler_type_struct_member_array_stride(spvc_compiler compiler, spvc_type type, unsigned index, unsigned *stride) { SPVC_BEGIN_SAFE_SCOPE { *stride = compiler->compiler->type_struct_member_array_stride(*static_cast(type), index); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } spvc_result spvc_compiler_type_struct_member_matrix_stride(spvc_compiler compiler, spvc_type type, unsigned index, unsigned *stride) { SPVC_BEGIN_SAFE_SCOPE { *stride = compiler->compiler->type_struct_member_matrix_stride(*static_cast(type), index); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } spvc_result spvc_compiler_build_dummy_sampler_for_combined_images(spvc_compiler compiler, spvc_variable_id *id) { SPVC_BEGIN_SAFE_SCOPE { *id = compiler->compiler->build_dummy_sampler_for_combined_images(); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } spvc_result spvc_compiler_build_combined_image_samplers(spvc_compiler compiler) { SPVC_BEGIN_SAFE_SCOPE { compiler->compiler->build_combined_image_samplers(); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_UNSUPPORTED_SPIRV) return SPVC_SUCCESS; } spvc_result spvc_compiler_get_combined_image_samplers(spvc_compiler compiler, const spvc_combined_image_sampler **samplers, size_t *num_samplers) { SPVC_BEGIN_SAFE_SCOPE { auto combined = compiler->compiler->get_combined_image_samplers(); SmallVector translated; translated.reserve(combined.size()); for (auto &c : combined) { spvc_combined_image_sampler trans = { c.combined_id, c.image_id, c.sampler_id }; translated.push_back(trans); } auto ptr = spvc_allocate>(); ptr->buffer = std::move(translated); *samplers = ptr->buffer.data(); *num_samplers = ptr->buffer.size(); compiler->context->allocations.push_back(std::move(ptr)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } spvc_result spvc_compiler_get_specialization_constants(spvc_compiler compiler, const spvc_specialization_constant **constants, size_t *num_constants) { SPVC_BEGIN_SAFE_SCOPE { auto spec_constants = compiler->compiler->get_specialization_constants(); SmallVector translated; translated.reserve(spec_constants.size()); for (auto &c : spec_constants) { spvc_specialization_constant trans = { c.id, c.constant_id }; translated.push_back(trans); } auto ptr = spvc_allocate>(); ptr->buffer = std::move(translated); *constants = ptr->buffer.data(); *num_constants = ptr->buffer.size(); compiler->context->allocations.push_back(std::move(ptr)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } spvc_constant spvc_compiler_get_constant_handle(spvc_compiler compiler, spvc_variable_id id) { SPVC_BEGIN_SAFE_SCOPE { return static_cast(&compiler->compiler->get_constant(id)); } SPVC_END_SAFE_SCOPE(compiler->context, nullptr) } spvc_constant_id spvc_compiler_get_work_group_size_specialization_constants(spvc_compiler compiler, spvc_specialization_constant *x, spvc_specialization_constant *y, spvc_specialization_constant *z) { SpecializationConstant tmpx; SpecializationConstant tmpy; SpecializationConstant tmpz; spvc_constant_id ret = compiler->compiler->get_work_group_size_specialization_constants(tmpx, tmpy, tmpz); x->id = tmpx.id; x->constant_id = tmpx.constant_id; y->id = tmpy.id; y->constant_id = tmpy.constant_id; z->id = tmpz.id; z->constant_id = tmpz.constant_id; return ret; } spvc_result spvc_compiler_get_active_buffer_ranges(spvc_compiler compiler, spvc_variable_id id, const spvc_buffer_range **ranges, size_t *num_ranges) { SPVC_BEGIN_SAFE_SCOPE { auto active_ranges = compiler->compiler->get_active_buffer_ranges(id); SmallVector translated; translated.reserve(active_ranges.size()); for (auto &r : active_ranges) { spvc_buffer_range trans = { r.index, r.offset, r.range }; translated.push_back(trans); } auto ptr = spvc_allocate>(); ptr->buffer = std::move(translated); *ranges = ptr->buffer.data(); *num_ranges = ptr->buffer.size(); compiler->context->allocations.push_back(std::move(ptr)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } float spvc_constant_get_scalar_fp16(spvc_constant constant, unsigned column, unsigned row) { return constant->scalar_f16(column, row); } float spvc_constant_get_scalar_fp32(spvc_constant constant, unsigned column, unsigned row) { return constant->scalar_f32(column, row); } double spvc_constant_get_scalar_fp64(spvc_constant constant, unsigned column, unsigned row) { return constant->scalar_f64(column, row); } unsigned spvc_constant_get_scalar_u32(spvc_constant constant, unsigned column, unsigned row) { return constant->scalar(column, row); } int spvc_constant_get_scalar_i32(spvc_constant constant, unsigned column, unsigned row) { return constant->scalar_i32(column, row); } unsigned spvc_constant_get_scalar_u16(spvc_constant constant, unsigned column, unsigned row) { return constant->scalar_u16(column, row); } int spvc_constant_get_scalar_i16(spvc_constant constant, unsigned column, unsigned row) { return constant->scalar_i16(column, row); } unsigned spvc_constant_get_scalar_u8(spvc_constant constant, unsigned column, unsigned row) { return constant->scalar_u8(column, row); } int spvc_constant_get_scalar_i8(spvc_constant constant, unsigned column, unsigned row) { return constant->scalar_i8(column, row); } void spvc_constant_get_subconstants(spvc_constant constant, const spvc_constant_id **constituents, size_t *count) { static_assert(sizeof(spvc_constant_id) == sizeof(constant->subconstants.front()), "ID size is not consistent."); *constituents = reinterpret_cast(constant->subconstants.data()); *count = constant->subconstants.size(); } spvc_type_id spvc_constant_get_type(spvc_constant constant) { return constant->constant_type; } spvc_bool spvc_compiler_get_binary_offset_for_decoration(spvc_compiler compiler, spvc_variable_id id, SpvDecoration decoration, unsigned *word_offset) { uint32_t off = 0; bool ret = compiler->compiler->get_binary_offset_for_decoration(id, static_cast(decoration), off); if (ret) { *word_offset = off; return SPVC_TRUE; } else return SPVC_FALSE; } spvc_bool spvc_compiler_buffer_is_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id) { return compiler->compiler->buffer_is_hlsl_counter_buffer(id) ? SPVC_TRUE : SPVC_FALSE; } spvc_bool spvc_compiler_buffer_get_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id, spvc_variable_id *counter_id) { uint32_t buffer; bool ret = compiler->compiler->buffer_get_hlsl_counter_buffer(id, buffer); if (ret) { *counter_id = buffer; return SPVC_TRUE; } else return SPVC_FALSE; } spvc_result spvc_compiler_get_declared_capabilities(spvc_compiler compiler, const SpvCapability **capabilities, size_t *num_capabilities) { auto &caps = compiler->compiler->get_declared_capabilities(); static_assert(sizeof(SpvCapability) == sizeof(spv::Capability), "Enum size mismatch."); *capabilities = reinterpret_cast(caps.data()); *num_capabilities = caps.size(); return SPVC_SUCCESS; } spvc_result spvc_compiler_get_declared_extensions(spvc_compiler compiler, const char ***extensions, size_t *num_extensions) { SPVC_BEGIN_SAFE_SCOPE { auto &exts = compiler->compiler->get_declared_extensions(); SmallVector duped; duped.reserve(exts.size()); for (auto &ext : exts) duped.push_back(compiler->context->allocate_name(ext)); auto ptr = spvc_allocate>(); ptr->buffer = std::move(duped); *extensions = ptr->buffer.data(); *num_extensions = ptr->buffer.size(); compiler->context->allocations.push_back(std::move(ptr)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY) return SPVC_SUCCESS; } const char *spvc_compiler_get_remapped_declared_block_name(spvc_compiler compiler, spvc_variable_id id) { SPVC_BEGIN_SAFE_SCOPE { auto name = compiler->compiler->get_remapped_declared_block_name(id); return compiler->context->allocate_name(name); } SPVC_END_SAFE_SCOPE(compiler->context, nullptr) } spvc_result spvc_compiler_get_buffer_block_decorations(spvc_compiler compiler, spvc_variable_id id, const SpvDecoration **decorations, size_t *num_decorations) { SPVC_BEGIN_SAFE_SCOPE { auto flags = compiler->compiler->get_buffer_block_flags(id); auto bitset = spvc_allocate>(); flags.for_each_bit([&](uint32_t bit) { bitset->buffer.push_back(static_cast(bit)); }); *decorations = bitset->buffer.data(); *num_decorations = bitset->buffer.size(); compiler->context->allocations.push_back(std::move(bitset)); } SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT) return SPVC_SUCCESS; } unsigned spvc_msl_get_aux_buffer_struct_version(void) { return SPVC_MSL_AUX_BUFFER_STRUCT_VERSION; } void spvc_msl_vertex_attribute_init(spvc_msl_vertex_attribute *attr) { #if SPIRV_CROSS_C_API_MSL // Crude, but works. MSLShaderInput attr_default; attr->location = attr_default.location; attr->format = static_cast(attr_default.format); attr->builtin = static_cast(attr_default.builtin); #else memset(attr, 0, sizeof(*attr)); #endif } void spvc_msl_shader_input_init(spvc_msl_shader_input *input) { #if SPIRV_CROSS_C_API_MSL MSLShaderInput input_default; input->location = input_default.location; input->format = static_cast(input_default.format); input->builtin = static_cast(input_default.builtin); input->vecsize = input_default.vecsize; #else memset(input, 0, sizeof(*input)); #endif } void spvc_msl_resource_binding_init(spvc_msl_resource_binding *binding) { #if SPIRV_CROSS_C_API_MSL MSLResourceBinding binding_default; binding->desc_set = binding_default.desc_set; binding->binding = binding_default.binding; binding->msl_buffer = binding_default.msl_buffer; binding->msl_texture = binding_default.msl_texture; binding->msl_sampler = binding_default.msl_sampler; binding->stage = static_cast(binding_default.stage); #else memset(binding, 0, sizeof(*binding)); #endif } void spvc_hlsl_resource_binding_init(spvc_hlsl_resource_binding *binding) { #if SPIRV_CROSS_C_API_HLSL HLSLResourceBinding binding_default; binding->desc_set = binding_default.desc_set; binding->binding = binding_default.binding; binding->cbv.register_binding = binding_default.cbv.register_binding; binding->cbv.register_space = binding_default.cbv.register_space; binding->srv.register_binding = binding_default.srv.register_binding; binding->srv.register_space = binding_default.srv.register_space; binding->uav.register_binding = binding_default.uav.register_binding; binding->uav.register_space = binding_default.uav.register_space; binding->sampler.register_binding = binding_default.sampler.register_binding; binding->sampler.register_space = binding_default.sampler.register_space; binding->stage = static_cast(binding_default.stage); #else memset(binding, 0, sizeof(*binding)); #endif } void spvc_msl_constexpr_sampler_init(spvc_msl_constexpr_sampler *sampler) { #if SPIRV_CROSS_C_API_MSL MSLConstexprSampler defaults; sampler->anisotropy_enable = defaults.anisotropy_enable ? SPVC_TRUE : SPVC_FALSE; sampler->border_color = static_cast(defaults.border_color); sampler->compare_enable = defaults.compare_enable ? SPVC_TRUE : SPVC_FALSE; sampler->coord = static_cast(defaults.coord); sampler->compare_func = static_cast(defaults.compare_func); sampler->lod_clamp_enable = defaults.lod_clamp_enable ? SPVC_TRUE : SPVC_FALSE; sampler->lod_clamp_max = defaults.lod_clamp_max; sampler->lod_clamp_min = defaults.lod_clamp_min; sampler->mag_filter = static_cast(defaults.mag_filter); sampler->min_filter = static_cast(defaults.min_filter); sampler->mip_filter = static_cast(defaults.mip_filter); sampler->max_anisotropy = defaults.max_anisotropy; sampler->s_address = static_cast(defaults.s_address); sampler->t_address = static_cast(defaults.t_address); sampler->r_address = static_cast(defaults.r_address); #else memset(sampler, 0, sizeof(*sampler)); #endif } void spvc_msl_sampler_ycbcr_conversion_init(spvc_msl_sampler_ycbcr_conversion *conv) { #if SPIRV_CROSS_C_API_MSL MSLConstexprSampler defaults; conv->planes = defaults.planes; conv->resolution = static_cast(defaults.resolution); conv->chroma_filter = static_cast(defaults.chroma_filter); conv->x_chroma_offset = static_cast(defaults.x_chroma_offset); conv->y_chroma_offset = static_cast(defaults.y_chroma_offset); for (int i = 0; i < 4; i++) conv->swizzle[i] = static_cast(defaults.swizzle[i]); conv->ycbcr_model = static_cast(defaults.ycbcr_model); conv->ycbcr_range = static_cast(defaults.ycbcr_range); #else memset(conv, 0, sizeof(*conv)); #endif } unsigned spvc_compiler_get_current_id_bound(spvc_compiler compiler) { return compiler->compiler->get_current_id_bound(); } void spvc_get_version(unsigned *major, unsigned *minor, unsigned *patch) { *major = SPVC_C_API_VERSION_MAJOR; *minor = SPVC_C_API_VERSION_MINOR; *patch = SPVC_C_API_VERSION_PATCH; } const char *spvc_get_commit_revision_and_timestamp(void) { #ifdef HAVE_SPIRV_CROSS_GIT_VERSION return SPIRV_CROSS_GIT_REVISION; #else return ""; #endif } #ifdef _MSC_VER #pragma warning(pop) #endif spirv-cross-2021.01.15/spirv_cross_c.h000066400000000000000000001343161400026215700174310ustar00rootroot00000000000000/* * Copyright 2019-2021 Hans-Kristian Arntzen * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_C_API_H #define SPIRV_CROSS_C_API_H #include #include "spirv.h" /* * C89-compatible wrapper for SPIRV-Cross' API. * Documentation here is sparse unless the behavior does not map 1:1 with C++ API. * It is recommended to look at the canonical C++ API for more detailed information. */ #ifdef __cplusplus extern "C" { #endif /* Bumped if ABI or API breaks backwards compatibility. */ #define SPVC_C_API_VERSION_MAJOR 0 /* Bumped if APIs or enumerations are added in a backwards compatible way. */ #define SPVC_C_API_VERSION_MINOR 44 /* Bumped if internal implementation details change. */ #define SPVC_C_API_VERSION_PATCH 0 #if !defined(SPVC_PUBLIC_API) #if defined(SPVC_EXPORT_SYMBOLS) /* Exports symbols. Standard C calling convention is used. */ #if defined(__GNUC__) #define SPVC_PUBLIC_API __attribute__((visibility("default"))) #elif defined(_MSC_VER) #define SPVC_PUBLIC_API __declspec(dllexport) #else #define SPVC_PUBLIC_API #endif #else #define SPVC_PUBLIC_API #endif #endif /* * Gets the SPVC_C_API_VERSION_* used to build this library. * Can be used to check for ABI mismatch if so-versioning did not catch it. */ SPVC_PUBLIC_API void spvc_get_version(unsigned *major, unsigned *minor, unsigned *patch); /* Gets a human readable version string to identify which commit a particular binary was created from. */ SPVC_PUBLIC_API const char *spvc_get_commit_revision_and_timestamp(void); /* These types are opaque to the user. */ typedef struct spvc_context_s *spvc_context; typedef struct spvc_parsed_ir_s *spvc_parsed_ir; typedef struct spvc_compiler_s *spvc_compiler; typedef struct spvc_compiler_options_s *spvc_compiler_options; typedef struct spvc_resources_s *spvc_resources; struct spvc_type_s; typedef const struct spvc_type_s *spvc_type; typedef struct spvc_constant_s *spvc_constant; struct spvc_set_s; typedef const struct spvc_set_s *spvc_set; /* * Shallow typedefs. All SPIR-V IDs are plain 32-bit numbers, but this helps communicate which data is used. * Maps to a SPIRType. */ typedef SpvId spvc_type_id; /* Maps to a SPIRVariable. */ typedef SpvId spvc_variable_id; /* Maps to a SPIRConstant. */ typedef SpvId spvc_constant_id; /* See C++ API. */ typedef struct spvc_reflected_resource { spvc_variable_id id; spvc_type_id base_type_id; spvc_type_id type_id; const char *name; } spvc_reflected_resource; /* See C++ API. */ typedef struct spvc_entry_point { SpvExecutionModel execution_model; const char *name; } spvc_entry_point; /* See C++ API. */ typedef struct spvc_combined_image_sampler { spvc_variable_id combined_id; spvc_variable_id image_id; spvc_variable_id sampler_id; } spvc_combined_image_sampler; /* See C++ API. */ typedef struct spvc_specialization_constant { spvc_constant_id id; unsigned constant_id; } spvc_specialization_constant; /* See C++ API. */ typedef struct spvc_buffer_range { unsigned index; size_t offset; size_t range; } spvc_buffer_range; /* See C++ API. */ typedef struct spvc_hlsl_root_constants { unsigned start; unsigned end; unsigned binding; unsigned space; } spvc_hlsl_root_constants; /* See C++ API. */ typedef struct spvc_hlsl_vertex_attribute_remap { unsigned location; const char *semantic; } spvc_hlsl_vertex_attribute_remap; /* * Be compatible with non-C99 compilers, which do not have stdbool. * Only recent MSVC compilers supports this for example, and ideally SPIRV-Cross should be linkable * from a wide range of compilers in its C wrapper. */ typedef unsigned char spvc_bool; #define SPVC_TRUE ((spvc_bool)1) #define SPVC_FALSE ((spvc_bool)0) typedef enum spvc_result { /* Success. */ SPVC_SUCCESS = 0, /* The SPIR-V is invalid. Should have been caught by validation ideally. */ SPVC_ERROR_INVALID_SPIRV = -1, /* The SPIR-V might be valid or invalid, but SPIRV-Cross currently cannot correctly translate this to your target language. */ SPVC_ERROR_UNSUPPORTED_SPIRV = -2, /* If for some reason we hit this, new or malloc failed. */ SPVC_ERROR_OUT_OF_MEMORY = -3, /* Invalid API argument. */ SPVC_ERROR_INVALID_ARGUMENT = -4, SPVC_ERROR_INT_MAX = 0x7fffffff } spvc_result; typedef enum spvc_capture_mode { /* The Parsed IR payload will be copied, and the handle can be reused to create other compiler instances. */ SPVC_CAPTURE_MODE_COPY = 0, /* * The payload will now be owned by the compiler. * parsed_ir should now be considered a dead blob and must not be used further. * This is optimal for performance and should be the go-to option. */ SPVC_CAPTURE_MODE_TAKE_OWNERSHIP = 1, SPVC_CAPTURE_MODE_INT_MAX = 0x7fffffff } spvc_capture_mode; typedef enum spvc_backend { /* This backend can only perform reflection, no compiler options are supported. Maps to spirv_cross::Compiler. */ SPVC_BACKEND_NONE = 0, SPVC_BACKEND_GLSL = 1, /* spirv_cross::CompilerGLSL */ SPVC_BACKEND_HLSL = 2, /* CompilerHLSL */ SPVC_BACKEND_MSL = 3, /* CompilerMSL */ SPVC_BACKEND_CPP = 4, /* CompilerCPP */ SPVC_BACKEND_JSON = 5, /* CompilerReflection w/ JSON backend */ SPVC_BACKEND_INT_MAX = 0x7fffffff } spvc_backend; /* Maps to C++ API. */ typedef enum spvc_resource_type { SPVC_RESOURCE_TYPE_UNKNOWN = 0, SPVC_RESOURCE_TYPE_UNIFORM_BUFFER = 1, SPVC_RESOURCE_TYPE_STORAGE_BUFFER = 2, SPVC_RESOURCE_TYPE_STAGE_INPUT = 3, SPVC_RESOURCE_TYPE_STAGE_OUTPUT = 4, SPVC_RESOURCE_TYPE_SUBPASS_INPUT = 5, SPVC_RESOURCE_TYPE_STORAGE_IMAGE = 6, SPVC_RESOURCE_TYPE_SAMPLED_IMAGE = 7, SPVC_RESOURCE_TYPE_ATOMIC_COUNTER = 8, SPVC_RESOURCE_TYPE_PUSH_CONSTANT = 9, SPVC_RESOURCE_TYPE_SEPARATE_IMAGE = 10, SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS = 11, SPVC_RESOURCE_TYPE_ACCELERATION_STRUCTURE = 12, SPVC_RESOURCE_TYPE_RAY_QUERY = 13, SPVC_RESOURCE_TYPE_INT_MAX = 0x7fffffff } spvc_resource_type; /* Maps to spirv_cross::SPIRType::BaseType. */ typedef enum spvc_basetype { SPVC_BASETYPE_UNKNOWN = 0, SPVC_BASETYPE_VOID = 1, SPVC_BASETYPE_BOOLEAN = 2, SPVC_BASETYPE_INT8 = 3, SPVC_BASETYPE_UINT8 = 4, SPVC_BASETYPE_INT16 = 5, SPVC_BASETYPE_UINT16 = 6, SPVC_BASETYPE_INT32 = 7, SPVC_BASETYPE_UINT32 = 8, SPVC_BASETYPE_INT64 = 9, SPVC_BASETYPE_UINT64 = 10, SPVC_BASETYPE_ATOMIC_COUNTER = 11, SPVC_BASETYPE_FP16 = 12, SPVC_BASETYPE_FP32 = 13, SPVC_BASETYPE_FP64 = 14, SPVC_BASETYPE_STRUCT = 15, SPVC_BASETYPE_IMAGE = 16, SPVC_BASETYPE_SAMPLED_IMAGE = 17, SPVC_BASETYPE_SAMPLER = 18, SPVC_BASETYPE_ACCELERATION_STRUCTURE = 19, SPVC_BASETYPE_INT_MAX = 0x7fffffff } spvc_basetype; #define SPVC_COMPILER_OPTION_COMMON_BIT 0x1000000 #define SPVC_COMPILER_OPTION_GLSL_BIT 0x2000000 #define SPVC_COMPILER_OPTION_HLSL_BIT 0x4000000 #define SPVC_COMPILER_OPTION_MSL_BIT 0x8000000 #define SPVC_COMPILER_OPTION_LANG_BITS 0x0f000000 #define SPVC_COMPILER_OPTION_ENUM_BITS 0xffffff #define SPVC_MAKE_MSL_VERSION(major, minor, patch) ((major) * 10000 + (minor) * 100 + (patch)) /* Maps to C++ API. */ typedef enum spvc_msl_platform { SPVC_MSL_PLATFORM_IOS = 0, SPVC_MSL_PLATFORM_MACOS = 1, SPVC_MSL_PLATFORM_MAX_INT = 0x7fffffff } spvc_msl_platform; /* Maps to C++ API. */ typedef enum spvc_msl_index_type { SPVC_MSL_INDEX_TYPE_NONE = 0, SPVC_MSL_INDEX_TYPE_UINT16 = 1, SPVC_MSL_INDEX_TYPE_UINT32 = 2, SPVC_MSL_INDEX_TYPE_MAX_INT = 0x7fffffff } spvc_msl_index_type; /* Maps to C++ API. */ typedef enum spvc_msl_shader_input_format { SPVC_MSL_SHADER_INPUT_FORMAT_OTHER = 0, SPVC_MSL_SHADER_INPUT_FORMAT_UINT8 = 1, SPVC_MSL_SHADER_INPUT_FORMAT_UINT16 = 2, SPVC_MSL_SHADER_INPUT_FORMAT_ANY16 = 3, SPVC_MSL_SHADER_INPUT_FORMAT_ANY32 = 4, /* Deprecated names. */ SPVC_MSL_VERTEX_FORMAT_OTHER = SPVC_MSL_SHADER_INPUT_FORMAT_OTHER, SPVC_MSL_VERTEX_FORMAT_UINT8 = SPVC_MSL_SHADER_INPUT_FORMAT_UINT8, SPVC_MSL_VERTEX_FORMAT_UINT16 = SPVC_MSL_SHADER_INPUT_FORMAT_UINT16, SPVC_MSL_SHADER_INPUT_FORMAT_INT_MAX = 0x7fffffff } spvc_msl_shader_input_format, spvc_msl_vertex_format; /* Maps to C++ API. Deprecated; use spvc_msl_shader_input. */ typedef struct spvc_msl_vertex_attribute { unsigned location; /* Obsolete, do not use. Only lingers on for ABI compatibility. */ unsigned msl_buffer; /* Obsolete, do not use. Only lingers on for ABI compatibility. */ unsigned msl_offset; /* Obsolete, do not use. Only lingers on for ABI compatibility. */ unsigned msl_stride; /* Obsolete, do not use. Only lingers on for ABI compatibility. */ spvc_bool per_instance; spvc_msl_vertex_format format; SpvBuiltIn builtin; } spvc_msl_vertex_attribute; /* * Initializes the vertex attribute struct. */ SPVC_PUBLIC_API void spvc_msl_vertex_attribute_init(spvc_msl_vertex_attribute *attr); /* Maps to C++ API. */ typedef struct spvc_msl_shader_input { unsigned location; spvc_msl_vertex_format format; SpvBuiltIn builtin; unsigned vecsize; } spvc_msl_shader_input; /* * Initializes the shader input struct. */ SPVC_PUBLIC_API void spvc_msl_shader_input_init(spvc_msl_shader_input *input); /* Maps to C++ API. */ typedef struct spvc_msl_resource_binding { SpvExecutionModel stage; unsigned desc_set; unsigned binding; unsigned msl_buffer; unsigned msl_texture; unsigned msl_sampler; } spvc_msl_resource_binding; /* * Initializes the resource binding struct. * The defaults are non-zero. */ SPVC_PUBLIC_API void spvc_msl_resource_binding_init(spvc_msl_resource_binding *binding); #define SPVC_MSL_PUSH_CONSTANT_DESC_SET (~(0u)) #define SPVC_MSL_PUSH_CONSTANT_BINDING (0) #define SPVC_MSL_SWIZZLE_BUFFER_BINDING (~(1u)) #define SPVC_MSL_BUFFER_SIZE_BUFFER_BINDING (~(2u)) #define SPVC_MSL_ARGUMENT_BUFFER_BINDING (~(3u)) /* Obsolete. Sticks around for backwards compatibility. */ #define SPVC_MSL_AUX_BUFFER_STRUCT_VERSION 1 /* Runtime check for incompatibility. Obsolete. */ SPVC_PUBLIC_API unsigned spvc_msl_get_aux_buffer_struct_version(void); /* Maps to C++ API. */ typedef enum spvc_msl_sampler_coord { SPVC_MSL_SAMPLER_COORD_NORMALIZED = 0, SPVC_MSL_SAMPLER_COORD_PIXEL = 1, SPVC_MSL_SAMPLER_INT_MAX = 0x7fffffff } spvc_msl_sampler_coord; /* Maps to C++ API. */ typedef enum spvc_msl_sampler_filter { SPVC_MSL_SAMPLER_FILTER_NEAREST = 0, SPVC_MSL_SAMPLER_FILTER_LINEAR = 1, SPVC_MSL_SAMPLER_FILTER_INT_MAX = 0x7fffffff } spvc_msl_sampler_filter; /* Maps to C++ API. */ typedef enum spvc_msl_sampler_mip_filter { SPVC_MSL_SAMPLER_MIP_FILTER_NONE = 0, SPVC_MSL_SAMPLER_MIP_FILTER_NEAREST = 1, SPVC_MSL_SAMPLER_MIP_FILTER_LINEAR = 2, SPVC_MSL_SAMPLER_MIP_FILTER_INT_MAX = 0x7fffffff } spvc_msl_sampler_mip_filter; /* Maps to C++ API. */ typedef enum spvc_msl_sampler_address { SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO = 0, SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE = 1, SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER = 2, SPVC_MSL_SAMPLER_ADDRESS_REPEAT = 3, SPVC_MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT = 4, SPVC_MSL_SAMPLER_ADDRESS_INT_MAX = 0x7fffffff } spvc_msl_sampler_address; /* Maps to C++ API. */ typedef enum spvc_msl_sampler_compare_func { SPVC_MSL_SAMPLER_COMPARE_FUNC_NEVER = 0, SPVC_MSL_SAMPLER_COMPARE_FUNC_LESS = 1, SPVC_MSL_SAMPLER_COMPARE_FUNC_LESS_EQUAL = 2, SPVC_MSL_SAMPLER_COMPARE_FUNC_GREATER = 3, SPVC_MSL_SAMPLER_COMPARE_FUNC_GREATER_EQUAL = 4, SPVC_MSL_SAMPLER_COMPARE_FUNC_EQUAL = 5, SPVC_MSL_SAMPLER_COMPARE_FUNC_NOT_EQUAL = 6, SPVC_MSL_SAMPLER_COMPARE_FUNC_ALWAYS = 7, SPVC_MSL_SAMPLER_COMPARE_FUNC_INT_MAX = 0x7fffffff } spvc_msl_sampler_compare_func; /* Maps to C++ API. */ typedef enum spvc_msl_sampler_border_color { SPVC_MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK = 0, SPVC_MSL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK = 1, SPVC_MSL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE = 2, SPVC_MSL_SAMPLER_BORDER_COLOR_INT_MAX = 0x7fffffff } spvc_msl_sampler_border_color; /* Maps to C++ API. */ typedef enum spvc_msl_format_resolution { SPVC_MSL_FORMAT_RESOLUTION_444 = 0, SPVC_MSL_FORMAT_RESOLUTION_422, SPVC_MSL_FORMAT_RESOLUTION_420, SPVC_MSL_FORMAT_RESOLUTION_INT_MAX = 0x7fffffff } spvc_msl_format_resolution; /* Maps to C++ API. */ typedef enum spvc_msl_chroma_location { SPVC_MSL_CHROMA_LOCATION_COSITED_EVEN = 0, SPVC_MSL_CHROMA_LOCATION_MIDPOINT, SPVC_MSL_CHROMA_LOCATION_INT_MAX = 0x7fffffff } spvc_msl_chroma_location; /* Maps to C++ API. */ typedef enum spvc_msl_component_swizzle { SPVC_MSL_COMPONENT_SWIZZLE_IDENTITY = 0, SPVC_MSL_COMPONENT_SWIZZLE_ZERO, SPVC_MSL_COMPONENT_SWIZZLE_ONE, SPVC_MSL_COMPONENT_SWIZZLE_R, SPVC_MSL_COMPONENT_SWIZZLE_G, SPVC_MSL_COMPONENT_SWIZZLE_B, SPVC_MSL_COMPONENT_SWIZZLE_A, SPVC_MSL_COMPONENT_SWIZZLE_INT_MAX = 0x7fffffff } spvc_msl_component_swizzle; /* Maps to C++ API. */ typedef enum spvc_msl_sampler_ycbcr_model_conversion { SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709, SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601, SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020, SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_INT_MAX = 0x7fffffff } spvc_msl_sampler_ycbcr_model_conversion; /* Maps to C+ API. */ typedef enum spvc_msl_sampler_ycbcr_range { SPVC_MSL_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, SPVC_MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW, SPVC_MSL_SAMPLER_YCBCR_RANGE_INT_MAX = 0x7fffffff } spvc_msl_sampler_ycbcr_range; /* Maps to C++ API. */ typedef struct spvc_msl_constexpr_sampler { spvc_msl_sampler_coord coord; spvc_msl_sampler_filter min_filter; spvc_msl_sampler_filter mag_filter; spvc_msl_sampler_mip_filter mip_filter; spvc_msl_sampler_address s_address; spvc_msl_sampler_address t_address; spvc_msl_sampler_address r_address; spvc_msl_sampler_compare_func compare_func; spvc_msl_sampler_border_color border_color; float lod_clamp_min; float lod_clamp_max; int max_anisotropy; spvc_bool compare_enable; spvc_bool lod_clamp_enable; spvc_bool anisotropy_enable; } spvc_msl_constexpr_sampler; /* * Initializes the constexpr sampler struct. * The defaults are non-zero. */ SPVC_PUBLIC_API void spvc_msl_constexpr_sampler_init(spvc_msl_constexpr_sampler *sampler); /* Maps to the sampler Y'CbCr conversion-related portions of MSLConstexprSampler. See C++ API for defaults and details. */ typedef struct spvc_msl_sampler_ycbcr_conversion { unsigned planes; spvc_msl_format_resolution resolution; spvc_msl_sampler_filter chroma_filter; spvc_msl_chroma_location x_chroma_offset; spvc_msl_chroma_location y_chroma_offset; spvc_msl_component_swizzle swizzle[4]; spvc_msl_sampler_ycbcr_model_conversion ycbcr_model; spvc_msl_sampler_ycbcr_range ycbcr_range; unsigned bpc; } spvc_msl_sampler_ycbcr_conversion; /* * Initializes the constexpr sampler struct. * The defaults are non-zero. */ SPVC_PUBLIC_API void spvc_msl_sampler_ycbcr_conversion_init(spvc_msl_sampler_ycbcr_conversion *conv); /* Maps to C++ API. */ typedef enum spvc_hlsl_binding_flag_bits { SPVC_HLSL_BINDING_AUTO_NONE_BIT = 0, SPVC_HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT = 1 << 0, SPVC_HLSL_BINDING_AUTO_CBV_BIT = 1 << 1, SPVC_HLSL_BINDING_AUTO_SRV_BIT = 1 << 2, SPVC_HLSL_BINDING_AUTO_UAV_BIT = 1 << 3, SPVC_HLSL_BINDING_AUTO_SAMPLER_BIT = 1 << 4, SPVC_HLSL_BINDING_AUTO_ALL = 0x7fffffff } spvc_hlsl_binding_flag_bits; typedef unsigned spvc_hlsl_binding_flags; #define SPVC_HLSL_PUSH_CONSTANT_DESC_SET (~(0u)) #define SPVC_HLSL_PUSH_CONSTANT_BINDING (0) /* Maps to C++ API. */ typedef struct spvc_hlsl_resource_binding_mapping { unsigned register_space; unsigned register_binding; } spvc_hlsl_resource_binding_mapping; typedef struct spvc_hlsl_resource_binding { SpvExecutionModel stage; unsigned desc_set; unsigned binding; spvc_hlsl_resource_binding_mapping cbv, uav, srv, sampler; } spvc_hlsl_resource_binding; /* * Initializes the resource binding struct. * The defaults are non-zero. */ SPVC_PUBLIC_API void spvc_hlsl_resource_binding_init(spvc_hlsl_resource_binding *binding); /* Maps to the various spirv_cross::Compiler*::Option structures. See C++ API for defaults and details. */ typedef enum spvc_compiler_option { SPVC_COMPILER_OPTION_UNKNOWN = 0, SPVC_COMPILER_OPTION_FORCE_TEMPORARY = 1 | SPVC_COMPILER_OPTION_COMMON_BIT, SPVC_COMPILER_OPTION_FLATTEN_MULTIDIMENSIONAL_ARRAYS = 2 | SPVC_COMPILER_OPTION_COMMON_BIT, SPVC_COMPILER_OPTION_FIXUP_DEPTH_CONVENTION = 3 | SPVC_COMPILER_OPTION_COMMON_BIT, SPVC_COMPILER_OPTION_FLIP_VERTEX_Y = 4 | SPVC_COMPILER_OPTION_COMMON_BIT, SPVC_COMPILER_OPTION_GLSL_SUPPORT_NONZERO_BASE_INSTANCE = 5 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_GLSL_SEPARATE_SHADER_OBJECTS = 6 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_GLSL_ENABLE_420PACK_EXTENSION = 7 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_GLSL_VERSION = 8 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_GLSL_ES = 9 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS = 10 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_FLOAT_PRECISION_HIGHP = 11 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_INT_PRECISION_HIGHP = 12 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_HLSL_SHADER_MODEL = 13 | SPVC_COMPILER_OPTION_HLSL_BIT, SPVC_COMPILER_OPTION_HLSL_POINT_SIZE_COMPAT = 14 | SPVC_COMPILER_OPTION_HLSL_BIT, SPVC_COMPILER_OPTION_HLSL_POINT_COORD_COMPAT = 15 | SPVC_COMPILER_OPTION_HLSL_BIT, SPVC_COMPILER_OPTION_HLSL_SUPPORT_NONZERO_BASE_VERTEX_BASE_INSTANCE = 16 | SPVC_COMPILER_OPTION_HLSL_BIT, SPVC_COMPILER_OPTION_MSL_VERSION = 17 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_TEXEL_BUFFER_TEXTURE_WIDTH = 18 | SPVC_COMPILER_OPTION_MSL_BIT, /* Obsolete, use SWIZZLE_BUFFER_INDEX instead. */ SPVC_COMPILER_OPTION_MSL_AUX_BUFFER_INDEX = 19 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_SWIZZLE_BUFFER_INDEX = 19 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_INDIRECT_PARAMS_BUFFER_INDEX = 20 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_SHADER_OUTPUT_BUFFER_INDEX = 21 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_SHADER_PATCH_OUTPUT_BUFFER_INDEX = 22 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_SHADER_TESS_FACTOR_OUTPUT_BUFFER_INDEX = 23 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_WORKGROUP_INDEX = 24 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_ENABLE_POINT_SIZE_BUILTIN = 25 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_DISABLE_RASTERIZATION = 26 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_CAPTURE_OUTPUT_TO_BUFFER = 27 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_SWIZZLE_TEXTURE_SAMPLES = 28 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_PAD_FRAGMENT_OUTPUT_COMPONENTS = 29 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_TESS_DOMAIN_ORIGIN_LOWER_LEFT = 30 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_PLATFORM = 31 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_ARGUMENT_BUFFERS = 32 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_GLSL_EMIT_PUSH_CONSTANT_AS_UNIFORM_BUFFER = 33 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_MSL_TEXTURE_BUFFER_NATIVE = 34 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_GLSL_EMIT_UNIFORM_BUFFER_AS_PLAIN_UNIFORMS = 35 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_MSL_BUFFER_SIZE_BUFFER_INDEX = 36 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_EMIT_LINE_DIRECTIVES = 37 | SPVC_COMPILER_OPTION_COMMON_BIT, SPVC_COMPILER_OPTION_MSL_MULTIVIEW = 38 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_VIEW_MASK_BUFFER_INDEX = 39 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_DEVICE_INDEX = 40 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_VIEW_INDEX_FROM_DEVICE_INDEX = 41 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_DISPATCH_BASE = 42 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_DYNAMIC_OFFSETS_BUFFER_INDEX = 43 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_TEXTURE_1D_AS_2D = 44 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_ENABLE_BASE_INDEX_ZERO = 45 | SPVC_COMPILER_OPTION_MSL_BIT, /* Obsolete. Use MSL_FRAMEBUFFER_FETCH_SUBPASS instead. */ SPVC_COMPILER_OPTION_MSL_IOS_FRAMEBUFFER_FETCH_SUBPASS = 46 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_FRAMEBUFFER_FETCH_SUBPASS = 46 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_INVARIANT_FP_MATH = 47 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_EMULATE_CUBEMAP_ARRAY = 48 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_ENABLE_DECORATION_BINDING = 49 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_FORCE_ACTIVE_ARGUMENT_BUFFER_RESOURCES = 50 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_FORCE_NATIVE_ARRAYS = 51 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_ENABLE_STORAGE_IMAGE_QUALIFIER_DEDUCTION = 52 | SPVC_COMPILER_OPTION_COMMON_BIT, SPVC_COMPILER_OPTION_HLSL_FORCE_STORAGE_BUFFER_AS_UAV = 53 | SPVC_COMPILER_OPTION_HLSL_BIT, SPVC_COMPILER_OPTION_FORCE_ZERO_INITIALIZED_VARIABLES = 54 | SPVC_COMPILER_OPTION_COMMON_BIT, SPVC_COMPILER_OPTION_HLSL_NONWRITABLE_UAV_TEXTURE_AS_SRV = 55 | SPVC_COMPILER_OPTION_HLSL_BIT, SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_OUTPUT_MASK = 56 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_DEPTH_BUILTIN = 57 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_STENCIL_REF_BUILTIN = 58 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_ENABLE_CLIP_DISTANCE_USER_VARYING = 59 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_HLSL_ENABLE_16BIT_TYPES = 60 | SPVC_COMPILER_OPTION_HLSL_BIT, SPVC_COMPILER_OPTION_MSL_MULTI_PATCH_WORKGROUP = 61 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_BUFFER_INDEX = 62 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_SHADER_INDEX_BUFFER_INDEX = 63 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_VERTEX_FOR_TESSELLATION = 64 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_VERTEX_INDEX_TYPE = 65 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_GLSL_FORCE_FLATTENED_IO_BLOCKS = 66 | SPVC_COMPILER_OPTION_GLSL_BIT, SPVC_COMPILER_OPTION_MSL_MULTIVIEW_LAYERED_RENDERING = 67 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_ARRAYED_SUBPASS_INPUT = 68 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_R32UI_LINEAR_TEXTURE_ALIGNMENT = 69 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_R32UI_ALIGNMENT_CONSTANT_ID = 70 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_HLSL_FLATTEN_MATRIX_VERTEX_INPUT_SEMANTICS = 71 | SPVC_COMPILER_OPTION_HLSL_BIT, SPVC_COMPILER_OPTION_MSL_IOS_USE_SIMDGROUP_FUNCTIONS = 72 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_EMULATE_SUBGROUPS = 73 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_FIXED_SUBGROUP_SIZE = 74 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_MSL_FORCE_SAMPLE_RATE_SHADING = 75 | SPVC_COMPILER_OPTION_MSL_BIT, SPVC_COMPILER_OPTION_INT_MAX = 0x7fffffff } spvc_compiler_option; /* * Context is the highest-level API construct. * The context owns all memory allocations made by its child object hierarchy, including various non-opaque structs and strings. * This means that the API user only has to care about one "destroy" call ever when using the C API. * All pointers handed out by the APIs are only valid as long as the context * is alive and spvc_context_release_allocations has not been called. */ SPVC_PUBLIC_API spvc_result spvc_context_create(spvc_context *context); /* Frees all memory allocations and objects associated with the context and its child objects. */ SPVC_PUBLIC_API void spvc_context_destroy(spvc_context context); /* Frees all memory allocations and objects associated with the context and its child objects, but keeps the context alive. */ SPVC_PUBLIC_API void spvc_context_release_allocations(spvc_context context); /* Get the string for the last error which was logged. */ SPVC_PUBLIC_API const char *spvc_context_get_last_error_string(spvc_context context); /* Get notified in a callback when an error triggers. Useful for debugging. */ typedef void (*spvc_error_callback)(void *userdata, const char *error); SPVC_PUBLIC_API void spvc_context_set_error_callback(spvc_context context, spvc_error_callback cb, void *userdata); /* SPIR-V parsing interface. Maps to Parser which then creates a ParsedIR, and that IR is extracted into the handle. */ SPVC_PUBLIC_API spvc_result spvc_context_parse_spirv(spvc_context context, const SpvId *spirv, size_t word_count, spvc_parsed_ir *parsed_ir); /* * Create a compiler backend. Capture mode controls if we construct by copy or move semantics. * It is always recommended to use SPVC_CAPTURE_MODE_TAKE_OWNERSHIP if you only intend to cross-compile the IR once. */ SPVC_PUBLIC_API spvc_result spvc_context_create_compiler(spvc_context context, spvc_backend backend, spvc_parsed_ir parsed_ir, spvc_capture_mode mode, spvc_compiler *compiler); /* Maps directly to C++ API. */ SPVC_PUBLIC_API unsigned spvc_compiler_get_current_id_bound(spvc_compiler compiler); /* Create compiler options, which will initialize defaults. */ SPVC_PUBLIC_API spvc_result spvc_compiler_create_compiler_options(spvc_compiler compiler, spvc_compiler_options *options); /* Override options. Will return error if e.g. MSL options are used for the HLSL backend, etc. */ SPVC_PUBLIC_API spvc_result spvc_compiler_options_set_bool(spvc_compiler_options options, spvc_compiler_option option, spvc_bool value); SPVC_PUBLIC_API spvc_result spvc_compiler_options_set_uint(spvc_compiler_options options, spvc_compiler_option option, unsigned value); /* Set compiler options. */ SPVC_PUBLIC_API spvc_result spvc_compiler_install_compiler_options(spvc_compiler compiler, spvc_compiler_options options); /* Compile IR into a string. *source is owned by the context, and caller must not free it themselves. */ SPVC_PUBLIC_API spvc_result spvc_compiler_compile(spvc_compiler compiler, const char **source); /* Maps to C++ API. */ SPVC_PUBLIC_API spvc_result spvc_compiler_add_header_line(spvc_compiler compiler, const char *line); SPVC_PUBLIC_API spvc_result spvc_compiler_require_extension(spvc_compiler compiler, const char *ext); SPVC_PUBLIC_API spvc_result spvc_compiler_flatten_buffer_block(spvc_compiler compiler, spvc_variable_id id); SPVC_PUBLIC_API spvc_bool spvc_compiler_variable_is_depth_or_compare(spvc_compiler compiler, spvc_variable_id id); /* * HLSL specifics. * Maps to C++ API. */ SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_set_root_constants_layout(spvc_compiler compiler, const spvc_hlsl_root_constants *constant_info, size_t count); SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_add_vertex_attribute_remap(spvc_compiler compiler, const spvc_hlsl_vertex_attribute_remap *remap, size_t remaps); SPVC_PUBLIC_API spvc_variable_id spvc_compiler_hlsl_remap_num_workgroups_builtin(spvc_compiler compiler); SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_set_resource_binding_flags(spvc_compiler compiler, spvc_hlsl_binding_flags flags); SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_add_resource_binding(spvc_compiler compiler, const spvc_hlsl_resource_binding *binding); SPVC_PUBLIC_API spvc_bool spvc_compiler_hlsl_is_resource_used(spvc_compiler compiler, SpvExecutionModel model, unsigned set, unsigned binding); /* * MSL specifics. * Maps to C++ API. */ SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_rasterization_disabled(spvc_compiler compiler); /* Obsolete. Renamed to needs_swizzle_buffer. */ SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_aux_buffer(spvc_compiler compiler); SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_swizzle_buffer(spvc_compiler compiler); SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_buffer_size_buffer(spvc_compiler compiler); SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_output_buffer(spvc_compiler compiler); SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_patch_output_buffer(spvc_compiler compiler); SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_input_threadgroup_mem(spvc_compiler compiler); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_vertex_attribute(spvc_compiler compiler, const spvc_msl_vertex_attribute *attrs); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_resource_binding(spvc_compiler compiler, const spvc_msl_resource_binding *binding); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_shader_input(spvc_compiler compiler, const spvc_msl_shader_input *input); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_discrete_descriptor_set(spvc_compiler compiler, unsigned desc_set); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_argument_buffer_device_address_space(spvc_compiler compiler, unsigned desc_set, spvc_bool device_address); /* Obsolete, use is_shader_input_used. */ SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_vertex_attribute_used(spvc_compiler compiler, unsigned location); SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_shader_input_used(spvc_compiler compiler, unsigned location); SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_resource_used(spvc_compiler compiler, SpvExecutionModel model, unsigned set, unsigned binding); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_ycbcr(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_fragment_output_components(spvc_compiler compiler, unsigned location, unsigned components); SPVC_PUBLIC_API unsigned spvc_compiler_msl_get_automatic_resource_binding(spvc_compiler compiler, spvc_variable_id id); SPVC_PUBLIC_API unsigned spvc_compiler_msl_get_automatic_resource_binding_secondary(spvc_compiler compiler, spvc_variable_id id); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_dynamic_buffer(spvc_compiler compiler, unsigned desc_set, unsigned binding, unsigned index); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_inline_uniform_block(spvc_compiler compiler, unsigned desc_set, unsigned binding); SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_combined_sampler_suffix(spvc_compiler compiler, const char *suffix); SPVC_PUBLIC_API const char *spvc_compiler_msl_get_combined_sampler_suffix(spvc_compiler compiler); /* * Reflect resources. * Maps almost 1:1 to C++ API. */ SPVC_PUBLIC_API spvc_result spvc_compiler_get_active_interface_variables(spvc_compiler compiler, spvc_set *set); SPVC_PUBLIC_API spvc_result spvc_compiler_set_enabled_interface_variables(spvc_compiler compiler, spvc_set set); SPVC_PUBLIC_API spvc_result spvc_compiler_create_shader_resources(spvc_compiler compiler, spvc_resources *resources); SPVC_PUBLIC_API spvc_result spvc_compiler_create_shader_resources_for_active_variables(spvc_compiler compiler, spvc_resources *resources, spvc_set active); SPVC_PUBLIC_API spvc_result spvc_resources_get_resource_list_for_type(spvc_resources resources, spvc_resource_type type, const spvc_reflected_resource **resource_list, size_t *resource_size); /* * Decorations. * Maps to C++ API. */ SPVC_PUBLIC_API void spvc_compiler_set_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration, unsigned argument); SPVC_PUBLIC_API void spvc_compiler_set_decoration_string(spvc_compiler compiler, SpvId id, SpvDecoration decoration, const char *argument); SPVC_PUBLIC_API void spvc_compiler_set_name(spvc_compiler compiler, SpvId id, const char *argument); SPVC_PUBLIC_API void spvc_compiler_set_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration, unsigned argument); SPVC_PUBLIC_API void spvc_compiler_set_member_decoration_string(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration, const char *argument); SPVC_PUBLIC_API void spvc_compiler_set_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index, const char *argument); SPVC_PUBLIC_API void spvc_compiler_unset_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration); SPVC_PUBLIC_API void spvc_compiler_unset_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration); SPVC_PUBLIC_API spvc_bool spvc_compiler_has_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration); SPVC_PUBLIC_API spvc_bool spvc_compiler_has_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration); SPVC_PUBLIC_API const char *spvc_compiler_get_name(spvc_compiler compiler, SpvId id); SPVC_PUBLIC_API unsigned spvc_compiler_get_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration); SPVC_PUBLIC_API const char *spvc_compiler_get_decoration_string(spvc_compiler compiler, SpvId id, SpvDecoration decoration); SPVC_PUBLIC_API unsigned spvc_compiler_get_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration); SPVC_PUBLIC_API const char *spvc_compiler_get_member_decoration_string(spvc_compiler compiler, spvc_type_id id, unsigned member_index, SpvDecoration decoration); SPVC_PUBLIC_API const char *spvc_compiler_get_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index); /* * Entry points. * Maps to C++ API. */ SPVC_PUBLIC_API spvc_result spvc_compiler_get_entry_points(spvc_compiler compiler, const spvc_entry_point **entry_points, size_t *num_entry_points); SPVC_PUBLIC_API spvc_result spvc_compiler_set_entry_point(spvc_compiler compiler, const char *name, SpvExecutionModel model); SPVC_PUBLIC_API spvc_result spvc_compiler_rename_entry_point(spvc_compiler compiler, const char *old_name, const char *new_name, SpvExecutionModel model); SPVC_PUBLIC_API const char *spvc_compiler_get_cleansed_entry_point_name(spvc_compiler compiler, const char *name, SpvExecutionModel model); SPVC_PUBLIC_API void spvc_compiler_set_execution_mode(spvc_compiler compiler, SpvExecutionMode mode); SPVC_PUBLIC_API void spvc_compiler_unset_execution_mode(spvc_compiler compiler, SpvExecutionMode mode); SPVC_PUBLIC_API void spvc_compiler_set_execution_mode_with_arguments(spvc_compiler compiler, SpvExecutionMode mode, unsigned arg0, unsigned arg1, unsigned arg2); SPVC_PUBLIC_API spvc_result spvc_compiler_get_execution_modes(spvc_compiler compiler, const SpvExecutionMode **modes, size_t *num_modes); SPVC_PUBLIC_API unsigned spvc_compiler_get_execution_mode_argument(spvc_compiler compiler, SpvExecutionMode mode); SPVC_PUBLIC_API unsigned spvc_compiler_get_execution_mode_argument_by_index(spvc_compiler compiler, SpvExecutionMode mode, unsigned index); SPVC_PUBLIC_API SpvExecutionModel spvc_compiler_get_execution_model(spvc_compiler compiler); /* * Type query interface. * Maps to C++ API, except it's read-only. */ SPVC_PUBLIC_API spvc_type spvc_compiler_get_type_handle(spvc_compiler compiler, spvc_type_id id); /* Pulls out SPIRType::self. This effectively gives the type ID without array or pointer qualifiers. * This is necessary when reflecting decoration/name information on members of a struct, * which are placed in the base type, not the qualified type. * This is similar to spvc_reflected_resource::base_type_id. */ SPVC_PUBLIC_API spvc_type_id spvc_type_get_base_type_id(spvc_type type); SPVC_PUBLIC_API spvc_basetype spvc_type_get_basetype(spvc_type type); SPVC_PUBLIC_API unsigned spvc_type_get_bit_width(spvc_type type); SPVC_PUBLIC_API unsigned spvc_type_get_vector_size(spvc_type type); SPVC_PUBLIC_API unsigned spvc_type_get_columns(spvc_type type); SPVC_PUBLIC_API unsigned spvc_type_get_num_array_dimensions(spvc_type type); SPVC_PUBLIC_API spvc_bool spvc_type_array_dimension_is_literal(spvc_type type, unsigned dimension); SPVC_PUBLIC_API SpvId spvc_type_get_array_dimension(spvc_type type, unsigned dimension); SPVC_PUBLIC_API unsigned spvc_type_get_num_member_types(spvc_type type); SPVC_PUBLIC_API spvc_type_id spvc_type_get_member_type(spvc_type type, unsigned index); SPVC_PUBLIC_API SpvStorageClass spvc_type_get_storage_class(spvc_type type); /* Image type query. */ SPVC_PUBLIC_API spvc_type_id spvc_type_get_image_sampled_type(spvc_type type); SPVC_PUBLIC_API SpvDim spvc_type_get_image_dimension(spvc_type type); SPVC_PUBLIC_API spvc_bool spvc_type_get_image_is_depth(spvc_type type); SPVC_PUBLIC_API spvc_bool spvc_type_get_image_arrayed(spvc_type type); SPVC_PUBLIC_API spvc_bool spvc_type_get_image_multisampled(spvc_type type); SPVC_PUBLIC_API spvc_bool spvc_type_get_image_is_storage(spvc_type type); SPVC_PUBLIC_API SpvImageFormat spvc_type_get_image_storage_format(spvc_type type); SPVC_PUBLIC_API SpvAccessQualifier spvc_type_get_image_access_qualifier(spvc_type type); /* * Buffer layout query. * Maps to C++ API. */ SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_size(spvc_compiler compiler, spvc_type struct_type, size_t *size); SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_size_runtime_array(spvc_compiler compiler, spvc_type struct_type, size_t array_size, size_t *size); SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_member_size(spvc_compiler compiler, spvc_type type, unsigned index, size_t *size); SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_offset(spvc_compiler compiler, spvc_type type, unsigned index, unsigned *offset); SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_array_stride(spvc_compiler compiler, spvc_type type, unsigned index, unsigned *stride); SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_matrix_stride(spvc_compiler compiler, spvc_type type, unsigned index, unsigned *stride); /* * Workaround helper functions. * Maps to C++ API. */ SPVC_PUBLIC_API spvc_result spvc_compiler_build_dummy_sampler_for_combined_images(spvc_compiler compiler, spvc_variable_id *id); SPVC_PUBLIC_API spvc_result spvc_compiler_build_combined_image_samplers(spvc_compiler compiler); SPVC_PUBLIC_API spvc_result spvc_compiler_get_combined_image_samplers(spvc_compiler compiler, const spvc_combined_image_sampler **samplers, size_t *num_samplers); /* * Constants * Maps to C++ API. */ SPVC_PUBLIC_API spvc_result spvc_compiler_get_specialization_constants(spvc_compiler compiler, const spvc_specialization_constant **constants, size_t *num_constants); SPVC_PUBLIC_API spvc_constant spvc_compiler_get_constant_handle(spvc_compiler compiler, spvc_constant_id id); SPVC_PUBLIC_API spvc_constant_id spvc_compiler_get_work_group_size_specialization_constants(spvc_compiler compiler, spvc_specialization_constant *x, spvc_specialization_constant *y, spvc_specialization_constant *z); /* * Buffer ranges * Maps to C++ API. */ SPVC_PUBLIC_API spvc_result spvc_compiler_get_active_buffer_ranges(spvc_compiler compiler, spvc_variable_id id, const spvc_buffer_range **ranges, size_t *num_ranges); /* * No stdint.h until C99, sigh :( * For smaller types, the result is sign or zero-extended as appropriate. * Maps to C++ API. * TODO: The SPIRConstant query interface and modification interface is not quite complete. */ SPVC_PUBLIC_API float spvc_constant_get_scalar_fp16(spvc_constant constant, unsigned column, unsigned row); SPVC_PUBLIC_API float spvc_constant_get_scalar_fp32(spvc_constant constant, unsigned column, unsigned row); SPVC_PUBLIC_API double spvc_constant_get_scalar_fp64(spvc_constant constant, unsigned column, unsigned row); SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u32(spvc_constant constant, unsigned column, unsigned row); SPVC_PUBLIC_API int spvc_constant_get_scalar_i32(spvc_constant constant, unsigned column, unsigned row); SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u16(spvc_constant constant, unsigned column, unsigned row); SPVC_PUBLIC_API int spvc_constant_get_scalar_i16(spvc_constant constant, unsigned column, unsigned row); SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u8(spvc_constant constant, unsigned column, unsigned row); SPVC_PUBLIC_API int spvc_constant_get_scalar_i8(spvc_constant constant, unsigned column, unsigned row); SPVC_PUBLIC_API void spvc_constant_get_subconstants(spvc_constant constant, const spvc_constant_id **constituents, size_t *count); SPVC_PUBLIC_API spvc_type_id spvc_constant_get_type(spvc_constant constant); /* * Misc reflection * Maps to C++ API. */ SPVC_PUBLIC_API spvc_bool spvc_compiler_get_binary_offset_for_decoration(spvc_compiler compiler, spvc_variable_id id, SpvDecoration decoration, unsigned *word_offset); SPVC_PUBLIC_API spvc_bool spvc_compiler_buffer_is_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id); SPVC_PUBLIC_API spvc_bool spvc_compiler_buffer_get_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id, spvc_variable_id *counter_id); SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_capabilities(spvc_compiler compiler, const SpvCapability **capabilities, size_t *num_capabilities); SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_extensions(spvc_compiler compiler, const char ***extensions, size_t *num_extensions); SPVC_PUBLIC_API const char *spvc_compiler_get_remapped_declared_block_name(spvc_compiler compiler, spvc_variable_id id); SPVC_PUBLIC_API spvc_result spvc_compiler_get_buffer_block_decorations(spvc_compiler compiler, spvc_variable_id id, const SpvDecoration **decorations, size_t *num_decorations); #ifdef __cplusplus } #endif #endif spirv-cross-2021.01.15/spirv_cross_containers.hpp000066400000000000000000000425431400026215700217140ustar00rootroot00000000000000/* * Copyright 2019-2021 Hans-Kristian Arntzen * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_CONTAINERS_HPP #define SPIRV_CROSS_CONTAINERS_HPP #include "spirv_cross_error_handling.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef SPIRV_CROSS_NAMESPACE_OVERRIDE #define SPIRV_CROSS_NAMESPACE SPIRV_CROSS_NAMESPACE_OVERRIDE #else #define SPIRV_CROSS_NAMESPACE spirv_cross #endif namespace SPIRV_CROSS_NAMESPACE { #ifndef SPIRV_CROSS_FORCE_STL_TYPES // std::aligned_storage does not support size == 0, so roll our own. template class AlignedBuffer { public: T *data() { #if defined(_MSC_VER) && _MSC_VER < 1900 // MSVC 2013 workarounds, sigh ... // Only use this workaround on MSVC 2013 due to some confusion around default initialized unions. // Spec seems to suggest the memory will be zero-initialized, which is *not* what we want. return reinterpret_cast(u.aligned_char); #else return reinterpret_cast(aligned_char); #endif } private: #if defined(_MSC_VER) && _MSC_VER < 1900 // MSVC 2013 workarounds, sigh ... union { char aligned_char[sizeof(T) * N]; double dummy_aligner; } u; #else alignas(T) char aligned_char[sizeof(T) * N]; #endif }; template class AlignedBuffer { public: T *data() { return nullptr; } }; // An immutable version of SmallVector which erases type information about storage. template class VectorView { public: T &operator[](size_t i) SPIRV_CROSS_NOEXCEPT { return ptr[i]; } const T &operator[](size_t i) const SPIRV_CROSS_NOEXCEPT { return ptr[i]; } bool empty() const SPIRV_CROSS_NOEXCEPT { return buffer_size == 0; } size_t size() const SPIRV_CROSS_NOEXCEPT { return buffer_size; } T *data() SPIRV_CROSS_NOEXCEPT { return ptr; } const T *data() const SPIRV_CROSS_NOEXCEPT { return ptr; } T *begin() SPIRV_CROSS_NOEXCEPT { return ptr; } T *end() SPIRV_CROSS_NOEXCEPT { return ptr + buffer_size; } const T *begin() const SPIRV_CROSS_NOEXCEPT { return ptr; } const T *end() const SPIRV_CROSS_NOEXCEPT { return ptr + buffer_size; } T &front() SPIRV_CROSS_NOEXCEPT { return ptr[0]; } const T &front() const SPIRV_CROSS_NOEXCEPT { return ptr[0]; } T &back() SPIRV_CROSS_NOEXCEPT { return ptr[buffer_size - 1]; } const T &back() const SPIRV_CROSS_NOEXCEPT { return ptr[buffer_size - 1]; } // Makes it easier to consume SmallVector. #if defined(_MSC_VER) && _MSC_VER < 1900 explicit operator std::vector() const { // Another MSVC 2013 workaround. It does not understand lvalue/rvalue qualified operations. return std::vector(ptr, ptr + buffer_size); } #else // Makes it easier to consume SmallVector. explicit operator std::vector() const & { return std::vector(ptr, ptr + buffer_size); } // If we are converting as an r-value, we can pilfer our elements. explicit operator std::vector() && { return std::vector(std::make_move_iterator(ptr), std::make_move_iterator(ptr + buffer_size)); } #endif // Avoid sliced copies. Base class should only be read as a reference. VectorView(const VectorView &) = delete; void operator=(const VectorView &) = delete; protected: VectorView() = default; T *ptr = nullptr; size_t buffer_size = 0; }; // Simple vector which supports up to N elements inline, without malloc/free. // We use a lot of throwaway vectors all over the place which triggers allocations. // This class only implements the subset of std::vector we need in SPIRV-Cross. // It is *NOT* a drop-in replacement in general projects. template class SmallVector : public VectorView { public: SmallVector() SPIRV_CROSS_NOEXCEPT { this->ptr = stack_storage.data(); buffer_capacity = N; } SmallVector(const T *arg_list_begin, const T *arg_list_end) SPIRV_CROSS_NOEXCEPT : SmallVector() { auto count = size_t(arg_list_end - arg_list_begin); reserve(count); for (size_t i = 0; i < count; i++, arg_list_begin++) new (&this->ptr[i]) T(*arg_list_begin); this->buffer_size = count; } SmallVector(std::initializer_list init) SPIRV_CROSS_NOEXCEPT : SmallVector(init.begin(), init.end()) { } SmallVector(SmallVector &&other) SPIRV_CROSS_NOEXCEPT : SmallVector() { *this = std::move(other); } SmallVector &operator=(SmallVector &&other) SPIRV_CROSS_NOEXCEPT { clear(); if (other.ptr != other.stack_storage.data()) { // Pilfer allocated pointer. if (this->ptr != stack_storage.data()) free(this->ptr); this->ptr = other.ptr; this->buffer_size = other.buffer_size; buffer_capacity = other.buffer_capacity; other.ptr = nullptr; other.buffer_size = 0; other.buffer_capacity = 0; } else { // Need to move the stack contents individually. reserve(other.buffer_size); for (size_t i = 0; i < other.buffer_size; i++) { new (&this->ptr[i]) T(std::move(other.ptr[i])); other.ptr[i].~T(); } this->buffer_size = other.buffer_size; other.buffer_size = 0; } return *this; } SmallVector(const SmallVector &other) SPIRV_CROSS_NOEXCEPT : SmallVector() { *this = other; } SmallVector &operator=(const SmallVector &other) SPIRV_CROSS_NOEXCEPT { if (this == &other) return *this; clear(); reserve(other.buffer_size); for (size_t i = 0; i < other.buffer_size; i++) new (&this->ptr[i]) T(other.ptr[i]); this->buffer_size = other.buffer_size; return *this; } explicit SmallVector(size_t count) SPIRV_CROSS_NOEXCEPT : SmallVector() { resize(count); } ~SmallVector() { clear(); if (this->ptr != stack_storage.data()) free(this->ptr); } void clear() SPIRV_CROSS_NOEXCEPT { for (size_t i = 0; i < this->buffer_size; i++) this->ptr[i].~T(); this->buffer_size = 0; } void push_back(const T &t) SPIRV_CROSS_NOEXCEPT { reserve(this->buffer_size + 1); new (&this->ptr[this->buffer_size]) T(t); this->buffer_size++; } void push_back(T &&t) SPIRV_CROSS_NOEXCEPT { reserve(this->buffer_size + 1); new (&this->ptr[this->buffer_size]) T(std::move(t)); this->buffer_size++; } void pop_back() SPIRV_CROSS_NOEXCEPT { // Work around false positive warning on GCC 8.3. // Calling pop_back on empty vector is undefined. if (!this->empty()) resize(this->buffer_size - 1); } template void emplace_back(Ts &&... ts) SPIRV_CROSS_NOEXCEPT { reserve(this->buffer_size + 1); new (&this->ptr[this->buffer_size]) T(std::forward(ts)...); this->buffer_size++; } void reserve(size_t count) SPIRV_CROSS_NOEXCEPT { if ((count > std::numeric_limits::max() / sizeof(T)) || (count > std::numeric_limits::max() / 2)) { // Only way this should ever happen is with garbage input, terminate. std::terminate(); } if (count > buffer_capacity) { size_t target_capacity = buffer_capacity; if (target_capacity == 0) target_capacity = 1; // Weird parens works around macro issues on Windows if NOMINMAX is not used. target_capacity = (std::max)(target_capacity, N); // Need to ensure there is a POT value of target capacity which is larger than count, // otherwise this will overflow. while (target_capacity < count) target_capacity <<= 1u; T *new_buffer = target_capacity > N ? static_cast(malloc(target_capacity * sizeof(T))) : stack_storage.data(); // If we actually fail this malloc, we are hosed anyways, there is no reason to attempt recovery. if (!new_buffer) std::terminate(); // In case for some reason two allocations both come from same stack. if (new_buffer != this->ptr) { // We don't deal with types which can throw in move constructor. for (size_t i = 0; i < this->buffer_size; i++) { new (&new_buffer[i]) T(std::move(this->ptr[i])); this->ptr[i].~T(); } } if (this->ptr != stack_storage.data()) free(this->ptr); this->ptr = new_buffer; buffer_capacity = target_capacity; } } void insert(T *itr, const T *insert_begin, const T *insert_end) SPIRV_CROSS_NOEXCEPT { auto count = size_t(insert_end - insert_begin); if (itr == this->end()) { reserve(this->buffer_size + count); for (size_t i = 0; i < count; i++, insert_begin++) new (&this->ptr[this->buffer_size + i]) T(*insert_begin); this->buffer_size += count; } else { if (this->buffer_size + count > buffer_capacity) { auto target_capacity = this->buffer_size + count; if (target_capacity == 0) target_capacity = 1; if (target_capacity < N) target_capacity = N; while (target_capacity < count) target_capacity <<= 1u; // Need to allocate new buffer. Move everything to a new buffer. T *new_buffer = target_capacity > N ? static_cast(malloc(target_capacity * sizeof(T))) : stack_storage.data(); // If we actually fail this malloc, we are hosed anyways, there is no reason to attempt recovery. if (!new_buffer) std::terminate(); // First, move elements from source buffer to new buffer. // We don't deal with types which can throw in move constructor. auto *target_itr = new_buffer; auto *original_source_itr = this->begin(); if (new_buffer != this->ptr) { while (original_source_itr != itr) { new (target_itr) T(std::move(*original_source_itr)); original_source_itr->~T(); ++original_source_itr; ++target_itr; } } // Copy-construct new elements. for (auto *source_itr = insert_begin; source_itr != insert_end; ++source_itr, ++target_itr) new (target_itr) T(*source_itr); // Move over the other half. if (new_buffer != this->ptr || insert_begin != insert_end) { while (original_source_itr != this->end()) { new (target_itr) T(std::move(*original_source_itr)); original_source_itr->~T(); ++original_source_itr; ++target_itr; } } if (this->ptr != stack_storage.data()) free(this->ptr); this->ptr = new_buffer; buffer_capacity = target_capacity; } else { // Move in place, need to be a bit careful about which elements are constructed and which are not. // Move the end and construct the new elements. auto *target_itr = this->end() + count; auto *source_itr = this->end(); while (target_itr != this->end() && source_itr != itr) { --target_itr; --source_itr; new (target_itr) T(std::move(*source_itr)); } // For already constructed elements we can move-assign. std::move_backward(itr, source_itr, target_itr); // For the inserts which go to already constructed elements, we can do a plain copy. while (itr != this->end() && insert_begin != insert_end) *itr++ = *insert_begin++; // For inserts into newly allocated memory, we must copy-construct instead. while (insert_begin != insert_end) { new (itr) T(*insert_begin); ++itr; ++insert_begin; } } this->buffer_size += count; } } void insert(T *itr, const T &value) SPIRV_CROSS_NOEXCEPT { insert(itr, &value, &value + 1); } T *erase(T *itr) SPIRV_CROSS_NOEXCEPT { std::move(itr + 1, this->end(), itr); this->ptr[--this->buffer_size].~T(); return itr; } void erase(T *start_erase, T *end_erase) SPIRV_CROSS_NOEXCEPT { if (end_erase == this->end()) { resize(size_t(start_erase - this->begin())); } else { auto new_size = this->buffer_size - (end_erase - start_erase); std::move(end_erase, this->end(), start_erase); resize(new_size); } } void resize(size_t new_size) SPIRV_CROSS_NOEXCEPT { if (new_size < this->buffer_size) { for (size_t i = new_size; i < this->buffer_size; i++) this->ptr[i].~T(); } else if (new_size > this->buffer_size) { reserve(new_size); for (size_t i = this->buffer_size; i < new_size; i++) new (&this->ptr[i]) T(); } this->buffer_size = new_size; } private: size_t buffer_capacity = 0; AlignedBuffer stack_storage; }; // A vector without stack storage. // Could also be a typedef-ed to std::vector, // but might as well use the one we have. template using Vector = SmallVector; #else // SPIRV_CROSS_FORCE_STL_TYPES template using SmallVector = std::vector; template using Vector = std::vector; template using VectorView = std::vector; #endif // SPIRV_CROSS_FORCE_STL_TYPES // An object pool which we use for allocating IVariant-derived objects. // We know we are going to allocate a bunch of objects of each type, // so amortize the mallocs. class ObjectPoolBase { public: virtual ~ObjectPoolBase() = default; virtual void free_opaque(void *ptr) = 0; }; template class ObjectPool : public ObjectPoolBase { public: explicit ObjectPool(unsigned start_object_count_ = 16) : start_object_count(start_object_count_) { } template T *allocate(P &&... p) { if (vacants.empty()) { unsigned num_objects = start_object_count << memory.size(); T *ptr = static_cast(malloc(num_objects * sizeof(T))); if (!ptr) return nullptr; for (unsigned i = 0; i < num_objects; i++) vacants.push_back(&ptr[i]); memory.emplace_back(ptr); } T *ptr = vacants.back(); vacants.pop_back(); new (ptr) T(std::forward

(p)...); return ptr; } void free(T *ptr) { ptr->~T(); vacants.push_back(ptr); } void free_opaque(void *ptr) override { free(static_cast(ptr)); } void clear() { vacants.clear(); memory.clear(); } protected: Vector vacants; struct MallocDeleter { void operator()(T *ptr) { ::free(ptr); } }; SmallVector> memory; unsigned start_object_count; }; template class StringStream { public: StringStream() { reset(); } ~StringStream() { reset(); } // Disable copies and moves. Makes it easier to implement, and we don't need it. StringStream(const StringStream &) = delete; void operator=(const StringStream &) = delete; template ::value, int>::type = 0> StringStream &operator<<(const T &t) { auto s = std::to_string(t); append(s.data(), s.size()); return *this; } // Only overload this to make float/double conversions ambiguous. StringStream &operator<<(uint32_t v) { auto s = std::to_string(v); append(s.data(), s.size()); return *this; } StringStream &operator<<(char c) { append(&c, 1); return *this; } StringStream &operator<<(const std::string &s) { append(s.data(), s.size()); return *this; } StringStream &operator<<(const char *s) { append(s, strlen(s)); return *this; } template StringStream &operator<<(const char (&s)[N]) { append(s, strlen(s)); return *this; } std::string str() const { std::string ret; size_t target_size = 0; for (auto &saved : saved_buffers) target_size += saved.offset; target_size += current_buffer.offset; ret.reserve(target_size); for (auto &saved : saved_buffers) ret.insert(ret.end(), saved.buffer, saved.buffer + saved.offset); ret.insert(ret.end(), current_buffer.buffer, current_buffer.buffer + current_buffer.offset); return ret; } void reset() { for (auto &saved : saved_buffers) if (saved.buffer != stack_buffer) free(saved.buffer); if (current_buffer.buffer != stack_buffer) free(current_buffer.buffer); saved_buffers.clear(); current_buffer.buffer = stack_buffer; current_buffer.offset = 0; current_buffer.size = sizeof(stack_buffer); } private: struct Buffer { char *buffer = nullptr; size_t offset = 0; size_t size = 0; }; Buffer current_buffer; char stack_buffer[StackSize]; SmallVector saved_buffers; void append(const char *s, size_t len) { size_t avail = current_buffer.size - current_buffer.offset; if (avail < len) { if (avail > 0) { memcpy(current_buffer.buffer + current_buffer.offset, s, avail); s += avail; len -= avail; current_buffer.offset += avail; } saved_buffers.push_back(current_buffer); size_t target_size = len > BlockSize ? len : BlockSize; current_buffer.buffer = static_cast(malloc(target_size)); if (!current_buffer.buffer) SPIRV_CROSS_THROW("Out of memory."); memcpy(current_buffer.buffer, s, len); current_buffer.offset = len; current_buffer.size = target_size; } else { memcpy(current_buffer.buffer + current_buffer.offset, s, len); current_buffer.offset += len; } } }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_cross_error_handling.hpp000066400000000000000000000050761400026215700225440ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_ERROR_HANDLING #define SPIRV_CROSS_ERROR_HANDLING #include #include #include #ifndef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS #include #endif #ifdef SPIRV_CROSS_NAMESPACE_OVERRIDE #define SPIRV_CROSS_NAMESPACE SPIRV_CROSS_NAMESPACE_OVERRIDE #else #define SPIRV_CROSS_NAMESPACE spirv_cross #endif namespace SPIRV_CROSS_NAMESPACE { #ifdef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS #if !defined(_MSC_VER) || defined(__clang__) [[noreturn]] #elif defined(_MSC_VER) __declspec(noreturn) #endif inline void report_and_abort(const std::string &msg) { #ifdef NDEBUG (void)msg; #else fprintf(stderr, "There was a compiler error: %s\n", msg.c_str()); #endif fflush(stderr); abort(); } #define SPIRV_CROSS_THROW(x) report_and_abort(x) #else class CompilerError : public std::runtime_error { public: explicit CompilerError(const std::string &str) : std::runtime_error(str) { } }; #define SPIRV_CROSS_THROW(x) throw CompilerError(x) #endif // MSVC 2013 does not have noexcept. We need this for Variant to get move constructor to work correctly // instead of copy constructor. // MSVC 2013 ignores that move constructors cannot throw in std::vector, so just don't define it. #if defined(_MSC_VER) && _MSC_VER < 1900 #define SPIRV_CROSS_NOEXCEPT #else #define SPIRV_CROSS_NOEXCEPT noexcept #endif #if __cplusplus >= 201402l #define SPIRV_CROSS_DEPRECATED(reason) [[deprecated(reason)]] #elif defined(__GNUC__) #define SPIRV_CROSS_DEPRECATED(reason) __attribute__((deprecated)) #elif defined(_MSC_VER) #define SPIRV_CROSS_DEPRECATED(reason) __declspec(deprecated(reason)) #else #define SPIRV_CROSS_DEPRECATED(reason) #endif } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_cross_parsed_ir.cpp000066400000000000000000000603231400026215700215060ustar00rootroot00000000000000/* * Copyright 2018-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_cross_parsed_ir.hpp" #include #include using namespace std; using namespace spv; namespace SPIRV_CROSS_NAMESPACE { ParsedIR::ParsedIR() { // If we move ParsedIR, we need to make sure the pointer stays fixed since the child Variant objects consume a pointer to this group, // so need an extra pointer here. pool_group.reset(new ObjectPoolGroup); pool_group->pools[TypeType].reset(new ObjectPool); pool_group->pools[TypeVariable].reset(new ObjectPool); pool_group->pools[TypeConstant].reset(new ObjectPool); pool_group->pools[TypeFunction].reset(new ObjectPool); pool_group->pools[TypeFunctionPrototype].reset(new ObjectPool); pool_group->pools[TypeBlock].reset(new ObjectPool); pool_group->pools[TypeExtension].reset(new ObjectPool); pool_group->pools[TypeExpression].reset(new ObjectPool); pool_group->pools[TypeConstantOp].reset(new ObjectPool); pool_group->pools[TypeCombinedImageSampler].reset(new ObjectPool); pool_group->pools[TypeAccessChain].reset(new ObjectPool); pool_group->pools[TypeUndef].reset(new ObjectPool); pool_group->pools[TypeString].reset(new ObjectPool); } // Should have been default-implemented, but need this on MSVC 2013. ParsedIR::ParsedIR(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT { *this = move(other); } ParsedIR &ParsedIR::operator=(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT { if (this != &other) { pool_group = move(other.pool_group); spirv = move(other.spirv); meta = move(other.meta); for (int i = 0; i < TypeCount; i++) ids_for_type[i] = move(other.ids_for_type[i]); ids_for_constant_or_type = move(other.ids_for_constant_or_type); ids_for_constant_or_variable = move(other.ids_for_constant_or_variable); declared_capabilities = move(other.declared_capabilities); declared_extensions = move(other.declared_extensions); block_meta = move(other.block_meta); continue_block_to_loop_header = move(other.continue_block_to_loop_header); entry_points = move(other.entry_points); ids = move(other.ids); addressing_model = other.addressing_model; memory_model = other.memory_model; default_entry_point = other.default_entry_point; source = other.source; loop_iteration_depth_hard = other.loop_iteration_depth_hard; loop_iteration_depth_soft = other.loop_iteration_depth_soft; meta_needing_name_fixup = std::move(other.meta_needing_name_fixup); } return *this; } ParsedIR::ParsedIR(const ParsedIR &other) : ParsedIR() { *this = other; } ParsedIR &ParsedIR::operator=(const ParsedIR &other) { if (this != &other) { spirv = other.spirv; meta = other.meta; for (int i = 0; i < TypeCount; i++) ids_for_type[i] = other.ids_for_type[i]; ids_for_constant_or_type = other.ids_for_constant_or_type; ids_for_constant_or_variable = other.ids_for_constant_or_variable; declared_capabilities = other.declared_capabilities; declared_extensions = other.declared_extensions; block_meta = other.block_meta; continue_block_to_loop_header = other.continue_block_to_loop_header; entry_points = other.entry_points; default_entry_point = other.default_entry_point; source = other.source; loop_iteration_depth_hard = other.loop_iteration_depth_hard; loop_iteration_depth_soft = other.loop_iteration_depth_soft; addressing_model = other.addressing_model; memory_model = other.memory_model; meta_needing_name_fixup = other.meta_needing_name_fixup; // Very deliberate copying of IDs. There is no default copy constructor, nor a simple default constructor. // Construct object first so we have the correct allocator set-up, then we can copy object into our new pool group. ids.clear(); ids.reserve(other.ids.size()); for (size_t i = 0; i < other.ids.size(); i++) { ids.emplace_back(pool_group.get()); ids.back() = other.ids[i]; } } return *this; } void ParsedIR::set_id_bounds(uint32_t bounds) { ids.reserve(bounds); while (ids.size() < bounds) ids.emplace_back(pool_group.get()); block_meta.resize(bounds); } // Roll our own versions of these functions to avoid potential locale shenanigans. static bool is_alpha(char c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); } static bool is_numeric(char c) { return c >= '0' && c <= '9'; } static bool is_alphanumeric(char c) { return is_alpha(c) || is_numeric(c); } static bool is_valid_identifier(const string &name) { if (name.empty()) return true; if (is_numeric(name[0])) return false; for (auto c : name) if (!is_alphanumeric(c) && c != '_') return false; bool saw_underscore = false; // Two underscores in a row is not a valid identifier either. // Technically reserved, but it's easier to treat it as invalid. for (auto c : name) { bool is_underscore = c == '_'; if (is_underscore && saw_underscore) return false; saw_underscore = is_underscore; } return true; } static bool is_reserved_prefix(const string &name) { // Generic reserved identifiers used by the implementation. return name.compare(0, 3, "gl_", 3) == 0 || // Ignore this case for now, might rewrite internal code to always use spv prefix. //name.compare(0, 11, "SPIRV_Cross", 11) == 0 || name.compare(0, 3, "spv", 3) == 0; } static bool is_reserved_identifier(const string &name, bool member, bool allow_reserved_prefixes) { if (!allow_reserved_prefixes && is_reserved_prefix(name)) return true; if (member) { // Reserved member identifiers come in one form: // _m[0-9]+$. if (name.size() < 3) return false; if (name.compare(0, 2, "_m", 2) != 0) return false; size_t index = 2; while (index < name.size() && is_numeric(name[index])) index++; return index == name.size(); } else { // Reserved non-member identifiers come in two forms: // _[0-9]+$, used for temporaries which map directly to a SPIR-V ID. // _[0-9]+_, used for auxillary temporaries which derived from a SPIR-V ID. if (name.size() < 2) return false; if (name[0] != '_' || !is_numeric(name[1])) return false; size_t index = 2; while (index < name.size() && is_numeric(name[index])) index++; return index == name.size() || (index < name.size() && name[index] == '_'); } } bool ParsedIR::is_globally_reserved_identifier(std::string &str, bool allow_reserved_prefixes) { return is_reserved_identifier(str, false, allow_reserved_prefixes); } uint32_t ParsedIR::get_spirv_version() const { return spirv[1]; } static string make_unreserved_identifier(const string &name) { if (is_reserved_prefix(name)) return "_RESERVED_IDENTIFIER_FIXUP_" + name; else return "_RESERVED_IDENTIFIER_FIXUP" + name; } void ParsedIR::sanitize_underscores(std::string &str) { // Compact adjacent underscores to make it valid. auto dst = str.begin(); auto src = dst; bool saw_underscore = false; while (src != str.end()) { bool is_underscore = *src == '_'; if (saw_underscore && is_underscore) { src++; } else { if (dst != src) *dst = *src; dst++; src++; saw_underscore = is_underscore; } } str.erase(dst, str.end()); } static string ensure_valid_identifier(const string &name) { // Functions in glslangValidator are mangled with name( stuff. // Normally, we would never see '(' in any legal identifiers, so just strip them out. auto str = name.substr(0, name.find('(')); if (str.empty()) return str; if (is_numeric(str[0])) str[0] = '_'; for (auto &c : str) if (!is_alphanumeric(c) && c != '_') c = '_'; ParsedIR::sanitize_underscores(str); return str; } const string &ParsedIR::get_name(ID id) const { auto *m = find_meta(id); if (m) return m->decoration.alias; else return empty_string; } const string &ParsedIR::get_member_name(TypeID id, uint32_t index) const { auto *m = find_meta(id); if (m) { if (index >= m->members.size()) return empty_string; return m->members[index].alias; } else return empty_string; } void ParsedIR::sanitize_identifier(std::string &name, bool member, bool allow_reserved_prefixes) { if (!is_valid_identifier(name)) name = ensure_valid_identifier(name); if (is_reserved_identifier(name, member, allow_reserved_prefixes)) name = make_unreserved_identifier(name); } void ParsedIR::fixup_reserved_names() { for (uint32_t id : meta_needing_name_fixup) { auto &m = meta[id]; sanitize_identifier(m.decoration.alias, false, false); for (auto &memb : m.members) sanitize_identifier(memb.alias, true, false); } meta_needing_name_fixup.clear(); } void ParsedIR::set_name(ID id, const string &name) { auto &m = meta[id]; m.decoration.alias = name; if (!is_valid_identifier(name) || is_reserved_identifier(name, false, false)) meta_needing_name_fixup.insert(id); } void ParsedIR::set_member_name(TypeID id, uint32_t index, const string &name) { auto &m = meta[id]; m.members.resize(max(meta[id].members.size(), size_t(index) + 1)); m.members[index].alias = name; if (!is_valid_identifier(name) || is_reserved_identifier(name, true, false)) meta_needing_name_fixup.insert(id); } void ParsedIR::set_decoration_string(ID id, Decoration decoration, const string &argument) { auto &dec = meta[id].decoration; dec.decoration_flags.set(decoration); switch (decoration) { case DecorationHlslSemanticGOOGLE: dec.hlsl_semantic = argument; break; default: break; } } void ParsedIR::set_decoration(ID id, Decoration decoration, uint32_t argument) { auto &dec = meta[id].decoration; dec.decoration_flags.set(decoration); switch (decoration) { case DecorationBuiltIn: dec.builtin = true; dec.builtin_type = static_cast(argument); break; case DecorationLocation: dec.location = argument; break; case DecorationComponent: dec.component = argument; break; case DecorationOffset: dec.offset = argument; break; case DecorationXfbBuffer: dec.xfb_buffer = argument; break; case DecorationXfbStride: dec.xfb_stride = argument; break; case DecorationStream: dec.stream = argument; break; case DecorationArrayStride: dec.array_stride = argument; break; case DecorationMatrixStride: dec.matrix_stride = argument; break; case DecorationBinding: dec.binding = argument; break; case DecorationDescriptorSet: dec.set = argument; break; case DecorationInputAttachmentIndex: dec.input_attachment = argument; break; case DecorationSpecId: dec.spec_id = argument; break; case DecorationIndex: dec.index = argument; break; case DecorationHlslCounterBufferGOOGLE: meta[id].hlsl_magic_counter_buffer = argument; meta[argument].hlsl_is_magic_counter_buffer = true; break; case DecorationFPRoundingMode: dec.fp_rounding_mode = static_cast(argument); break; default: break; } } void ParsedIR::set_member_decoration(TypeID id, uint32_t index, Decoration decoration, uint32_t argument) { meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1)); auto &dec = meta[id].members[index]; dec.decoration_flags.set(decoration); switch (decoration) { case DecorationBuiltIn: dec.builtin = true; dec.builtin_type = static_cast(argument); break; case DecorationLocation: dec.location = argument; break; case DecorationComponent: dec.component = argument; break; case DecorationBinding: dec.binding = argument; break; case DecorationOffset: dec.offset = argument; break; case DecorationXfbBuffer: dec.xfb_buffer = argument; break; case DecorationXfbStride: dec.xfb_stride = argument; break; case DecorationStream: dec.stream = argument; break; case DecorationSpecId: dec.spec_id = argument; break; case DecorationMatrixStride: dec.matrix_stride = argument; break; case DecorationIndex: dec.index = argument; break; default: break; } } // Recursively marks any constants referenced by the specified constant instruction as being used // as an array length. The id must be a constant instruction (SPIRConstant or SPIRConstantOp). void ParsedIR::mark_used_as_array_length(ID id) { switch (ids[id].get_type()) { case TypeConstant: get(id).is_used_as_array_length = true; break; case TypeConstantOp: { auto &cop = get(id); if (cop.opcode == OpCompositeExtract) mark_used_as_array_length(cop.arguments[0]); else if (cop.opcode == OpCompositeInsert) { mark_used_as_array_length(cop.arguments[0]); mark_used_as_array_length(cop.arguments[1]); } else for (uint32_t arg_id : cop.arguments) mark_used_as_array_length(arg_id); break; } case TypeUndef: break; default: assert(0); } } Bitset ParsedIR::get_buffer_block_type_flags(const SPIRType &type) const { if (type.member_types.empty()) return {}; Bitset all_members_flags = get_member_decoration_bitset(type.self, 0); for (uint32_t i = 1; i < uint32_t(type.member_types.size()); i++) all_members_flags.merge_and(get_member_decoration_bitset(type.self, i)); return all_members_flags; } Bitset ParsedIR::get_buffer_block_flags(const SPIRVariable &var) const { auto &type = get(var.basetype); assert(type.basetype == SPIRType::Struct); // Some flags like non-writable, non-readable are actually found // as member decorations. If all members have a decoration set, propagate // the decoration up as a regular variable decoration. Bitset base_flags; auto *m = find_meta(var.self); if (m) base_flags = m->decoration.decoration_flags; if (type.member_types.empty()) return base_flags; auto all_members_flags = get_buffer_block_type_flags(type); base_flags.merge_or(all_members_flags); return base_flags; } const Bitset &ParsedIR::get_member_decoration_bitset(TypeID id, uint32_t index) const { auto *m = find_meta(id); if (m) { if (index >= m->members.size()) return cleared_bitset; return m->members[index].decoration_flags; } else return cleared_bitset; } bool ParsedIR::has_decoration(ID id, Decoration decoration) const { return get_decoration_bitset(id).get(decoration); } uint32_t ParsedIR::get_decoration(ID id, Decoration decoration) const { auto *m = find_meta(id); if (!m) return 0; auto &dec = m->decoration; if (!dec.decoration_flags.get(decoration)) return 0; switch (decoration) { case DecorationBuiltIn: return dec.builtin_type; case DecorationLocation: return dec.location; case DecorationComponent: return dec.component; case DecorationOffset: return dec.offset; case DecorationXfbBuffer: return dec.xfb_buffer; case DecorationXfbStride: return dec.xfb_stride; case DecorationStream: return dec.stream; case DecorationBinding: return dec.binding; case DecorationDescriptorSet: return dec.set; case DecorationInputAttachmentIndex: return dec.input_attachment; case DecorationSpecId: return dec.spec_id; case DecorationArrayStride: return dec.array_stride; case DecorationMatrixStride: return dec.matrix_stride; case DecorationIndex: return dec.index; case DecorationFPRoundingMode: return dec.fp_rounding_mode; default: return 1; } } const string &ParsedIR::get_decoration_string(ID id, Decoration decoration) const { auto *m = find_meta(id); if (!m) return empty_string; auto &dec = m->decoration; if (!dec.decoration_flags.get(decoration)) return empty_string; switch (decoration) { case DecorationHlslSemanticGOOGLE: return dec.hlsl_semantic; default: return empty_string; } } void ParsedIR::unset_decoration(ID id, Decoration decoration) { auto &dec = meta[id].decoration; dec.decoration_flags.clear(decoration); switch (decoration) { case DecorationBuiltIn: dec.builtin = false; break; case DecorationLocation: dec.location = 0; break; case DecorationComponent: dec.component = 0; break; case DecorationOffset: dec.offset = 0; break; case DecorationXfbBuffer: dec.xfb_buffer = 0; break; case DecorationXfbStride: dec.xfb_stride = 0; break; case DecorationStream: dec.stream = 0; break; case DecorationBinding: dec.binding = 0; break; case DecorationDescriptorSet: dec.set = 0; break; case DecorationInputAttachmentIndex: dec.input_attachment = 0; break; case DecorationSpecId: dec.spec_id = 0; break; case DecorationHlslSemanticGOOGLE: dec.hlsl_semantic.clear(); break; case DecorationFPRoundingMode: dec.fp_rounding_mode = FPRoundingModeMax; break; case DecorationHlslCounterBufferGOOGLE: { auto &counter = meta[id].hlsl_magic_counter_buffer; if (counter) { meta[counter].hlsl_is_magic_counter_buffer = false; counter = 0; } break; } default: break; } } bool ParsedIR::has_member_decoration(TypeID id, uint32_t index, Decoration decoration) const { return get_member_decoration_bitset(id, index).get(decoration); } uint32_t ParsedIR::get_member_decoration(TypeID id, uint32_t index, Decoration decoration) const { auto *m = find_meta(id); if (!m) return 0; if (index >= m->members.size()) return 0; auto &dec = m->members[index]; if (!dec.decoration_flags.get(decoration)) return 0; switch (decoration) { case DecorationBuiltIn: return dec.builtin_type; case DecorationLocation: return dec.location; case DecorationComponent: return dec.component; case DecorationBinding: return dec.binding; case DecorationOffset: return dec.offset; case DecorationXfbBuffer: return dec.xfb_buffer; case DecorationXfbStride: return dec.xfb_stride; case DecorationStream: return dec.stream; case DecorationSpecId: return dec.spec_id; case DecorationIndex: return dec.index; default: return 1; } } const Bitset &ParsedIR::get_decoration_bitset(ID id) const { auto *m = find_meta(id); if (m) { auto &dec = m->decoration; return dec.decoration_flags; } else return cleared_bitset; } void ParsedIR::set_member_decoration_string(TypeID id, uint32_t index, Decoration decoration, const string &argument) { meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1)); auto &dec = meta[id].members[index]; dec.decoration_flags.set(decoration); switch (decoration) { case DecorationHlslSemanticGOOGLE: dec.hlsl_semantic = argument; break; default: break; } } const string &ParsedIR::get_member_decoration_string(TypeID id, uint32_t index, Decoration decoration) const { auto *m = find_meta(id); if (m) { if (!has_member_decoration(id, index, decoration)) return empty_string; auto &dec = m->members[index]; switch (decoration) { case DecorationHlslSemanticGOOGLE: return dec.hlsl_semantic; default: return empty_string; } } else return empty_string; } void ParsedIR::unset_member_decoration(TypeID id, uint32_t index, Decoration decoration) { auto &m = meta[id]; if (index >= m.members.size()) return; auto &dec = m.members[index]; dec.decoration_flags.clear(decoration); switch (decoration) { case DecorationBuiltIn: dec.builtin = false; break; case DecorationLocation: dec.location = 0; break; case DecorationComponent: dec.component = 0; break; case DecorationOffset: dec.offset = 0; break; case DecorationXfbBuffer: dec.xfb_buffer = 0; break; case DecorationXfbStride: dec.xfb_stride = 0; break; case DecorationStream: dec.stream = 0; break; case DecorationSpecId: dec.spec_id = 0; break; case DecorationHlslSemanticGOOGLE: dec.hlsl_semantic.clear(); break; default: break; } } uint32_t ParsedIR::increase_bound_by(uint32_t incr_amount) { auto curr_bound = ids.size(); auto new_bound = curr_bound + incr_amount; ids.reserve(ids.size() + incr_amount); for (uint32_t i = 0; i < incr_amount; i++) ids.emplace_back(pool_group.get()); block_meta.resize(new_bound); return uint32_t(curr_bound); } void ParsedIR::remove_typed_id(Types type, ID id) { auto &type_ids = ids_for_type[type]; type_ids.erase(remove(begin(type_ids), end(type_ids), id), end(type_ids)); } void ParsedIR::reset_all_of_type(Types type) { for (auto &id : ids_for_type[type]) if (ids[id].get_type() == type) ids[id].reset(); ids_for_type[type].clear(); } void ParsedIR::add_typed_id(Types type, ID id) { if (loop_iteration_depth_hard != 0) SPIRV_CROSS_THROW("Cannot add typed ID while looping over it."); if (loop_iteration_depth_soft != 0) { if (!ids[id].empty()) SPIRV_CROSS_THROW("Cannot override IDs when loop is soft locked."); return; } if (ids[id].empty() || ids[id].get_type() != type) { switch (type) { case TypeConstant: ids_for_constant_or_variable.push_back(id); ids_for_constant_or_type.push_back(id); break; case TypeVariable: ids_for_constant_or_variable.push_back(id); break; case TypeType: case TypeConstantOp: ids_for_constant_or_type.push_back(id); break; default: break; } } if (ids[id].empty()) { ids_for_type[type].push_back(id); } else if (ids[id].get_type() != type) { remove_typed_id(ids[id].get_type(), id); ids_for_type[type].push_back(id); } } const Meta *ParsedIR::find_meta(ID id) const { auto itr = meta.find(id); if (itr != end(meta)) return &itr->second; else return nullptr; } Meta *ParsedIR::find_meta(ID id) { auto itr = meta.find(id); if (itr != end(meta)) return &itr->second; else return nullptr; } ParsedIR::LoopLock ParsedIR::create_loop_hard_lock() const { return ParsedIR::LoopLock(&loop_iteration_depth_hard); } ParsedIR::LoopLock ParsedIR::create_loop_soft_lock() const { return ParsedIR::LoopLock(&loop_iteration_depth_soft); } ParsedIR::LoopLock::~LoopLock() { if (lock) (*lock)--; } ParsedIR::LoopLock::LoopLock(uint32_t *lock_) : lock(lock_) { if (lock) (*lock)++; } ParsedIR::LoopLock::LoopLock(LoopLock &&other) SPIRV_CROSS_NOEXCEPT { *this = move(other); } ParsedIR::LoopLock &ParsedIR::LoopLock::operator=(LoopLock &&other) SPIRV_CROSS_NOEXCEPT { if (lock) (*lock)--; lock = other.lock; other.lock = nullptr; return *this; } void ParsedIR::make_constant_null(uint32_t id, uint32_t type, bool add_to_typed_id_set) { auto &constant_type = get(type); if (constant_type.pointer) { if (add_to_typed_id_set) add_typed_id(TypeConstant, id); auto &constant = variant_set(ids[id], type); constant.self = id; constant.make_null(constant_type); } else if (!constant_type.array.empty()) { assert(constant_type.parent_type); uint32_t parent_id = increase_bound_by(1); make_constant_null(parent_id, constant_type.parent_type, add_to_typed_id_set); if (!constant_type.array_size_literal.back()) SPIRV_CROSS_THROW("Array size of OpConstantNull must be a literal."); SmallVector elements(constant_type.array.back()); for (uint32_t i = 0; i < constant_type.array.back(); i++) elements[i] = parent_id; if (add_to_typed_id_set) add_typed_id(TypeConstant, id); variant_set(ids[id], type, elements.data(), uint32_t(elements.size()), false).self = id; } else if (!constant_type.member_types.empty()) { uint32_t member_ids = increase_bound_by(uint32_t(constant_type.member_types.size())); SmallVector elements(constant_type.member_types.size()); for (uint32_t i = 0; i < constant_type.member_types.size(); i++) { make_constant_null(member_ids + i, constant_type.member_types[i], add_to_typed_id_set); elements[i] = member_ids + i; } if (add_to_typed_id_set) add_typed_id(TypeConstant, id); variant_set(ids[id], type, elements.data(), uint32_t(elements.size()), false).self = id; } else { if (add_to_typed_id_set) add_typed_id(TypeConstant, id); auto &constant = variant_set(ids[id], type); constant.self = id; constant.make_null(constant_type); } } } // namespace SPIRV_CROSS_NAMESPACE spirv-cross-2021.01.15/spirv_cross_parsed_ir.hpp000066400000000000000000000212361400026215700215130ustar00rootroot00000000000000/* * Copyright 2018-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_PARSED_IR_HPP #define SPIRV_CROSS_PARSED_IR_HPP #include "spirv_common.hpp" #include #include namespace SPIRV_CROSS_NAMESPACE { // This data structure holds all information needed to perform cross-compilation and reflection. // It is the output of the Parser, but any implementation could create this structure. // It is intentionally very "open" and struct-like with some helper functions to deal with decorations. // Parser is the reference implementation of how this data structure should be filled in. class ParsedIR { private: // This must be destroyed after the "ids" vector. std::unique_ptr pool_group; public: ParsedIR(); // Due to custom allocations from object pools, we cannot use a default copy constructor. ParsedIR(const ParsedIR &other); ParsedIR &operator=(const ParsedIR &other); // Moves are unproblematic, but we need to implement it anyways, since MSVC 2013 does not understand // how to default-implement these. ParsedIR(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT; ParsedIR &operator=(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT; // Resizes ids, meta and block_meta. void set_id_bounds(uint32_t bounds); // The raw SPIR-V, instructions and opcodes refer to this by offset + count. std::vector spirv; // Holds various data structures which inherit from IVariant. SmallVector ids; // Various meta data for IDs, decorations, names, etc. std::unordered_map meta; // Holds all IDs which have a certain type. // This is needed so we can iterate through a specific kind of resource quickly, // and in-order of module declaration. SmallVector ids_for_type[TypeCount]; // Special purpose lists which contain a union of types. // This is needed so we can declare specialization constants and structs in an interleaved fashion, // among other things. // Constants can be of struct type, and struct array sizes can use specialization constants. SmallVector ids_for_constant_or_type; SmallVector ids_for_constant_or_variable; // Declared capabilities and extensions in the SPIR-V module. // Not really used except for reflection at the moment. SmallVector declared_capabilities; SmallVector declared_extensions; // Meta data about blocks. The cross-compiler needs to query if a block is either of these types. // It is a bitset as there can be more than one tag per block. enum BlockMetaFlagBits { BLOCK_META_LOOP_HEADER_BIT = 1 << 0, BLOCK_META_CONTINUE_BIT = 1 << 1, BLOCK_META_LOOP_MERGE_BIT = 1 << 2, BLOCK_META_SELECTION_MERGE_BIT = 1 << 3, BLOCK_META_MULTISELECT_MERGE_BIT = 1 << 4 }; using BlockMetaFlags = uint8_t; SmallVector block_meta; std::unordered_map continue_block_to_loop_header; // Normally, we'd stick SPIREntryPoint in ids array, but it conflicts with SPIRFunction. // Entry points can therefore be seen as some sort of meta structure. std::unordered_map entry_points; FunctionID default_entry_point = 0; struct Source { uint32_t version = 0; bool es = false; bool known = false; bool hlsl = false; Source() = default; }; Source source; spv::AddressingModel addressing_model = spv::AddressingModelMax; spv::MemoryModel memory_model = spv::MemoryModelMax; // Decoration handling methods. // Can be useful for simple "raw" reflection. // However, most members are here because the Parser needs most of these, // and might as well just have the whole suite of decoration/name handling in one place. void set_name(ID id, const std::string &name); const std::string &get_name(ID id) const; void set_decoration(ID id, spv::Decoration decoration, uint32_t argument = 0); void set_decoration_string(ID id, spv::Decoration decoration, const std::string &argument); bool has_decoration(ID id, spv::Decoration decoration) const; uint32_t get_decoration(ID id, spv::Decoration decoration) const; const std::string &get_decoration_string(ID id, spv::Decoration decoration) const; const Bitset &get_decoration_bitset(ID id) const; void unset_decoration(ID id, spv::Decoration decoration); // Decoration handling methods (for members of a struct). void set_member_name(TypeID id, uint32_t index, const std::string &name); const std::string &get_member_name(TypeID id, uint32_t index) const; void set_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration, uint32_t argument = 0); void set_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration, const std::string &argument); uint32_t get_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const; const std::string &get_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration) const; bool has_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const; const Bitset &get_member_decoration_bitset(TypeID id, uint32_t index) const; void unset_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration); void mark_used_as_array_length(ID id); uint32_t increase_bound_by(uint32_t count); Bitset get_buffer_block_flags(const SPIRVariable &var) const; Bitset get_buffer_block_type_flags(const SPIRType &type) const; void add_typed_id(Types type, ID id); void remove_typed_id(Types type, ID id); class LoopLock { public: explicit LoopLock(uint32_t *counter); LoopLock(const LoopLock &) = delete; void operator=(const LoopLock &) = delete; LoopLock(LoopLock &&other) SPIRV_CROSS_NOEXCEPT; LoopLock &operator=(LoopLock &&other) SPIRV_CROSS_NOEXCEPT; ~LoopLock(); private: uint32_t *lock; }; // This must be held while iterating over a type ID array. // It is undefined if someone calls set<>() while we're iterating over a data structure, so we must // make sure that this case is avoided. // If we have a hard lock, it is an error to call set<>(), and an exception is thrown. // If we have a soft lock, we silently ignore any additions to the typed arrays. // This should only be used for physical ID remapping where we need to create an ID, but we will never // care about iterating over them. LoopLock create_loop_hard_lock() const; LoopLock create_loop_soft_lock() const; template void for_each_typed_id(const Op &op) { auto loop_lock = create_loop_hard_lock(); for (auto &id : ids_for_type[T::type]) { if (ids[id].get_type() == static_cast(T::type)) op(id, get(id)); } } template void for_each_typed_id(const Op &op) const { auto loop_lock = create_loop_hard_lock(); for (auto &id : ids_for_type[T::type]) { if (ids[id].get_type() == static_cast(T::type)) op(id, get(id)); } } template void reset_all_of_type() { reset_all_of_type(static_cast(T::type)); } void reset_all_of_type(Types type); Meta *find_meta(ID id); const Meta *find_meta(ID id) const; const std::string &get_empty_string() const { return empty_string; } void make_constant_null(uint32_t id, uint32_t type, bool add_to_typed_id_set); void fixup_reserved_names(); static void sanitize_underscores(std::string &str); static void sanitize_identifier(std::string &str, bool member, bool allow_reserved_prefixes); static bool is_globally_reserved_identifier(std::string &str, bool allow_reserved_prefixes); uint32_t get_spirv_version() const; private: template T &get(uint32_t id) { return variant_get(ids[id]); } template const T &get(uint32_t id) const { return variant_get(ids[id]); } mutable uint32_t loop_iteration_depth_hard = 0; mutable uint32_t loop_iteration_depth_soft = 0; std::string empty_string; Bitset cleared_bitset; std::unordered_set meta_needing_name_fixup; }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_cross_util.cpp000066400000000000000000000051111400026215700205050ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_cross_util.hpp" #include "spirv_common.hpp" using namespace spv; using namespace SPIRV_CROSS_NAMESPACE; namespace spirv_cross_util { void rename_interface_variable(Compiler &compiler, const SmallVector &resources, uint32_t location, const std::string &name) { for (auto &v : resources) { if (!compiler.has_decoration(v.id, spv::DecorationLocation)) continue; auto loc = compiler.get_decoration(v.id, spv::DecorationLocation); if (loc != location) continue; auto &type = compiler.get_type(v.base_type_id); // This is more of a friendly variant. If we need to rename interface variables, we might have to rename // structs as well and make sure all the names match up. if (type.basetype == SPIRType::Struct) { compiler.set_name(v.base_type_id, join("SPIRV_Cross_Interface_Location", location)); for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++) compiler.set_member_name(v.base_type_id, i, join("InterfaceMember", i)); } compiler.set_name(v.id, name); } } void inherit_combined_sampler_bindings(Compiler &compiler) { auto &samplers = compiler.get_combined_image_samplers(); for (auto &s : samplers) { if (compiler.has_decoration(s.image_id, spv::DecorationDescriptorSet)) { uint32_t set = compiler.get_decoration(s.image_id, spv::DecorationDescriptorSet); compiler.set_decoration(s.combined_id, spv::DecorationDescriptorSet, set); } if (compiler.has_decoration(s.image_id, spv::DecorationBinding)) { uint32_t binding = compiler.get_decoration(s.image_id, spv::DecorationBinding); compiler.set_decoration(s.combined_id, spv::DecorationBinding, binding); } } } } // namespace spirv_cross_util spirv-cross-2021.01.15/spirv_cross_util.hpp000066400000000000000000000025731400026215700205230ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_UTIL_HPP #define SPIRV_CROSS_UTIL_HPP #include "spirv_cross.hpp" namespace spirv_cross_util { void rename_interface_variable(SPIRV_CROSS_NAMESPACE::Compiler &compiler, const SPIRV_CROSS_NAMESPACE::SmallVector &resources, uint32_t location, const std::string &name); void inherit_combined_sampler_bindings(SPIRV_CROSS_NAMESPACE::Compiler &compiler); } // namespace spirv_cross_util #endif spirv-cross-2021.01.15/spirv_glsl.cpp000066400000000000000000017266071400026215700173050ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_glsl.hpp" #include "GLSL.std.450.h" #include "spirv_common.hpp" #include #include #include #include #include #include #ifndef _WIN32 #include #endif #include using namespace spv; using namespace SPIRV_CROSS_NAMESPACE; using namespace std; static bool is_unsigned_opcode(Op op) { // Don't have to be exhaustive, only relevant for legacy target checking ... switch (op) { case OpShiftRightLogical: case OpUGreaterThan: case OpUGreaterThanEqual: case OpULessThan: case OpULessThanEqual: case OpUConvert: case OpUDiv: case OpUMod: case OpUMulExtended: case OpConvertUToF: case OpConvertFToU: return true; default: return false; } } static bool is_unsigned_glsl_opcode(GLSLstd450 op) { // Don't have to be exhaustive, only relevant for legacy target checking ... switch (op) { case GLSLstd450UClamp: case GLSLstd450UMin: case GLSLstd450UMax: case GLSLstd450FindUMsb: return true; default: return false; } } static bool packing_is_vec4_padded(BufferPackingStandard packing) { switch (packing) { case BufferPackingHLSLCbuffer: case BufferPackingHLSLCbufferPackOffset: case BufferPackingStd140: case BufferPackingStd140EnhancedLayout: return true; default: return false; } } static bool packing_is_hlsl(BufferPackingStandard packing) { switch (packing) { case BufferPackingHLSLCbuffer: case BufferPackingHLSLCbufferPackOffset: return true; default: return false; } } static bool packing_has_flexible_offset(BufferPackingStandard packing) { switch (packing) { case BufferPackingStd140: case BufferPackingStd430: case BufferPackingScalar: case BufferPackingHLSLCbuffer: return false; default: return true; } } static bool packing_is_scalar(BufferPackingStandard packing) { switch (packing) { case BufferPackingScalar: case BufferPackingScalarEnhancedLayout: return true; default: return false; } } static BufferPackingStandard packing_to_substruct_packing(BufferPackingStandard packing) { switch (packing) { case BufferPackingStd140EnhancedLayout: return BufferPackingStd140; case BufferPackingStd430EnhancedLayout: return BufferPackingStd430; case BufferPackingHLSLCbufferPackOffset: return BufferPackingHLSLCbuffer; case BufferPackingScalarEnhancedLayout: return BufferPackingScalar; default: return packing; } } void CompilerGLSL::init() { if (ir.source.known) { options.es = ir.source.es; options.version = ir.source.version; } // Query the locale to see what the decimal point is. // We'll rely on fixing it up ourselves in the rare case we have a comma-as-decimal locale // rather than setting locales ourselves. Settings locales in a safe and isolated way is rather // tricky. #ifdef _WIN32 // On Windows, localeconv uses thread-local storage, so it should be fine. const struct lconv *conv = localeconv(); if (conv && conv->decimal_point) current_locale_radix_character = *conv->decimal_point; #elif defined(__ANDROID__) && __ANDROID_API__ < 26 // nl_langinfo is not supported on this platform, fall back to the worse alternative. const struct lconv *conv = localeconv(); if (conv && conv->decimal_point) current_locale_radix_character = *conv->decimal_point; #else // localeconv, the portable function is not MT safe ... const char *decimal_point = nl_langinfo(RADIXCHAR); if (decimal_point && *decimal_point != '\0') current_locale_radix_character = *decimal_point; #endif } static const char *to_pls_layout(PlsFormat format) { switch (format) { case PlsR11FG11FB10F: return "layout(r11f_g11f_b10f) "; case PlsR32F: return "layout(r32f) "; case PlsRG16F: return "layout(rg16f) "; case PlsRGB10A2: return "layout(rgb10_a2) "; case PlsRGBA8: return "layout(rgba8) "; case PlsRG16: return "layout(rg16) "; case PlsRGBA8I: return "layout(rgba8i)"; case PlsRG16I: return "layout(rg16i) "; case PlsRGB10A2UI: return "layout(rgb10_a2ui) "; case PlsRGBA8UI: return "layout(rgba8ui) "; case PlsRG16UI: return "layout(rg16ui) "; case PlsR32UI: return "layout(r32ui) "; default: return ""; } } static SPIRType::BaseType pls_format_to_basetype(PlsFormat format) { switch (format) { default: case PlsR11FG11FB10F: case PlsR32F: case PlsRG16F: case PlsRGB10A2: case PlsRGBA8: case PlsRG16: return SPIRType::Float; case PlsRGBA8I: case PlsRG16I: return SPIRType::Int; case PlsRGB10A2UI: case PlsRGBA8UI: case PlsRG16UI: case PlsR32UI: return SPIRType::UInt; } } static uint32_t pls_format_to_components(PlsFormat format) { switch (format) { default: case PlsR32F: case PlsR32UI: return 1; case PlsRG16F: case PlsRG16: case PlsRG16UI: case PlsRG16I: return 2; case PlsR11FG11FB10F: return 3; case PlsRGB10A2: case PlsRGBA8: case PlsRGBA8I: case PlsRGB10A2UI: case PlsRGBA8UI: return 4; } } const char *CompilerGLSL::vector_swizzle(int vecsize, int index) { static const char *const swizzle[4][4] = { { ".x", ".y", ".z", ".w" }, { ".xy", ".yz", ".zw", nullptr }, { ".xyz", ".yzw", nullptr, nullptr }, #if defined(__GNUC__) && (__GNUC__ == 9) // This works around a GCC 9 bug, see details in https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90947. // This array ends up being compiled as all nullptrs, tripping the assertions below. { "", nullptr, nullptr, "$" }, #else { "", nullptr, nullptr, nullptr }, #endif }; assert(vecsize >= 1 && vecsize <= 4); assert(index >= 0 && index < 4); assert(swizzle[vecsize - 1][index]); return swizzle[vecsize - 1][index]; } void CompilerGLSL::reset() { // We do some speculative optimizations which should pretty much always work out, // but just in case the SPIR-V is rather weird, recompile until it's happy. // This typically only means one extra pass. clear_force_recompile(); // Clear invalid expression tracking. invalid_expressions.clear(); current_function = nullptr; // Clear temporary usage tracking. expression_usage_counts.clear(); forwarded_temporaries.clear(); suppressed_usage_tracking.clear(); // Ensure that we declare phi-variable copies even if the original declaration isn't deferred flushed_phi_variables.clear(); reset_name_caches(); ir.for_each_typed_id([&](uint32_t, SPIRFunction &func) { func.active = false; func.flush_undeclared = true; }); ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { var.dependees.clear(); }); ir.reset_all_of_type(); ir.reset_all_of_type(); statement_count = 0; indent = 0; current_loop_level = 0; } void CompilerGLSL::remap_pls_variables() { for (auto &input : pls_inputs) { auto &var = get(input.id); bool input_is_target = false; if (var.storage == StorageClassUniformConstant) { auto &type = get(var.basetype); input_is_target = type.image.dim == DimSubpassData; } if (var.storage != StorageClassInput && !input_is_target) SPIRV_CROSS_THROW("Can only use in and target variables for PLS inputs."); var.remapped_variable = true; } for (auto &output : pls_outputs) { auto &var = get(output.id); if (var.storage != StorageClassOutput) SPIRV_CROSS_THROW("Can only use out variables for PLS outputs."); var.remapped_variable = true; } } void CompilerGLSL::remap_ext_framebuffer_fetch(uint32_t input_attachment_index, uint32_t color_location) { subpass_to_framebuffer_fetch_attachment.push_back({ input_attachment_index, color_location }); inout_color_attachments.insert(color_location); } void CompilerGLSL::find_static_extensions() { ir.for_each_typed_id([&](uint32_t, const SPIRType &type) { if (type.basetype == SPIRType::Double) { if (options.es) SPIRV_CROSS_THROW("FP64 not supported in ES profile."); if (!options.es && options.version < 400) require_extension_internal("GL_ARB_gpu_shader_fp64"); } else if (type.basetype == SPIRType::Int64 || type.basetype == SPIRType::UInt64) { if (options.es) SPIRV_CROSS_THROW("64-bit integers not supported in ES profile."); if (!options.es) require_extension_internal("GL_ARB_gpu_shader_int64"); } else if (type.basetype == SPIRType::Half) { require_extension_internal("GL_EXT_shader_explicit_arithmetic_types_float16"); if (options.vulkan_semantics) require_extension_internal("GL_EXT_shader_16bit_storage"); } else if (type.basetype == SPIRType::SByte || type.basetype == SPIRType::UByte) { require_extension_internal("GL_EXT_shader_explicit_arithmetic_types_int8"); if (options.vulkan_semantics) require_extension_internal("GL_EXT_shader_8bit_storage"); } else if (type.basetype == SPIRType::Short || type.basetype == SPIRType::UShort) { require_extension_internal("GL_EXT_shader_explicit_arithmetic_types_int16"); if (options.vulkan_semantics) require_extension_internal("GL_EXT_shader_16bit_storage"); } }); auto &execution = get_entry_point(); switch (execution.model) { case ExecutionModelGLCompute: if (!options.es && options.version < 430) require_extension_internal("GL_ARB_compute_shader"); if (options.es && options.version < 310) SPIRV_CROSS_THROW("At least ESSL 3.10 required for compute shaders."); break; case ExecutionModelGeometry: if (options.es && options.version < 320) require_extension_internal("GL_EXT_geometry_shader"); if (!options.es && options.version < 150) require_extension_internal("GL_ARB_geometry_shader4"); if (execution.flags.get(ExecutionModeInvocations) && execution.invocations != 1) { // Instanced GS is part of 400 core or this extension. if (!options.es && options.version < 400) require_extension_internal("GL_ARB_gpu_shader5"); } break; case ExecutionModelTessellationEvaluation: case ExecutionModelTessellationControl: if (options.es && options.version < 320) require_extension_internal("GL_EXT_tessellation_shader"); if (!options.es && options.version < 400) require_extension_internal("GL_ARB_tessellation_shader"); break; case ExecutionModelRayGenerationKHR: case ExecutionModelIntersectionKHR: case ExecutionModelAnyHitKHR: case ExecutionModelClosestHitKHR: case ExecutionModelMissKHR: case ExecutionModelCallableKHR: // NV enums are aliases. if (options.es || options.version < 460) SPIRV_CROSS_THROW("Ray tracing shaders require non-es profile with version 460 or above."); if (!options.vulkan_semantics) SPIRV_CROSS_THROW("Ray tracing requires Vulkan semantics."); // Need to figure out if we should target KHR or NV extension based on capabilities. for (auto &cap : ir.declared_capabilities) { if (cap == CapabilityRayTracingKHR || cap == CapabilityRayQueryKHR) { ray_tracing_is_khr = true; break; } } if (ray_tracing_is_khr) { // In KHR ray tracing we pass payloads by pointer instead of location, // so make sure we assign locations properly. ray_tracing_khr_fixup_locations(); require_extension_internal("GL_EXT_ray_tracing"); } else require_extension_internal("GL_NV_ray_tracing"); break; default: break; } if (!pls_inputs.empty() || !pls_outputs.empty()) { if (execution.model != ExecutionModelFragment) SPIRV_CROSS_THROW("Can only use GL_EXT_shader_pixel_local_storage in fragment shaders."); require_extension_internal("GL_EXT_shader_pixel_local_storage"); } if (!inout_color_attachments.empty()) { if (execution.model != ExecutionModelFragment) SPIRV_CROSS_THROW("Can only use GL_EXT_shader_framebuffer_fetch in fragment shaders."); if (options.vulkan_semantics) SPIRV_CROSS_THROW("Cannot use EXT_shader_framebuffer_fetch in Vulkan GLSL."); require_extension_internal("GL_EXT_shader_framebuffer_fetch"); } if (options.separate_shader_objects && !options.es && options.version < 410) require_extension_internal("GL_ARB_separate_shader_objects"); if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT) { if (!options.vulkan_semantics) SPIRV_CROSS_THROW("GL_EXT_buffer_reference is only supported in Vulkan GLSL."); if (options.es && options.version < 320) SPIRV_CROSS_THROW("GL_EXT_buffer_reference requires ESSL 320."); else if (!options.es && options.version < 450) SPIRV_CROSS_THROW("GL_EXT_buffer_reference requires GLSL 450."); require_extension_internal("GL_EXT_buffer_reference"); } else if (ir.addressing_model != AddressingModelLogical) { SPIRV_CROSS_THROW("Only Logical and PhysicalStorageBuffer64EXT addressing models are supported."); } // Check for nonuniform qualifier and passthrough. // Instead of looping over all decorations to find this, just look at capabilities. for (auto &cap : ir.declared_capabilities) { switch (cap) { case CapabilityShaderNonUniformEXT: if (!options.vulkan_semantics) require_extension_internal("GL_NV_gpu_shader5"); else require_extension_internal("GL_EXT_nonuniform_qualifier"); break; case CapabilityRuntimeDescriptorArrayEXT: if (!options.vulkan_semantics) SPIRV_CROSS_THROW("GL_EXT_nonuniform_qualifier is only supported in Vulkan GLSL."); require_extension_internal("GL_EXT_nonuniform_qualifier"); break; case CapabilityGeometryShaderPassthroughNV: if (execution.model == ExecutionModelGeometry) { require_extension_internal("GL_NV_geometry_shader_passthrough"); execution.geometry_passthrough = true; } break; case CapabilityVariablePointers: case CapabilityVariablePointersStorageBuffer: SPIRV_CROSS_THROW("VariablePointers capability is not supported in GLSL."); default: break; } } } void CompilerGLSL::ray_tracing_khr_fixup_locations() { uint32_t location = 0; ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { if (var.storage != StorageClassRayPayloadKHR && var.storage != StorageClassCallableDataKHR) return; if (!interface_variable_exists_in_entry_point(var.self)) return; set_decoration(var.self, DecorationLocation, location++); }); } string CompilerGLSL::compile() { ir.fixup_reserved_names(); if (options.vulkan_semantics) backend.allow_precision_qualifiers = true; else { // only NV_gpu_shader5 supports divergent indexing on OpenGL, and it does so without extra qualifiers backend.nonuniform_qualifier = ""; backend.needs_row_major_load_workaround = true; } backend.force_gl_in_out_block = true; backend.supports_extensions = true; backend.use_array_constructor = true; if (is_legacy_es()) backend.support_case_fallthrough = false; // Scan the SPIR-V to find trivial uses of extensions. fixup_type_alias(); reorder_type_alias(); build_function_control_flow_graphs_and_analyze(); find_static_extensions(); fixup_image_load_store_access(); update_active_builtins(); analyze_image_and_sampler_usage(); analyze_interlocked_resource_usage(); if (!inout_color_attachments.empty()) emit_inout_fragment_outputs_copy_to_subpass_inputs(); // Shaders might cast unrelated data to pointers of non-block types. // Find all such instances and make sure we can cast the pointers to a synthesized block type. if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT) analyze_non_block_pointer_types(); uint32_t pass_count = 0; do { if (pass_count >= 3) SPIRV_CROSS_THROW("Over 3 compilation loops detected. Must be a bug!"); reset(); buffer.reset(); emit_header(); emit_resources(); emit_extension_workarounds(get_execution_model()); emit_function(get(ir.default_entry_point), Bitset()); pass_count++; } while (is_forcing_recompilation()); // Implement the interlocked wrapper function at the end. // The body was implemented in lieu of main(). if (interlocked_is_complex) { statement("void main()"); begin_scope(); statement("// Interlocks were used in a way not compatible with GLSL, this is very slow."); if (options.es) statement("beginInvocationInterlockNV();"); else statement("beginInvocationInterlockARB();"); statement("spvMainInterlockedBody();"); if (options.es) statement("endInvocationInterlockNV();"); else statement("endInvocationInterlockARB();"); end_scope(); } // Entry point in GLSL is always main(). get_entry_point().name = "main"; return buffer.str(); } std::string CompilerGLSL::get_partial_source() { return buffer.str(); } void CompilerGLSL::build_workgroup_size(SmallVector &arguments, const SpecializationConstant &wg_x, const SpecializationConstant &wg_y, const SpecializationConstant &wg_z) { auto &execution = get_entry_point(); if (wg_x.id) { if (options.vulkan_semantics) arguments.push_back(join("local_size_x_id = ", wg_x.constant_id)); else arguments.push_back(join("local_size_x = ", get(wg_x.id).specialization_constant_macro_name)); } else arguments.push_back(join("local_size_x = ", execution.workgroup_size.x)); if (wg_y.id) { if (options.vulkan_semantics) arguments.push_back(join("local_size_y_id = ", wg_y.constant_id)); else arguments.push_back(join("local_size_y = ", get(wg_y.id).specialization_constant_macro_name)); } else arguments.push_back(join("local_size_y = ", execution.workgroup_size.y)); if (wg_z.id) { if (options.vulkan_semantics) arguments.push_back(join("local_size_z_id = ", wg_z.constant_id)); else arguments.push_back(join("local_size_z = ", get(wg_z.id).specialization_constant_macro_name)); } else arguments.push_back(join("local_size_z = ", execution.workgroup_size.z)); } void CompilerGLSL::request_subgroup_feature(ShaderSubgroupSupportHelper::Feature feature) { if (options.vulkan_semantics) { auto khr_extension = ShaderSubgroupSupportHelper::get_KHR_extension_for_feature(feature); require_extension_internal(ShaderSubgroupSupportHelper::get_extension_name(khr_extension)); } else { if (!shader_subgroup_supporter.is_feature_requested(feature)) force_recompile(); shader_subgroup_supporter.request_feature(feature); } } void CompilerGLSL::emit_header() { auto &execution = get_entry_point(); statement("#version ", options.version, options.es && options.version > 100 ? " es" : ""); if (!options.es && options.version < 420) { // Needed for binding = # on UBOs, etc. if (options.enable_420pack_extension) { statement("#ifdef GL_ARB_shading_language_420pack"); statement("#extension GL_ARB_shading_language_420pack : require"); statement("#endif"); } // Needed for: layout(early_fragment_tests) in; if (execution.flags.get(ExecutionModeEarlyFragmentTests)) require_extension_internal("GL_ARB_shader_image_load_store"); } // Needed for: layout(post_depth_coverage) in; if (execution.flags.get(ExecutionModePostDepthCoverage)) require_extension_internal("GL_ARB_post_depth_coverage"); // Needed for: layout({pixel,sample}_interlock_[un]ordered) in; if (execution.flags.get(ExecutionModePixelInterlockOrderedEXT) || execution.flags.get(ExecutionModePixelInterlockUnorderedEXT) || execution.flags.get(ExecutionModeSampleInterlockOrderedEXT) || execution.flags.get(ExecutionModeSampleInterlockUnorderedEXT)) { if (options.es) { if (options.version < 310) SPIRV_CROSS_THROW("At least ESSL 3.10 required for fragment shader interlock."); require_extension_internal("GL_NV_fragment_shader_interlock"); } else { if (options.version < 420) require_extension_internal("GL_ARB_shader_image_load_store"); require_extension_internal("GL_ARB_fragment_shader_interlock"); } } for (auto &ext : forced_extensions) { if (ext == "GL_EXT_shader_explicit_arithmetic_types_float16") { // Special case, this extension has a potential fallback to another vendor extension in normal GLSL. // GL_AMD_gpu_shader_half_float is a superset, so try that first. statement("#if defined(GL_AMD_gpu_shader_half_float)"); statement("#extension GL_AMD_gpu_shader_half_float : require"); if (!options.vulkan_semantics) { statement("#elif defined(GL_NV_gpu_shader5)"); statement("#extension GL_NV_gpu_shader5 : require"); } else { statement("#elif defined(GL_EXT_shader_explicit_arithmetic_types_float16)"); statement("#extension GL_EXT_shader_explicit_arithmetic_types_float16 : require"); } statement("#else"); statement("#error No extension available for FP16."); statement("#endif"); } else if (ext == "GL_EXT_shader_explicit_arithmetic_types_int16") { if (options.vulkan_semantics) statement("#extension GL_EXT_shader_explicit_arithmetic_types_int16 : require"); else { statement("#if defined(GL_AMD_gpu_shader_int16)"); statement("#extension GL_AMD_gpu_shader_int16 : require"); statement("#else"); statement("#error No extension available for Int16."); statement("#endif"); } } else if (ext == "GL_ARB_post_depth_coverage") { if (options.es) statement("#extension GL_EXT_post_depth_coverage : require"); else { statement("#if defined(GL_ARB_post_depth_coverge)"); statement("#extension GL_ARB_post_depth_coverage : require"); statement("#else"); statement("#extension GL_EXT_post_depth_coverage : require"); statement("#endif"); } } else if (!options.vulkan_semantics && ext == "GL_ARB_shader_draw_parameters") { // Soft-enable this extension on plain GLSL. statement("#ifdef ", ext); statement("#extension ", ext, " : enable"); statement("#endif"); } else statement("#extension ", ext, " : require"); } if (!options.vulkan_semantics) { using Supp = ShaderSubgroupSupportHelper; auto result = shader_subgroup_supporter.resolve(); for (uint32_t feature_index = 0; feature_index < Supp::FeatureCount; feature_index++) { auto feature = static_cast(feature_index); if (!shader_subgroup_supporter.is_feature_requested(feature)) continue; auto exts = Supp::get_candidates_for_feature(feature, result); if (exts.empty()) continue; statement(""); for (auto &ext : exts) { const char *name = Supp::get_extension_name(ext); const char *extra_predicate = Supp::get_extra_required_extension_predicate(ext); auto extra_names = Supp::get_extra_required_extension_names(ext); statement(&ext != &exts.front() ? "#elif" : "#if", " defined(", name, ")", (*extra_predicate != '\0' ? " && " : ""), extra_predicate); for (const auto &e : extra_names) statement("#extension ", e, " : enable"); statement("#extension ", name, " : require"); } if (!Supp::can_feature_be_implemented_without_extensions(feature)) { statement("#else"); statement("#error No extensions available to emulate requested subgroup feature."); } statement("#endif"); } } for (auto &header : header_lines) statement(header); SmallVector inputs; SmallVector outputs; switch (execution.model) { case ExecutionModelGeometry: if ((execution.flags.get(ExecutionModeInvocations)) && execution.invocations != 1) inputs.push_back(join("invocations = ", execution.invocations)); if (execution.flags.get(ExecutionModeInputPoints)) inputs.push_back("points"); if (execution.flags.get(ExecutionModeInputLines)) inputs.push_back("lines"); if (execution.flags.get(ExecutionModeInputLinesAdjacency)) inputs.push_back("lines_adjacency"); if (execution.flags.get(ExecutionModeTriangles)) inputs.push_back("triangles"); if (execution.flags.get(ExecutionModeInputTrianglesAdjacency)) inputs.push_back("triangles_adjacency"); if (!execution.geometry_passthrough) { // For passthrough, these are implies and cannot be declared in shader. outputs.push_back(join("max_vertices = ", execution.output_vertices)); if (execution.flags.get(ExecutionModeOutputTriangleStrip)) outputs.push_back("triangle_strip"); if (execution.flags.get(ExecutionModeOutputPoints)) outputs.push_back("points"); if (execution.flags.get(ExecutionModeOutputLineStrip)) outputs.push_back("line_strip"); } break; case ExecutionModelTessellationControl: if (execution.flags.get(ExecutionModeOutputVertices)) outputs.push_back(join("vertices = ", execution.output_vertices)); break; case ExecutionModelTessellationEvaluation: if (execution.flags.get(ExecutionModeQuads)) inputs.push_back("quads"); if (execution.flags.get(ExecutionModeTriangles)) inputs.push_back("triangles"); if (execution.flags.get(ExecutionModeIsolines)) inputs.push_back("isolines"); if (execution.flags.get(ExecutionModePointMode)) inputs.push_back("point_mode"); if (!execution.flags.get(ExecutionModeIsolines)) { if (execution.flags.get(ExecutionModeVertexOrderCw)) inputs.push_back("cw"); if (execution.flags.get(ExecutionModeVertexOrderCcw)) inputs.push_back("ccw"); } if (execution.flags.get(ExecutionModeSpacingFractionalEven)) inputs.push_back("fractional_even_spacing"); if (execution.flags.get(ExecutionModeSpacingFractionalOdd)) inputs.push_back("fractional_odd_spacing"); if (execution.flags.get(ExecutionModeSpacingEqual)) inputs.push_back("equal_spacing"); break; case ExecutionModelGLCompute: { if (execution.workgroup_size.constant != 0) { SpecializationConstant wg_x, wg_y, wg_z; get_work_group_size_specialization_constants(wg_x, wg_y, wg_z); // If there are any spec constants on legacy GLSL, defer declaration, we need to set up macro // declarations before we can emit the work group size. if (options.vulkan_semantics || ((wg_x.id == ConstantID(0)) && (wg_y.id == ConstantID(0)) && (wg_z.id == ConstantID(0)))) build_workgroup_size(inputs, wg_x, wg_y, wg_z); } else { inputs.push_back(join("local_size_x = ", execution.workgroup_size.x)); inputs.push_back(join("local_size_y = ", execution.workgroup_size.y)); inputs.push_back(join("local_size_z = ", execution.workgroup_size.z)); } break; } case ExecutionModelFragment: if (options.es) { switch (options.fragment.default_float_precision) { case Options::Lowp: statement("precision lowp float;"); break; case Options::Mediump: statement("precision mediump float;"); break; case Options::Highp: statement("precision highp float;"); break; default: break; } switch (options.fragment.default_int_precision) { case Options::Lowp: statement("precision lowp int;"); break; case Options::Mediump: statement("precision mediump int;"); break; case Options::Highp: statement("precision highp int;"); break; default: break; } } if (execution.flags.get(ExecutionModeEarlyFragmentTests)) inputs.push_back("early_fragment_tests"); if (execution.flags.get(ExecutionModePostDepthCoverage)) inputs.push_back("post_depth_coverage"); if (execution.flags.get(ExecutionModePixelInterlockOrderedEXT)) inputs.push_back("pixel_interlock_ordered"); else if (execution.flags.get(ExecutionModePixelInterlockUnorderedEXT)) inputs.push_back("pixel_interlock_unordered"); else if (execution.flags.get(ExecutionModeSampleInterlockOrderedEXT)) inputs.push_back("sample_interlock_ordered"); else if (execution.flags.get(ExecutionModeSampleInterlockUnorderedEXT)) inputs.push_back("sample_interlock_unordered"); if (!options.es && execution.flags.get(ExecutionModeDepthGreater)) statement("layout(depth_greater) out float gl_FragDepth;"); else if (!options.es && execution.flags.get(ExecutionModeDepthLess)) statement("layout(depth_less) out float gl_FragDepth;"); break; default: break; } if (!inputs.empty()) statement("layout(", merge(inputs), ") in;"); if (!outputs.empty()) statement("layout(", merge(outputs), ") out;"); statement(""); } bool CompilerGLSL::type_is_empty(const SPIRType &type) { return type.basetype == SPIRType::Struct && type.member_types.empty(); } void CompilerGLSL::emit_struct(SPIRType &type) { // Struct types can be stamped out multiple times // with just different offsets, matrix layouts, etc ... // Type-punning with these types is legal, which complicates things // when we are storing struct and array types in an SSBO for example. // If the type master is packed however, we can no longer assume that the struct declaration will be redundant. if (type.type_alias != TypeID(0) && !has_extended_decoration(type.type_alias, SPIRVCrossDecorationBufferBlockRepacked)) return; add_resource_name(type.self); auto name = type_to_glsl(type); statement(!backend.explicit_struct_type ? "struct " : "", name); begin_scope(); type.member_name_cache.clear(); uint32_t i = 0; bool emitted = false; for (auto &member : type.member_types) { add_member_name(type, i); emit_struct_member(type, member, i); i++; emitted = true; } // Don't declare empty structs in GLSL, this is not allowed. if (type_is_empty(type) && !backend.supports_empty_struct) { statement("int empty_struct_member;"); emitted = true; } if (has_extended_decoration(type.self, SPIRVCrossDecorationPaddingTarget)) emit_struct_padding_target(type); end_scope_decl(); if (emitted) statement(""); } string CompilerGLSL::to_interpolation_qualifiers(const Bitset &flags) { string res; //if (flags & (1ull << DecorationSmooth)) // res += "smooth "; if (flags.get(DecorationFlat)) res += "flat "; if (flags.get(DecorationNoPerspective)) res += "noperspective "; if (flags.get(DecorationCentroid)) res += "centroid "; if (flags.get(DecorationPatch)) res += "patch "; if (flags.get(DecorationSample)) res += "sample "; if (flags.get(DecorationInvariant)) res += "invariant "; if (flags.get(DecorationExplicitInterpAMD)) res += "__explicitInterpAMD "; return res; } string CompilerGLSL::layout_for_member(const SPIRType &type, uint32_t index) { if (is_legacy()) return ""; bool is_block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) || ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock); if (!is_block) return ""; auto &memb = ir.meta[type.self].members; if (index >= memb.size()) return ""; auto &dec = memb[index]; SmallVector attr; if (has_member_decoration(type.self, index, DecorationPassthroughNV)) attr.push_back("passthrough"); // We can only apply layouts on members in block interfaces. // This is a bit problematic because in SPIR-V decorations are applied on the struct types directly. // This is not supported on GLSL, so we have to make the assumption that if a struct within our buffer block struct // has a decoration, it was originally caused by a top-level layout() qualifier in GLSL. // // We would like to go from (SPIR-V style): // // struct Foo { layout(row_major) mat4 matrix; }; // buffer UBO { Foo foo; }; // // to // // struct Foo { mat4 matrix; }; // GLSL doesn't support any layout shenanigans in raw struct declarations. // buffer UBO { layout(row_major) Foo foo; }; // Apply the layout on top-level. auto flags = combined_decoration_for_member(type, index); if (flags.get(DecorationRowMajor)) attr.push_back("row_major"); // We don't emit any global layouts, so column_major is default. //if (flags & (1ull << DecorationColMajor)) // attr.push_back("column_major"); if (dec.decoration_flags.get(DecorationLocation) && can_use_io_location(type.storage, true)) attr.push_back(join("location = ", dec.location)); // Can only declare component if we can declare location. if (dec.decoration_flags.get(DecorationComponent) && can_use_io_location(type.storage, true)) { if (!options.es) { if (options.version < 440 && options.version >= 140) require_extension_internal("GL_ARB_enhanced_layouts"); else if (options.version < 140) SPIRV_CROSS_THROW("Component decoration is not supported in targets below GLSL 1.40."); attr.push_back(join("component = ", dec.component)); } else SPIRV_CROSS_THROW("Component decoration is not supported in ES targets."); } // SPIRVCrossDecorationPacked is set by layout_for_variable earlier to mark that we need to emit offset qualifiers. // This is only done selectively in GLSL as needed. if (has_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset) && dec.decoration_flags.get(DecorationOffset)) attr.push_back(join("offset = ", dec.offset)); else if (type.storage == StorageClassOutput && dec.decoration_flags.get(DecorationOffset)) attr.push_back(join("xfb_offset = ", dec.offset)); if (attr.empty()) return ""; string res = "layout("; res += merge(attr); res += ") "; return res; } const char *CompilerGLSL::format_to_glsl(spv::ImageFormat format) { if (options.es && is_desktop_only_format(format)) SPIRV_CROSS_THROW("Attempting to use image format not supported in ES profile."); switch (format) { case ImageFormatRgba32f: return "rgba32f"; case ImageFormatRgba16f: return "rgba16f"; case ImageFormatR32f: return "r32f"; case ImageFormatRgba8: return "rgba8"; case ImageFormatRgba8Snorm: return "rgba8_snorm"; case ImageFormatRg32f: return "rg32f"; case ImageFormatRg16f: return "rg16f"; case ImageFormatRgba32i: return "rgba32i"; case ImageFormatRgba16i: return "rgba16i"; case ImageFormatR32i: return "r32i"; case ImageFormatRgba8i: return "rgba8i"; case ImageFormatRg32i: return "rg32i"; case ImageFormatRg16i: return "rg16i"; case ImageFormatRgba32ui: return "rgba32ui"; case ImageFormatRgba16ui: return "rgba16ui"; case ImageFormatR32ui: return "r32ui"; case ImageFormatRgba8ui: return "rgba8ui"; case ImageFormatRg32ui: return "rg32ui"; case ImageFormatRg16ui: return "rg16ui"; case ImageFormatR11fG11fB10f: return "r11f_g11f_b10f"; case ImageFormatR16f: return "r16f"; case ImageFormatRgb10A2: return "rgb10_a2"; case ImageFormatR8: return "r8"; case ImageFormatRg8: return "rg8"; case ImageFormatR16: return "r16"; case ImageFormatRg16: return "rg16"; case ImageFormatRgba16: return "rgba16"; case ImageFormatR16Snorm: return "r16_snorm"; case ImageFormatRg16Snorm: return "rg16_snorm"; case ImageFormatRgba16Snorm: return "rgba16_snorm"; case ImageFormatR8Snorm: return "r8_snorm"; case ImageFormatRg8Snorm: return "rg8_snorm"; case ImageFormatR8ui: return "r8ui"; case ImageFormatRg8ui: return "rg8ui"; case ImageFormatR16ui: return "r16ui"; case ImageFormatRgb10a2ui: return "rgb10_a2ui"; case ImageFormatR8i: return "r8i"; case ImageFormatRg8i: return "rg8i"; case ImageFormatR16i: return "r16i"; default: case ImageFormatUnknown: return nullptr; } } uint32_t CompilerGLSL::type_to_packed_base_size(const SPIRType &type, BufferPackingStandard) { switch (type.basetype) { case SPIRType::Double: case SPIRType::Int64: case SPIRType::UInt64: return 8; case SPIRType::Float: case SPIRType::Int: case SPIRType::UInt: return 4; case SPIRType::Half: case SPIRType::Short: case SPIRType::UShort: return 2; case SPIRType::SByte: case SPIRType::UByte: return 1; default: SPIRV_CROSS_THROW("Unrecognized type in type_to_packed_base_size."); } } uint32_t CompilerGLSL::type_to_packed_alignment(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing) { // If using PhysicalStorageBufferEXT storage class, this is a pointer, // and is 64-bit. if (type.storage == StorageClassPhysicalStorageBufferEXT) { if (!type.pointer) SPIRV_CROSS_THROW("Types in PhysicalStorageBufferEXT must be pointers."); if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT) { if (packing_is_vec4_padded(packing) && type_is_array_of_pointers(type)) return 16; else return 8; } else SPIRV_CROSS_THROW("AddressingModelPhysicalStorageBuffer64EXT must be used for PhysicalStorageBufferEXT."); } if (!type.array.empty()) { uint32_t minimum_alignment = 1; if (packing_is_vec4_padded(packing)) minimum_alignment = 16; auto *tmp = &get(type.parent_type); while (!tmp->array.empty()) tmp = &get(tmp->parent_type); // Get the alignment of the base type, then maybe round up. return max(minimum_alignment, type_to_packed_alignment(*tmp, flags, packing)); } if (type.basetype == SPIRType::Struct) { // Rule 9. Structs alignments are maximum alignment of its members. uint32_t alignment = 1; for (uint32_t i = 0; i < type.member_types.size(); i++) { auto member_flags = ir.meta[type.self].members[i].decoration_flags; alignment = max(alignment, type_to_packed_alignment(get(type.member_types[i]), member_flags, packing)); } // In std140, struct alignment is rounded up to 16. if (packing_is_vec4_padded(packing)) alignment = max(alignment, 16u); return alignment; } else { const uint32_t base_alignment = type_to_packed_base_size(type, packing); // Alignment requirement for scalar block layout is always the alignment for the most basic component. if (packing_is_scalar(packing)) return base_alignment; // Vectors are *not* aligned in HLSL, but there's an extra rule where vectors cannot straddle // a vec4, this is handled outside since that part knows our current offset. if (type.columns == 1 && packing_is_hlsl(packing)) return base_alignment; // From 7.6.2.2 in GL 4.5 core spec. // Rule 1 if (type.vecsize == 1 && type.columns == 1) return base_alignment; // Rule 2 if ((type.vecsize == 2 || type.vecsize == 4) && type.columns == 1) return type.vecsize * base_alignment; // Rule 3 if (type.vecsize == 3 && type.columns == 1) return 4 * base_alignment; // Rule 4 implied. Alignment does not change in std430. // Rule 5. Column-major matrices are stored as arrays of // vectors. if (flags.get(DecorationColMajor) && type.columns > 1) { if (packing_is_vec4_padded(packing)) return 4 * base_alignment; else if (type.vecsize == 3) return 4 * base_alignment; else return type.vecsize * base_alignment; } // Rule 6 implied. // Rule 7. if (flags.get(DecorationRowMajor) && type.vecsize > 1) { if (packing_is_vec4_padded(packing)) return 4 * base_alignment; else if (type.columns == 3) return 4 * base_alignment; else return type.columns * base_alignment; } // Rule 8 implied. } SPIRV_CROSS_THROW("Did not find suitable rule for type. Bogus decorations?"); } uint32_t CompilerGLSL::type_to_packed_array_stride(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing) { // Array stride is equal to aligned size of the underlying type. uint32_t parent = type.parent_type; assert(parent); auto &tmp = get(parent); uint32_t size = type_to_packed_size(tmp, flags, packing); uint32_t alignment = type_to_packed_alignment(type, flags, packing); return (size + alignment - 1) & ~(alignment - 1); } uint32_t CompilerGLSL::type_to_packed_size(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing) { if (!type.array.empty()) { uint32_t packed_size = to_array_size_literal(type) * type_to_packed_array_stride(type, flags, packing); // For arrays of vectors and matrices in HLSL, the last element has a size which depends on its vector size, // so that it is possible to pack other vectors into the last element. if (packing_is_hlsl(packing) && type.basetype != SPIRType::Struct) packed_size -= (4 - type.vecsize) * (type.width / 8); return packed_size; } // If using PhysicalStorageBufferEXT storage class, this is a pointer, // and is 64-bit. if (type.storage == StorageClassPhysicalStorageBufferEXT) { if (!type.pointer) SPIRV_CROSS_THROW("Types in PhysicalStorageBufferEXT must be pointers."); if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT) return 8; else SPIRV_CROSS_THROW("AddressingModelPhysicalStorageBuffer64EXT must be used for PhysicalStorageBufferEXT."); } uint32_t size = 0; if (type.basetype == SPIRType::Struct) { uint32_t pad_alignment = 1; for (uint32_t i = 0; i < type.member_types.size(); i++) { auto member_flags = ir.meta[type.self].members[i].decoration_flags; auto &member_type = get(type.member_types[i]); uint32_t packed_alignment = type_to_packed_alignment(member_type, member_flags, packing); uint32_t alignment = max(packed_alignment, pad_alignment); // The next member following a struct member is aligned to the base alignment of the struct that came before. // GL 4.5 spec, 7.6.2.2. if (member_type.basetype == SPIRType::Struct) pad_alignment = packed_alignment; else pad_alignment = 1; size = (size + alignment - 1) & ~(alignment - 1); size += type_to_packed_size(member_type, member_flags, packing); } } else { const uint32_t base_alignment = type_to_packed_base_size(type, packing); if (packing_is_scalar(packing)) { size = type.vecsize * type.columns * base_alignment; } else { if (type.columns == 1) size = type.vecsize * base_alignment; if (flags.get(DecorationColMajor) && type.columns > 1) { if (packing_is_vec4_padded(packing)) size = type.columns * 4 * base_alignment; else if (type.vecsize == 3) size = type.columns * 4 * base_alignment; else size = type.columns * type.vecsize * base_alignment; } if (flags.get(DecorationRowMajor) && type.vecsize > 1) { if (packing_is_vec4_padded(packing)) size = type.vecsize * 4 * base_alignment; else if (type.columns == 3) size = type.vecsize * 4 * base_alignment; else size = type.vecsize * type.columns * base_alignment; } // For matrices in HLSL, the last element has a size which depends on its vector size, // so that it is possible to pack other vectors into the last element. if (packing_is_hlsl(packing) && type.columns > 1) size -= (4 - type.vecsize) * (type.width / 8); } } return size; } bool CompilerGLSL::buffer_is_packing_standard(const SPIRType &type, BufferPackingStandard packing, uint32_t *failed_validation_index, uint32_t start_offset, uint32_t end_offset) { // This is very tricky and error prone, but try to be exhaustive and correct here. // SPIR-V doesn't directly say if we're using std430 or std140. // SPIR-V communicates this using Offset and ArrayStride decorations (which is what really matters), // so we have to try to infer whether or not the original GLSL source was std140 or std430 based on this information. // We do not have to consider shared or packed since these layouts are not allowed in Vulkan SPIR-V (they are useless anyways, and custom offsets would do the same thing). // // It is almost certain that we're using std430, but it gets tricky with arrays in particular. // We will assume std430, but infer std140 if we can prove the struct is not compliant with std430. // // The only two differences between std140 and std430 are related to padding alignment/array stride // in arrays and structs. In std140 they take minimum vec4 alignment. // std430 only removes the vec4 requirement. uint32_t offset = 0; uint32_t pad_alignment = 1; bool is_top_level_block = has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock); for (uint32_t i = 0; i < type.member_types.size(); i++) { auto &memb_type = get(type.member_types[i]); auto member_flags = ir.meta[type.self].members[i].decoration_flags; // Verify alignment rules. uint32_t packed_alignment = type_to_packed_alignment(memb_type, member_flags, packing); // This is a rather dirty workaround to deal with some cases of OpSpecConstantOp used as array size, e.g: // layout(constant_id = 0) const int s = 10; // const int S = s + 5; // SpecConstantOp // buffer Foo { int data[S]; }; // <-- Very hard for us to deduce a fixed value here, // we would need full implementation of compile-time constant folding. :( // If we are the last member of a struct, there might be cases where the actual size of that member is irrelevant // for our analysis (e.g. unsized arrays). // This lets us simply ignore that there are spec constant op sized arrays in our buffers. // Querying size of this member will fail, so just don't call it unless we have to. // // This is likely "best effort" we can support without going into unacceptably complicated workarounds. bool member_can_be_unsized = is_top_level_block && size_t(i + 1) == type.member_types.size() && !memb_type.array.empty(); uint32_t packed_size = 0; if (!member_can_be_unsized || packing_is_hlsl(packing)) packed_size = type_to_packed_size(memb_type, member_flags, packing); // We only need to care about this if we have non-array types which can straddle the vec4 boundary. if (packing_is_hlsl(packing)) { // If a member straddles across a vec4 boundary, alignment is actually vec4. uint32_t begin_word = offset / 16; uint32_t end_word = (offset + packed_size - 1) / 16; if (begin_word != end_word) packed_alignment = max(packed_alignment, 16u); } uint32_t actual_offset = type_struct_member_offset(type, i); // Field is not in the specified range anymore and we can ignore any further fields. if (actual_offset >= end_offset) break; uint32_t alignment = max(packed_alignment, pad_alignment); offset = (offset + alignment - 1) & ~(alignment - 1); // The next member following a struct member is aligned to the base alignment of the struct that came before. // GL 4.5 spec, 7.6.2.2. if (memb_type.basetype == SPIRType::Struct && !memb_type.pointer) pad_alignment = packed_alignment; else pad_alignment = 1; // Only care about packing if we are in the given range if (actual_offset >= start_offset) { // We only care about offsets in std140, std430, etc ... // For EnhancedLayout variants, we have the flexibility to choose our own offsets. if (!packing_has_flexible_offset(packing)) { if (actual_offset != offset) // This cannot be the packing we're looking for. { if (failed_validation_index) *failed_validation_index = i; return false; } } else if ((actual_offset & (alignment - 1)) != 0) { // We still need to verify that alignment rules are observed, even if we have explicit offset. if (failed_validation_index) *failed_validation_index = i; return false; } // Verify array stride rules. if (!memb_type.array.empty() && type_to_packed_array_stride(memb_type, member_flags, packing) != type_struct_member_array_stride(type, i)) { if (failed_validation_index) *failed_validation_index = i; return false; } // Verify that sub-structs also follow packing rules. // We cannot use enhanced layouts on substructs, so they better be up to spec. auto substruct_packing = packing_to_substruct_packing(packing); if (!memb_type.pointer && !memb_type.member_types.empty() && !buffer_is_packing_standard(memb_type, substruct_packing)) { if (failed_validation_index) *failed_validation_index = i; return false; } } // Bump size. offset = actual_offset + packed_size; } return true; } bool CompilerGLSL::can_use_io_location(StorageClass storage, bool block) { // Location specifiers are must have in SPIR-V, but they aren't really supported in earlier versions of GLSL. // Be very explicit here about how to solve the issue. if ((get_execution_model() != ExecutionModelVertex && storage == StorageClassInput) || (get_execution_model() != ExecutionModelFragment && storage == StorageClassOutput)) { uint32_t minimum_desktop_version = block ? 440 : 410; // ARB_enhanced_layouts vs ARB_separate_shader_objects ... if (!options.es && options.version < minimum_desktop_version && !options.separate_shader_objects) return false; else if (options.es && options.version < 310) return false; } if ((get_execution_model() == ExecutionModelVertex && storage == StorageClassInput) || (get_execution_model() == ExecutionModelFragment && storage == StorageClassOutput)) { if (options.es && options.version < 300) return false; else if (!options.es && options.version < 330) return false; } if (storage == StorageClassUniform || storage == StorageClassUniformConstant || storage == StorageClassPushConstant) { if (options.es && options.version < 310) return false; else if (!options.es && options.version < 430) return false; } return true; } string CompilerGLSL::layout_for_variable(const SPIRVariable &var) { // FIXME: Come up with a better solution for when to disable layouts. // Having layouts depend on extensions as well as which types // of layouts are used. For now, the simple solution is to just disable // layouts for legacy versions. if (is_legacy()) return ""; if (subpass_input_is_framebuffer_fetch(var.self)) return ""; SmallVector attr; auto &type = get(var.basetype); auto &flags = get_decoration_bitset(var.self); auto &typeflags = get_decoration_bitset(type.self); if (flags.get(DecorationPassthroughNV)) attr.push_back("passthrough"); if (options.vulkan_semantics && var.storage == StorageClassPushConstant) attr.push_back("push_constant"); else if (var.storage == StorageClassShaderRecordBufferKHR) attr.push_back(ray_tracing_is_khr ? "shaderRecordEXT" : "shaderRecordNV"); if (flags.get(DecorationRowMajor)) attr.push_back("row_major"); if (flags.get(DecorationColMajor)) attr.push_back("column_major"); if (options.vulkan_semantics) { if (flags.get(DecorationInputAttachmentIndex)) attr.push_back(join("input_attachment_index = ", get_decoration(var.self, DecorationInputAttachmentIndex))); } bool is_block = has_decoration(type.self, DecorationBlock); if (flags.get(DecorationLocation) && can_use_io_location(var.storage, is_block)) { Bitset combined_decoration; for (uint32_t i = 0; i < ir.meta[type.self].members.size(); i++) combined_decoration.merge_or(combined_decoration_for_member(type, i)); // If our members have location decorations, we don't need to // emit location decorations at the top as well (looks weird). if (!combined_decoration.get(DecorationLocation)) attr.push_back(join("location = ", get_decoration(var.self, DecorationLocation))); } // Transform feedback bool uses_enhanced_layouts = false; if (is_block && var.storage == StorageClassOutput) { // For blocks, there is a restriction where xfb_stride/xfb_buffer must only be declared on the block itself, // since all members must match the same xfb_buffer. The only thing we will declare for members of the block // is the xfb_offset. uint32_t member_count = uint32_t(type.member_types.size()); bool have_xfb_buffer_stride = false; bool have_any_xfb_offset = false; bool have_geom_stream = false; uint32_t xfb_stride = 0, xfb_buffer = 0, geom_stream = 0; if (flags.get(DecorationXfbBuffer) && flags.get(DecorationXfbStride)) { have_xfb_buffer_stride = true; xfb_buffer = get_decoration(var.self, DecorationXfbBuffer); xfb_stride = get_decoration(var.self, DecorationXfbStride); } if (flags.get(DecorationStream)) { have_geom_stream = true; geom_stream = get_decoration(var.self, DecorationStream); } // Verify that none of the members violate our assumption. for (uint32_t i = 0; i < member_count; i++) { if (has_member_decoration(type.self, i, DecorationStream)) { uint32_t member_geom_stream = get_member_decoration(type.self, i, DecorationStream); if (have_geom_stream && member_geom_stream != geom_stream) SPIRV_CROSS_THROW("IO block member Stream mismatch."); have_geom_stream = true; geom_stream = member_geom_stream; } // Only members with an Offset decoration participate in XFB. if (!has_member_decoration(type.self, i, DecorationOffset)) continue; have_any_xfb_offset = true; if (has_member_decoration(type.self, i, DecorationXfbBuffer)) { uint32_t buffer_index = get_member_decoration(type.self, i, DecorationXfbBuffer); if (have_xfb_buffer_stride && buffer_index != xfb_buffer) SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch."); have_xfb_buffer_stride = true; xfb_buffer = buffer_index; } if (has_member_decoration(type.self, i, DecorationXfbStride)) { uint32_t stride = get_member_decoration(type.self, i, DecorationXfbStride); if (have_xfb_buffer_stride && stride != xfb_stride) SPIRV_CROSS_THROW("IO block member XfbStride mismatch."); have_xfb_buffer_stride = true; xfb_stride = stride; } } if (have_xfb_buffer_stride && have_any_xfb_offset) { attr.push_back(join("xfb_buffer = ", xfb_buffer)); attr.push_back(join("xfb_stride = ", xfb_stride)); uses_enhanced_layouts = true; } if (have_geom_stream) { if (get_execution_model() != ExecutionModelGeometry) SPIRV_CROSS_THROW("Geometry streams can only be used in geometry shaders."); if (options.es) SPIRV_CROSS_THROW("Multiple geometry streams not supported in ESSL."); if (options.version < 400) require_extension_internal("GL_ARB_transform_feedback3"); attr.push_back(join("stream = ", get_decoration(var.self, DecorationStream))); } } else if (var.storage == StorageClassOutput) { if (flags.get(DecorationXfbBuffer) && flags.get(DecorationXfbStride) && flags.get(DecorationOffset)) { // XFB for standalone variables, we can emit all decorations. attr.push_back(join("xfb_buffer = ", get_decoration(var.self, DecorationXfbBuffer))); attr.push_back(join("xfb_stride = ", get_decoration(var.self, DecorationXfbStride))); attr.push_back(join("xfb_offset = ", get_decoration(var.self, DecorationOffset))); uses_enhanced_layouts = true; } if (flags.get(DecorationStream)) { if (get_execution_model() != ExecutionModelGeometry) SPIRV_CROSS_THROW("Geometry streams can only be used in geometry shaders."); if (options.es) SPIRV_CROSS_THROW("Multiple geometry streams not supported in ESSL."); if (options.version < 400) require_extension_internal("GL_ARB_transform_feedback3"); attr.push_back(join("stream = ", get_decoration(var.self, DecorationStream))); } } // Can only declare Component if we can declare location. if (flags.get(DecorationComponent) && can_use_io_location(var.storage, is_block)) { uses_enhanced_layouts = true; attr.push_back(join("component = ", get_decoration(var.self, DecorationComponent))); } if (uses_enhanced_layouts) { if (!options.es) { if (options.version < 440 && options.version >= 140) require_extension_internal("GL_ARB_enhanced_layouts"); else if (options.version < 140) SPIRV_CROSS_THROW("GL_ARB_enhanced_layouts is not supported in targets below GLSL 1.40."); if (!options.es && options.version < 440) require_extension_internal("GL_ARB_enhanced_layouts"); } else if (options.es) SPIRV_CROSS_THROW("GL_ARB_enhanced_layouts is not supported in ESSL."); } if (flags.get(DecorationIndex)) attr.push_back(join("index = ", get_decoration(var.self, DecorationIndex))); // Do not emit set = decoration in regular GLSL output, but // we need to preserve it in Vulkan GLSL mode. if (var.storage != StorageClassPushConstant && var.storage != StorageClassShaderRecordBufferKHR) { if (flags.get(DecorationDescriptorSet) && options.vulkan_semantics) attr.push_back(join("set = ", get_decoration(var.self, DecorationDescriptorSet))); } bool push_constant_block = options.vulkan_semantics && var.storage == StorageClassPushConstant; bool ssbo_block = var.storage == StorageClassStorageBuffer || var.storage == StorageClassShaderRecordBufferKHR || (var.storage == StorageClassUniform && typeflags.get(DecorationBufferBlock)); bool emulated_ubo = var.storage == StorageClassPushConstant && options.emit_push_constant_as_uniform_buffer; bool ubo_block = var.storage == StorageClassUniform && typeflags.get(DecorationBlock); // GL 3.0/GLSL 1.30 is not considered legacy, but it doesn't have UBOs ... bool can_use_buffer_blocks = (options.es && options.version >= 300) || (!options.es && options.version >= 140); // pretend no UBOs when options say so if (ubo_block && options.emit_uniform_buffer_as_plain_uniforms) can_use_buffer_blocks = false; bool can_use_binding; if (options.es) can_use_binding = options.version >= 310; else can_use_binding = options.enable_420pack_extension || (options.version >= 420); // Make sure we don't emit binding layout for a classic uniform on GLSL 1.30. if (!can_use_buffer_blocks && var.storage == StorageClassUniform) can_use_binding = false; if (var.storage == StorageClassShaderRecordBufferKHR) can_use_binding = false; if (can_use_binding && flags.get(DecorationBinding)) attr.push_back(join("binding = ", get_decoration(var.self, DecorationBinding))); if (var.storage != StorageClassOutput && flags.get(DecorationOffset)) attr.push_back(join("offset = ", get_decoration(var.self, DecorationOffset))); // Instead of adding explicit offsets for every element here, just assume we're using std140 or std430. // If SPIR-V does not comply with either layout, we cannot really work around it. if (can_use_buffer_blocks && (ubo_block || emulated_ubo)) { attr.push_back(buffer_to_packing_standard(type, false)); } else if (can_use_buffer_blocks && (push_constant_block || ssbo_block)) { attr.push_back(buffer_to_packing_standard(type, true)); } // For images, the type itself adds a layout qualifer. // Only emit the format for storage images. if (type.basetype == SPIRType::Image && type.image.sampled == 2) { const char *fmt = format_to_glsl(type.image.format); if (fmt) attr.push_back(fmt); } if (attr.empty()) return ""; string res = "layout("; res += merge(attr); res += ") "; return res; } string CompilerGLSL::buffer_to_packing_standard(const SPIRType &type, bool support_std430_without_scalar_layout) { if (support_std430_without_scalar_layout && buffer_is_packing_standard(type, BufferPackingStd430)) return "std430"; else if (buffer_is_packing_standard(type, BufferPackingStd140)) return "std140"; else if (options.vulkan_semantics && buffer_is_packing_standard(type, BufferPackingScalar)) { require_extension_internal("GL_EXT_scalar_block_layout"); return "scalar"; } else if (support_std430_without_scalar_layout && buffer_is_packing_standard(type, BufferPackingStd430EnhancedLayout)) { if (options.es && !options.vulkan_semantics) SPIRV_CROSS_THROW("Push constant block cannot be expressed as neither std430 nor std140. ES-targets do " "not support GL_ARB_enhanced_layouts."); if (!options.es && !options.vulkan_semantics && options.version < 440) require_extension_internal("GL_ARB_enhanced_layouts"); set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset); return "std430"; } else if (buffer_is_packing_standard(type, BufferPackingStd140EnhancedLayout)) { // Fallback time. We might be able to use the ARB_enhanced_layouts to deal with this difference, // however, we can only use layout(offset) on the block itself, not any substructs, so the substructs better be the appropriate layout. // Enhanced layouts seem to always work in Vulkan GLSL, so no need for extensions there. if (options.es && !options.vulkan_semantics) SPIRV_CROSS_THROW("Push constant block cannot be expressed as neither std430 nor std140. ES-targets do " "not support GL_ARB_enhanced_layouts."); if (!options.es && !options.vulkan_semantics && options.version < 440) require_extension_internal("GL_ARB_enhanced_layouts"); set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset); return "std140"; } else if (options.vulkan_semantics && buffer_is_packing_standard(type, BufferPackingScalarEnhancedLayout)) { set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset); require_extension_internal("GL_EXT_scalar_block_layout"); return "scalar"; } else if (!support_std430_without_scalar_layout && options.vulkan_semantics && buffer_is_packing_standard(type, BufferPackingStd430)) { // UBOs can support std430 with GL_EXT_scalar_block_layout. require_extension_internal("GL_EXT_scalar_block_layout"); return "std430"; } else if (!support_std430_without_scalar_layout && options.vulkan_semantics && buffer_is_packing_standard(type, BufferPackingStd430EnhancedLayout)) { // UBOs can support std430 with GL_EXT_scalar_block_layout. set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset); require_extension_internal("GL_EXT_scalar_block_layout"); return "std430"; } else { SPIRV_CROSS_THROW("Buffer block cannot be expressed as any of std430, std140, scalar, even with enhanced " "layouts. You can try flattening this block to support a more flexible layout."); } } void CompilerGLSL::emit_push_constant_block(const SPIRVariable &var) { if (flattened_buffer_blocks.count(var.self)) emit_buffer_block_flattened(var); else if (options.vulkan_semantics) emit_push_constant_block_vulkan(var); else if (options.emit_push_constant_as_uniform_buffer) emit_buffer_block_native(var); else emit_push_constant_block_glsl(var); } void CompilerGLSL::emit_push_constant_block_vulkan(const SPIRVariable &var) { emit_buffer_block(var); } void CompilerGLSL::emit_push_constant_block_glsl(const SPIRVariable &var) { // OpenGL has no concept of push constant blocks, implement it as a uniform struct. auto &type = get(var.basetype); auto &flags = ir.meta[var.self].decoration.decoration_flags; flags.clear(DecorationBinding); flags.clear(DecorationDescriptorSet); #if 0 if (flags & ((1ull << DecorationBinding) | (1ull << DecorationDescriptorSet))) SPIRV_CROSS_THROW("Push constant blocks cannot be compiled to GLSL with Binding or Set syntax. " "Remap to location with reflection API first or disable these decorations."); #endif // We're emitting the push constant block as a regular struct, so disable the block qualifier temporarily. // Otherwise, we will end up emitting layout() qualifiers on naked structs which is not allowed. auto &block_flags = ir.meta[type.self].decoration.decoration_flags; bool block_flag = block_flags.get(DecorationBlock); block_flags.clear(DecorationBlock); emit_struct(type); if (block_flag) block_flags.set(DecorationBlock); emit_uniform(var); statement(""); } void CompilerGLSL::emit_buffer_block(const SPIRVariable &var) { auto &type = get(var.basetype); bool ubo_block = var.storage == StorageClassUniform && has_decoration(type.self, DecorationBlock); if (flattened_buffer_blocks.count(var.self)) emit_buffer_block_flattened(var); else if (is_legacy() || (!options.es && options.version == 130) || (ubo_block && options.emit_uniform_buffer_as_plain_uniforms)) emit_buffer_block_legacy(var); else emit_buffer_block_native(var); } void CompilerGLSL::emit_buffer_block_legacy(const SPIRVariable &var) { auto &type = get(var.basetype); bool ssbo = var.storage == StorageClassStorageBuffer || ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock); if (ssbo) SPIRV_CROSS_THROW("SSBOs not supported in legacy targets."); // We're emitting the push constant block as a regular struct, so disable the block qualifier temporarily. // Otherwise, we will end up emitting layout() qualifiers on naked structs which is not allowed. auto &block_flags = ir.meta[type.self].decoration.decoration_flags; bool block_flag = block_flags.get(DecorationBlock); block_flags.clear(DecorationBlock); emit_struct(type); if (block_flag) block_flags.set(DecorationBlock); emit_uniform(var); statement(""); } void CompilerGLSL::emit_buffer_reference_block(SPIRType &type, bool forward_declaration) { string buffer_name; if (forward_declaration) { // Block names should never alias, but from HLSL input they kind of can because block types are reused for UAVs ... // Allow aliased name since we might be declaring the block twice. Once with buffer reference (forward declared) and one proper declaration. // The names must match up. buffer_name = to_name(type.self, false); // Shaders never use the block by interface name, so we don't // have to track this other than updating name caches. // If we have a collision for any reason, just fallback immediately. if (ir.meta[type.self].decoration.alias.empty() || block_ssbo_names.find(buffer_name) != end(block_ssbo_names) || resource_names.find(buffer_name) != end(resource_names)) { buffer_name = join("_", type.self); } // Make sure we get something unique for both global name scope and block name scope. // See GLSL 4.5 spec: section 4.3.9 for details. add_variable(block_ssbo_names, resource_names, buffer_name); // If for some reason buffer_name is an illegal name, make a final fallback to a workaround name. // This cannot conflict with anything else, so we're safe now. // We cannot reuse this fallback name in neither global scope (blocked by block_names) nor block name scope. if (buffer_name.empty()) buffer_name = join("_", type.self); block_names.insert(buffer_name); block_ssbo_names.insert(buffer_name); // Ensure we emit the correct name when emitting non-forward pointer type. ir.meta[type.self].decoration.alias = buffer_name; } else if (type.basetype != SPIRType::Struct) buffer_name = type_to_glsl(type); else buffer_name = to_name(type.self, false); if (!forward_declaration) { if (type.basetype == SPIRType::Struct) { auto flags = ir.get_buffer_block_type_flags(type); string decorations; if (flags.get(DecorationRestrict)) decorations += " restrict"; if (flags.get(DecorationCoherent)) decorations += " coherent"; if (flags.get(DecorationNonReadable)) decorations += " writeonly"; if (flags.get(DecorationNonWritable)) decorations += " readonly"; statement("layout(buffer_reference, ", buffer_to_packing_standard(type, true), ")", decorations, " buffer ", buffer_name); } else statement("layout(buffer_reference) buffer ", buffer_name); begin_scope(); if (type.basetype == SPIRType::Struct) { type.member_name_cache.clear(); uint32_t i = 0; for (auto &member : type.member_types) { add_member_name(type, i); emit_struct_member(type, member, i); i++; } } else { auto &pointee_type = get_pointee_type(type); statement(type_to_glsl(pointee_type), " value", type_to_array_glsl(pointee_type), ";"); } end_scope_decl(); statement(""); } else { statement("layout(buffer_reference) buffer ", buffer_name, ";"); } } void CompilerGLSL::emit_buffer_block_native(const SPIRVariable &var) { auto &type = get(var.basetype); Bitset flags = ir.get_buffer_block_flags(var); bool ssbo = var.storage == StorageClassStorageBuffer || var.storage == StorageClassShaderRecordBufferKHR || ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock); bool is_restrict = ssbo && flags.get(DecorationRestrict); bool is_writeonly = ssbo && flags.get(DecorationNonReadable); bool is_readonly = ssbo && flags.get(DecorationNonWritable); bool is_coherent = ssbo && flags.get(DecorationCoherent); // Block names should never alias, but from HLSL input they kind of can because block types are reused for UAVs ... auto buffer_name = to_name(type.self, false); auto &block_namespace = ssbo ? block_ssbo_names : block_ubo_names; // Shaders never use the block by interface name, so we don't // have to track this other than updating name caches. // If we have a collision for any reason, just fallback immediately. if (ir.meta[type.self].decoration.alias.empty() || block_namespace.find(buffer_name) != end(block_namespace) || resource_names.find(buffer_name) != end(resource_names)) { buffer_name = get_block_fallback_name(var.self); } // Make sure we get something unique for both global name scope and block name scope. // See GLSL 4.5 spec: section 4.3.9 for details. add_variable(block_namespace, resource_names, buffer_name); // If for some reason buffer_name is an illegal name, make a final fallback to a workaround name. // This cannot conflict with anything else, so we're safe now. // We cannot reuse this fallback name in neither global scope (blocked by block_names) nor block name scope. if (buffer_name.empty()) buffer_name = join("_", get(var.basetype).self, "_", var.self); block_names.insert(buffer_name); block_namespace.insert(buffer_name); // Save for post-reflection later. declared_block_names[var.self] = buffer_name; statement(layout_for_variable(var), is_coherent ? "coherent " : "", is_restrict ? "restrict " : "", is_writeonly ? "writeonly " : "", is_readonly ? "readonly " : "", ssbo ? "buffer " : "uniform ", buffer_name); begin_scope(); type.member_name_cache.clear(); uint32_t i = 0; for (auto &member : type.member_types) { add_member_name(type, i); emit_struct_member(type, member, i); i++; } // var.self can be used as a backup name for the block name, // so we need to make sure we don't disturb the name here on a recompile. // It will need to be reset if we have to recompile. preserve_alias_on_reset(var.self); add_resource_name(var.self); end_scope_decl(to_name(var.self) + type_to_array_glsl(type)); statement(""); } void CompilerGLSL::emit_buffer_block_flattened(const SPIRVariable &var) { auto &type = get(var.basetype); // Block names should never alias. auto buffer_name = to_name(type.self, false); size_t buffer_size = (get_declared_struct_size(type) + 15) / 16; SPIRType::BaseType basic_type; if (get_common_basic_type(type, basic_type)) { SPIRType tmp; tmp.basetype = basic_type; tmp.vecsize = 4; if (basic_type != SPIRType::Float && basic_type != SPIRType::Int && basic_type != SPIRType::UInt) SPIRV_CROSS_THROW("Basic types in a flattened UBO must be float, int or uint."); auto flags = ir.get_buffer_block_flags(var); statement("uniform ", flags_to_qualifiers_glsl(tmp, flags), type_to_glsl(tmp), " ", buffer_name, "[", buffer_size, "];"); } else SPIRV_CROSS_THROW("All basic types in a flattened block must be the same."); } const char *CompilerGLSL::to_storage_qualifiers_glsl(const SPIRVariable &var) { auto &execution = get_entry_point(); if (subpass_input_is_framebuffer_fetch(var.self)) return ""; if (var.storage == StorageClassInput || var.storage == StorageClassOutput) { if (is_legacy() && execution.model == ExecutionModelVertex) return var.storage == StorageClassInput ? "attribute " : "varying "; else if (is_legacy() && execution.model == ExecutionModelFragment) return "varying "; // Fragment outputs are renamed so they never hit this case. else if (execution.model == ExecutionModelFragment && var.storage == StorageClassOutput) { if (inout_color_attachments.count(get_decoration(var.self, DecorationLocation)) != 0) return "inout "; else return "out "; } else return var.storage == StorageClassInput ? "in " : "out "; } else if (var.storage == StorageClassUniformConstant || var.storage == StorageClassUniform || var.storage == StorageClassPushConstant) { return "uniform "; } else if (var.storage == StorageClassRayPayloadKHR) { return ray_tracing_is_khr ? "rayPayloadEXT " : "rayPayloadNV "; } else if (var.storage == StorageClassIncomingRayPayloadKHR) { return ray_tracing_is_khr ? "rayPayloadInEXT " : "rayPayloadInNV "; } else if (var.storage == StorageClassHitAttributeKHR) { return ray_tracing_is_khr ? "hitAttributeEXT " : "hitAttributeNV "; } else if (var.storage == StorageClassCallableDataKHR) { return ray_tracing_is_khr ? "callableDataEXT " : "callableDataNV "; } else if (var.storage == StorageClassIncomingCallableDataKHR) { return ray_tracing_is_khr ? "callableDataInEXT " : "callableDataInNV "; } return ""; } void CompilerGLSL::emit_flattened_io_block_member(const std::string &basename, const SPIRType &type, const char *qual, const SmallVector &indices) { uint32_t member_type_id = type.self; const SPIRType *member_type = &type; const SPIRType *parent_type = nullptr; auto flattened_name = basename; for (auto &index : indices) { flattened_name += "_"; flattened_name += to_member_name(*member_type, index); parent_type = member_type; member_type_id = member_type->member_types[index]; member_type = &get(member_type_id); } assert(member_type->basetype != SPIRType::Struct); // We're overriding struct member names, so ensure we do so on the primary type. if (parent_type->type_alias) parent_type = &get(parent_type->type_alias); // Sanitize underscores because joining the two identifiers might create more than 1 underscore in a row, // which is not allowed. ParsedIR::sanitize_underscores(flattened_name); uint32_t last_index = indices.back(); // Pass in the varying qualifier here so it will appear in the correct declaration order. // Replace member name while emitting it so it encodes both struct name and member name. auto backup_name = get_member_name(parent_type->self, last_index); auto member_name = to_member_name(*parent_type, last_index); set_member_name(parent_type->self, last_index, flattened_name); emit_struct_member(*parent_type, member_type_id, last_index, qual); // Restore member name. set_member_name(parent_type->self, last_index, member_name); } void CompilerGLSL::emit_flattened_io_block_struct(const std::string &basename, const SPIRType &type, const char *qual, const SmallVector &indices) { auto sub_indices = indices; sub_indices.push_back(0); const SPIRType *member_type = &type; for (auto &index : indices) member_type = &get(member_type->member_types[index]); assert(member_type->basetype == SPIRType::Struct); if (!member_type->array.empty()) SPIRV_CROSS_THROW("Cannot flatten array of structs in I/O blocks."); for (uint32_t i = 0; i < uint32_t(member_type->member_types.size()); i++) { sub_indices.back() = i; if (get(member_type->member_types[i]).basetype == SPIRType::Struct) emit_flattened_io_block_struct(basename, type, qual, sub_indices); else emit_flattened_io_block_member(basename, type, qual, sub_indices); } } void CompilerGLSL::emit_flattened_io_block(const SPIRVariable &var, const char *qual) { auto &var_type = get(var.basetype); if (!var_type.array.empty()) SPIRV_CROSS_THROW("Array of varying structs cannot be flattened to legacy-compatible varyings."); // Emit flattened types based on the type alias. Normally, we are never supposed to emit // struct declarations for aliased types. auto &type = var_type.type_alias ? get(var_type.type_alias) : var_type; auto old_flags = ir.meta[type.self].decoration.decoration_flags; // Emit the members as if they are part of a block to get all qualifiers. ir.meta[type.self].decoration.decoration_flags.set(DecorationBlock); type.member_name_cache.clear(); SmallVector member_indices; member_indices.push_back(0); auto basename = to_name(var.self); uint32_t i = 0; for (auto &member : type.member_types) { add_member_name(type, i); auto &membertype = get(member); member_indices.back() = i; if (membertype.basetype == SPIRType::Struct) emit_flattened_io_block_struct(basename, type, qual, member_indices); else emit_flattened_io_block_member(basename, type, qual, member_indices); i++; } ir.meta[type.self].decoration.decoration_flags = old_flags; // Treat this variable as fully flattened from now on. flattened_structs[var.self] = true; } void CompilerGLSL::emit_interface_block(const SPIRVariable &var) { auto &type = get(var.basetype); if (var.storage == StorageClassInput && type.basetype == SPIRType::Double && !options.es && options.version < 410) { require_extension_internal("GL_ARB_vertex_attrib_64bit"); } // Either make it plain in/out or in/out blocks depending on what shader is doing ... bool block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock); const char *qual = to_storage_qualifiers_glsl(var); if (block) { // ESSL earlier than 310 and GLSL earlier than 150 did not support // I/O variables which are struct types. // To support this, flatten the struct into separate varyings instead. if (options.force_flattened_io_blocks || (options.es && options.version < 310) || (!options.es && options.version < 150)) { // I/O blocks on ES require version 310 with Android Extension Pack extensions, or core version 320. // On desktop, I/O blocks were introduced with geometry shaders in GL 3.2 (GLSL 150). emit_flattened_io_block(var, qual); } else { if (options.es && options.version < 320) { // Geometry and tessellation extensions imply this extension. if (!has_extension("GL_EXT_geometry_shader") && !has_extension("GL_EXT_tessellation_shader")) require_extension_internal("GL_EXT_shader_io_blocks"); } // Workaround to make sure we can emit "patch in/out" correctly. fixup_io_block_patch_qualifiers(var); // Block names should never alias. auto block_name = to_name(type.self, false); // The namespace for I/O blocks is separate from other variables in GLSL. auto &block_namespace = type.storage == StorageClassInput ? block_input_names : block_output_names; // Shaders never use the block by interface name, so we don't // have to track this other than updating name caches. if (block_name.empty() || block_namespace.find(block_name) != end(block_namespace)) block_name = get_fallback_name(type.self); else block_namespace.insert(block_name); // If for some reason buffer_name is an illegal name, make a final fallback to a workaround name. // This cannot conflict with anything else, so we're safe now. if (block_name.empty()) block_name = join("_", get(var.basetype).self, "_", var.self); // Instance names cannot alias block names. resource_names.insert(block_name); bool is_patch = has_decoration(var.self, DecorationPatch); statement(layout_for_variable(var), (is_patch ? "patch " : ""), qual, block_name); begin_scope(); type.member_name_cache.clear(); uint32_t i = 0; for (auto &member : type.member_types) { add_member_name(type, i); emit_struct_member(type, member, i); i++; } add_resource_name(var.self); end_scope_decl(join(to_name(var.self), type_to_array_glsl(type))); statement(""); } } else { // ESSL earlier than 310 and GLSL earlier than 150 did not support // I/O variables which are struct types. // To support this, flatten the struct into separate varyings instead. if (type.basetype == SPIRType::Struct && (options.force_flattened_io_blocks || (options.es && options.version < 310) || (!options.es && options.version < 150))) { emit_flattened_io_block(var, qual); } else { add_resource_name(var.self); // Tessellation control and evaluation shaders must have either gl_MaxPatchVertices or unsized arrays for input arrays. // Opt for unsized as it's the more "correct" variant to use. bool control_point_input_array = type.storage == StorageClassInput && !type.array.empty() && !has_decoration(var.self, DecorationPatch) && (get_entry_point().model == ExecutionModelTessellationControl || get_entry_point().model == ExecutionModelTessellationEvaluation); uint32_t old_array_size = 0; bool old_array_size_literal = true; if (control_point_input_array) { swap(type.array.back(), old_array_size); swap(type.array_size_literal.back(), old_array_size_literal); } statement(layout_for_variable(var), to_qualifiers_glsl(var.self), variable_decl(type, to_name(var.self), var.self), ";"); if (control_point_input_array) { swap(type.array.back(), old_array_size); swap(type.array_size_literal.back(), old_array_size_literal); } } } } void CompilerGLSL::emit_uniform(const SPIRVariable &var) { auto &type = get(var.basetype); if (type.basetype == SPIRType::Image && type.image.sampled == 2 && type.image.dim != DimSubpassData) { if (!options.es && options.version < 420) require_extension_internal("GL_ARB_shader_image_load_store"); else if (options.es && options.version < 310) SPIRV_CROSS_THROW("At least ESSL 3.10 required for shader image load store."); } add_resource_name(var.self); statement(layout_for_variable(var), variable_decl(var), ";"); } string CompilerGLSL::constant_value_macro_name(uint32_t id) { return join("SPIRV_CROSS_CONSTANT_ID_", id); } void CompilerGLSL::emit_specialization_constant_op(const SPIRConstantOp &constant) { auto &type = get(constant.basetype); auto name = to_name(constant.self); statement("const ", variable_decl(type, name), " = ", constant_op_expression(constant), ";"); } void CompilerGLSL::emit_constant(const SPIRConstant &constant) { auto &type = get(constant.constant_type); auto name = to_name(constant.self); SpecializationConstant wg_x, wg_y, wg_z; ID workgroup_size_id = get_work_group_size_specialization_constants(wg_x, wg_y, wg_z); // This specialization constant is implicitly declared by emitting layout() in; if (constant.self == workgroup_size_id) return; // These specialization constants are implicitly declared by emitting layout() in; // In legacy GLSL, we will still need to emit macros for these, so a layout() in; declaration // later can use macro overrides for work group size. bool is_workgroup_size_constant = ConstantID(constant.self) == wg_x.id || ConstantID(constant.self) == wg_y.id || ConstantID(constant.self) == wg_z.id; if (options.vulkan_semantics && is_workgroup_size_constant) { // Vulkan GLSL does not need to declare workgroup spec constants explicitly, it is handled in layout(). return; } else if (!options.vulkan_semantics && is_workgroup_size_constant && !has_decoration(constant.self, DecorationSpecId)) { // Only bother declaring a workgroup size if it is actually a specialization constant, because we need macros. return; } // Only scalars have constant IDs. if (has_decoration(constant.self, DecorationSpecId)) { if (options.vulkan_semantics) { statement("layout(constant_id = ", get_decoration(constant.self, DecorationSpecId), ") const ", variable_decl(type, name), " = ", constant_expression(constant), ";"); } else { const string ¯o_name = constant.specialization_constant_macro_name; statement("#ifndef ", macro_name); statement("#define ", macro_name, " ", constant_expression(constant)); statement("#endif"); // For workgroup size constants, only emit the macros. if (!is_workgroup_size_constant) statement("const ", variable_decl(type, name), " = ", macro_name, ";"); } } else { statement("const ", variable_decl(type, name), " = ", constant_expression(constant), ";"); } } void CompilerGLSL::emit_entry_point_declarations() { } void CompilerGLSL::replace_illegal_names(const unordered_set &keywords) { ir.for_each_typed_id([&](uint32_t, const SPIRVariable &var) { if (is_hidden_variable(var)) return; auto *meta = ir.find_meta(var.self); if (!meta) return; auto &m = meta->decoration; if (keywords.find(m.alias) != end(keywords)) m.alias = join("_", m.alias); }); ir.for_each_typed_id([&](uint32_t, const SPIRFunction &func) { auto *meta = ir.find_meta(func.self); if (!meta) return; auto &m = meta->decoration; if (keywords.find(m.alias) != end(keywords)) m.alias = join("_", m.alias); }); ir.for_each_typed_id([&](uint32_t, const SPIRType &type) { auto *meta = ir.find_meta(type.self); if (!meta) return; auto &m = meta->decoration; if (keywords.find(m.alias) != end(keywords)) m.alias = join("_", m.alias); for (auto &memb : meta->members) if (keywords.find(memb.alias) != end(keywords)) memb.alias = join("_", memb.alias); }); } void CompilerGLSL::replace_illegal_names() { // clang-format off static const unordered_set keywords = { "abs", "acos", "acosh", "all", "any", "asin", "asinh", "atan", "atanh", "atomicAdd", "atomicCompSwap", "atomicCounter", "atomicCounterDecrement", "atomicCounterIncrement", "atomicExchange", "atomicMax", "atomicMin", "atomicOr", "atomicXor", "bitCount", "bitfieldExtract", "bitfieldInsert", "bitfieldReverse", "ceil", "cos", "cosh", "cross", "degrees", "dFdx", "dFdxCoarse", "dFdxFine", "dFdy", "dFdyCoarse", "dFdyFine", "distance", "dot", "EmitStreamVertex", "EmitVertex", "EndPrimitive", "EndStreamPrimitive", "equal", "exp", "exp2", "faceforward", "findLSB", "findMSB", "float16BitsToInt16", "float16BitsToUint16", "floatBitsToInt", "floatBitsToUint", "floor", "fma", "fract", "frexp", "fwidth", "fwidthCoarse", "fwidthFine", "greaterThan", "greaterThanEqual", "groupMemoryBarrier", "imageAtomicAdd", "imageAtomicAnd", "imageAtomicCompSwap", "imageAtomicExchange", "imageAtomicMax", "imageAtomicMin", "imageAtomicOr", "imageAtomicXor", "imageLoad", "imageSamples", "imageSize", "imageStore", "imulExtended", "int16BitsToFloat16", "intBitsToFloat", "interpolateAtOffset", "interpolateAtCentroid", "interpolateAtSample", "inverse", "inversesqrt", "isinf", "isnan", "ldexp", "length", "lessThan", "lessThanEqual", "log", "log2", "matrixCompMult", "max", "memoryBarrier", "memoryBarrierAtomicCounter", "memoryBarrierBuffer", "memoryBarrierImage", "memoryBarrierShared", "min", "mix", "mod", "modf", "noise", "noise1", "noise2", "noise3", "noise4", "normalize", "not", "notEqual", "outerProduct", "packDouble2x32", "packHalf2x16", "packInt2x16", "packInt4x16", "packSnorm2x16", "packSnorm4x8", "packUint2x16", "packUint4x16", "packUnorm2x16", "packUnorm4x8", "pow", "radians", "reflect", "refract", "round", "roundEven", "sign", "sin", "sinh", "smoothstep", "sqrt", "step", "tan", "tanh", "texelFetch", "texelFetchOffset", "texture", "textureGather", "textureGatherOffset", "textureGatherOffsets", "textureGrad", "textureGradOffset", "textureLod", "textureLodOffset", "textureOffset", "textureProj", "textureProjGrad", "textureProjGradOffset", "textureProjLod", "textureProjLodOffset", "textureProjOffset", "textureQueryLevels", "textureQueryLod", "textureSamples", "textureSize", "transpose", "trunc", "uaddCarry", "uint16BitsToFloat16", "uintBitsToFloat", "umulExtended", "unpackDouble2x32", "unpackHalf2x16", "unpackInt2x16", "unpackInt4x16", "unpackSnorm2x16", "unpackSnorm4x8", "unpackUint2x16", "unpackUint4x16", "unpackUnorm2x16", "unpackUnorm4x8", "usubBorrow", "active", "asm", "atomic_uint", "attribute", "bool", "break", "buffer", "bvec2", "bvec3", "bvec4", "case", "cast", "centroid", "class", "coherent", "common", "const", "continue", "default", "discard", "dmat2", "dmat2x2", "dmat2x3", "dmat2x4", "dmat3", "dmat3x2", "dmat3x3", "dmat3x4", "dmat4", "dmat4x2", "dmat4x3", "dmat4x4", "do", "double", "dvec2", "dvec3", "dvec4", "else", "enum", "extern", "external", "false", "filter", "fixed", "flat", "float", "for", "fvec2", "fvec3", "fvec4", "goto", "half", "highp", "hvec2", "hvec3", "hvec4", "if", "iimage1D", "iimage1DArray", "iimage2D", "iimage2DArray", "iimage2DMS", "iimage2DMSArray", "iimage2DRect", "iimage3D", "iimageBuffer", "iimageCube", "iimageCubeArray", "image1D", "image1DArray", "image2D", "image2DArray", "image2DMS", "image2DMSArray", "image2DRect", "image3D", "imageBuffer", "imageCube", "imageCubeArray", "in", "inline", "inout", "input", "int", "interface", "invariant", "isampler1D", "isampler1DArray", "isampler2D", "isampler2DArray", "isampler2DMS", "isampler2DMSArray", "isampler2DRect", "isampler3D", "isamplerBuffer", "isamplerCube", "isamplerCubeArray", "ivec2", "ivec3", "ivec4", "layout", "long", "lowp", "mat2", "mat2x2", "mat2x3", "mat2x4", "mat3", "mat3x2", "mat3x3", "mat3x4", "mat4", "mat4x2", "mat4x3", "mat4x4", "mediump", "namespace", "noinline", "noperspective", "out", "output", "packed", "partition", "patch", "precise", "precision", "public", "readonly", "resource", "restrict", "return", "sample", "sampler1D", "sampler1DArray", "sampler1DArrayShadow", "sampler1DShadow", "sampler2D", "sampler2DArray", "sampler2DArrayShadow", "sampler2DMS", "sampler2DMSArray", "sampler2DRect", "sampler2DRectShadow", "sampler2DShadow", "sampler3D", "sampler3DRect", "samplerBuffer", "samplerCube", "samplerCubeArray", "samplerCubeArrayShadow", "samplerCubeShadow", "shared", "short", "sizeof", "smooth", "static", "struct", "subroutine", "superp", "switch", "template", "this", "true", "typedef", "uimage1D", "uimage1DArray", "uimage2D", "uimage2DArray", "uimage2DMS", "uimage2DMSArray", "uimage2DRect", "uimage3D", "uimageBuffer", "uimageCube", "uimageCubeArray", "uint", "uniform", "union", "unsigned", "usampler1D", "usampler1DArray", "usampler2D", "usampler2DArray", "usampler2DMS", "usampler2DMSArray", "usampler2DRect", "usampler3D", "usamplerBuffer", "usamplerCube", "usamplerCubeArray", "using", "uvec2", "uvec3", "uvec4", "varying", "vec2", "vec3", "vec4", "void", "volatile", "while", "writeonly", }; // clang-format on replace_illegal_names(keywords); } void CompilerGLSL::replace_fragment_output(SPIRVariable &var) { auto &m = ir.meta[var.self].decoration; uint32_t location = 0; if (m.decoration_flags.get(DecorationLocation)) location = m.location; // If our variable is arrayed, we must not emit the array part of this as the SPIR-V will // do the access chain part of this for us. auto &type = get(var.basetype); if (type.array.empty()) { // Redirect the write to a specific render target in legacy GLSL. m.alias = join("gl_FragData[", location, "]"); if (is_legacy_es() && location != 0) require_extension_internal("GL_EXT_draw_buffers"); } else if (type.array.size() == 1) { // If location is non-zero, we probably have to add an offset. // This gets really tricky since we'd have to inject an offset in the access chain. // FIXME: This seems like an extremely odd-ball case, so it's probably fine to leave it like this for now. m.alias = "gl_FragData"; if (location != 0) SPIRV_CROSS_THROW("Arrayed output variable used, but location is not 0. " "This is unimplemented in SPIRV-Cross."); if (is_legacy_es()) require_extension_internal("GL_EXT_draw_buffers"); } else SPIRV_CROSS_THROW("Array-of-array output variable used. This cannot be implemented in legacy GLSL."); var.compat_builtin = true; // We don't want to declare this variable, but use the name as-is. } void CompilerGLSL::replace_fragment_outputs() { ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); if (!is_builtin_variable(var) && !var.remapped_variable && type.pointer && var.storage == StorageClassOutput) replace_fragment_output(var); }); } string CompilerGLSL::remap_swizzle(const SPIRType &out_type, uint32_t input_components, const string &expr) { if (out_type.vecsize == input_components) return expr; else if (input_components == 1 && !backend.can_swizzle_scalar) return join(type_to_glsl(out_type), "(", expr, ")"); else { // FIXME: This will not work with packed expressions. auto e = enclose_expression(expr) + "."; // Just clamp the swizzle index if we have more outputs than inputs. for (uint32_t c = 0; c < out_type.vecsize; c++) e += index_to_swizzle(min(c, input_components - 1)); if (backend.swizzle_is_function && out_type.vecsize > 1) e += "()"; remove_duplicate_swizzle(e); return e; } } void CompilerGLSL::emit_pls() { auto &execution = get_entry_point(); if (execution.model != ExecutionModelFragment) SPIRV_CROSS_THROW("Pixel local storage only supported in fragment shaders."); if (!options.es) SPIRV_CROSS_THROW("Pixel local storage only supported in OpenGL ES."); if (options.version < 300) SPIRV_CROSS_THROW("Pixel local storage only supported in ESSL 3.0 and above."); if (!pls_inputs.empty()) { statement("__pixel_local_inEXT _PLSIn"); begin_scope(); for (auto &input : pls_inputs) statement(pls_decl(input), ";"); end_scope_decl(); statement(""); } if (!pls_outputs.empty()) { statement("__pixel_local_outEXT _PLSOut"); begin_scope(); for (auto &output : pls_outputs) statement(pls_decl(output), ";"); end_scope_decl(); statement(""); } } void CompilerGLSL::fixup_image_load_store_access() { if (!options.enable_storage_image_qualifier_deduction) return; ir.for_each_typed_id([&](uint32_t var, const SPIRVariable &) { auto &vartype = expression_type(var); if (vartype.basetype == SPIRType::Image && vartype.image.sampled == 2) { // Very old glslangValidator and HLSL compilers do not emit required qualifiers here. // Solve this by making the image access as restricted as possible and loosen up if we need to. // If any no-read/no-write flags are actually set, assume that the compiler knows what it's doing. auto &flags = ir.meta[var].decoration.decoration_flags; if (!flags.get(DecorationNonWritable) && !flags.get(DecorationNonReadable)) { flags.set(DecorationNonWritable); flags.set(DecorationNonReadable); } } }); } static bool is_block_builtin(BuiltIn builtin) { return builtin == BuiltInPosition || builtin == BuiltInPointSize || builtin == BuiltInClipDistance || builtin == BuiltInCullDistance; } bool CompilerGLSL::should_force_emit_builtin_block(StorageClass storage) { // If the builtin block uses XFB, we need to force explicit redeclaration of the builtin block. if (storage != StorageClassOutput) return false; bool should_force = false; ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { if (should_force) return; auto &type = this->get(var.basetype); bool block = has_decoration(type.self, DecorationBlock); if (var.storage == storage && block && is_builtin_variable(var)) { uint32_t member_count = uint32_t(type.member_types.size()); for (uint32_t i = 0; i < member_count; i++) { if (has_member_decoration(type.self, i, DecorationBuiltIn) && is_block_builtin(BuiltIn(get_member_decoration(type.self, i, DecorationBuiltIn))) && has_member_decoration(type.self, i, DecorationOffset)) { should_force = true; } } } else if (var.storage == storage && !block && is_builtin_variable(var)) { if (is_block_builtin(BuiltIn(get_decoration(type.self, DecorationBuiltIn))) && has_decoration(var.self, DecorationOffset)) { should_force = true; } } }); // If we're declaring clip/cull planes with control points we need to force block declaration. if (get_execution_model() == ExecutionModelTessellationControl && (clip_distance_count || cull_distance_count)) { should_force = true; } return should_force; } void CompilerGLSL::fixup_implicit_builtin_block_names() { ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool block = has_decoration(type.self, DecorationBlock); if ((var.storage == StorageClassOutput || var.storage == StorageClassInput) && block && is_builtin_variable(var)) { // Make sure the array has a supported name in the code. if (var.storage == StorageClassOutput) set_name(var.self, "gl_out"); else if (var.storage == StorageClassInput) set_name(var.self, "gl_in"); } }); } void CompilerGLSL::emit_declared_builtin_block(StorageClass storage, ExecutionModel model) { Bitset emitted_builtins; Bitset global_builtins; const SPIRVariable *block_var = nullptr; bool emitted_block = false; bool builtin_array = false; // Need to use declared size in the type. // These variables might have been declared, but not statically used, so we haven't deduced their size yet. uint32_t cull_distance_size = 0; uint32_t clip_distance_size = 0; bool have_xfb_buffer_stride = false; bool have_geom_stream = false; bool have_any_xfb_offset = false; uint32_t xfb_stride = 0, xfb_buffer = 0, geom_stream = 0; std::unordered_map builtin_xfb_offsets; ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool block = has_decoration(type.self, DecorationBlock); Bitset builtins; if (var.storage == storage && block && is_builtin_variable(var)) { uint32_t index = 0; for (auto &m : ir.meta[type.self].members) { if (m.builtin) { builtins.set(m.builtin_type); if (m.builtin_type == BuiltInCullDistance) cull_distance_size = to_array_size_literal(this->get(type.member_types[index])); else if (m.builtin_type == BuiltInClipDistance) clip_distance_size = to_array_size_literal(this->get(type.member_types[index])); if (is_block_builtin(m.builtin_type) && m.decoration_flags.get(DecorationOffset)) { have_any_xfb_offset = true; builtin_xfb_offsets[m.builtin_type] = m.offset; } if (is_block_builtin(m.builtin_type) && m.decoration_flags.get(DecorationStream)) { uint32_t stream = m.stream; if (have_geom_stream && geom_stream != stream) SPIRV_CROSS_THROW("IO block member Stream mismatch."); have_geom_stream = true; geom_stream = stream; } } index++; } if (storage == StorageClassOutput && has_decoration(var.self, DecorationXfbBuffer) && has_decoration(var.self, DecorationXfbStride)) { uint32_t buffer_index = get_decoration(var.self, DecorationXfbBuffer); uint32_t stride = get_decoration(var.self, DecorationXfbStride); if (have_xfb_buffer_stride && buffer_index != xfb_buffer) SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch."); if (have_xfb_buffer_stride && stride != xfb_stride) SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch."); have_xfb_buffer_stride = true; xfb_buffer = buffer_index; xfb_stride = stride; } if (storage == StorageClassOutput && has_decoration(var.self, DecorationStream)) { uint32_t stream = get_decoration(var.self, DecorationStream); if (have_geom_stream && geom_stream != stream) SPIRV_CROSS_THROW("IO block member Stream mismatch."); have_geom_stream = true; geom_stream = stream; } } else if (var.storage == storage && !block && is_builtin_variable(var)) { // While we're at it, collect all declared global builtins (HLSL mostly ...). auto &m = ir.meta[var.self].decoration; if (m.builtin) { global_builtins.set(m.builtin_type); if (m.builtin_type == BuiltInCullDistance) cull_distance_size = to_array_size_literal(type); else if (m.builtin_type == BuiltInClipDistance) clip_distance_size = to_array_size_literal(type); if (is_block_builtin(m.builtin_type) && m.decoration_flags.get(DecorationXfbStride) && m.decoration_flags.get(DecorationXfbBuffer) && m.decoration_flags.get(DecorationOffset)) { have_any_xfb_offset = true; builtin_xfb_offsets[m.builtin_type] = m.offset; uint32_t buffer_index = m.xfb_buffer; uint32_t stride = m.xfb_stride; if (have_xfb_buffer_stride && buffer_index != xfb_buffer) SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch."); if (have_xfb_buffer_stride && stride != xfb_stride) SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch."); have_xfb_buffer_stride = true; xfb_buffer = buffer_index; xfb_stride = stride; } if (is_block_builtin(m.builtin_type) && m.decoration_flags.get(DecorationStream)) { uint32_t stream = get_decoration(var.self, DecorationStream); if (have_geom_stream && geom_stream != stream) SPIRV_CROSS_THROW("IO block member Stream mismatch."); have_geom_stream = true; geom_stream = stream; } } } if (builtins.empty()) return; if (emitted_block) SPIRV_CROSS_THROW("Cannot use more than one builtin I/O block."); emitted_builtins = builtins; emitted_block = true; builtin_array = !type.array.empty(); block_var = &var; }); global_builtins = Bitset(global_builtins.get_lower() & ((1ull << BuiltInPosition) | (1ull << BuiltInPointSize) | (1ull << BuiltInClipDistance) | (1ull << BuiltInCullDistance))); // Try to collect all other declared builtins. if (!emitted_block) emitted_builtins = global_builtins; // Can't declare an empty interface block. if (emitted_builtins.empty()) return; if (storage == StorageClassOutput) { SmallVector attr; if (have_xfb_buffer_stride && have_any_xfb_offset) { if (!options.es) { if (options.version < 440 && options.version >= 140) require_extension_internal("GL_ARB_enhanced_layouts"); else if (options.version < 140) SPIRV_CROSS_THROW("Component decoration is not supported in targets below GLSL 1.40."); if (!options.es && options.version < 440) require_extension_internal("GL_ARB_enhanced_layouts"); } else if (options.es) SPIRV_CROSS_THROW("Need GL_ARB_enhanced_layouts for xfb_stride or xfb_buffer."); attr.push_back(join("xfb_buffer = ", xfb_buffer, ", xfb_stride = ", xfb_stride)); } if (have_geom_stream) { if (get_execution_model() != ExecutionModelGeometry) SPIRV_CROSS_THROW("Geometry streams can only be used in geometry shaders."); if (options.es) SPIRV_CROSS_THROW("Multiple geometry streams not supported in ESSL."); if (options.version < 400) require_extension_internal("GL_ARB_transform_feedback3"); attr.push_back(join("stream = ", geom_stream)); } if (!attr.empty()) statement("layout(", merge(attr), ") out gl_PerVertex"); else statement("out gl_PerVertex"); } else { // If we have passthrough, there is no way PerVertex cannot be passthrough. if (get_entry_point().geometry_passthrough) statement("layout(passthrough) in gl_PerVertex"); else statement("in gl_PerVertex"); } begin_scope(); if (emitted_builtins.get(BuiltInPosition)) { auto itr = builtin_xfb_offsets.find(BuiltInPosition); if (itr != end(builtin_xfb_offsets)) statement("layout(xfb_offset = ", itr->second, ") vec4 gl_Position;"); else statement("vec4 gl_Position;"); } if (emitted_builtins.get(BuiltInPointSize)) { auto itr = builtin_xfb_offsets.find(BuiltInPointSize); if (itr != end(builtin_xfb_offsets)) statement("layout(xfb_offset = ", itr->second, ") float gl_PointSize;"); else statement("float gl_PointSize;"); } if (emitted_builtins.get(BuiltInClipDistance)) { auto itr = builtin_xfb_offsets.find(BuiltInClipDistance); if (itr != end(builtin_xfb_offsets)) statement("layout(xfb_offset = ", itr->second, ") float gl_ClipDistance[", clip_distance_size, "];"); else statement("float gl_ClipDistance[", clip_distance_size, "];"); } if (emitted_builtins.get(BuiltInCullDistance)) { auto itr = builtin_xfb_offsets.find(BuiltInCullDistance); if (itr != end(builtin_xfb_offsets)) statement("layout(xfb_offset = ", itr->second, ") float gl_CullDistance[", cull_distance_size, "];"); else statement("float gl_CullDistance[", cull_distance_size, "];"); } if (builtin_array) { if (model == ExecutionModelTessellationControl && storage == StorageClassOutput) end_scope_decl(join(to_name(block_var->self), "[", get_entry_point().output_vertices, "]")); else end_scope_decl(join(to_name(block_var->self), "[]")); } else end_scope_decl(); statement(""); } void CompilerGLSL::declare_undefined_values() { bool emitted = false; ir.for_each_typed_id([&](uint32_t, const SPIRUndef &undef) { auto &type = this->get(undef.basetype); // OpUndef can be void for some reason ... if (type.basetype == SPIRType::Void) return; string initializer; if (options.force_zero_initialized_variables && type_can_zero_initialize(type)) initializer = join(" = ", to_zero_initialized_expression(undef.basetype)); statement(variable_decl(type, to_name(undef.self), undef.self), initializer, ";"); emitted = true; }); if (emitted) statement(""); } bool CompilerGLSL::variable_is_lut(const SPIRVariable &var) const { bool statically_assigned = var.statically_assigned && var.static_expression != ID(0) && var.remapped_variable; if (statically_assigned) { auto *constant = maybe_get(var.static_expression); if (constant && constant->is_used_as_lut) return true; } return false; } void CompilerGLSL::emit_resources() { auto &execution = get_entry_point(); replace_illegal_names(); // Legacy GL uses gl_FragData[], redeclare all fragment outputs // with builtins. if (execution.model == ExecutionModelFragment && is_legacy()) replace_fragment_outputs(); // Emit PLS blocks if we have such variables. if (!pls_inputs.empty() || !pls_outputs.empty()) emit_pls(); switch (execution.model) { case ExecutionModelGeometry: case ExecutionModelTessellationControl: case ExecutionModelTessellationEvaluation: fixup_implicit_builtin_block_names(); break; default: break; } // Emit custom gl_PerVertex for SSO compatibility. if (options.separate_shader_objects && !options.es && execution.model != ExecutionModelFragment) { switch (execution.model) { case ExecutionModelGeometry: case ExecutionModelTessellationControl: case ExecutionModelTessellationEvaluation: emit_declared_builtin_block(StorageClassInput, execution.model); emit_declared_builtin_block(StorageClassOutput, execution.model); break; case ExecutionModelVertex: emit_declared_builtin_block(StorageClassOutput, execution.model); break; default: break; } } else if (should_force_emit_builtin_block(StorageClassOutput)) { emit_declared_builtin_block(StorageClassOutput, execution.model); } else if (execution.geometry_passthrough) { // Need to declare gl_in with Passthrough. // If we're doing passthrough, we cannot emit an output block, so the output block test above will never pass. emit_declared_builtin_block(StorageClassInput, execution.model); } else { // Need to redeclare clip/cull distance with explicit size to use them. // SPIR-V mandates these builtins have a size declared. const char *storage = execution.model == ExecutionModelFragment ? "in" : "out"; if (clip_distance_count != 0) statement(storage, " float gl_ClipDistance[", clip_distance_count, "];"); if (cull_distance_count != 0) statement(storage, " float gl_CullDistance[", cull_distance_count, "];"); if (clip_distance_count != 0 || cull_distance_count != 0) statement(""); } if (position_invariant) { statement("invariant gl_Position;"); statement(""); } bool emitted = false; // If emitted Vulkan GLSL, // emit specialization constants as actual floats, // spec op expressions will redirect to the constant name. // { auto loop_lock = ir.create_loop_hard_lock(); for (auto &id_ : ir.ids_for_constant_or_type) { auto &id = ir.ids[id_]; if (id.get_type() == TypeConstant) { auto &c = id.get(); bool needs_declaration = c.specialization || c.is_used_as_lut; if (needs_declaration) { if (!options.vulkan_semantics && c.specialization) { c.specialization_constant_macro_name = constant_value_macro_name(get_decoration(c.self, DecorationSpecId)); } emit_constant(c); emitted = true; } } else if (id.get_type() == TypeConstantOp) { emit_specialization_constant_op(id.get()); emitted = true; } else if (id.get_type() == TypeType) { auto *type = &id.get(); bool is_natural_struct = type->basetype == SPIRType::Struct && type->array.empty() && !type->pointer && (!has_decoration(type->self, DecorationBlock) && !has_decoration(type->self, DecorationBufferBlock)); // Special case, ray payload and hit attribute blocks are not really blocks, just regular structs. if (type->basetype == SPIRType::Struct && type->pointer && has_decoration(type->self, DecorationBlock) && (type->storage == StorageClassRayPayloadKHR || type->storage == StorageClassIncomingRayPayloadKHR || type->storage == StorageClassHitAttributeKHR)) { type = &get(type->parent_type); is_natural_struct = true; } if (is_natural_struct) { if (emitted) statement(""); emitted = false; emit_struct(*type); } } } } if (emitted) statement(""); // If we needed to declare work group size late, check here. // If the work group size depends on a specialization constant, we need to declare the layout() block // after constants (and their macros) have been declared. if (execution.model == ExecutionModelGLCompute && !options.vulkan_semantics && execution.workgroup_size.constant != 0) { SpecializationConstant wg_x, wg_y, wg_z; get_work_group_size_specialization_constants(wg_x, wg_y, wg_z); if ((wg_x.id != ConstantID(0)) || (wg_y.id != ConstantID(0)) || (wg_z.id != ConstantID(0))) { SmallVector inputs; build_workgroup_size(inputs, wg_x, wg_y, wg_z); statement("layout(", merge(inputs), ") in;"); statement(""); } } emitted = false; if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT) { for (auto type : physical_storage_non_block_pointer_types) { emit_buffer_reference_block(get(type), false); } // Output buffer reference blocks. // Do this in two stages, one with forward declaration, // and one without. Buffer reference blocks can reference themselves // to support things like linked lists. ir.for_each_typed_id([&](uint32_t, SPIRType &type) { bool has_block_flags = has_decoration(type.self, DecorationBlock); if (has_block_flags && type.pointer && type.pointer_depth == 1 && !type_is_array_of_pointers(type) && type.storage == StorageClassPhysicalStorageBufferEXT) { emit_buffer_reference_block(type, true); } }); ir.for_each_typed_id([&](uint32_t, SPIRType &type) { bool has_block_flags = has_decoration(type.self, DecorationBlock); if (has_block_flags && type.pointer && type.pointer_depth == 1 && !type_is_array_of_pointers(type) && type.storage == StorageClassPhysicalStorageBufferEXT) { emit_buffer_reference_block(type, false); } }); } // Output UBOs and SSBOs ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool is_block_storage = type.storage == StorageClassStorageBuffer || type.storage == StorageClassUniform || type.storage == StorageClassShaderRecordBufferKHR; bool has_block_flags = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) || ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock); if (var.storage != StorageClassFunction && type.pointer && is_block_storage && !is_hidden_variable(var) && has_block_flags) { emit_buffer_block(var); } }); // Output push constant blocks ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); if (var.storage != StorageClassFunction && type.pointer && type.storage == StorageClassPushConstant && !is_hidden_variable(var)) { emit_push_constant_block(var); } }); bool skip_separate_image_sampler = !combined_image_samplers.empty() || !options.vulkan_semantics; // Output Uniform Constants (values, samplers, images, etc). ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); // If we're remapping separate samplers and images, only emit the combined samplers. if (skip_separate_image_sampler) { // Sampler buffers are always used without a sampler, and they will also work in regular GL. bool sampler_buffer = type.basetype == SPIRType::Image && type.image.dim == DimBuffer; bool separate_image = type.basetype == SPIRType::Image && type.image.sampled == 1; bool separate_sampler = type.basetype == SPIRType::Sampler; if (!sampler_buffer && (separate_image || separate_sampler)) return; } if (var.storage != StorageClassFunction && type.pointer && (type.storage == StorageClassUniformConstant || type.storage == StorageClassAtomicCounter || type.storage == StorageClassRayPayloadKHR || type.storage == StorageClassIncomingRayPayloadKHR || type.storage == StorageClassCallableDataKHR || type.storage == StorageClassIncomingCallableDataKHR || type.storage == StorageClassHitAttributeKHR) && !is_hidden_variable(var)) { emit_uniform(var); emitted = true; } }); if (emitted) statement(""); emitted = false; bool emitted_base_instance = false; // Output in/out interfaces. ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool is_hidden = is_hidden_variable(var); // Unused output I/O variables might still be required to implement framebuffer fetch. if (var.storage == StorageClassOutput && !is_legacy() && inout_color_attachments.count(get_decoration(var.self, DecorationLocation)) != 0) { is_hidden = false; } if (var.storage != StorageClassFunction && type.pointer && (var.storage == StorageClassInput || var.storage == StorageClassOutput) && interface_variable_exists_in_entry_point(var.self) && !is_hidden) { emit_interface_block(var); emitted = true; } else if (is_builtin_variable(var)) { auto builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn)); // For gl_InstanceIndex emulation on GLES, the API user needs to // supply this uniform. // The draw parameter extension is soft-enabled on GL with some fallbacks. if (!options.vulkan_semantics) { if (!emitted_base_instance && ((options.vertex.support_nonzero_base_instance && builtin == BuiltInInstanceIndex) || (builtin == BuiltInBaseInstance))) { statement("#ifdef GL_ARB_shader_draw_parameters"); statement("#define SPIRV_Cross_BaseInstance gl_BaseInstanceARB"); statement("#else"); // A crude, but simple workaround which should be good enough for non-indirect draws. statement("uniform int SPIRV_Cross_BaseInstance;"); statement("#endif"); emitted = true; emitted_base_instance = true; } else if (builtin == BuiltInBaseVertex) { statement("#ifdef GL_ARB_shader_draw_parameters"); statement("#define SPIRV_Cross_BaseVertex gl_BaseVertexARB"); statement("#else"); // A crude, but simple workaround which should be good enough for non-indirect draws. statement("uniform int SPIRV_Cross_BaseVertex;"); statement("#endif"); } else if (builtin == BuiltInDrawIndex) { statement("#ifndef GL_ARB_shader_draw_parameters"); // Cannot really be worked around. statement("#error GL_ARB_shader_draw_parameters is not supported."); statement("#endif"); } } } }); // Global variables. for (auto global : global_variables) { auto &var = get(global); if (var.storage != StorageClassOutput) { if (!variable_is_lut(var)) { add_resource_name(var.self); string initializer; if (options.force_zero_initialized_variables && var.storage == StorageClassPrivate && !var.initializer && !var.static_expression && type_can_zero_initialize(get_variable_data_type(var))) { initializer = join(" = ", to_zero_initialized_expression(get_variable_data_type_id(var))); } statement(variable_decl(var), initializer, ";"); emitted = true; } } else if (var.initializer && maybe_get(var.initializer) != nullptr) { emit_output_variable_initializer(var); } } if (emitted) statement(""); declare_undefined_values(); } void CompilerGLSL::emit_output_variable_initializer(const SPIRVariable &var) { // If a StorageClassOutput variable has an initializer, we need to initialize it in main(). auto &entry_func = this->get(ir.default_entry_point); auto &type = get(var.basetype); bool is_patch = has_decoration(var.self, DecorationPatch); bool is_block = has_decoration(type.self, DecorationBlock); bool is_control_point = get_execution_model() == ExecutionModelTessellationControl && !is_patch; if (is_block) { uint32_t member_count = uint32_t(type.member_types.size()); bool type_is_array = type.array.size() == 1; uint32_t array_size = 1; if (type_is_array) array_size = to_array_size_literal(type); uint32_t iteration_count = is_control_point ? 1 : array_size; // If the initializer is a block, we must initialize each block member one at a time. for (uint32_t i = 0; i < member_count; i++) { // These outputs might not have been properly declared, so don't initialize them in that case. if (has_member_decoration(type.self, i, DecorationBuiltIn)) { if (get_member_decoration(type.self, i, DecorationBuiltIn) == BuiltInCullDistance && !cull_distance_count) continue; if (get_member_decoration(type.self, i, DecorationBuiltIn) == BuiltInClipDistance && !clip_distance_count) continue; } // We need to build a per-member array first, essentially transposing from AoS to SoA. // This code path hits when we have an array of blocks. string lut_name; if (type_is_array) { lut_name = join("_", var.self, "_", i, "_init"); uint32_t member_type_id = get(var.basetype).member_types[i]; auto &member_type = get(member_type_id); auto array_type = member_type; array_type.parent_type = member_type_id; array_type.array.push_back(array_size); array_type.array_size_literal.push_back(true); SmallVector exprs; exprs.reserve(array_size); auto &c = get(var.initializer); for (uint32_t j = 0; j < array_size; j++) exprs.push_back(to_expression(get(c.subconstants[j]).subconstants[i])); statement("const ", type_to_glsl(array_type), " ", lut_name, type_to_array_glsl(array_type), " = ", type_to_glsl_constructor(array_type), "(", merge(exprs, ", "), ");"); } for (uint32_t j = 0; j < iteration_count; j++) { entry_func.fixup_hooks_in.push_back([=, &var]() { AccessChainMeta meta; auto &c = this->get(var.initializer); uint32_t invocation_id = 0; uint32_t member_index_id = 0; if (is_control_point) { uint32_t ids = ir.increase_bound_by(3); SPIRType uint_type; uint_type.basetype = SPIRType::UInt; uint_type.width = 32; set(ids, uint_type); set(ids + 1, builtin_to_glsl(BuiltInInvocationId, StorageClassInput), ids, true); set(ids + 2, ids, i, false); invocation_id = ids + 1; member_index_id = ids + 2; } if (is_patch) { statement("if (gl_InvocationID == 0)"); begin_scope(); } if (type_is_array && !is_control_point) { uint32_t indices[2] = { j, i }; auto chain = access_chain_internal(var.self, indices, 2, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &meta); statement(chain, " = ", lut_name, "[", j, "];"); } else if (is_control_point) { uint32_t indices[2] = { invocation_id, member_index_id }; auto chain = access_chain_internal(var.self, indices, 2, 0, &meta); statement(chain, " = ", lut_name, "[", builtin_to_glsl(BuiltInInvocationId, StorageClassInput), "];"); } else { auto chain = access_chain_internal(var.self, &i, 1, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &meta); statement(chain, " = ", to_expression(c.subconstants[i]), ";"); } if (is_patch) end_scope(); }); } } } else if (is_control_point) { auto lut_name = join("_", var.self, "_init"); statement("const ", type_to_glsl(type), " ", lut_name, type_to_array_glsl(type), " = ", to_expression(var.initializer), ";"); entry_func.fixup_hooks_in.push_back([&, lut_name]() { statement(to_expression(var.self), "[gl_InvocationID] = ", lut_name, "[gl_InvocationID];"); }); } else { auto lut_name = join("_", var.self, "_init"); statement("const ", type_to_glsl(type), " ", lut_name, type_to_array_glsl(type), " = ", to_expression(var.initializer), ";"); entry_func.fixup_hooks_in.push_back([&, lut_name, is_patch]() { if (is_patch) { statement("if (gl_InvocationID == 0)"); begin_scope(); } statement(to_expression(var.self), " = ", lut_name, ";"); if (is_patch) end_scope(); }); } } void CompilerGLSL::emit_extension_workarounds(spv::ExecutionModel model) { static const char *workaround_types[] = { "int", "ivec2", "ivec3", "ivec4", "uint", "uvec2", "uvec3", "uvec4", "float", "vec2", "vec3", "vec4", "double", "dvec2", "dvec3", "dvec4" }; if (!options.vulkan_semantics) { using Supp = ShaderSubgroupSupportHelper; auto result = shader_subgroup_supporter.resolve(); if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupMask)) { auto exts = Supp::get_candidates_for_feature(Supp::SubgroupMask, result); for (auto &e : exts) { const char *name = Supp::get_extension_name(e); statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")"); switch (e) { case Supp::NV_shader_thread_group: statement("#define gl_SubgroupEqMask uvec4(gl_ThreadEqMaskNV, 0u, 0u, 0u)"); statement("#define gl_SubgroupGeMask uvec4(gl_ThreadGeMaskNV, 0u, 0u, 0u)"); statement("#define gl_SubgroupGtMask uvec4(gl_ThreadGtMaskNV, 0u, 0u, 0u)"); statement("#define gl_SubgroupLeMask uvec4(gl_ThreadLeMaskNV, 0u, 0u, 0u)"); statement("#define gl_SubgroupLtMask uvec4(gl_ThreadLtMaskNV, 0u, 0u, 0u)"); break; case Supp::ARB_shader_ballot: statement("#define gl_SubgroupEqMask uvec4(unpackUint2x32(gl_SubGroupEqMaskARB), 0u, 0u)"); statement("#define gl_SubgroupGeMask uvec4(unpackUint2x32(gl_SubGroupGeMaskARB), 0u, 0u)"); statement("#define gl_SubgroupGtMask uvec4(unpackUint2x32(gl_SubGroupGtMaskARB), 0u, 0u)"); statement("#define gl_SubgroupLeMask uvec4(unpackUint2x32(gl_SubGroupLeMaskARB), 0u, 0u)"); statement("#define gl_SubgroupLtMask uvec4(unpackUint2x32(gl_SubGroupLtMaskARB), 0u, 0u)"); break; default: break; } } statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupSize)) { auto exts = Supp::get_candidates_for_feature(Supp::SubgroupSize, result); for (auto &e : exts) { const char *name = Supp::get_extension_name(e); statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")"); switch (e) { case Supp::NV_shader_thread_group: statement("#define gl_SubgroupSize gl_WarpSizeNV"); break; case Supp::ARB_shader_ballot: statement("#define gl_SubgroupSize gl_SubGroupSizeARB"); break; case Supp::AMD_gcn_shader: statement("#define gl_SubgroupSize uint(gl_SIMDGroupSizeAMD)"); break; default: break; } } statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupInvocationID)) { auto exts = Supp::get_candidates_for_feature(Supp::SubgroupInvocationID, result); for (auto &e : exts) { const char *name = Supp::get_extension_name(e); statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")"); switch (e) { case Supp::NV_shader_thread_group: statement("#define gl_SubgroupInvocationID gl_ThreadInWarpNV"); break; case Supp::ARB_shader_ballot: statement("#define gl_SubgroupInvocationID gl_SubGroupInvocationARB"); break; default: break; } } statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupID)) { auto exts = Supp::get_candidates_for_feature(Supp::SubgroupID, result); for (auto &e : exts) { const char *name = Supp::get_extension_name(e); statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")"); switch (e) { case Supp::NV_shader_thread_group: statement("#define gl_SubgroupID gl_WarpIDNV"); break; default: break; } } statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::NumSubgroups)) { auto exts = Supp::get_candidates_for_feature(Supp::NumSubgroups, result); for (auto &e : exts) { const char *name = Supp::get_extension_name(e); statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")"); switch (e) { case Supp::NV_shader_thread_group: statement("#define gl_NumSubgroups gl_WarpsPerSMNV"); break; default: break; } } statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBroadcast_First)) { auto exts = Supp::get_candidates_for_feature(Supp::SubgroupBroadcast_First, result); for (auto &e : exts) { const char *name = Supp::get_extension_name(e); statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")"); switch (e) { case Supp::NV_shader_thread_shuffle: for (const char *t : workaround_types) { statement(t, " subgroupBroadcastFirst(", t, " value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); }"); } for (const char *t : workaround_types) { statement(t, " subgroupBroadcast(", t, " value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); }"); } break; case Supp::ARB_shader_ballot: for (const char *t : workaround_types) { statement(t, " subgroupBroadcastFirst(", t, " value) { return readFirstInvocationARB(value); }"); } for (const char *t : workaround_types) { statement(t, " subgroupBroadcast(", t, " value, uint id) { return readInvocationARB(value, id); }"); } break; default: break; } } statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBallotFindLSB_MSB)) { auto exts = Supp::get_candidates_for_feature(Supp::SubgroupBallotFindLSB_MSB, result); for (auto &e : exts) { const char *name = Supp::get_extension_name(e); statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")"); switch (e) { case Supp::NV_shader_thread_group: statement("uint subgroupBallotFindLSB(uvec4 value) { return findLSB(value.x); }"); statement("uint subgroupBallotFindMSB(uvec4 value) { return findMSB(value.x); }"); break; default: break; } } statement("#else"); statement("uint subgroupBallotFindLSB(uvec4 value)"); begin_scope(); statement("int firstLive = findLSB(value.x);"); statement("return uint(firstLive != -1 ? firstLive : (findLSB(value.y) + 32));"); end_scope(); statement("uint subgroupBallotFindMSB(uvec4 value)"); begin_scope(); statement("int firstLive = findMSB(value.y);"); statement("return uint(firstLive != -1 ? (firstLive + 32) : findMSB(value.x));"); end_scope(); statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupAll_Any_AllEqualBool)) { auto exts = Supp::get_candidates_for_feature(Supp::SubgroupAll_Any_AllEqualBool, result); for (auto &e : exts) { const char *name = Supp::get_extension_name(e); statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")"); switch (e) { case Supp::NV_gpu_shader_5: statement("bool subgroupAll(bool value) { return allThreadsNV(value); }"); statement("bool subgroupAny(bool value) { return anyThreadNV(value); }"); statement("bool subgroupAllEqual(bool value) { return allThreadsEqualNV(value); }"); break; case Supp::ARB_shader_group_vote: statement("bool subgroupAll(bool v) { return allInvocationsARB(v); }"); statement("bool subgroupAny(bool v) { return anyInvocationARB(v); }"); statement("bool subgroupAllEqual(bool v) { return allInvocationsEqualARB(v); }"); break; case Supp::AMD_gcn_shader: statement("bool subgroupAll(bool value) { return ballotAMD(value) == ballotAMD(true); }"); statement("bool subgroupAny(bool value) { return ballotAMD(value) != 0ull; }"); statement("bool subgroupAllEqual(bool value) { uint64_t b = ballotAMD(value); return b == 0ull || " "b == ballotAMD(true); }"); break; default: break; } } statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupAllEqualT)) { statement("#ifndef GL_KHR_shader_subgroup_vote"); statement( "#define _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(type) bool subgroupAllEqual(type value) { return " "subgroupAllEqual(subgroupBroadcastFirst(value) == value); }"); for (const char *t : workaround_types) statement("_SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(", t, ")"); statement("#undef _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND"); statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBallot)) { auto exts = Supp::get_candidates_for_feature(Supp::SubgroupBallot, result); for (auto &e : exts) { const char *name = Supp::get_extension_name(e); statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")"); switch (e) { case Supp::NV_shader_thread_group: statement("uvec4 subgroupBallot(bool v) { return uvec4(ballotThreadNV(v), 0u, 0u, 0u); }"); break; case Supp::ARB_shader_ballot: statement("uvec4 subgroupBallot(bool v) { return uvec4(unpackUint2x32(ballotARB(v)), 0u, 0u); }"); break; default: break; } } statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupElect)) { statement("#ifndef GL_KHR_shader_subgroup_basic"); statement("bool subgroupElect()"); begin_scope(); statement("uvec4 activeMask = subgroupBallot(true);"); statement("uint firstLive = subgroupBallotFindLSB(activeMask);"); statement("return gl_SubgroupInvocationID == firstLive;"); end_scope(); statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBarrier)) { // Extensions we're using in place of GL_KHR_shader_subgroup_basic state // that subgroup execute in lockstep so this barrier is implicit. // However the GL 4.6 spec also states that `barrier` implies a shared memory barrier, // and a specific test of optimizing scans by leveraging lock-step invocation execution, // has shown that a `memoryBarrierShared` is needed in place of a `subgroupBarrier`. // https://github.com/buildaworldnet/IrrlichtBAW/commit/d8536857991b89a30a6b65d29441e51b64c2c7ad#diff-9f898d27be1ea6fc79b03d9b361e299334c1a347b6e4dc344ee66110c6aa596aR19 statement("#ifndef GL_KHR_shader_subgroup_basic"); statement("void subgroupBarrier() { memoryBarrierShared(); }"); statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupMemBarrier)) { if (model == spv::ExecutionModelGLCompute) { statement("#ifndef GL_KHR_shader_subgroup_basic"); statement("void subgroupMemoryBarrier() { groupMemoryBarrier(); }"); statement("void subgroupMemoryBarrierBuffer() { groupMemoryBarrier(); }"); statement("void subgroupMemoryBarrierShared() { memoryBarrierShared(); }"); statement("void subgroupMemoryBarrierImage() { groupMemoryBarrier(); }"); statement("#endif"); } else { statement("#ifndef GL_KHR_shader_subgroup_basic"); statement("void subgroupMemoryBarrier() { memoryBarrier(); }"); statement("void subgroupMemoryBarrierBuffer() { memoryBarrierBuffer(); }"); statement("void subgroupMemoryBarrierImage() { memoryBarrierImage(); }"); statement("#endif"); } statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupInverseBallot_InclBitCount_ExclBitCout)) { statement("#ifndef GL_KHR_shader_subgroup_ballot"); statement("bool subgroupInverseBallot(uvec4 value)"); begin_scope(); statement("return any(notEqual(value.xy & gl_SubgroupEqMask.xy, uvec2(0u)));"); end_scope(); statement("uint subgroupBallotInclusiveBitCount(uvec4 value)"); begin_scope(); statement("uvec2 v = value.xy & gl_SubgroupLeMask.xy;"); statement("ivec2 c = bitCount(v);"); statement_no_indent("#ifdef GL_NV_shader_thread_group"); statement("return uint(c.x);"); statement_no_indent("#else"); statement("return uint(c.x + c.y);"); statement_no_indent("#endif"); end_scope(); statement("uint subgroupBallotExclusiveBitCount(uvec4 value)"); begin_scope(); statement("uvec2 v = value.xy & gl_SubgroupLtMask.xy;"); statement("ivec2 c = bitCount(v);"); statement_no_indent("#ifdef GL_NV_shader_thread_group"); statement("return uint(c.x);"); statement_no_indent("#else"); statement("return uint(c.x + c.y);"); statement_no_indent("#endif"); end_scope(); statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBallotBitCount)) { statement("#ifndef GL_KHR_shader_subgroup_ballot"); statement("uint subgroupBallotBitCount(uvec4 value)"); begin_scope(); statement("ivec2 c = bitCount(value.xy);"); statement_no_indent("#ifdef GL_NV_shader_thread_group"); statement("return uint(c.x);"); statement_no_indent("#else"); statement("return uint(c.x + c.y);"); statement_no_indent("#endif"); end_scope(); statement("#endif"); statement(""); } if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBallotBitExtract)) { statement("#ifndef GL_KHR_shader_subgroup_ballot"); statement("bool subgroupBallotBitExtract(uvec4 value, uint index)"); begin_scope(); statement_no_indent("#ifdef GL_NV_shader_thread_group"); statement("uint shifted = value.x >> index;"); statement_no_indent("#else"); statement("uint shifted = value[index >> 5u] >> (index & 0x1fu);"); statement_no_indent("#endif"); statement("return (shifted & 1u) != 0u;"); end_scope(); statement("#endif"); statement(""); } } if (!workaround_ubo_load_overload_types.empty()) { for (auto &type_id : workaround_ubo_load_overload_types) { auto &type = get(type_id); statement(type_to_glsl(type), " spvWorkaroundRowMajor(", type_to_glsl(type), " wrap) { return wrap; }"); } statement(""); } if (requires_transpose_2x2) { statement("mat2 spvTranspose(mat2 m)"); begin_scope(); statement("return mat2(m[0][0], m[1][0], m[0][1], m[1][1]);"); end_scope(); statement(""); } if (requires_transpose_3x3) { statement("mat3 spvTranspose(mat3 m)"); begin_scope(); statement("return mat3(m[0][0], m[1][0], m[2][0], m[0][1], m[1][1], m[2][1], m[0][2], m[1][2], m[2][2]);"); end_scope(); statement(""); } if (requires_transpose_4x4) { statement("mat4 spvTranspose(mat4 m)"); begin_scope(); statement("return mat4(m[0][0], m[1][0], m[2][0], m[3][0], m[0][1], m[1][1], m[2][1], m[3][1], m[0][2], " "m[1][2], m[2][2], m[3][2], m[0][3], m[1][3], m[2][3], m[3][3]);"); end_scope(); statement(""); } } // Returns a string representation of the ID, usable as a function arg. // Default is to simply return the expression representation fo the arg ID. // Subclasses may override to modify the return value. string CompilerGLSL::to_func_call_arg(const SPIRFunction::Parameter &, uint32_t id) { // Make sure that we use the name of the original variable, and not the parameter alias. uint32_t name_id = id; auto *var = maybe_get(id); if (var && var->basevariable) name_id = var->basevariable; return to_expression(name_id); } void CompilerGLSL::handle_invalid_expression(uint32_t id) { // We tried to read an invalidated expression. // This means we need another pass at compilation, but next time, force temporary variables so that they cannot be invalidated. forced_temporaries.insert(id); force_recompile(); } // Converts the format of the current expression from packed to unpacked, // by wrapping the expression in a constructor of the appropriate type. // GLSL does not support packed formats, so simply return the expression. // Subclasses that do will override. string CompilerGLSL::unpack_expression_type(string expr_str, const SPIRType &, uint32_t, bool, bool) { return expr_str; } // Sometimes we proactively enclosed an expression where it turns out we might have not needed it after all. void CompilerGLSL::strip_enclosed_expression(string &expr) { if (expr.size() < 2 || expr.front() != '(' || expr.back() != ')') return; // Have to make sure that our first and last parens actually enclose everything inside it. uint32_t paren_count = 0; for (auto &c : expr) { if (c == '(') paren_count++; else if (c == ')') { paren_count--; // If we hit 0 and this is not the final char, our first and final parens actually don't // enclose the expression, and we cannot strip, e.g.: (a + b) * (c + d). if (paren_count == 0 && &c != &expr.back()) return; } } expr.erase(expr.size() - 1, 1); expr.erase(begin(expr)); } string CompilerGLSL::enclose_expression(const string &expr) { bool need_parens = false; // If the expression starts with a unary we need to enclose to deal with cases where we have back-to-back // unary expressions. if (!expr.empty()) { auto c = expr.front(); if (c == '-' || c == '+' || c == '!' || c == '~' || c == '&' || c == '*') need_parens = true; } if (!need_parens) { uint32_t paren_count = 0; for (auto c : expr) { if (c == '(' || c == '[') paren_count++; else if (c == ')' || c == ']') { assert(paren_count); paren_count--; } else if (c == ' ' && paren_count == 0) { need_parens = true; break; } } assert(paren_count == 0); } // If this expression contains any spaces which are not enclosed by parentheses, // we need to enclose it so we can treat the whole string as an expression. // This happens when two expressions have been part of a binary op earlier. if (need_parens) return join('(', expr, ')'); else return expr; } string CompilerGLSL::dereference_expression(const SPIRType &expr_type, const std::string &expr) { // If this expression starts with an address-of operator ('&'), then // just return the part after the operator. // TODO: Strip parens if unnecessary? if (expr.front() == '&') return expr.substr(1); else if (backend.native_pointers) return join('*', expr); else if (expr_type.storage == StorageClassPhysicalStorageBufferEXT && expr_type.basetype != SPIRType::Struct && expr_type.pointer_depth == 1) { return join(enclose_expression(expr), ".value"); } else return expr; } string CompilerGLSL::address_of_expression(const std::string &expr) { if (expr.size() > 3 && expr[0] == '(' && expr[1] == '*' && expr.back() == ')') { // If we have an expression which looks like (*foo), taking the address of it is the same as stripping // the first two and last characters. We might have to enclose the expression. // This doesn't work for cases like (*foo + 10), // but this is an r-value expression which we cannot take the address of anyways. return enclose_expression(expr.substr(2, expr.size() - 3)); } else if (expr.front() == '*') { // If this expression starts with a dereference operator ('*'), then // just return the part after the operator. return expr.substr(1); } else return join('&', enclose_expression(expr)); } // Just like to_expression except that we enclose the expression inside parentheses if needed. string CompilerGLSL::to_enclosed_expression(uint32_t id, bool register_expression_read) { return enclose_expression(to_expression(id, register_expression_read)); } // Used explicitly when we want to read a row-major expression, but without any transpose shenanigans. // need_transpose must be forced to false. string CompilerGLSL::to_unpacked_row_major_matrix_expression(uint32_t id) { return unpack_expression_type(to_expression(id), expression_type(id), get_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID), has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked), true); } string CompilerGLSL::to_unpacked_expression(uint32_t id, bool register_expression_read) { // If we need to transpose, it will also take care of unpacking rules. auto *e = maybe_get(id); bool need_transpose = e && e->need_transpose; bool is_remapped = has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID); bool is_packed = has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked); if (!need_transpose && (is_remapped || is_packed)) { return unpack_expression_type(to_expression(id, register_expression_read), get_pointee_type(expression_type_id(id)), get_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID), has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked), false); } else return to_expression(id, register_expression_read); } string CompilerGLSL::to_enclosed_unpacked_expression(uint32_t id, bool register_expression_read) { // If we need to transpose, it will also take care of unpacking rules. auto *e = maybe_get(id); bool need_transpose = e && e->need_transpose; bool is_remapped = has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID); bool is_packed = has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked); if (!need_transpose && (is_remapped || is_packed)) { return unpack_expression_type(to_expression(id, register_expression_read), expression_type(id), get_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID), has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked), false); } else return to_enclosed_expression(id, register_expression_read); } string CompilerGLSL::to_dereferenced_expression(uint32_t id, bool register_expression_read) { auto &type = expression_type(id); if (type.pointer && should_dereference(id)) return dereference_expression(type, to_enclosed_expression(id, register_expression_read)); else return to_expression(id, register_expression_read); } string CompilerGLSL::to_pointer_expression(uint32_t id, bool register_expression_read) { auto &type = expression_type(id); if (type.pointer && expression_is_lvalue(id) && !should_dereference(id)) return address_of_expression(to_enclosed_expression(id, register_expression_read)); else return to_unpacked_expression(id, register_expression_read); } string CompilerGLSL::to_enclosed_pointer_expression(uint32_t id, bool register_expression_read) { auto &type = expression_type(id); if (type.pointer && expression_is_lvalue(id) && !should_dereference(id)) return address_of_expression(to_enclosed_expression(id, register_expression_read)); else return to_enclosed_unpacked_expression(id, register_expression_read); } string CompilerGLSL::to_extract_component_expression(uint32_t id, uint32_t index) { auto expr = to_enclosed_expression(id); if (has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked)) return join(expr, "[", index, "]"); else return join(expr, ".", index_to_swizzle(index)); } string CompilerGLSL::to_rerolled_array_expression(const string &base_expr, const SPIRType &type) { uint32_t size = to_array_size_literal(type); auto &parent = get(type.parent_type); string expr = "{ "; for (uint32_t i = 0; i < size; i++) { auto subexpr = join(base_expr, "[", convert_to_string(i), "]"); if (parent.array.empty()) expr += subexpr; else expr += to_rerolled_array_expression(subexpr, parent); if (i + 1 < size) expr += ", "; } expr += " }"; return expr; } string CompilerGLSL::to_composite_constructor_expression(uint32_t id, bool uses_buffer_offset) { auto &type = expression_type(id); bool reroll_array = !type.array.empty() && (!backend.array_is_value_type || (uses_buffer_offset && !backend.buffer_offset_array_is_value_type)); if (reroll_array) { // For this case, we need to "re-roll" an array initializer from a temporary. // We cannot simply pass the array directly, since it decays to a pointer and it cannot // participate in a struct initializer. E.g. // float arr[2] = { 1.0, 2.0 }; // Foo foo = { arr }; must be transformed to // Foo foo = { { arr[0], arr[1] } }; // The array sizes cannot be deduced from specialization constants since we cannot use any loops. // We're only triggering one read of the array expression, but this is fine since arrays have to be declared // as temporaries anyways. return to_rerolled_array_expression(to_enclosed_expression(id), type); } else return to_unpacked_expression(id); } string CompilerGLSL::to_expression(uint32_t id, bool register_expression_read) { auto itr = invalid_expressions.find(id); if (itr != end(invalid_expressions)) handle_invalid_expression(id); if (ir.ids[id].get_type() == TypeExpression) { // We might have a more complex chain of dependencies. // A possible scenario is that we // // %1 = OpLoad // %2 = OpDoSomething %1 %1. here %2 will have a dependency on %1. // %3 = OpDoSomethingAgain %2 %2. Here %3 will lose the link to %1 since we don't propagate the dependencies like that. // OpStore %1 %foo // Here we can invalidate %1, and hence all expressions which depend on %1. Only %2 will know since it's part of invalid_expressions. // %4 = OpDoSomethingAnotherTime %3 %3 // If we forward all expressions we will see %1 expression after store, not before. // // However, we can propagate up a list of depended expressions when we used %2, so we can check if %2 is invalid when reading %3 after the store, // and see that we should not forward reads of the original variable. auto &expr = get(id); for (uint32_t dep : expr.expression_dependencies) if (invalid_expressions.find(dep) != end(invalid_expressions)) handle_invalid_expression(dep); } if (register_expression_read) track_expression_read(id); switch (ir.ids[id].get_type()) { case TypeExpression: { auto &e = get(id); if (e.base_expression) return to_enclosed_expression(e.base_expression) + e.expression; else if (e.need_transpose) { // This should not be reached for access chains, since we always deal explicitly with transpose state // when consuming an access chain expression. uint32_t physical_type_id = get_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID); bool is_packed = has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked); return convert_row_major_matrix(e.expression, get(e.expression_type), physical_type_id, is_packed); } else if (flattened_structs.count(id)) { return load_flattened_struct(e.expression, get(e.expression_type)); } else { if (is_forcing_recompilation()) { // During first compilation phase, certain expression patterns can trigger exponential growth of memory. // Avoid this by returning dummy expressions during this phase. // Do not use empty expressions here, because those are sentinels for other cases. return "_"; } else return e.expression; } } case TypeConstant: { auto &c = get(id); auto &type = get(c.constant_type); // WorkGroupSize may be a constant. auto &dec = ir.meta[c.self].decoration; if (dec.builtin) return builtin_to_glsl(dec.builtin_type, StorageClassGeneric); else if (c.specialization) return to_name(id); else if (c.is_used_as_lut) return to_name(id); else if (type.basetype == SPIRType::Struct && !backend.can_declare_struct_inline) return to_name(id); else if (!type.array.empty() && !backend.can_declare_arrays_inline) return to_name(id); else return constant_expression(c); } case TypeConstantOp: return to_name(id); case TypeVariable: { auto &var = get(id); // If we try to use a loop variable before the loop header, we have to redirect it to the static expression, // the variable has not been declared yet. if (var.statically_assigned || (var.loop_variable && !var.loop_variable_enable)) return to_expression(var.static_expression); else if (var.deferred_declaration) { var.deferred_declaration = false; return variable_decl(var); } else if (flattened_structs.count(id)) { return load_flattened_struct(to_name(id), get(var.basetype)); } else { auto &dec = ir.meta[var.self].decoration; if (dec.builtin) return builtin_to_glsl(dec.builtin_type, var.storage); else return to_name(id); } } case TypeCombinedImageSampler: // This type should never be taken the expression of directly. // The intention is that texture sampling functions will extract the image and samplers // separately and take their expressions as needed. // GLSL does not use this type because OpSampledImage immediately creates a combined image sampler // expression ala sampler2D(texture, sampler). SPIRV_CROSS_THROW("Combined image samplers have no default expression representation."); case TypeAccessChain: // We cannot express this type. They only have meaning in other OpAccessChains, OpStore or OpLoad. SPIRV_CROSS_THROW("Access chains have no default expression representation."); default: return to_name(id); } } string CompilerGLSL::constant_op_expression(const SPIRConstantOp &cop) { auto &type = get(cop.basetype); bool binary = false; bool unary = false; string op; if (is_legacy() && is_unsigned_opcode(cop.opcode)) SPIRV_CROSS_THROW("Unsigned integers are not supported on legacy targets."); // TODO: Find a clean way to reuse emit_instruction. switch (cop.opcode) { case OpSConvert: case OpUConvert: case OpFConvert: op = type_to_glsl_constructor(type); break; #define GLSL_BOP(opname, x) \ case Op##opname: \ binary = true; \ op = x; \ break #define GLSL_UOP(opname, x) \ case Op##opname: \ unary = true; \ op = x; \ break GLSL_UOP(SNegate, "-"); GLSL_UOP(Not, "~"); GLSL_BOP(IAdd, "+"); GLSL_BOP(ISub, "-"); GLSL_BOP(IMul, "*"); GLSL_BOP(SDiv, "/"); GLSL_BOP(UDiv, "/"); GLSL_BOP(UMod, "%"); GLSL_BOP(SMod, "%"); GLSL_BOP(ShiftRightLogical, ">>"); GLSL_BOP(ShiftRightArithmetic, ">>"); GLSL_BOP(ShiftLeftLogical, "<<"); GLSL_BOP(BitwiseOr, "|"); GLSL_BOP(BitwiseXor, "^"); GLSL_BOP(BitwiseAnd, "&"); GLSL_BOP(LogicalOr, "||"); GLSL_BOP(LogicalAnd, "&&"); GLSL_UOP(LogicalNot, "!"); GLSL_BOP(LogicalEqual, "=="); GLSL_BOP(LogicalNotEqual, "!="); GLSL_BOP(IEqual, "=="); GLSL_BOP(INotEqual, "!="); GLSL_BOP(ULessThan, "<"); GLSL_BOP(SLessThan, "<"); GLSL_BOP(ULessThanEqual, "<="); GLSL_BOP(SLessThanEqual, "<="); GLSL_BOP(UGreaterThan, ">"); GLSL_BOP(SGreaterThan, ">"); GLSL_BOP(UGreaterThanEqual, ">="); GLSL_BOP(SGreaterThanEqual, ">="); case OpSelect: { if (cop.arguments.size() < 3) SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp."); // This one is pretty annoying. It's triggered from // uint(bool), int(bool) from spec constants. // In order to preserve its compile-time constness in Vulkan GLSL, // we need to reduce the OpSelect expression back to this simplified model. // If we cannot, fail. if (to_trivial_mix_op(type, op, cop.arguments[2], cop.arguments[1], cop.arguments[0])) { // Implement as a simple cast down below. } else { // Implement a ternary and pray the compiler understands it :) return to_ternary_expression(type, cop.arguments[0], cop.arguments[1], cop.arguments[2]); } break; } case OpVectorShuffle: { string expr = type_to_glsl_constructor(type); expr += "("; uint32_t left_components = expression_type(cop.arguments[0]).vecsize; string left_arg = to_enclosed_expression(cop.arguments[0]); string right_arg = to_enclosed_expression(cop.arguments[1]); for (uint32_t i = 2; i < uint32_t(cop.arguments.size()); i++) { uint32_t index = cop.arguments[i]; if (index >= left_components) expr += right_arg + "." + "xyzw"[index - left_components]; else expr += left_arg + "." + "xyzw"[index]; if (i + 1 < uint32_t(cop.arguments.size())) expr += ", "; } expr += ")"; return expr; } case OpCompositeExtract: { auto expr = access_chain_internal(cop.arguments[0], &cop.arguments[1], uint32_t(cop.arguments.size() - 1), ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr); return expr; } case OpCompositeInsert: SPIRV_CROSS_THROW("OpCompositeInsert spec constant op is not supported."); default: // Some opcodes are unimplemented here, these are currently not possible to test from glslang. SPIRV_CROSS_THROW("Unimplemented spec constant op."); } uint32_t bit_width = 0; if (unary || binary || cop.opcode == OpSConvert || cop.opcode == OpUConvert) bit_width = expression_type(cop.arguments[0]).width; SPIRType::BaseType input_type; bool skip_cast_if_equal_type = opcode_is_sign_invariant(cop.opcode); switch (cop.opcode) { case OpIEqual: case OpINotEqual: input_type = to_signed_basetype(bit_width); break; case OpSLessThan: case OpSLessThanEqual: case OpSGreaterThan: case OpSGreaterThanEqual: case OpSMod: case OpSDiv: case OpShiftRightArithmetic: case OpSConvert: case OpSNegate: input_type = to_signed_basetype(bit_width); break; case OpULessThan: case OpULessThanEqual: case OpUGreaterThan: case OpUGreaterThanEqual: case OpUMod: case OpUDiv: case OpShiftRightLogical: case OpUConvert: input_type = to_unsigned_basetype(bit_width); break; default: input_type = type.basetype; break; } #undef GLSL_BOP #undef GLSL_UOP if (binary) { if (cop.arguments.size() < 2) SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp."); string cast_op0; string cast_op1; auto expected_type = binary_op_bitcast_helper(cast_op0, cast_op1, input_type, cop.arguments[0], cop.arguments[1], skip_cast_if_equal_type); if (type.basetype != input_type && type.basetype != SPIRType::Boolean) { expected_type.basetype = input_type; auto expr = bitcast_glsl_op(type, expected_type); expr += '('; expr += join(cast_op0, " ", op, " ", cast_op1); expr += ')'; return expr; } else return join("(", cast_op0, " ", op, " ", cast_op1, ")"); } else if (unary) { if (cop.arguments.size() < 1) SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp."); // Auto-bitcast to result type as needed. // Works around various casting scenarios in glslang as there is no OpBitcast for specialization constants. return join("(", op, bitcast_glsl(type, cop.arguments[0]), ")"); } else if (cop.opcode == OpSConvert || cop.opcode == OpUConvert) { if (cop.arguments.size() < 1) SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp."); auto &arg_type = expression_type(cop.arguments[0]); if (arg_type.width < type.width && input_type != arg_type.basetype) { auto expected = arg_type; expected.basetype = input_type; return join(op, "(", bitcast_glsl(expected, cop.arguments[0]), ")"); } else return join(op, "(", to_expression(cop.arguments[0]), ")"); } else { if (cop.arguments.size() < 1) SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp."); return join(op, "(", to_expression(cop.arguments[0]), ")"); } } string CompilerGLSL::constant_expression(const SPIRConstant &c) { auto &type = get(c.constant_type); if (type.pointer) { return backend.null_pointer_literal; } else if (!c.subconstants.empty()) { // Handles Arrays and structures. string res; // Allow Metal to use the array template to make arrays a value type bool needs_trailing_tracket = false; if (backend.use_initializer_list && backend.use_typed_initializer_list && type.basetype == SPIRType::Struct && type.array.empty()) { res = type_to_glsl_constructor(type) + "{ "; } else if (backend.use_initializer_list && backend.use_typed_initializer_list && backend.array_is_value_type && !type.array.empty()) { res = type_to_glsl_constructor(type) + "({ "; needs_trailing_tracket = true; } else if (backend.use_initializer_list) { res = "{ "; } else { res = type_to_glsl_constructor(type) + "("; } for (auto &elem : c.subconstants) { auto &subc = get(elem); if (subc.specialization) res += to_name(elem); else res += constant_expression(subc); if (&elem != &c.subconstants.back()) res += ", "; } res += backend.use_initializer_list ? " }" : ")"; if (needs_trailing_tracket) res += ")"; return res; } else if (type.basetype == SPIRType::Struct && type.member_types.size() == 0) { // Metal tessellation likes empty structs which are then constant expressions. if (backend.supports_empty_struct) return "{ }"; else if (backend.use_typed_initializer_list) return join(type_to_glsl(get(c.constant_type)), "{ 0 }"); else if (backend.use_initializer_list) return "{ 0 }"; else return join(type_to_glsl(get(c.constant_type)), "(0)"); } else if (c.columns() == 1) { return constant_expression_vector(c, 0); } else { string res = type_to_glsl(get(c.constant_type)) + "("; for (uint32_t col = 0; col < c.columns(); col++) { if (c.specialization_constant_id(col) != 0) res += to_name(c.specialization_constant_id(col)); else res += constant_expression_vector(c, col); if (col + 1 < c.columns()) res += ", "; } res += ")"; return res; } } #ifdef _MSC_VER // sprintf warning. // We cannot rely on snprintf existing because, ..., MSVC. #pragma warning(push) #pragma warning(disable : 4996) #endif string CompilerGLSL::convert_half_to_string(const SPIRConstant &c, uint32_t col, uint32_t row) { string res; float float_value = c.scalar_f16(col, row); // There is no literal "hf" in GL_NV_gpu_shader5, so to avoid lots // of complicated workarounds, just value-cast to the half type always. if (std::isnan(float_value) || std::isinf(float_value)) { SPIRType type; type.basetype = SPIRType::Half; type.vecsize = 1; type.columns = 1; if (float_value == numeric_limits::infinity()) res = join(type_to_glsl(type), "(1.0 / 0.0)"); else if (float_value == -numeric_limits::infinity()) res = join(type_to_glsl(type), "(-1.0 / 0.0)"); else if (std::isnan(float_value)) res = join(type_to_glsl(type), "(0.0 / 0.0)"); else SPIRV_CROSS_THROW("Cannot represent non-finite floating point constant."); } else { SPIRType type; type.basetype = SPIRType::Half; type.vecsize = 1; type.columns = 1; res = join(type_to_glsl(type), "(", convert_to_string(float_value, current_locale_radix_character), ")"); } return res; } string CompilerGLSL::convert_float_to_string(const SPIRConstant &c, uint32_t col, uint32_t row) { string res; float float_value = c.scalar_f32(col, row); if (std::isnan(float_value) || std::isinf(float_value)) { // Use special representation. if (!is_legacy()) { SPIRType out_type; SPIRType in_type; out_type.basetype = SPIRType::Float; in_type.basetype = SPIRType::UInt; out_type.vecsize = 1; in_type.vecsize = 1; out_type.width = 32; in_type.width = 32; char print_buffer[32]; sprintf(print_buffer, "0x%xu", c.scalar(col, row)); res = join(bitcast_glsl_op(out_type, in_type), "(", print_buffer, ")"); } else { if (float_value == numeric_limits::infinity()) { if (backend.float_literal_suffix) res = "(1.0f / 0.0f)"; else res = "(1.0 / 0.0)"; } else if (float_value == -numeric_limits::infinity()) { if (backend.float_literal_suffix) res = "(-1.0f / 0.0f)"; else res = "(-1.0 / 0.0)"; } else if (std::isnan(float_value)) { if (backend.float_literal_suffix) res = "(0.0f / 0.0f)"; else res = "(0.0 / 0.0)"; } else SPIRV_CROSS_THROW("Cannot represent non-finite floating point constant."); } } else { res = convert_to_string(float_value, current_locale_radix_character); if (backend.float_literal_suffix) res += "f"; } return res; } std::string CompilerGLSL::convert_double_to_string(const SPIRConstant &c, uint32_t col, uint32_t row) { string res; double double_value = c.scalar_f64(col, row); if (std::isnan(double_value) || std::isinf(double_value)) { // Use special representation. if (!is_legacy()) { SPIRType out_type; SPIRType in_type; out_type.basetype = SPIRType::Double; in_type.basetype = SPIRType::UInt64; out_type.vecsize = 1; in_type.vecsize = 1; out_type.width = 64; in_type.width = 64; uint64_t u64_value = c.scalar_u64(col, row); if (options.es) SPIRV_CROSS_THROW("64-bit integers/float not supported in ES profile."); require_extension_internal("GL_ARB_gpu_shader_int64"); char print_buffer[64]; sprintf(print_buffer, "0x%llx%s", static_cast(u64_value), backend.long_long_literal_suffix ? "ull" : "ul"); res = join(bitcast_glsl_op(out_type, in_type), "(", print_buffer, ")"); } else { if (options.es) SPIRV_CROSS_THROW("FP64 not supported in ES profile."); if (options.version < 400) require_extension_internal("GL_ARB_gpu_shader_fp64"); if (double_value == numeric_limits::infinity()) { if (backend.double_literal_suffix) res = "(1.0lf / 0.0lf)"; else res = "(1.0 / 0.0)"; } else if (double_value == -numeric_limits::infinity()) { if (backend.double_literal_suffix) res = "(-1.0lf / 0.0lf)"; else res = "(-1.0 / 0.0)"; } else if (std::isnan(double_value)) { if (backend.double_literal_suffix) res = "(0.0lf / 0.0lf)"; else res = "(0.0 / 0.0)"; } else SPIRV_CROSS_THROW("Cannot represent non-finite floating point constant."); } } else { res = convert_to_string(double_value, current_locale_radix_character); if (backend.double_literal_suffix) res += "lf"; } return res; } #ifdef _MSC_VER #pragma warning(pop) #endif string CompilerGLSL::constant_expression_vector(const SPIRConstant &c, uint32_t vector) { auto type = get(c.constant_type); type.columns = 1; auto scalar_type = type; scalar_type.vecsize = 1; string res; bool splat = backend.use_constructor_splatting && c.vector_size() > 1; bool swizzle_splat = backend.can_swizzle_scalar && c.vector_size() > 1; if (!type_is_floating_point(type)) { // Cannot swizzle literal integers as a special case. swizzle_splat = false; } if (splat || swizzle_splat) { // Cannot use constant splatting if we have specialization constants somewhere in the vector. for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.specialization_constant_id(vector, i) != 0) { splat = false; swizzle_splat = false; break; } } } if (splat || swizzle_splat) { if (type.width == 64) { uint64_t ident = c.scalar_u64(vector, 0); for (uint32_t i = 1; i < c.vector_size(); i++) { if (ident != c.scalar_u64(vector, i)) { splat = false; swizzle_splat = false; break; } } } else { uint32_t ident = c.scalar(vector, 0); for (uint32_t i = 1; i < c.vector_size(); i++) { if (ident != c.scalar(vector, i)) { splat = false; swizzle_splat = false; } } } } if (c.vector_size() > 1 && !swizzle_splat) res += type_to_glsl(type) + "("; switch (type.basetype) { case SPIRType::Half: if (splat || swizzle_splat) { res += convert_half_to_string(c, vector, 0); if (swizzle_splat) res = remap_swizzle(get(c.constant_type), 1, res); } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else res += convert_half_to_string(c, vector, i); if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::Float: if (splat || swizzle_splat) { res += convert_float_to_string(c, vector, 0); if (swizzle_splat) res = remap_swizzle(get(c.constant_type), 1, res); } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else res += convert_float_to_string(c, vector, i); if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::Double: if (splat || swizzle_splat) { res += convert_double_to_string(c, vector, 0); if (swizzle_splat) res = remap_swizzle(get(c.constant_type), 1, res); } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else res += convert_double_to_string(c, vector, i); if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::Int64: if (splat) { res += convert_to_string(c.scalar_i64(vector, 0)); if (backend.long_long_literal_suffix) res += "ll"; else res += "l"; } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else { res += convert_to_string(c.scalar_i64(vector, i)); if (backend.long_long_literal_suffix) res += "ll"; else res += "l"; } if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::UInt64: if (splat) { res += convert_to_string(c.scalar_u64(vector, 0)); if (backend.long_long_literal_suffix) res += "ull"; else res += "ul"; } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else { res += convert_to_string(c.scalar_u64(vector, i)); if (backend.long_long_literal_suffix) res += "ull"; else res += "ul"; } if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::UInt: if (splat) { res += convert_to_string(c.scalar(vector, 0)); if (is_legacy()) { // Fake unsigned constant literals with signed ones if possible. // Things like array sizes, etc, tend to be unsigned even though they could just as easily be signed. if (c.scalar_i32(vector, 0) < 0) SPIRV_CROSS_THROW("Tried to convert uint literal into int, but this made the literal negative."); } else if (backend.uint32_t_literal_suffix) res += "u"; } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else { res += convert_to_string(c.scalar(vector, i)); if (is_legacy()) { // Fake unsigned constant literals with signed ones if possible. // Things like array sizes, etc, tend to be unsigned even though they could just as easily be signed. if (c.scalar_i32(vector, i) < 0) SPIRV_CROSS_THROW("Tried to convert uint literal into int, but this made " "the literal negative."); } else if (backend.uint32_t_literal_suffix) res += "u"; } if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::Int: if (splat) res += convert_to_string(c.scalar_i32(vector, 0)); else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else res += convert_to_string(c.scalar_i32(vector, i)); if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::UShort: if (splat) { res += convert_to_string(c.scalar(vector, 0)); } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else { if (*backend.uint16_t_literal_suffix) { res += convert_to_string(c.scalar_u16(vector, i)); res += backend.uint16_t_literal_suffix; } else { // If backend doesn't have a literal suffix, we need to value cast. res += type_to_glsl(scalar_type); res += "("; res += convert_to_string(c.scalar_u16(vector, i)); res += ")"; } } if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::Short: if (splat) { res += convert_to_string(c.scalar_i16(vector, 0)); } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else { if (*backend.int16_t_literal_suffix) { res += convert_to_string(c.scalar_i16(vector, i)); res += backend.int16_t_literal_suffix; } else { // If backend doesn't have a literal suffix, we need to value cast. res += type_to_glsl(scalar_type); res += "("; res += convert_to_string(c.scalar_i16(vector, i)); res += ")"; } } if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::UByte: if (splat) { res += convert_to_string(c.scalar_u8(vector, 0)); } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else { res += type_to_glsl(scalar_type); res += "("; res += convert_to_string(c.scalar_u8(vector, i)); res += ")"; } if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::SByte: if (splat) { res += convert_to_string(c.scalar_i8(vector, 0)); } else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else { res += type_to_glsl(scalar_type); res += "("; res += convert_to_string(c.scalar_i8(vector, i)); res += ")"; } if (i + 1 < c.vector_size()) res += ", "; } } break; case SPIRType::Boolean: if (splat) res += c.scalar(vector, 0) ? "true" : "false"; else { for (uint32_t i = 0; i < c.vector_size(); i++) { if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) res += to_name(c.specialization_constant_id(vector, i)); else res += c.scalar(vector, i) ? "true" : "false"; if (i + 1 < c.vector_size()) res += ", "; } } break; default: SPIRV_CROSS_THROW("Invalid constant expression basetype."); } if (c.vector_size() > 1 && !swizzle_splat) res += ")"; return res; } SPIRExpression &CompilerGLSL::emit_uninitialized_temporary_expression(uint32_t type, uint32_t id) { forced_temporaries.insert(id); emit_uninitialized_temporary(type, id); return set(id, to_name(id), type, true); } void CompilerGLSL::emit_uninitialized_temporary(uint32_t result_type, uint32_t result_id) { // If we're declaring temporaries inside continue blocks, // we must declare the temporary in the loop header so that the continue block can avoid declaring new variables. if (current_continue_block && !hoisted_temporaries.count(result_id)) { auto &header = get(current_continue_block->loop_dominator); if (find_if(begin(header.declare_temporary), end(header.declare_temporary), [result_type, result_id](const pair &tmp) { return tmp.first == result_type && tmp.second == result_id; }) == end(header.declare_temporary)) { header.declare_temporary.emplace_back(result_type, result_id); hoisted_temporaries.insert(result_id); force_recompile(); } } else if (hoisted_temporaries.count(result_id) == 0) { auto &type = get(result_type); auto &flags = ir.meta[result_id].decoration.decoration_flags; // The result_id has not been made into an expression yet, so use flags interface. add_local_variable_name(result_id); string initializer; if (options.force_zero_initialized_variables && type_can_zero_initialize(type)) initializer = join(" = ", to_zero_initialized_expression(result_type)); statement(flags_to_qualifiers_glsl(type, flags), variable_decl(type, to_name(result_id)), initializer, ";"); } } string CompilerGLSL::declare_temporary(uint32_t result_type, uint32_t result_id) { auto &type = get(result_type); auto &flags = ir.meta[result_id].decoration.decoration_flags; // If we're declaring temporaries inside continue blocks, // we must declare the temporary in the loop header so that the continue block can avoid declaring new variables. if (current_continue_block && !hoisted_temporaries.count(result_id)) { auto &header = get(current_continue_block->loop_dominator); if (find_if(begin(header.declare_temporary), end(header.declare_temporary), [result_type, result_id](const pair &tmp) { return tmp.first == result_type && tmp.second == result_id; }) == end(header.declare_temporary)) { header.declare_temporary.emplace_back(result_type, result_id); hoisted_temporaries.insert(result_id); force_recompile(); } return join(to_name(result_id), " = "); } else if (hoisted_temporaries.count(result_id)) { // The temporary has already been declared earlier, so just "declare" the temporary by writing to it. return join(to_name(result_id), " = "); } else { // The result_id has not been made into an expression yet, so use flags interface. add_local_variable_name(result_id); return join(flags_to_qualifiers_glsl(type, flags), variable_decl(type, to_name(result_id)), " = "); } } bool CompilerGLSL::expression_is_forwarded(uint32_t id) const { return forwarded_temporaries.count(id) != 0; } bool CompilerGLSL::expression_suppresses_usage_tracking(uint32_t id) const { return suppressed_usage_tracking.count(id) != 0; } bool CompilerGLSL::expression_read_implies_multiple_reads(uint32_t id) const { auto *expr = maybe_get(id); if (!expr) return false; // If we're emitting code at a deeper loop level than when we emitted the expression, // we're probably reading the same expression over and over. return current_loop_level > expr->emitted_loop_level; } SPIRExpression &CompilerGLSL::emit_op(uint32_t result_type, uint32_t result_id, const string &rhs, bool forwarding, bool suppress_usage_tracking) { if (forwarding && (forced_temporaries.find(result_id) == end(forced_temporaries))) { // Just forward it without temporary. // If the forward is trivial, we do not force flushing to temporary for this expression. forwarded_temporaries.insert(result_id); if (suppress_usage_tracking) suppressed_usage_tracking.insert(result_id); return set(result_id, rhs, result_type, true); } else { // If expression isn't immutable, bind it to a temporary and make the new temporary immutable (they always are). statement(declare_temporary(result_type, result_id), rhs, ";"); return set(result_id, to_name(result_id), result_type, true); } } void CompilerGLSL::emit_unary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op) { bool forward = should_forward(op0); emit_op(result_type, result_id, join(op, to_enclosed_unpacked_expression(op0)), forward); inherit_expression_dependencies(result_id, op0); } void CompilerGLSL::emit_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op) { bool forward = should_forward(op0) && should_forward(op1); emit_op(result_type, result_id, join(to_enclosed_unpacked_expression(op0), " ", op, " ", to_enclosed_unpacked_expression(op1)), forward); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); } void CompilerGLSL::emit_unrolled_unary_op(uint32_t result_type, uint32_t result_id, uint32_t operand, const char *op) { auto &type = get(result_type); auto expr = type_to_glsl_constructor(type); expr += '('; for (uint32_t i = 0; i < type.vecsize; i++) { // Make sure to call to_expression multiple times to ensure // that these expressions are properly flushed to temporaries if needed. expr += op; expr += to_extract_component_expression(operand, i); if (i + 1 < type.vecsize) expr += ", "; } expr += ')'; emit_op(result_type, result_id, expr, should_forward(operand)); inherit_expression_dependencies(result_id, operand); } void CompilerGLSL::emit_unrolled_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, bool negate, SPIRType::BaseType expected_type) { auto &type0 = expression_type(op0); auto &type1 = expression_type(op1); SPIRType target_type0 = type0; SPIRType target_type1 = type1; target_type0.basetype = expected_type; target_type1.basetype = expected_type; target_type0.vecsize = 1; target_type1.vecsize = 1; auto &type = get(result_type); auto expr = type_to_glsl_constructor(type); expr += '('; for (uint32_t i = 0; i < type.vecsize; i++) { // Make sure to call to_expression multiple times to ensure // that these expressions are properly flushed to temporaries if needed. if (negate) expr += "!("; if (expected_type != SPIRType::Unknown && type0.basetype != expected_type) expr += bitcast_expression(target_type0, type0.basetype, to_extract_component_expression(op0, i)); else expr += to_extract_component_expression(op0, i); expr += ' '; expr += op; expr += ' '; if (expected_type != SPIRType::Unknown && type1.basetype != expected_type) expr += bitcast_expression(target_type1, type1.basetype, to_extract_component_expression(op1, i)); else expr += to_extract_component_expression(op1, i); if (negate) expr += ")"; if (i + 1 < type.vecsize) expr += ", "; } expr += ')'; emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1)); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); } SPIRType CompilerGLSL::binary_op_bitcast_helper(string &cast_op0, string &cast_op1, SPIRType::BaseType &input_type, uint32_t op0, uint32_t op1, bool skip_cast_if_equal_type) { auto &type0 = expression_type(op0); auto &type1 = expression_type(op1); // We have to bitcast if our inputs are of different type, or if our types are not equal to expected inputs. // For some functions like OpIEqual and INotEqual, we don't care if inputs are of different types than expected // since equality test is exactly the same. bool cast = (type0.basetype != type1.basetype) || (!skip_cast_if_equal_type && type0.basetype != input_type); // Create a fake type so we can bitcast to it. // We only deal with regular arithmetic types here like int, uints and so on. SPIRType expected_type; expected_type.basetype = input_type; expected_type.vecsize = type0.vecsize; expected_type.columns = type0.columns; expected_type.width = type0.width; if (cast) { cast_op0 = bitcast_glsl(expected_type, op0); cast_op1 = bitcast_glsl(expected_type, op1); } else { // If we don't cast, our actual input type is that of the first (or second) argument. cast_op0 = to_enclosed_unpacked_expression(op0); cast_op1 = to_enclosed_unpacked_expression(op1); input_type = type0.basetype; } return expected_type; } bool CompilerGLSL::emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0) { // Some bitcasts may require complex casting sequences, and are implemented here. // Otherwise a simply unary function will do with bitcast_glsl_op. auto &output_type = get(result_type); auto &input_type = expression_type(op0); string expr; if (output_type.basetype == SPIRType::Half && input_type.basetype == SPIRType::Float && input_type.vecsize == 1) expr = join("unpackFloat2x16(floatBitsToUint(", to_unpacked_expression(op0), "))"); else if (output_type.basetype == SPIRType::Float && input_type.basetype == SPIRType::Half && input_type.vecsize == 2) expr = join("uintBitsToFloat(packFloat2x16(", to_unpacked_expression(op0), "))"); else return false; emit_op(result_type, id, expr, should_forward(op0)); return true; } void CompilerGLSL::emit_binary_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, SPIRType::BaseType input_type, bool skip_cast_if_equal_type) { string cast_op0, cast_op1; auto expected_type = binary_op_bitcast_helper(cast_op0, cast_op1, input_type, op0, op1, skip_cast_if_equal_type); auto &out_type = get(result_type); // We might have casted away from the result type, so bitcast again. // For example, arithmetic right shift with uint inputs. // Special case boolean outputs since relational opcodes output booleans instead of int/uint. string expr; if (out_type.basetype != input_type && out_type.basetype != SPIRType::Boolean) { expected_type.basetype = input_type; expr = bitcast_glsl_op(out_type, expected_type); expr += '('; expr += join(cast_op0, " ", op, " ", cast_op1); expr += ')'; } else expr += join(cast_op0, " ", op, " ", cast_op1); emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1)); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); } void CompilerGLSL::emit_unary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op) { bool forward = should_forward(op0); emit_op(result_type, result_id, join(op, "(", to_unpacked_expression(op0), ")"), forward); inherit_expression_dependencies(result_id, op0); } void CompilerGLSL::emit_binary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op) { bool forward = should_forward(op0) && should_forward(op1); emit_op(result_type, result_id, join(op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), ")"), forward); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); } void CompilerGLSL::emit_unary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op, SPIRType::BaseType input_type, SPIRType::BaseType expected_result_type) { auto &out_type = get(result_type); auto &expr_type = expression_type(op0); auto expected_type = out_type; // Bit-widths might be different in unary cases because we use it for SConvert/UConvert and friends. expected_type.basetype = input_type; expected_type.width = expr_type.width; string cast_op = expr_type.basetype != input_type ? bitcast_glsl(expected_type, op0) : to_unpacked_expression(op0); string expr; if (out_type.basetype != expected_result_type) { expected_type.basetype = expected_result_type; expected_type.width = out_type.width; expr = bitcast_glsl_op(out_type, expected_type); expr += '('; expr += join(op, "(", cast_op, ")"); expr += ')'; } else { expr += join(op, "(", cast_op, ")"); } emit_op(result_type, result_id, expr, should_forward(op0)); inherit_expression_dependencies(result_id, op0); } // Very special case. Handling bitfieldExtract requires us to deal with different bitcasts of different signs // and different vector sizes all at once. Need a special purpose method here. void CompilerGLSL::emit_trinary_func_op_bitextract(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, const char *op, SPIRType::BaseType expected_result_type, SPIRType::BaseType input_type0, SPIRType::BaseType input_type1, SPIRType::BaseType input_type2) { auto &out_type = get(result_type); auto expected_type = out_type; expected_type.basetype = input_type0; string cast_op0 = expression_type(op0).basetype != input_type0 ? bitcast_glsl(expected_type, op0) : to_unpacked_expression(op0); auto op1_expr = to_unpacked_expression(op1); auto op2_expr = to_unpacked_expression(op2); // Use value casts here instead. Input must be exactly int or uint, but SPIR-V might be 16-bit. expected_type.basetype = input_type1; expected_type.vecsize = 1; string cast_op1 = expression_type(op1).basetype != input_type1 ? join(type_to_glsl_constructor(expected_type), "(", op1_expr, ")") : op1_expr; expected_type.basetype = input_type2; expected_type.vecsize = 1; string cast_op2 = expression_type(op2).basetype != input_type2 ? join(type_to_glsl_constructor(expected_type), "(", op2_expr, ")") : op2_expr; string expr; if (out_type.basetype != expected_result_type) { expected_type.vecsize = out_type.vecsize; expected_type.basetype = expected_result_type; expr = bitcast_glsl_op(out_type, expected_type); expr += '('; expr += join(op, "(", cast_op0, ", ", cast_op1, ", ", cast_op2, ")"); expr += ')'; } else { expr += join(op, "(", cast_op0, ", ", cast_op1, ", ", cast_op2, ")"); } emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1) && should_forward(op2)); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); inherit_expression_dependencies(result_id, op2); } void CompilerGLSL::emit_trinary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, const char *op, SPIRType::BaseType input_type) { auto &out_type = get(result_type); auto expected_type = out_type; expected_type.basetype = input_type; string cast_op0 = expression_type(op0).basetype != input_type ? bitcast_glsl(expected_type, op0) : to_unpacked_expression(op0); string cast_op1 = expression_type(op1).basetype != input_type ? bitcast_glsl(expected_type, op1) : to_unpacked_expression(op1); string cast_op2 = expression_type(op2).basetype != input_type ? bitcast_glsl(expected_type, op2) : to_unpacked_expression(op2); string expr; if (out_type.basetype != input_type) { expr = bitcast_glsl_op(out_type, expected_type); expr += '('; expr += join(op, "(", cast_op0, ", ", cast_op1, ", ", cast_op2, ")"); expr += ')'; } else { expr += join(op, "(", cast_op0, ", ", cast_op1, ", ", cast_op2, ")"); } emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1) && should_forward(op2)); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); inherit_expression_dependencies(result_id, op2); } void CompilerGLSL::emit_binary_func_op_cast_clustered(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, SPIRType::BaseType input_type) { // Special purpose method for implementing clustered subgroup opcodes. // Main difference is that op1 does not participate in any casting, it needs to be a literal. auto &out_type = get(result_type); auto expected_type = out_type; expected_type.basetype = input_type; string cast_op0 = expression_type(op0).basetype != input_type ? bitcast_glsl(expected_type, op0) : to_unpacked_expression(op0); string expr; if (out_type.basetype != input_type) { expr = bitcast_glsl_op(out_type, expected_type); expr += '('; expr += join(op, "(", cast_op0, ", ", to_expression(op1), ")"); expr += ')'; } else { expr += join(op, "(", cast_op0, ", ", to_expression(op1), ")"); } emit_op(result_type, result_id, expr, should_forward(op0)); inherit_expression_dependencies(result_id, op0); } void CompilerGLSL::emit_binary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, SPIRType::BaseType input_type, bool skip_cast_if_equal_type) { string cast_op0, cast_op1; auto expected_type = binary_op_bitcast_helper(cast_op0, cast_op1, input_type, op0, op1, skip_cast_if_equal_type); auto &out_type = get(result_type); // Special case boolean outputs since relational opcodes output booleans instead of int/uint. string expr; if (out_type.basetype != input_type && out_type.basetype != SPIRType::Boolean) { expected_type.basetype = input_type; expr = bitcast_glsl_op(out_type, expected_type); expr += '('; expr += join(op, "(", cast_op0, ", ", cast_op1, ")"); expr += ')'; } else { expr += join(op, "(", cast_op0, ", ", cast_op1, ")"); } emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1)); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); } void CompilerGLSL::emit_trinary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, const char *op) { bool forward = should_forward(op0) && should_forward(op1) && should_forward(op2); emit_op(result_type, result_id, join(op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), ", ", to_unpacked_expression(op2), ")"), forward); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); inherit_expression_dependencies(result_id, op2); } void CompilerGLSL::emit_quaternary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, uint32_t op3, const char *op) { bool forward = should_forward(op0) && should_forward(op1) && should_forward(op2) && should_forward(op3); emit_op(result_type, result_id, join(op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), ", ", to_unpacked_expression(op2), ", ", to_unpacked_expression(op3), ")"), forward); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); inherit_expression_dependencies(result_id, op2); inherit_expression_dependencies(result_id, op3); } void CompilerGLSL::emit_bitfield_insert_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, uint32_t op3, const char *op, SPIRType::BaseType offset_count_type) { // Only need to cast offset/count arguments. Types of base/insert must be same as result type, // and bitfieldInsert is sign invariant. bool forward = should_forward(op0) && should_forward(op1) && should_forward(op2) && should_forward(op3); auto op0_expr = to_unpacked_expression(op0); auto op1_expr = to_unpacked_expression(op1); auto op2_expr = to_unpacked_expression(op2); auto op3_expr = to_unpacked_expression(op3); SPIRType target_type; target_type.vecsize = 1; target_type.basetype = offset_count_type; if (expression_type(op2).basetype != offset_count_type) { // Value-cast here. Input might be 16-bit. GLSL requires int. op2_expr = join(type_to_glsl_constructor(target_type), "(", op2_expr, ")"); } if (expression_type(op3).basetype != offset_count_type) { // Value-cast here. Input might be 16-bit. GLSL requires int. op3_expr = join(type_to_glsl_constructor(target_type), "(", op3_expr, ")"); } emit_op(result_type, result_id, join(op, "(", op0_expr, ", ", op1_expr, ", ", op2_expr, ", ", op3_expr, ")"), forward); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); inherit_expression_dependencies(result_id, op2); inherit_expression_dependencies(result_id, op3); } string CompilerGLSL::legacy_tex_op(const std::string &op, const SPIRType &imgtype, uint32_t tex) { const char *type; switch (imgtype.image.dim) { case spv::Dim1D: type = (imgtype.image.arrayed && !options.es) ? "1DArray" : "1D"; break; case spv::Dim2D: type = (imgtype.image.arrayed && !options.es) ? "2DArray" : "2D"; break; case spv::Dim3D: type = "3D"; break; case spv::DimCube: type = "Cube"; break; case spv::DimRect: type = "2DRect"; break; case spv::DimBuffer: type = "Buffer"; break; case spv::DimSubpassData: type = "2D"; break; default: type = ""; break; } // In legacy GLSL, an extension is required for textureLod in the fragment // shader or textureGrad anywhere. bool legacy_lod_ext = false; auto &execution = get_entry_point(); if (op == "textureGrad" || op == "textureProjGrad" || ((op == "textureLod" || op == "textureProjLod") && execution.model != ExecutionModelVertex)) { if (is_legacy_es()) { legacy_lod_ext = true; require_extension_internal("GL_EXT_shader_texture_lod"); } else if (is_legacy_desktop()) require_extension_internal("GL_ARB_shader_texture_lod"); } if (op == "textureLodOffset" || op == "textureProjLodOffset") { if (is_legacy_es()) SPIRV_CROSS_THROW(join(op, " not allowed in legacy ES")); require_extension_internal("GL_EXT_gpu_shader4"); } // GLES has very limited support for shadow samplers. // Basically shadow2D and shadow2DProj work through EXT_shadow_samplers, // everything else can just throw bool is_comparison = image_is_comparison(imgtype, tex); if (is_comparison && is_legacy_es()) { if (op == "texture" || op == "textureProj") require_extension_internal("GL_EXT_shadow_samplers"); else SPIRV_CROSS_THROW(join(op, " not allowed on depth samplers in legacy ES")); } if (op == "textureSize") { if (is_legacy_es()) SPIRV_CROSS_THROW("textureSize not supported in legacy ES"); if (is_comparison) SPIRV_CROSS_THROW("textureSize not supported on shadow sampler in legacy GLSL"); require_extension_internal("GL_EXT_gpu_shader4"); } if (op == "texelFetch" && is_legacy_es()) SPIRV_CROSS_THROW("texelFetch not supported in legacy ES"); bool is_es_and_depth = is_legacy_es() && is_comparison; std::string type_prefix = is_comparison ? "shadow" : "texture"; if (op == "texture") return is_es_and_depth ? join(type_prefix, type, "EXT") : join(type_prefix, type); else if (op == "textureLod") return join(type_prefix, type, legacy_lod_ext ? "LodEXT" : "Lod"); else if (op == "textureProj") return join(type_prefix, type, is_es_and_depth ? "ProjEXT" : "Proj"); else if (op == "textureGrad") return join(type_prefix, type, is_legacy_es() ? "GradEXT" : is_legacy_desktop() ? "GradARB" : "Grad"); else if (op == "textureProjLod") return join(type_prefix, type, legacy_lod_ext ? "ProjLodEXT" : "ProjLod"); else if (op == "textureLodOffset") return join(type_prefix, type, "LodOffset"); else if (op == "textureProjGrad") return join(type_prefix, type, is_legacy_es() ? "ProjGradEXT" : is_legacy_desktop() ? "ProjGradARB" : "ProjGrad"); else if (op == "textureProjLodOffset") return join(type_prefix, type, "ProjLodOffset"); else if (op == "textureSize") return join("textureSize", type); else if (op == "texelFetch") return join("texelFetch", type); else { SPIRV_CROSS_THROW(join("Unsupported legacy texture op: ", op)); } } bool CompilerGLSL::to_trivial_mix_op(const SPIRType &type, string &op, uint32_t left, uint32_t right, uint32_t lerp) { auto *cleft = maybe_get(left); auto *cright = maybe_get(right); auto &lerptype = expression_type(lerp); // If our targets aren't constants, we cannot use construction. if (!cleft || !cright) return false; // If our targets are spec constants, we cannot use construction. if (cleft->specialization || cright->specialization) return false; // We can only use trivial construction if we have a scalar // (should be possible to do it for vectors as well, but that is overkill for now). if (lerptype.basetype != SPIRType::Boolean || lerptype.vecsize > 1) return false; // If our bool selects between 0 and 1, we can cast from bool instead, making our trivial constructor. bool ret = false; switch (type.basetype) { case SPIRType::Short: case SPIRType::UShort: ret = cleft->scalar_u16() == 0 && cright->scalar_u16() == 1; break; case SPIRType::Int: case SPIRType::UInt: ret = cleft->scalar() == 0 && cright->scalar() == 1; break; case SPIRType::Half: ret = cleft->scalar_f16() == 0.0f && cright->scalar_f16() == 1.0f; break; case SPIRType::Float: ret = cleft->scalar_f32() == 0.0f && cright->scalar_f32() == 1.0f; break; case SPIRType::Double: ret = cleft->scalar_f64() == 0.0 && cright->scalar_f64() == 1.0; break; case SPIRType::Int64: case SPIRType::UInt64: ret = cleft->scalar_u64() == 0 && cright->scalar_u64() == 1; break; default: break; } if (ret) op = type_to_glsl_constructor(type); return ret; } string CompilerGLSL::to_ternary_expression(const SPIRType &restype, uint32_t select, uint32_t true_value, uint32_t false_value) { string expr; auto &lerptype = expression_type(select); if (lerptype.vecsize == 1) expr = join(to_enclosed_expression(select), " ? ", to_enclosed_pointer_expression(true_value), " : ", to_enclosed_pointer_expression(false_value)); else { auto swiz = [this](uint32_t expression, uint32_t i) { return to_extract_component_expression(expression, i); }; expr = type_to_glsl_constructor(restype); expr += "("; for (uint32_t i = 0; i < restype.vecsize; i++) { expr += swiz(select, i); expr += " ? "; expr += swiz(true_value, i); expr += " : "; expr += swiz(false_value, i); if (i + 1 < restype.vecsize) expr += ", "; } expr += ")"; } return expr; } void CompilerGLSL::emit_mix_op(uint32_t result_type, uint32_t id, uint32_t left, uint32_t right, uint32_t lerp) { auto &lerptype = expression_type(lerp); auto &restype = get(result_type); // If this results in a variable pointer, assume it may be written through. if (restype.pointer) { register_write(left); register_write(right); } string mix_op; bool has_boolean_mix = *backend.boolean_mix_function && ((options.es && options.version >= 310) || (!options.es && options.version >= 450)); bool trivial_mix = to_trivial_mix_op(restype, mix_op, left, right, lerp); // Cannot use boolean mix when the lerp argument is just one boolean, // fall back to regular trinary statements. if (lerptype.vecsize == 1) has_boolean_mix = false; // If we can reduce the mix to a simple cast, do so. // This helps for cases like int(bool), uint(bool) which is implemented with // OpSelect bool 1 0. if (trivial_mix) { emit_unary_func_op(result_type, id, lerp, mix_op.c_str()); } else if (!has_boolean_mix && lerptype.basetype == SPIRType::Boolean) { // Boolean mix not supported on desktop without extension. // Was added in OpenGL 4.5 with ES 3.1 compat. // // Could use GL_EXT_shader_integer_mix on desktop at least, // but Apple doesn't support it. :( // Just implement it as ternary expressions. auto expr = to_ternary_expression(get(result_type), lerp, right, left); emit_op(result_type, id, expr, should_forward(left) && should_forward(right) && should_forward(lerp)); inherit_expression_dependencies(id, left); inherit_expression_dependencies(id, right); inherit_expression_dependencies(id, lerp); } else if (lerptype.basetype == SPIRType::Boolean) emit_trinary_func_op(result_type, id, left, right, lerp, backend.boolean_mix_function); else emit_trinary_func_op(result_type, id, left, right, lerp, "mix"); } string CompilerGLSL::to_combined_image_sampler(VariableID image_id, VariableID samp_id) { // Keep track of the array indices we have used to load the image. // We'll need to use the same array index into the combined image sampler array. auto image_expr = to_expression(image_id); string array_expr; auto array_index = image_expr.find_first_of('['); if (array_index != string::npos) array_expr = image_expr.substr(array_index, string::npos); auto &args = current_function->arguments; // For GLSL and ESSL targets, we must enumerate all possible combinations for sampler2D(texture2D, sampler) and redirect // all possible combinations into new sampler2D uniforms. auto *image = maybe_get_backing_variable(image_id); auto *samp = maybe_get_backing_variable(samp_id); if (image) image_id = image->self; if (samp) samp_id = samp->self; auto image_itr = find_if(begin(args), end(args), [image_id](const SPIRFunction::Parameter ¶m) { return image_id == param.id; }); auto sampler_itr = find_if(begin(args), end(args), [samp_id](const SPIRFunction::Parameter ¶m) { return samp_id == param.id; }); if (image_itr != end(args) || sampler_itr != end(args)) { // If any parameter originates from a parameter, we will find it in our argument list. bool global_image = image_itr == end(args); bool global_sampler = sampler_itr == end(args); VariableID iid = global_image ? image_id : VariableID(uint32_t(image_itr - begin(args))); VariableID sid = global_sampler ? samp_id : VariableID(uint32_t(sampler_itr - begin(args))); auto &combined = current_function->combined_parameters; auto itr = find_if(begin(combined), end(combined), [=](const SPIRFunction::CombinedImageSamplerParameter &p) { return p.global_image == global_image && p.global_sampler == global_sampler && p.image_id == iid && p.sampler_id == sid; }); if (itr != end(combined)) return to_expression(itr->id) + array_expr; else { SPIRV_CROSS_THROW("Cannot find mapping for combined sampler parameter, was " "build_combined_image_samplers() used " "before compile() was called?"); } } else { // For global sampler2D, look directly at the global remapping table. auto &mapping = combined_image_samplers; auto itr = find_if(begin(mapping), end(mapping), [image_id, samp_id](const CombinedImageSampler &combined) { return combined.image_id == image_id && combined.sampler_id == samp_id; }); if (itr != end(combined_image_samplers)) return to_expression(itr->combined_id) + array_expr; else { SPIRV_CROSS_THROW("Cannot find mapping for combined sampler, was build_combined_image_samplers() used " "before compile() was called?"); } } } bool CompilerGLSL::is_supported_subgroup_op_in_opengl(spv::Op op) { switch (op) { case OpGroupNonUniformElect: case OpGroupNonUniformBallot: case OpGroupNonUniformBallotFindLSB: case OpGroupNonUniformBallotFindMSB: case OpGroupNonUniformBroadcast: case OpGroupNonUniformBroadcastFirst: case OpGroupNonUniformAll: case OpGroupNonUniformAny: case OpGroupNonUniformAllEqual: case OpControlBarrier: case OpMemoryBarrier: case OpGroupNonUniformBallotBitCount: case OpGroupNonUniformBallotBitExtract: case OpGroupNonUniformInverseBallot: return true; default: return false; } } void CompilerGLSL::emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) { if (options.vulkan_semantics && combined_image_samplers.empty()) { emit_binary_func_op(result_type, result_id, image_id, samp_id, type_to_glsl(get(result_type), result_id).c_str()); } else { // Make sure to suppress usage tracking. It is illegal to create temporaries of opaque types. emit_op(result_type, result_id, to_combined_image_sampler(image_id, samp_id), true, true); } // Make sure to suppress usage tracking and any expression invalidation. // It is illegal to create temporaries of opaque types. forwarded_temporaries.erase(result_id); } static inline bool image_opcode_is_sample_no_dref(Op op) { switch (op) { case OpImageSampleExplicitLod: case OpImageSampleImplicitLod: case OpImageSampleProjExplicitLod: case OpImageSampleProjImplicitLod: case OpImageFetch: case OpImageRead: case OpImageSparseSampleExplicitLod: case OpImageSparseSampleImplicitLod: case OpImageSparseSampleProjExplicitLod: case OpImageSparseSampleProjImplicitLod: case OpImageSparseFetch: case OpImageSparseRead: return true; default: return false; } } void CompilerGLSL::emit_sparse_feedback_temporaries(uint32_t result_type_id, uint32_t id, uint32_t &feedback_id, uint32_t &texel_id) { // Need to allocate two temporaries. if (options.es) SPIRV_CROSS_THROW("Sparse texture feedback is not supported on ESSL."); require_extension_internal("GL_ARB_sparse_texture2"); auto &temps = extra_sub_expressions[id]; if (temps == 0) temps = ir.increase_bound_by(2); feedback_id = temps + 0; texel_id = temps + 1; auto &return_type = get(result_type_id); if (return_type.basetype != SPIRType::Struct || return_type.member_types.size() != 2) SPIRV_CROSS_THROW("Invalid return type for sparse feedback."); emit_uninitialized_temporary(return_type.member_types[0], feedback_id); emit_uninitialized_temporary(return_type.member_types[1], texel_id); } uint32_t CompilerGLSL::get_sparse_feedback_texel_id(uint32_t id) const { auto itr = extra_sub_expressions.find(id); if (itr == extra_sub_expressions.end()) return 0; else return itr->second + 1; } void CompilerGLSL::emit_texture_op(const Instruction &i, bool sparse) { auto *ops = stream(i); auto op = static_cast(i.op); SmallVector inherited_expressions; uint32_t result_type_id = ops[0]; uint32_t id = ops[1]; auto &return_type = get(result_type_id); uint32_t sparse_code_id = 0; uint32_t sparse_texel_id = 0; if (sparse) emit_sparse_feedback_temporaries(result_type_id, id, sparse_code_id, sparse_texel_id); bool forward = false; string expr = to_texture_op(i, sparse, &forward, inherited_expressions); if (sparse) { statement(to_expression(sparse_code_id), " = ", expr, ";"); expr = join(type_to_glsl(return_type), "(", to_expression(sparse_code_id), ", ", to_expression(sparse_texel_id), ")"); forward = true; inherited_expressions.clear(); } emit_op(result_type_id, id, expr, forward); for (auto &inherit : inherited_expressions) inherit_expression_dependencies(id, inherit); // Do not register sparse ops as control dependent as they are always lowered to a temporary. switch (op) { case OpImageSampleDrefImplicitLod: case OpImageSampleImplicitLod: case OpImageSampleProjImplicitLod: case OpImageSampleProjDrefImplicitLod: register_control_dependent_expression(id); break; default: break; } } std::string CompilerGLSL::to_texture_op(const Instruction &i, bool sparse, bool *forward, SmallVector &inherited_expressions) { auto *ops = stream(i); auto op = static_cast(i.op); uint32_t length = i.length; uint32_t result_type_id = ops[0]; VariableID img = ops[2]; uint32_t coord = ops[3]; uint32_t dref = 0; uint32_t comp = 0; bool gather = false; bool proj = false; bool fetch = false; bool nonuniform_expression = false; const uint32_t *opt = nullptr; auto &result_type = get(result_type_id); inherited_expressions.push_back(coord); // Make sure non-uniform decoration is back-propagated to where it needs to be. if (has_decoration(img, DecorationNonUniformEXT)) { // In Vulkan GLSL, we cannot back-propgate nonuniform qualifiers if we // use a combined image sampler constructor. // We're only interested in back-propagating if we can trace back through access chains. // If not, we will apply nonuniform to the sampled image expression itself. auto *backing = maybe_get_backing_variable(img); if (backing) propagate_nonuniform_qualifier(img); else nonuniform_expression = true; } switch (op) { case OpImageSampleDrefImplicitLod: case OpImageSampleDrefExplicitLod: case OpImageSparseSampleDrefImplicitLod: case OpImageSparseSampleDrefExplicitLod: dref = ops[4]; opt = &ops[5]; length -= 5; break; case OpImageSampleProjDrefImplicitLod: case OpImageSampleProjDrefExplicitLod: case OpImageSparseSampleProjDrefImplicitLod: case OpImageSparseSampleProjDrefExplicitLod: dref = ops[4]; opt = &ops[5]; length -= 5; proj = true; break; case OpImageDrefGather: case OpImageSparseDrefGather: dref = ops[4]; opt = &ops[5]; length -= 5; gather = true; if (options.es && options.version < 310) SPIRV_CROSS_THROW("textureGather requires ESSL 310."); else if (!options.es && options.version < 400) SPIRV_CROSS_THROW("textureGather with depth compare requires GLSL 400."); break; case OpImageGather: case OpImageSparseGather: comp = ops[4]; opt = &ops[5]; length -= 5; gather = true; if (options.es && options.version < 310) SPIRV_CROSS_THROW("textureGather requires ESSL 310."); else if (!options.es && options.version < 400) { if (!expression_is_constant_null(comp)) SPIRV_CROSS_THROW("textureGather with component requires GLSL 400."); require_extension_internal("GL_ARB_texture_gather"); } break; case OpImageFetch: case OpImageSparseFetch: case OpImageRead: // Reads == fetches in Metal (other langs will not get here) opt = &ops[4]; length -= 4; fetch = true; break; case OpImageSampleProjImplicitLod: case OpImageSampleProjExplicitLod: case OpImageSparseSampleProjImplicitLod: case OpImageSparseSampleProjExplicitLod: opt = &ops[4]; length -= 4; proj = true; break; default: opt = &ops[4]; length -= 4; break; } // Bypass pointers because we need the real image struct auto &type = expression_type(img); auto &imgtype = get(type.self); uint32_t coord_components = 0; switch (imgtype.image.dim) { case spv::Dim1D: coord_components = 1; break; case spv::Dim2D: coord_components = 2; break; case spv::Dim3D: coord_components = 3; break; case spv::DimCube: coord_components = 3; break; case spv::DimBuffer: coord_components = 1; break; default: coord_components = 2; break; } if (dref) inherited_expressions.push_back(dref); if (proj) coord_components++; if (imgtype.image.arrayed) coord_components++; uint32_t bias = 0; uint32_t lod = 0; uint32_t grad_x = 0; uint32_t grad_y = 0; uint32_t coffset = 0; uint32_t offset = 0; uint32_t coffsets = 0; uint32_t sample = 0; uint32_t minlod = 0; uint32_t flags = 0; if (length) { flags = *opt++; length--; } auto test = [&](uint32_t &v, uint32_t flag) { if (length && (flags & flag)) { v = *opt++; inherited_expressions.push_back(v); length--; } }; test(bias, ImageOperandsBiasMask); test(lod, ImageOperandsLodMask); test(grad_x, ImageOperandsGradMask); test(grad_y, ImageOperandsGradMask); test(coffset, ImageOperandsConstOffsetMask); test(offset, ImageOperandsOffsetMask); test(coffsets, ImageOperandsConstOffsetsMask); test(sample, ImageOperandsSampleMask); test(minlod, ImageOperandsMinLodMask); TextureFunctionBaseArguments base_args = {}; base_args.img = img; base_args.imgtype = &imgtype; base_args.is_fetch = fetch != 0; base_args.is_gather = gather != 0; base_args.is_proj = proj != 0; string expr; TextureFunctionNameArguments name_args = {}; name_args.base = base_args; name_args.has_array_offsets = coffsets != 0; name_args.has_offset = coffset != 0 || offset != 0; name_args.has_grad = grad_x != 0 || grad_y != 0; name_args.has_dref = dref != 0; name_args.is_sparse_feedback = sparse; name_args.has_min_lod = minlod != 0; name_args.lod = lod; expr += to_function_name(name_args); expr += "("; uint32_t sparse_texel_id = 0; if (sparse) sparse_texel_id = get_sparse_feedback_texel_id(ops[1]); TextureFunctionArguments args = {}; args.base = base_args; args.coord = coord; args.coord_components = coord_components; args.dref = dref; args.grad_x = grad_x; args.grad_y = grad_y; args.lod = lod; args.coffset = coffset; args.offset = offset; args.bias = bias; args.component = comp; args.sample = sample; args.sparse_texel = sparse_texel_id; args.min_lod = minlod; args.nonuniform_expression = nonuniform_expression; expr += to_function_args(args, forward); expr += ")"; // texture(samplerXShadow) returns float. shadowX() returns vec4. Swizzle here. if (is_legacy() && image_is_comparison(imgtype, img)) expr += ".r"; // Sampling from a texture which was deduced to be a depth image, might actually return 1 component here. // Remap back to 4 components as sampling opcodes expect. if (backend.comparison_image_samples_scalar && image_opcode_is_sample_no_dref(op)) { bool image_is_depth = false; const auto *combined = maybe_get(img); VariableID image_id = combined ? combined->image : img; if (combined && image_is_comparison(imgtype, combined->image)) image_is_depth = true; else if (image_is_comparison(imgtype, img)) image_is_depth = true; // We must also check the backing variable for the image. // We might have loaded an OpImage, and used that handle for two different purposes. // Once with comparison, once without. auto *image_variable = maybe_get_backing_variable(image_id); if (image_variable && image_is_comparison(get(image_variable->basetype), image_variable->self)) image_is_depth = true; if (image_is_depth) expr = remap_swizzle(result_type, 1, expr); } if (!sparse && !backend.support_small_type_sampling_result && result_type.width < 32) { // Just value cast (narrowing) to expected type since we cannot rely on narrowing to work automatically. // Hopefully compiler picks this up and converts the texturing instruction to the appropriate precision. expr = join(type_to_glsl_constructor(result_type), "(", expr, ")"); } // Deals with reads from MSL. We might need to downconvert to fewer components. if (op == OpImageRead) expr = remap_swizzle(result_type, 4, expr); return expr; } bool CompilerGLSL::expression_is_constant_null(uint32_t id) const { auto *c = maybe_get(id); if (!c) return false; return c->constant_is_null(); } bool CompilerGLSL::expression_is_non_value_type_array(uint32_t ptr) { auto &type = expression_type(ptr); if (type.array.empty()) return false; if (!backend.array_is_value_type) return true; auto *var = maybe_get_backing_variable(ptr); if (!var) return false; auto &backed_type = get(var->basetype); return !backend.buffer_offset_array_is_value_type && backed_type.basetype == SPIRType::Struct && has_member_decoration(backed_type.self, 0, DecorationOffset); } // Returns the function name for a texture sampling function for the specified image and sampling characteristics. // For some subclasses, the function is a method on the specified image. string CompilerGLSL::to_function_name(const TextureFunctionNameArguments &args) { if (args.has_min_lod) { if (options.es) SPIRV_CROSS_THROW("Sparse residency is not supported in ESSL."); require_extension_internal("GL_ARB_sparse_texture_clamp"); } string fname; auto &imgtype = *args.base.imgtype; VariableID tex = args.base.img; // textureLod on sampler2DArrayShadow and samplerCubeShadow does not exist in GLSL for some reason. // To emulate this, we will have to use textureGrad with a constant gradient of 0. // The workaround will assert that the LOD is in fact constant 0, or we cannot emit correct code. // This happens for HLSL SampleCmpLevelZero on Texture2DArray and TextureCube. bool workaround_lod_array_shadow_as_grad = false; if (((imgtype.image.arrayed && imgtype.image.dim == Dim2D) || imgtype.image.dim == DimCube) && image_is_comparison(imgtype, tex) && args.lod) { if (!expression_is_constant_null(args.lod)) { SPIRV_CROSS_THROW("textureLod on sampler2DArrayShadow is not constant 0.0. This cannot be " "expressed in GLSL."); } workaround_lod_array_shadow_as_grad = true; } if (args.is_sparse_feedback) fname += "sparse"; if (args.base.is_fetch) fname += args.is_sparse_feedback ? "TexelFetch" : "texelFetch"; else { fname += args.is_sparse_feedback ? "Texture" : "texture"; if (args.base.is_gather) fname += "Gather"; if (args.has_array_offsets) fname += "Offsets"; if (args.base.is_proj) fname += "Proj"; if (args.has_grad || workaround_lod_array_shadow_as_grad) fname += "Grad"; if (args.lod != 0 && !workaround_lod_array_shadow_as_grad) fname += "Lod"; } if (args.has_offset) fname += "Offset"; if (args.has_min_lod) fname += "Clamp"; if (args.is_sparse_feedback || args.has_min_lod) fname += "ARB"; return (is_legacy() && !args.base.is_gather) ? legacy_tex_op(fname, imgtype, tex) : fname; } std::string CompilerGLSL::convert_separate_image_to_expression(uint32_t id) { auto *var = maybe_get_backing_variable(id); // If we are fetching from a plain OpTypeImage, we must combine with a dummy sampler in GLSL. // In Vulkan GLSL, we can make use of the newer GL_EXT_samplerless_texture_functions. if (var) { auto &type = get(var->basetype); if (type.basetype == SPIRType::Image && type.image.sampled == 1 && type.image.dim != DimBuffer) { if (options.vulkan_semantics) { if (dummy_sampler_id) { // Don't need to consider Shadow state since the dummy sampler is always non-shadow. auto sampled_type = type; sampled_type.basetype = SPIRType::SampledImage; return join(type_to_glsl(sampled_type), "(", to_expression(id), ", ", to_expression(dummy_sampler_id), ")"); } else { // Newer glslang supports this extension to deal with texture2D as argument to texture functions. require_extension_internal("GL_EXT_samplerless_texture_functions"); } } else { if (!dummy_sampler_id) SPIRV_CROSS_THROW("Cannot find dummy sampler ID. Was " "build_dummy_sampler_for_combined_images() called?"); return to_combined_image_sampler(id, dummy_sampler_id); } } } return to_expression(id); } // Returns the function args for a texture sampling function for the specified image and sampling characteristics. string CompilerGLSL::to_function_args(const TextureFunctionArguments &args, bool *p_forward) { VariableID img = args.base.img; auto &imgtype = *args.base.imgtype; string farg_str; if (args.base.is_fetch) farg_str = convert_separate_image_to_expression(img); else farg_str = to_expression(img); if (args.nonuniform_expression && farg_str.find_first_of('[') != string::npos) { // Only emit nonuniformEXT() wrapper if the underlying expression is arrayed in some way. farg_str = join(backend.nonuniform_qualifier, "(", farg_str, ")"); } bool swizz_func = backend.swizzle_is_function; auto swizzle = [swizz_func](uint32_t comps, uint32_t in_comps) -> const char * { if (comps == in_comps) return ""; switch (comps) { case 1: return ".x"; case 2: return swizz_func ? ".xy()" : ".xy"; case 3: return swizz_func ? ".xyz()" : ".xyz"; default: return ""; } }; bool forward = should_forward(args.coord); // The IR can give us more components than we need, so chop them off as needed. auto swizzle_expr = swizzle(args.coord_components, expression_type(args.coord).vecsize); // Only enclose the UV expression if needed. auto coord_expr = (*swizzle_expr == '\0') ? to_expression(args.coord) : (to_enclosed_expression(args.coord) + swizzle_expr); // texelFetch only takes int, not uint. auto &coord_type = expression_type(args.coord); if (coord_type.basetype == SPIRType::UInt) { auto expected_type = coord_type; expected_type.vecsize = args.coord_components; expected_type.basetype = SPIRType::Int; coord_expr = bitcast_expression(expected_type, coord_type.basetype, coord_expr); } // textureLod on sampler2DArrayShadow and samplerCubeShadow does not exist in GLSL for some reason. // To emulate this, we will have to use textureGrad with a constant gradient of 0. // The workaround will assert that the LOD is in fact constant 0, or we cannot emit correct code. // This happens for HLSL SampleCmpLevelZero on Texture2DArray and TextureCube. bool workaround_lod_array_shadow_as_grad = ((imgtype.image.arrayed && imgtype.image.dim == Dim2D) || imgtype.image.dim == DimCube) && image_is_comparison(imgtype, img) && args.lod != 0; if (args.dref) { forward = forward && should_forward(args.dref); // SPIR-V splits dref and coordinate. if (args.base.is_gather || args.coord_components == 4) // GLSL also splits the arguments in two. Same for textureGather. { farg_str += ", "; farg_str += to_expression(args.coord); farg_str += ", "; farg_str += to_expression(args.dref); } else if (args.base.is_proj) { // Have to reshuffle so we get vec4(coord, dref, proj), special case. // Other shading languages splits up the arguments for coord and compare value like SPIR-V. // The coordinate type for textureProj shadow is always vec4 even for sampler1DShadow. farg_str += ", vec4("; if (imgtype.image.dim == Dim1D) { // Could reuse coord_expr, but we will mess up the temporary usage checking. farg_str += to_enclosed_expression(args.coord) + ".x"; farg_str += ", "; farg_str += "0.0, "; farg_str += to_expression(args.dref); farg_str += ", "; farg_str += to_enclosed_expression(args.coord) + ".y)"; } else if (imgtype.image.dim == Dim2D) { // Could reuse coord_expr, but we will mess up the temporary usage checking. farg_str += to_enclosed_expression(args.coord) + (swizz_func ? ".xy()" : ".xy"); farg_str += ", "; farg_str += to_expression(args.dref); farg_str += ", "; farg_str += to_enclosed_expression(args.coord) + ".z)"; } else SPIRV_CROSS_THROW("Invalid type for textureProj with shadow."); } else { // Create a composite which merges coord/dref into a single vector. auto type = expression_type(args.coord); type.vecsize = args.coord_components + 1; farg_str += ", "; farg_str += type_to_glsl_constructor(type); farg_str += "("; farg_str += coord_expr; farg_str += ", "; farg_str += to_expression(args.dref); farg_str += ")"; } } else { farg_str += ", "; farg_str += coord_expr; } if (args.grad_x || args.grad_y) { forward = forward && should_forward(args.grad_x); forward = forward && should_forward(args.grad_y); farg_str += ", "; farg_str += to_expression(args.grad_x); farg_str += ", "; farg_str += to_expression(args.grad_y); } if (args.lod) { if (workaround_lod_array_shadow_as_grad) { // Implement textureGrad() instead. LOD == 0.0 is implemented as gradient of 0.0. // Implementing this as plain texture() is not safe on some implementations. if (imgtype.image.dim == Dim2D) farg_str += ", vec2(0.0), vec2(0.0)"; else if (imgtype.image.dim == DimCube) farg_str += ", vec3(0.0), vec3(0.0)"; } else { forward = forward && should_forward(args.lod); farg_str += ", "; auto &lod_expr_type = expression_type(args.lod); // Lod expression for TexelFetch in GLSL must be int, and only int. if (args.base.is_fetch && imgtype.image.dim != DimBuffer && !imgtype.image.ms && lod_expr_type.basetype != SPIRType::Int) { farg_str += join("int(", to_expression(args.lod), ")"); } else { farg_str += to_expression(args.lod); } } } else if (args.base.is_fetch && imgtype.image.dim != DimBuffer && !imgtype.image.ms) { // Lod argument is optional in OpImageFetch, but we require a LOD value, pick 0 as the default. farg_str += ", 0"; } if (args.coffset) { forward = forward && should_forward(args.coffset); farg_str += ", "; farg_str += to_expression(args.coffset); } else if (args.offset) { forward = forward && should_forward(args.offset); farg_str += ", "; farg_str += to_expression(args.offset); } if (args.sample) { farg_str += ", "; farg_str += to_expression(args.sample); } if (args.min_lod) { farg_str += ", "; farg_str += to_expression(args.min_lod); } if (args.sparse_texel) { // Sparse texel output parameter comes after everything else, except it's before the optional, component/bias arguments. farg_str += ", "; farg_str += to_expression(args.sparse_texel); } if (args.bias) { forward = forward && should_forward(args.bias); farg_str += ", "; farg_str += to_expression(args.bias); } if (args.component && !expression_is_constant_null(args.component)) { forward = forward && should_forward(args.component); farg_str += ", "; farg_str += to_expression(args.component); } *p_forward = forward; return farg_str; } void CompilerGLSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t length) { auto op = static_cast(eop); if (is_legacy() && is_unsigned_glsl_opcode(op)) SPIRV_CROSS_THROW("Unsigned integers are not supported on legacy GLSL targets."); // If we need to do implicit bitcasts, make sure we do it with the correct type. uint32_t integer_width = get_integer_width_for_glsl_instruction(op, args, length); auto int_type = to_signed_basetype(integer_width); auto uint_type = to_unsigned_basetype(integer_width); switch (op) { // FP fiddling case GLSLstd450Round: if (!is_legacy()) emit_unary_func_op(result_type, id, args[0], "round"); else { auto op0 = to_enclosed_expression(args[0]); auto &op0_type = expression_type(args[0]); auto expr = join("floor(", op0, " + ", type_to_glsl_constructor(op0_type), "(0.5))"); bool forward = should_forward(args[0]); emit_op(result_type, id, expr, forward); inherit_expression_dependencies(id, args[0]); } break; case GLSLstd450RoundEven: if (!is_legacy()) emit_unary_func_op(result_type, id, args[0], "roundEven"); else if (!options.es) { // This extension provides round() with round-to-even semantics. require_extension_internal("GL_EXT_gpu_shader4"); emit_unary_func_op(result_type, id, args[0], "round"); } else SPIRV_CROSS_THROW("roundEven supported only in ESSL 300."); break; case GLSLstd450Trunc: emit_unary_func_op(result_type, id, args[0], "trunc"); break; case GLSLstd450SAbs: emit_unary_func_op_cast(result_type, id, args[0], "abs", int_type, int_type); break; case GLSLstd450FAbs: emit_unary_func_op(result_type, id, args[0], "abs"); break; case GLSLstd450SSign: emit_unary_func_op_cast(result_type, id, args[0], "sign", int_type, int_type); break; case GLSLstd450FSign: emit_unary_func_op(result_type, id, args[0], "sign"); break; case GLSLstd450Floor: emit_unary_func_op(result_type, id, args[0], "floor"); break; case GLSLstd450Ceil: emit_unary_func_op(result_type, id, args[0], "ceil"); break; case GLSLstd450Fract: emit_unary_func_op(result_type, id, args[0], "fract"); break; case GLSLstd450Radians: emit_unary_func_op(result_type, id, args[0], "radians"); break; case GLSLstd450Degrees: emit_unary_func_op(result_type, id, args[0], "degrees"); break; case GLSLstd450Fma: if ((!options.es && options.version < 400) || (options.es && options.version < 320)) { auto expr = join(to_enclosed_expression(args[0]), " * ", to_enclosed_expression(args[1]), " + ", to_enclosed_expression(args[2])); emit_op(result_type, id, expr, should_forward(args[0]) && should_forward(args[1]) && should_forward(args[2])); for (uint32_t i = 0; i < 3; i++) inherit_expression_dependencies(id, args[i]); } else emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "fma"); break; case GLSLstd450Modf: register_call_out_argument(args[1]); forced_temporaries.insert(id); emit_binary_func_op(result_type, id, args[0], args[1], "modf"); break; case GLSLstd450ModfStruct: { auto &type = get(result_type); emit_uninitialized_temporary_expression(result_type, id); statement(to_expression(id), ".", to_member_name(type, 0), " = ", "modf(", to_expression(args[0]), ", ", to_expression(id), ".", to_member_name(type, 1), ");"); break; } // Minmax case GLSLstd450UMin: emit_binary_func_op_cast(result_type, id, args[0], args[1], "min", uint_type, false); break; case GLSLstd450SMin: emit_binary_func_op_cast(result_type, id, args[0], args[1], "min", int_type, false); break; case GLSLstd450FMin: emit_binary_func_op(result_type, id, args[0], args[1], "min"); break; case GLSLstd450FMax: emit_binary_func_op(result_type, id, args[0], args[1], "max"); break; case GLSLstd450UMax: emit_binary_func_op_cast(result_type, id, args[0], args[1], "max", uint_type, false); break; case GLSLstd450SMax: emit_binary_func_op_cast(result_type, id, args[0], args[1], "max", int_type, false); break; case GLSLstd450FClamp: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "clamp"); break; case GLSLstd450UClamp: emit_trinary_func_op_cast(result_type, id, args[0], args[1], args[2], "clamp", uint_type); break; case GLSLstd450SClamp: emit_trinary_func_op_cast(result_type, id, args[0], args[1], args[2], "clamp", int_type); break; // Trig case GLSLstd450Sin: emit_unary_func_op(result_type, id, args[0], "sin"); break; case GLSLstd450Cos: emit_unary_func_op(result_type, id, args[0], "cos"); break; case GLSLstd450Tan: emit_unary_func_op(result_type, id, args[0], "tan"); break; case GLSLstd450Asin: emit_unary_func_op(result_type, id, args[0], "asin"); break; case GLSLstd450Acos: emit_unary_func_op(result_type, id, args[0], "acos"); break; case GLSLstd450Atan: emit_unary_func_op(result_type, id, args[0], "atan"); break; case GLSLstd450Sinh: emit_unary_func_op(result_type, id, args[0], "sinh"); break; case GLSLstd450Cosh: emit_unary_func_op(result_type, id, args[0], "cosh"); break; case GLSLstd450Tanh: emit_unary_func_op(result_type, id, args[0], "tanh"); break; case GLSLstd450Asinh: emit_unary_func_op(result_type, id, args[0], "asinh"); break; case GLSLstd450Acosh: emit_unary_func_op(result_type, id, args[0], "acosh"); break; case GLSLstd450Atanh: emit_unary_func_op(result_type, id, args[0], "atanh"); break; case GLSLstd450Atan2: emit_binary_func_op(result_type, id, args[0], args[1], "atan"); break; // Exponentials case GLSLstd450Pow: emit_binary_func_op(result_type, id, args[0], args[1], "pow"); break; case GLSLstd450Exp: emit_unary_func_op(result_type, id, args[0], "exp"); break; case GLSLstd450Log: emit_unary_func_op(result_type, id, args[0], "log"); break; case GLSLstd450Exp2: emit_unary_func_op(result_type, id, args[0], "exp2"); break; case GLSLstd450Log2: emit_unary_func_op(result_type, id, args[0], "log2"); break; case GLSLstd450Sqrt: emit_unary_func_op(result_type, id, args[0], "sqrt"); break; case GLSLstd450InverseSqrt: emit_unary_func_op(result_type, id, args[0], "inversesqrt"); break; // Matrix math case GLSLstd450Determinant: emit_unary_func_op(result_type, id, args[0], "determinant"); break; case GLSLstd450MatrixInverse: emit_unary_func_op(result_type, id, args[0], "inverse"); break; // Lerping case GLSLstd450FMix: case GLSLstd450IMix: { emit_mix_op(result_type, id, args[0], args[1], args[2]); break; } case GLSLstd450Step: emit_binary_func_op(result_type, id, args[0], args[1], "step"); break; case GLSLstd450SmoothStep: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "smoothstep"); break; // Packing case GLSLstd450Frexp: register_call_out_argument(args[1]); forced_temporaries.insert(id); emit_binary_func_op(result_type, id, args[0], args[1], "frexp"); break; case GLSLstd450FrexpStruct: { auto &type = get(result_type); emit_uninitialized_temporary_expression(result_type, id); statement(to_expression(id), ".", to_member_name(type, 0), " = ", "frexp(", to_expression(args[0]), ", ", to_expression(id), ".", to_member_name(type, 1), ");"); break; } case GLSLstd450Ldexp: { bool forward = should_forward(args[0]) && should_forward(args[1]); auto op0 = to_unpacked_expression(args[0]); auto op1 = to_unpacked_expression(args[1]); auto &op1_type = expression_type(args[1]); if (op1_type.basetype != SPIRType::Int) { // Need a value cast here. auto target_type = op1_type; target_type.basetype = SPIRType::Int; op1 = join(type_to_glsl_constructor(target_type), "(", op1, ")"); } auto expr = join("ldexp(", op0, ", ", op1, ")"); emit_op(result_type, id, expr, forward); inherit_expression_dependencies(id, args[0]); inherit_expression_dependencies(id, args[1]); break; } case GLSLstd450PackSnorm4x8: emit_unary_func_op(result_type, id, args[0], "packSnorm4x8"); break; case GLSLstd450PackUnorm4x8: emit_unary_func_op(result_type, id, args[0], "packUnorm4x8"); break; case GLSLstd450PackSnorm2x16: emit_unary_func_op(result_type, id, args[0], "packSnorm2x16"); break; case GLSLstd450PackUnorm2x16: emit_unary_func_op(result_type, id, args[0], "packUnorm2x16"); break; case GLSLstd450PackHalf2x16: emit_unary_func_op(result_type, id, args[0], "packHalf2x16"); break; case GLSLstd450UnpackSnorm4x8: emit_unary_func_op(result_type, id, args[0], "unpackSnorm4x8"); break; case GLSLstd450UnpackUnorm4x8: emit_unary_func_op(result_type, id, args[0], "unpackUnorm4x8"); break; case GLSLstd450UnpackSnorm2x16: emit_unary_func_op(result_type, id, args[0], "unpackSnorm2x16"); break; case GLSLstd450UnpackUnorm2x16: emit_unary_func_op(result_type, id, args[0], "unpackUnorm2x16"); break; case GLSLstd450UnpackHalf2x16: emit_unary_func_op(result_type, id, args[0], "unpackHalf2x16"); break; case GLSLstd450PackDouble2x32: emit_unary_func_op(result_type, id, args[0], "packDouble2x32"); break; case GLSLstd450UnpackDouble2x32: emit_unary_func_op(result_type, id, args[0], "unpackDouble2x32"); break; // Vector math case GLSLstd450Length: emit_unary_func_op(result_type, id, args[0], "length"); break; case GLSLstd450Distance: emit_binary_func_op(result_type, id, args[0], args[1], "distance"); break; case GLSLstd450Cross: emit_binary_func_op(result_type, id, args[0], args[1], "cross"); break; case GLSLstd450Normalize: emit_unary_func_op(result_type, id, args[0], "normalize"); break; case GLSLstd450FaceForward: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "faceforward"); break; case GLSLstd450Reflect: emit_binary_func_op(result_type, id, args[0], args[1], "reflect"); break; case GLSLstd450Refract: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "refract"); break; // Bit-fiddling case GLSLstd450FindILsb: // findLSB always returns int. emit_unary_func_op_cast(result_type, id, args[0], "findLSB", expression_type(args[0]).basetype, int_type); break; case GLSLstd450FindSMsb: emit_unary_func_op_cast(result_type, id, args[0], "findMSB", int_type, int_type); break; case GLSLstd450FindUMsb: emit_unary_func_op_cast(result_type, id, args[0], "findMSB", uint_type, int_type); // findMSB always returns int. break; // Multisampled varying case GLSLstd450InterpolateAtCentroid: emit_unary_func_op(result_type, id, args[0], "interpolateAtCentroid"); break; case GLSLstd450InterpolateAtSample: emit_binary_func_op(result_type, id, args[0], args[1], "interpolateAtSample"); break; case GLSLstd450InterpolateAtOffset: emit_binary_func_op(result_type, id, args[0], args[1], "interpolateAtOffset"); break; case GLSLstd450NMin: case GLSLstd450NMax: { emit_nminmax_op(result_type, id, args[0], args[1], op); break; } case GLSLstd450NClamp: { // Make sure we have a unique ID here to avoid aliasing the extra sub-expressions between clamp and NMin sub-op. // IDs cannot exceed 24 bits, so we can make use of the higher bits for some unique flags. uint32_t &max_id = extra_sub_expressions[id | 0x80000000u]; if (!max_id) max_id = ir.increase_bound_by(1); // Inherit precision qualifiers. ir.meta[max_id] = ir.meta[id]; emit_nminmax_op(result_type, max_id, args[0], args[1], GLSLstd450NMax); emit_nminmax_op(result_type, id, max_id, args[2], GLSLstd450NMin); break; } default: statement("// unimplemented GLSL op ", eop); break; } } void CompilerGLSL::emit_nminmax_op(uint32_t result_type, uint32_t id, uint32_t op0, uint32_t op1, GLSLstd450 op) { // Need to emulate this call. uint32_t &ids = extra_sub_expressions[id]; if (!ids) { ids = ir.increase_bound_by(5); auto btype = get(result_type); btype.basetype = SPIRType::Boolean; set(ids, btype); } uint32_t btype_id = ids + 0; uint32_t left_nan_id = ids + 1; uint32_t right_nan_id = ids + 2; uint32_t tmp_id = ids + 3; uint32_t mixed_first_id = ids + 4; // Inherit precision qualifiers. ir.meta[tmp_id] = ir.meta[id]; ir.meta[mixed_first_id] = ir.meta[id]; emit_unary_func_op(btype_id, left_nan_id, op0, "isnan"); emit_unary_func_op(btype_id, right_nan_id, op1, "isnan"); emit_binary_func_op(result_type, tmp_id, op0, op1, op == GLSLstd450NMin ? "min" : "max"); emit_mix_op(result_type, mixed_first_id, tmp_id, op1, left_nan_id); emit_mix_op(result_type, id, mixed_first_id, op0, right_nan_id); } void CompilerGLSL::emit_spv_amd_shader_ballot_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t) { require_extension_internal("GL_AMD_shader_ballot"); enum AMDShaderBallot { SwizzleInvocationsAMD = 1, SwizzleInvocationsMaskedAMD = 2, WriteInvocationAMD = 3, MbcntAMD = 4 }; auto op = static_cast(eop); switch (op) { case SwizzleInvocationsAMD: emit_binary_func_op(result_type, id, args[0], args[1], "swizzleInvocationsAMD"); register_control_dependent_expression(id); break; case SwizzleInvocationsMaskedAMD: emit_binary_func_op(result_type, id, args[0], args[1], "swizzleInvocationsMaskedAMD"); register_control_dependent_expression(id); break; case WriteInvocationAMD: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "writeInvocationAMD"); register_control_dependent_expression(id); break; case MbcntAMD: emit_unary_func_op(result_type, id, args[0], "mbcntAMD"); register_control_dependent_expression(id); break; default: statement("// unimplemented SPV AMD shader ballot op ", eop); break; } } void CompilerGLSL::emit_spv_amd_shader_explicit_vertex_parameter_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t) { require_extension_internal("GL_AMD_shader_explicit_vertex_parameter"); enum AMDShaderExplicitVertexParameter { InterpolateAtVertexAMD = 1 }; auto op = static_cast(eop); switch (op) { case InterpolateAtVertexAMD: emit_binary_func_op(result_type, id, args[0], args[1], "interpolateAtVertexAMD"); break; default: statement("// unimplemented SPV AMD shader explicit vertex parameter op ", eop); break; } } void CompilerGLSL::emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t) { require_extension_internal("GL_AMD_shader_trinary_minmax"); enum AMDShaderTrinaryMinMax { FMin3AMD = 1, UMin3AMD = 2, SMin3AMD = 3, FMax3AMD = 4, UMax3AMD = 5, SMax3AMD = 6, FMid3AMD = 7, UMid3AMD = 8, SMid3AMD = 9 }; auto op = static_cast(eop); switch (op) { case FMin3AMD: case UMin3AMD: case SMin3AMD: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "min3"); break; case FMax3AMD: case UMax3AMD: case SMax3AMD: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "max3"); break; case FMid3AMD: case UMid3AMD: case SMid3AMD: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "mid3"); break; default: statement("// unimplemented SPV AMD shader trinary minmax op ", eop); break; } } void CompilerGLSL::emit_spv_amd_gcn_shader_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t) { require_extension_internal("GL_AMD_gcn_shader"); enum AMDGCNShader { CubeFaceIndexAMD = 1, CubeFaceCoordAMD = 2, TimeAMD = 3 }; auto op = static_cast(eop); switch (op) { case CubeFaceIndexAMD: emit_unary_func_op(result_type, id, args[0], "cubeFaceIndexAMD"); break; case CubeFaceCoordAMD: emit_unary_func_op(result_type, id, args[0], "cubeFaceCoordAMD"); break; case TimeAMD: { string expr = "timeAMD()"; emit_op(result_type, id, expr, true); register_control_dependent_expression(id); break; } default: statement("// unimplemented SPV AMD gcn shader op ", eop); break; } } void CompilerGLSL::emit_subgroup_op(const Instruction &i) { const uint32_t *ops = stream(i); auto op = static_cast(i.op); if (!options.vulkan_semantics && !is_supported_subgroup_op_in_opengl(op)) SPIRV_CROSS_THROW("This subgroup operation is only supported in Vulkan semantics."); // If we need to do implicit bitcasts, make sure we do it with the correct type. uint32_t integer_width = get_integer_width_for_instruction(i); auto int_type = to_signed_basetype(integer_width); auto uint_type = to_unsigned_basetype(integer_width); switch (op) { case OpGroupNonUniformElect: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupElect); break; case OpGroupNonUniformBallotBitCount: { const GroupOperation operation = static_cast(ops[3]); if (operation == GroupOperationReduce) request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBallotBitCount); else if (operation == GroupOperationInclusiveScan || operation == GroupOperationExclusiveScan) request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupInverseBallot_InclBitCount_ExclBitCout); } break; case OpGroupNonUniformBallotBitExtract: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBallotBitExtract); break; case OpGroupNonUniformInverseBallot: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupInverseBallot_InclBitCount_ExclBitCout); break; case OpGroupNonUniformBallot: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBallot); break; case OpGroupNonUniformBallotFindLSB: case OpGroupNonUniformBallotFindMSB: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBallotFindLSB_MSB); break; case OpGroupNonUniformBroadcast: case OpGroupNonUniformBroadcastFirst: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBroadcast_First); break; case OpGroupNonUniformShuffle: case OpGroupNonUniformShuffleXor: require_extension_internal("GL_KHR_shader_subgroup_shuffle"); break; case OpGroupNonUniformShuffleUp: case OpGroupNonUniformShuffleDown: require_extension_internal("GL_KHR_shader_subgroup_shuffle_relative"); break; case OpGroupNonUniformAll: case OpGroupNonUniformAny: case OpGroupNonUniformAllEqual: { const SPIRType &type = expression_type(ops[3]); if (type.basetype == SPIRType::BaseType::Boolean && type.vecsize == 1u) request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupAll_Any_AllEqualBool); else request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupAllEqualT); } break; case OpGroupNonUniformFAdd: case OpGroupNonUniformFMul: case OpGroupNonUniformFMin: case OpGroupNonUniformFMax: case OpGroupNonUniformIAdd: case OpGroupNonUniformIMul: case OpGroupNonUniformSMin: case OpGroupNonUniformSMax: case OpGroupNonUniformUMin: case OpGroupNonUniformUMax: case OpGroupNonUniformBitwiseAnd: case OpGroupNonUniformBitwiseOr: case OpGroupNonUniformBitwiseXor: { auto operation = static_cast(ops[3]); if (operation == GroupOperationClusteredReduce) { require_extension_internal("GL_KHR_shader_subgroup_clustered"); } else if (operation == GroupOperationExclusiveScan || operation == GroupOperationInclusiveScan || operation == GroupOperationReduce) { require_extension_internal("GL_KHR_shader_subgroup_arithmetic"); } else SPIRV_CROSS_THROW("Invalid group operation."); break; } case OpGroupNonUniformQuadSwap: case OpGroupNonUniformQuadBroadcast: require_extension_internal("GL_KHR_shader_subgroup_quad"); break; default: SPIRV_CROSS_THROW("Invalid opcode for subgroup."); } uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto scope = static_cast(evaluate_constant_u32(ops[2])); if (scope != ScopeSubgroup) SPIRV_CROSS_THROW("Only subgroup scope is supported."); switch (op) { case OpGroupNonUniformElect: emit_op(result_type, id, "subgroupElect()", true); break; case OpGroupNonUniformBroadcast: emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupBroadcast"); break; case OpGroupNonUniformBroadcastFirst: emit_unary_func_op(result_type, id, ops[3], "subgroupBroadcastFirst"); break; case OpGroupNonUniformBallot: emit_unary_func_op(result_type, id, ops[3], "subgroupBallot"); break; case OpGroupNonUniformInverseBallot: emit_unary_func_op(result_type, id, ops[3], "subgroupInverseBallot"); break; case OpGroupNonUniformBallotBitExtract: emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupBallotBitExtract"); break; case OpGroupNonUniformBallotFindLSB: emit_unary_func_op(result_type, id, ops[3], "subgroupBallotFindLSB"); break; case OpGroupNonUniformBallotFindMSB: emit_unary_func_op(result_type, id, ops[3], "subgroupBallotFindMSB"); break; case OpGroupNonUniformBallotBitCount: { auto operation = static_cast(ops[3]); if (operation == GroupOperationReduce) emit_unary_func_op(result_type, id, ops[4], "subgroupBallotBitCount"); else if (operation == GroupOperationInclusiveScan) emit_unary_func_op(result_type, id, ops[4], "subgroupBallotInclusiveBitCount"); else if (operation == GroupOperationExclusiveScan) emit_unary_func_op(result_type, id, ops[4], "subgroupBallotExclusiveBitCount"); else SPIRV_CROSS_THROW("Invalid BitCount operation."); break; } case OpGroupNonUniformShuffle: emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupShuffle"); break; case OpGroupNonUniformShuffleXor: emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupShuffleXor"); break; case OpGroupNonUniformShuffleUp: emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupShuffleUp"); break; case OpGroupNonUniformShuffleDown: emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupShuffleDown"); break; case OpGroupNonUniformAll: emit_unary_func_op(result_type, id, ops[3], "subgroupAll"); break; case OpGroupNonUniformAny: emit_unary_func_op(result_type, id, ops[3], "subgroupAny"); break; case OpGroupNonUniformAllEqual: emit_unary_func_op(result_type, id, ops[3], "subgroupAllEqual"); break; // clang-format off #define GLSL_GROUP_OP(op, glsl_op) \ case OpGroupNonUniform##op: \ { \ auto operation = static_cast(ops[3]); \ if (operation == GroupOperationReduce) \ emit_unary_func_op(result_type, id, ops[4], "subgroup" #glsl_op); \ else if (operation == GroupOperationInclusiveScan) \ emit_unary_func_op(result_type, id, ops[4], "subgroupInclusive" #glsl_op); \ else if (operation == GroupOperationExclusiveScan) \ emit_unary_func_op(result_type, id, ops[4], "subgroupExclusive" #glsl_op); \ else if (operation == GroupOperationClusteredReduce) \ emit_binary_func_op(result_type, id, ops[4], ops[5], "subgroupClustered" #glsl_op); \ else \ SPIRV_CROSS_THROW("Invalid group operation."); \ break; \ } #define GLSL_GROUP_OP_CAST(op, glsl_op, type) \ case OpGroupNonUniform##op: \ { \ auto operation = static_cast(ops[3]); \ if (operation == GroupOperationReduce) \ emit_unary_func_op_cast(result_type, id, ops[4], "subgroup" #glsl_op, type, type); \ else if (operation == GroupOperationInclusiveScan) \ emit_unary_func_op_cast(result_type, id, ops[4], "subgroupInclusive" #glsl_op, type, type); \ else if (operation == GroupOperationExclusiveScan) \ emit_unary_func_op_cast(result_type, id, ops[4], "subgroupExclusive" #glsl_op, type, type); \ else if (operation == GroupOperationClusteredReduce) \ emit_binary_func_op_cast_clustered(result_type, id, ops[4], ops[5], "subgroupClustered" #glsl_op, type); \ else \ SPIRV_CROSS_THROW("Invalid group operation."); \ break; \ } GLSL_GROUP_OP(FAdd, Add) GLSL_GROUP_OP(FMul, Mul) GLSL_GROUP_OP(FMin, Min) GLSL_GROUP_OP(FMax, Max) GLSL_GROUP_OP(IAdd, Add) GLSL_GROUP_OP(IMul, Mul) GLSL_GROUP_OP_CAST(SMin, Min, int_type) GLSL_GROUP_OP_CAST(SMax, Max, int_type) GLSL_GROUP_OP_CAST(UMin, Min, uint_type) GLSL_GROUP_OP_CAST(UMax, Max, uint_type) GLSL_GROUP_OP(BitwiseAnd, And) GLSL_GROUP_OP(BitwiseOr, Or) GLSL_GROUP_OP(BitwiseXor, Xor) #undef GLSL_GROUP_OP #undef GLSL_GROUP_OP_CAST // clang-format on case OpGroupNonUniformQuadSwap: { uint32_t direction = evaluate_constant_u32(ops[4]); if (direction == 0) emit_unary_func_op(result_type, id, ops[3], "subgroupQuadSwapHorizontal"); else if (direction == 1) emit_unary_func_op(result_type, id, ops[3], "subgroupQuadSwapVertical"); else if (direction == 2) emit_unary_func_op(result_type, id, ops[3], "subgroupQuadSwapDiagonal"); else SPIRV_CROSS_THROW("Invalid quad swap direction."); break; } case OpGroupNonUniformQuadBroadcast: { emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupQuadBroadcast"); break; } default: SPIRV_CROSS_THROW("Invalid opcode for subgroup."); } register_control_dependent_expression(id); } string CompilerGLSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in_type) { // OpBitcast can deal with pointers. if (out_type.pointer || in_type.pointer) return type_to_glsl(out_type); if (out_type.basetype == in_type.basetype) return ""; assert(out_type.basetype != SPIRType::Boolean); assert(in_type.basetype != SPIRType::Boolean); bool integral_cast = type_is_integral(out_type) && type_is_integral(in_type); bool same_size_cast = out_type.width == in_type.width; // Trivial bitcast case, casts between integers. if (integral_cast && same_size_cast) return type_to_glsl(out_type); // Catch-all 8-bit arithmetic casts (GL_EXT_shader_explicit_arithmetic_types). if (out_type.width == 8 && in_type.width >= 16 && integral_cast && in_type.vecsize == 1) return "unpack8"; else if (in_type.width == 8 && out_type.width == 16 && integral_cast && out_type.vecsize == 1) return "pack16"; else if (in_type.width == 8 && out_type.width == 32 && integral_cast && out_type.vecsize == 1) return "pack32"; // Floating <-> Integer special casts. Just have to enumerate all cases. :( // 16-bit, 32-bit and 64-bit floats. if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Float) { if (is_legacy_es()) SPIRV_CROSS_THROW("Float -> Uint bitcast not supported on legacy ESSL."); else if (!options.es && options.version < 330) require_extension_internal("GL_ARB_shader_bit_encoding"); return "floatBitsToUint"; } else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::Float) { if (is_legacy_es()) SPIRV_CROSS_THROW("Float -> Int bitcast not supported on legacy ESSL."); else if (!options.es && options.version < 330) require_extension_internal("GL_ARB_shader_bit_encoding"); return "floatBitsToInt"; } else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::UInt) { if (is_legacy_es()) SPIRV_CROSS_THROW("Uint -> Float bitcast not supported on legacy ESSL."); else if (!options.es && options.version < 330) require_extension_internal("GL_ARB_shader_bit_encoding"); return "uintBitsToFloat"; } else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::Int) { if (is_legacy_es()) SPIRV_CROSS_THROW("Int -> Float bitcast not supported on legacy ESSL."); else if (!options.es && options.version < 330) require_extension_internal("GL_ARB_shader_bit_encoding"); return "intBitsToFloat"; } else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::Double) return "doubleBitsToInt64"; else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Double) return "doubleBitsToUint64"; else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::Int64) return "int64BitsToDouble"; else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::UInt64) return "uint64BitsToDouble"; else if (out_type.basetype == SPIRType::Short && in_type.basetype == SPIRType::Half) return "float16BitsToInt16"; else if (out_type.basetype == SPIRType::UShort && in_type.basetype == SPIRType::Half) return "float16BitsToUint16"; else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::Short) return "int16BitsToFloat16"; else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UShort) return "uint16BitsToFloat16"; // And finally, some even more special purpose casts. if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::UInt && in_type.vecsize == 2) return "packUint2x32"; else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::UInt64 && out_type.vecsize == 2) return "unpackUint2x32"; else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UInt && in_type.vecsize == 1) return "unpackFloat2x16"; else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Half && in_type.vecsize == 2) return "packFloat2x16"; else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::Short && in_type.vecsize == 2) return "packInt2x16"; else if (out_type.basetype == SPIRType::Short && in_type.basetype == SPIRType::Int && in_type.vecsize == 1) return "unpackInt2x16"; else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::UShort && in_type.vecsize == 2) return "packUint2x16"; else if (out_type.basetype == SPIRType::UShort && in_type.basetype == SPIRType::UInt && in_type.vecsize == 1) return "unpackUint2x16"; else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::Short && in_type.vecsize == 4) return "packInt4x16"; else if (out_type.basetype == SPIRType::Short && in_type.basetype == SPIRType::Int64 && in_type.vecsize == 1) return "unpackInt4x16"; else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::UShort && in_type.vecsize == 4) return "packUint4x16"; else if (out_type.basetype == SPIRType::UShort && in_type.basetype == SPIRType::UInt64 && in_type.vecsize == 1) return "unpackUint4x16"; return ""; } string CompilerGLSL::bitcast_glsl(const SPIRType &result_type, uint32_t argument) { auto op = bitcast_glsl_op(result_type, expression_type(argument)); if (op.empty()) return to_enclosed_unpacked_expression(argument); else return join(op, "(", to_unpacked_expression(argument), ")"); } std::string CompilerGLSL::bitcast_expression(SPIRType::BaseType target_type, uint32_t arg) { auto expr = to_expression(arg); auto &src_type = expression_type(arg); if (src_type.basetype != target_type) { auto target = src_type; target.basetype = target_type; expr = join(bitcast_glsl_op(target, src_type), "(", expr, ")"); } return expr; } std::string CompilerGLSL::bitcast_expression(const SPIRType &target_type, SPIRType::BaseType expr_type, const std::string &expr) { if (target_type.basetype == expr_type) return expr; auto src_type = target_type; src_type.basetype = expr_type; return join(bitcast_glsl_op(target_type, src_type), "(", expr, ")"); } string CompilerGLSL::builtin_to_glsl(BuiltIn builtin, StorageClass storage) { switch (builtin) { case BuiltInPosition: return "gl_Position"; case BuiltInPointSize: return "gl_PointSize"; case BuiltInClipDistance: return "gl_ClipDistance"; case BuiltInCullDistance: return "gl_CullDistance"; case BuiltInVertexId: if (options.vulkan_semantics) SPIRV_CROSS_THROW("Cannot implement gl_VertexID in Vulkan GLSL. This shader was created " "with GL semantics."); return "gl_VertexID"; case BuiltInInstanceId: if (options.vulkan_semantics) { auto model = get_entry_point().model; switch (model) { case spv::ExecutionModelIntersectionKHR: case spv::ExecutionModelAnyHitKHR: case spv::ExecutionModelClosestHitKHR: // gl_InstanceID is allowed in these shaders. break; default: SPIRV_CROSS_THROW("Cannot implement gl_InstanceID in Vulkan GLSL. This shader was " "created with GL semantics."); } } if (!options.es && options.version < 140) { require_extension_internal("GL_ARB_draw_instanced"); } return "gl_InstanceID"; case BuiltInVertexIndex: if (options.vulkan_semantics) return "gl_VertexIndex"; else return "gl_VertexID"; // gl_VertexID already has the base offset applied. case BuiltInInstanceIndex: if (options.vulkan_semantics) return "gl_InstanceIndex"; if (!options.es && options.version < 140) { require_extension_internal("GL_ARB_draw_instanced"); } if (options.vertex.support_nonzero_base_instance) { if (!options.vulkan_semantics) { // This is a soft-enable. We will opt-in to using gl_BaseInstanceARB if supported. require_extension_internal("GL_ARB_shader_draw_parameters"); } return "(gl_InstanceID + SPIRV_Cross_BaseInstance)"; // ... but not gl_InstanceID. } else return "gl_InstanceID"; case BuiltInPrimitiveId: if (storage == StorageClassInput && get_entry_point().model == ExecutionModelGeometry) return "gl_PrimitiveIDIn"; else return "gl_PrimitiveID"; case BuiltInInvocationId: return "gl_InvocationID"; case BuiltInLayer: return "gl_Layer"; case BuiltInViewportIndex: return "gl_ViewportIndex"; case BuiltInTessLevelOuter: return "gl_TessLevelOuter"; case BuiltInTessLevelInner: return "gl_TessLevelInner"; case BuiltInTessCoord: return "gl_TessCoord"; case BuiltInFragCoord: return "gl_FragCoord"; case BuiltInPointCoord: return "gl_PointCoord"; case BuiltInFrontFacing: return "gl_FrontFacing"; case BuiltInFragDepth: return "gl_FragDepth"; case BuiltInNumWorkgroups: return "gl_NumWorkGroups"; case BuiltInWorkgroupSize: return "gl_WorkGroupSize"; case BuiltInWorkgroupId: return "gl_WorkGroupID"; case BuiltInLocalInvocationId: return "gl_LocalInvocationID"; case BuiltInGlobalInvocationId: return "gl_GlobalInvocationID"; case BuiltInLocalInvocationIndex: return "gl_LocalInvocationIndex"; case BuiltInHelperInvocation: return "gl_HelperInvocation"; case BuiltInBaseVertex: if (options.es) SPIRV_CROSS_THROW("BaseVertex not supported in ES profile."); if (options.vulkan_semantics) { if (options.version < 460) { require_extension_internal("GL_ARB_shader_draw_parameters"); return "gl_BaseVertexARB"; } return "gl_BaseVertex"; } else { // On regular GL, this is soft-enabled and we emit ifdefs in code. require_extension_internal("GL_ARB_shader_draw_parameters"); return "SPIRV_Cross_BaseVertex"; } break; case BuiltInBaseInstance: if (options.es) SPIRV_CROSS_THROW("BaseInstance not supported in ES profile."); if (options.vulkan_semantics) { if (options.version < 460) { require_extension_internal("GL_ARB_shader_draw_parameters"); return "gl_BaseInstanceARB"; } return "gl_BaseInstance"; } else { // On regular GL, this is soft-enabled and we emit ifdefs in code. require_extension_internal("GL_ARB_shader_draw_parameters"); return "SPIRV_Cross_BaseInstance"; } break; case BuiltInDrawIndex: if (options.es) SPIRV_CROSS_THROW("DrawIndex not supported in ES profile."); if (options.vulkan_semantics) { if (options.version < 460) { require_extension_internal("GL_ARB_shader_draw_parameters"); return "gl_DrawIDARB"; } return "gl_DrawID"; } else { // On regular GL, this is soft-enabled and we emit ifdefs in code. require_extension_internal("GL_ARB_shader_draw_parameters"); return "gl_DrawIDARB"; } break; case BuiltInSampleId: if (options.es && options.version < 320) require_extension_internal("GL_OES_sample_variables"); if (!options.es && options.version < 400) SPIRV_CROSS_THROW("gl_SampleID not supported before GLSL 400."); return "gl_SampleID"; case BuiltInSampleMask: if (options.es && options.version < 320) require_extension_internal("GL_OES_sample_variables"); if (!options.es && options.version < 400) SPIRV_CROSS_THROW("gl_SampleMask/gl_SampleMaskIn not supported before GLSL 400."); if (storage == StorageClassInput) return "gl_SampleMaskIn"; else return "gl_SampleMask"; case BuiltInSamplePosition: if (options.es && options.version < 320) require_extension_internal("GL_OES_sample_variables"); if (!options.es && options.version < 400) SPIRV_CROSS_THROW("gl_SamplePosition not supported before GLSL 400."); return "gl_SamplePosition"; case BuiltInViewIndex: if (options.vulkan_semantics) { require_extension_internal("GL_EXT_multiview"); return "gl_ViewIndex"; } else { require_extension_internal("GL_OVR_multiview2"); return "gl_ViewID_OVR"; } case BuiltInNumSubgroups: request_subgroup_feature(ShaderSubgroupSupportHelper::NumSubgroups); return "gl_NumSubgroups"; case BuiltInSubgroupId: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupID); return "gl_SubgroupID"; case BuiltInSubgroupSize: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupSize); return "gl_SubgroupSize"; case BuiltInSubgroupLocalInvocationId: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupInvocationID); return "gl_SubgroupInvocationID"; case BuiltInSubgroupEqMask: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask); return "gl_SubgroupEqMask"; case BuiltInSubgroupGeMask: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask); return "gl_SubgroupGeMask"; case BuiltInSubgroupGtMask: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask); return "gl_SubgroupGtMask"; case BuiltInSubgroupLeMask: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask); return "gl_SubgroupLeMask"; case BuiltInSubgroupLtMask: request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask); return "gl_SubgroupLtMask"; case BuiltInLaunchIdKHR: return ray_tracing_is_khr ? "gl_LaunchIDEXT" : "gl_LaunchIDNV"; case BuiltInLaunchSizeKHR: return ray_tracing_is_khr ? "gl_LaunchSizeEXT" : "gl_LaunchSizeNV"; case BuiltInWorldRayOriginKHR: return ray_tracing_is_khr ? "gl_WorldRayOriginEXT" : "gl_WorldRayOriginNV"; case BuiltInWorldRayDirectionKHR: return ray_tracing_is_khr ? "gl_WorldRayDirectionEXT" : "gl_WorldRayDirectionNV"; case BuiltInObjectRayOriginKHR: return ray_tracing_is_khr ? "gl_ObjectRayOriginEXT" : "gl_ObjectRayOriginNV"; case BuiltInObjectRayDirectionKHR: return ray_tracing_is_khr ? "gl_ObjectRayDirectionEXT" : "gl_ObjectRayDirectionNV"; case BuiltInRayTminKHR: return ray_tracing_is_khr ? "gl_RayTminEXT" : "gl_RayTminNV"; case BuiltInRayTmaxKHR: return ray_tracing_is_khr ? "gl_RayTmaxEXT" : "gl_RayTmaxNV"; case BuiltInInstanceCustomIndexKHR: return ray_tracing_is_khr ? "gl_InstanceCustomIndexEXT" : "gl_InstanceCustomIndexNV"; case BuiltInObjectToWorldKHR: return ray_tracing_is_khr ? "gl_ObjectToWorldEXT" : "gl_ObjectToWorldNV"; case BuiltInWorldToObjectKHR: return ray_tracing_is_khr ? "gl_WorldToObjectEXT" : "gl_WorldToObjectNV"; case BuiltInHitTNV: // gl_HitTEXT is an alias of RayTMax in KHR. return "gl_HitTNV"; case BuiltInHitKindKHR: return ray_tracing_is_khr ? "gl_HitKindEXT" : "gl_HitKindNV"; case BuiltInIncomingRayFlagsKHR: return ray_tracing_is_khr ? "gl_IncomingRayFlagsEXT" : "gl_IncomingRayFlagsNV"; case BuiltInBaryCoordNV: { if (options.es && options.version < 320) SPIRV_CROSS_THROW("gl_BaryCoordNV requires ESSL 320."); else if (!options.es && options.version < 450) SPIRV_CROSS_THROW("gl_BaryCoordNV requires GLSL 450."); require_extension_internal("GL_NV_fragment_shader_barycentric"); return "gl_BaryCoordNV"; } case BuiltInBaryCoordNoPerspNV: { if (options.es && options.version < 320) SPIRV_CROSS_THROW("gl_BaryCoordNoPerspNV requires ESSL 320."); else if (!options.es && options.version < 450) SPIRV_CROSS_THROW("gl_BaryCoordNoPerspNV requires GLSL 450."); require_extension_internal("GL_NV_fragment_shader_barycentric"); return "gl_BaryCoordNoPerspNV"; } case BuiltInFragStencilRefEXT: { if (!options.es) { require_extension_internal("GL_ARB_shader_stencil_export"); return "gl_FragStencilRefARB"; } else SPIRV_CROSS_THROW("Stencil export not supported in GLES."); } case BuiltInDeviceIndex: if (!options.vulkan_semantics) SPIRV_CROSS_THROW("Need Vulkan semantics for device group support."); require_extension_internal("GL_EXT_device_group"); return "gl_DeviceIndex"; default: return join("gl_BuiltIn_", convert_to_string(builtin)); } } const char *CompilerGLSL::index_to_swizzle(uint32_t index) { switch (index) { case 0: return "x"; case 1: return "y"; case 2: return "z"; case 3: return "w"; default: SPIRV_CROSS_THROW("Swizzle index out of range"); } } void CompilerGLSL::access_chain_internal_append_index(std::string &expr, uint32_t /*base*/, const SPIRType *type, AccessChainFlags flags, bool & /*access_chain_is_arrayed*/, uint32_t index) { bool index_is_literal = (flags & ACCESS_CHAIN_INDEX_IS_LITERAL_BIT) != 0; bool register_expression_read = (flags & ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT) == 0; expr += "["; // If we are indexing into an array of SSBOs or UBOs, we need to index it with a non-uniform qualifier. bool nonuniform_index = has_decoration(index, DecorationNonUniformEXT) && (has_decoration(type->self, DecorationBlock) || has_decoration(type->self, DecorationBufferBlock)); if (nonuniform_index) { expr += backend.nonuniform_qualifier; expr += "("; } if (index_is_literal) expr += convert_to_string(index); else expr += to_expression(index, register_expression_read); if (nonuniform_index) expr += ")"; expr += "]"; } string CompilerGLSL::access_chain_internal(uint32_t base, const uint32_t *indices, uint32_t count, AccessChainFlags flags, AccessChainMeta *meta) { string expr; bool index_is_literal = (flags & ACCESS_CHAIN_INDEX_IS_LITERAL_BIT) != 0; bool msb_is_id = (flags & ACCESS_CHAIN_LITERAL_MSB_FORCE_ID) != 0; bool chain_only = (flags & ACCESS_CHAIN_CHAIN_ONLY_BIT) != 0; bool ptr_chain = (flags & ACCESS_CHAIN_PTR_CHAIN_BIT) != 0; bool register_expression_read = (flags & ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT) == 0; bool flatten_member_reference = (flags & ACCESS_CHAIN_FLATTEN_ALL_MEMBERS_BIT) != 0; if (!chain_only) { // We handle transpose explicitly, so don't resolve that here. auto *e = maybe_get(base); bool old_transpose = e && e->need_transpose; if (e) e->need_transpose = false; expr = to_enclosed_expression(base, register_expression_read); if (e) e->need_transpose = old_transpose; } // Start traversing type hierarchy at the proper non-pointer types, // but keep type_id referencing the original pointer for use below. uint32_t type_id = expression_type_id(base); if (!backend.native_pointers) { if (ptr_chain) SPIRV_CROSS_THROW("Backend does not support native pointers and does not support OpPtrAccessChain."); // Wrapped buffer reference pointer types will need to poke into the internal "value" member before // continuing the access chain. if (should_dereference(base)) { auto &type = get(type_id); expr = dereference_expression(type, expr); } } const auto *type = &get_pointee_type(type_id); bool access_chain_is_arrayed = expr.find_first_of('[') != string::npos; bool row_major_matrix_needs_conversion = is_non_native_row_major_matrix(base); bool is_packed = has_extended_decoration(base, SPIRVCrossDecorationPhysicalTypePacked); uint32_t physical_type = get_extended_decoration(base, SPIRVCrossDecorationPhysicalTypeID); bool is_invariant = has_decoration(base, DecorationInvariant); bool pending_array_enclose = false; bool dimension_flatten = false; const auto append_index = [&](uint32_t index, bool is_literal) { AccessChainFlags mod_flags = flags; if (!is_literal) mod_flags &= ~ACCESS_CHAIN_INDEX_IS_LITERAL_BIT; access_chain_internal_append_index(expr, base, type, mod_flags, access_chain_is_arrayed, index); }; for (uint32_t i = 0; i < count; i++) { uint32_t index = indices[i]; bool is_literal = index_is_literal; if (is_literal && msb_is_id && (index >> 31u) != 0u) { is_literal = false; index &= 0x7fffffffu; } // Pointer chains if (ptr_chain && i == 0) { // If we are flattening multidimensional arrays, only create opening bracket on first // array index. if (options.flatten_multidimensional_arrays) { dimension_flatten = type->array.size() >= 1; pending_array_enclose = dimension_flatten; if (pending_array_enclose) expr += "["; } if (options.flatten_multidimensional_arrays && dimension_flatten) { // If we are flattening multidimensional arrays, do manual stride computation. if (is_literal) expr += convert_to_string(index); else expr += to_enclosed_expression(index, register_expression_read); for (auto j = uint32_t(type->array.size()); j; j--) { expr += " * "; expr += enclose_expression(to_array_size(*type, j - 1)); } if (type->array.empty()) pending_array_enclose = false; else expr += " + "; if (!pending_array_enclose) expr += "]"; } else { append_index(index, is_literal); } if (type->basetype == SPIRType::ControlPointArray) { type_id = type->parent_type; type = &get(type_id); } access_chain_is_arrayed = true; } // Arrays else if (!type->array.empty()) { // If we are flattening multidimensional arrays, only create opening bracket on first // array index. if (options.flatten_multidimensional_arrays && !pending_array_enclose) { dimension_flatten = type->array.size() > 1; pending_array_enclose = dimension_flatten; if (pending_array_enclose) expr += "["; } assert(type->parent_type); auto *var = maybe_get(base); if (backend.force_gl_in_out_block && i == 0 && var && is_builtin_variable(*var) && !has_decoration(type->self, DecorationBlock)) { // This deals with scenarios for tesc/geom where arrays of gl_Position[] are declared. // Normally, these variables live in blocks when compiled from GLSL, // but HLSL seems to just emit straight arrays here. // We must pretend this access goes through gl_in/gl_out arrays // to be able to access certain builtins as arrays. auto builtin = ir.meta[base].decoration.builtin_type; switch (builtin) { // case BuiltInCullDistance: // These are already arrays, need to figure out rules for these in tess/geom. // case BuiltInClipDistance: case BuiltInPosition: case BuiltInPointSize: if (var->storage == StorageClassInput) expr = join("gl_in[", to_expression(index, register_expression_read), "].", expr); else if (var->storage == StorageClassOutput) expr = join("gl_out[", to_expression(index, register_expression_read), "].", expr); else append_index(index, is_literal); break; default: append_index(index, is_literal); break; } } else if (options.flatten_multidimensional_arrays && dimension_flatten) { // If we are flattening multidimensional arrays, do manual stride computation. auto &parent_type = get(type->parent_type); if (is_literal) expr += convert_to_string(index); else expr += to_enclosed_expression(index, register_expression_read); for (auto j = uint32_t(parent_type.array.size()); j; j--) { expr += " * "; expr += enclose_expression(to_array_size(parent_type, j - 1)); } if (parent_type.array.empty()) pending_array_enclose = false; else expr += " + "; if (!pending_array_enclose) expr += "]"; } // Some builtins are arrays in SPIR-V but not in other languages, e.g. gl_SampleMask[] is an array in SPIR-V but not in Metal. // By throwing away the index, we imply the index was 0, which it must be for gl_SampleMask. else if (!builtin_translates_to_nonarray(BuiltIn(get_decoration(base, DecorationBuiltIn)))) { append_index(index, is_literal); } type_id = type->parent_type; type = &get(type_id); access_chain_is_arrayed = true; } // For structs, the index refers to a constant, which indexes into the members. // We also check if this member is a builtin, since we then replace the entire expression with the builtin one. else if (type->basetype == SPIRType::Struct) { if (!is_literal) index = evaluate_constant_u32(index); if (index >= type->member_types.size()) SPIRV_CROSS_THROW("Member index is out of bounds!"); BuiltIn builtin; if (is_member_builtin(*type, index, &builtin)) { if (access_chain_is_arrayed) { expr += "."; expr += builtin_to_glsl(builtin, type->storage); } else expr = builtin_to_glsl(builtin, type->storage); } else { // If the member has a qualified name, use it as the entire chain string qual_mbr_name = get_member_qualified_name(type_id, index); if (!qual_mbr_name.empty()) expr = qual_mbr_name; else if (flatten_member_reference) expr += join("_", to_member_name(*type, index)); else expr += to_member_reference(base, *type, index, ptr_chain); } if (has_member_decoration(type->self, index, DecorationInvariant)) is_invariant = true; is_packed = member_is_packed_physical_type(*type, index); if (member_is_remapped_physical_type(*type, index)) physical_type = get_extended_member_decoration(type->self, index, SPIRVCrossDecorationPhysicalTypeID); else physical_type = 0; row_major_matrix_needs_conversion = member_is_non_native_row_major_matrix(*type, index); type = &get(type->member_types[index]); } // Matrix -> Vector else if (type->columns > 1) { // If we have a row-major matrix here, we need to defer any transpose in case this access chain // is used to store a column. We can resolve it right here and now if we access a scalar directly, // by flipping indexing order of the matrix. expr += "["; if (is_literal) expr += convert_to_string(index); else expr += to_expression(index, register_expression_read); expr += "]"; type_id = type->parent_type; type = &get(type_id); } // Vector -> Scalar else if (type->vecsize > 1) { string deferred_index; if (row_major_matrix_needs_conversion) { // Flip indexing order. auto column_index = expr.find_last_of('['); if (column_index != string::npos) { deferred_index = expr.substr(column_index); expr.resize(column_index); } } // Internally, access chain implementation can also be used on composites, // ignore scalar access workarounds in this case. StorageClass effective_storage; if (expression_type(base).pointer) effective_storage = get_expression_effective_storage_class(base); else effective_storage = StorageClassGeneric; if (!row_major_matrix_needs_conversion) { // On some backends, we might not be able to safely access individual scalars in a vector. // To work around this, we might have to cast the access chain reference to something which can, // like a pointer to scalar, which we can then index into. prepare_access_chain_for_scalar_access(expr, get(type->parent_type), effective_storage, is_packed); } if (is_literal && !is_packed && !row_major_matrix_needs_conversion) { expr += "."; expr += index_to_swizzle(index); } else if (ir.ids[index].get_type() == TypeConstant && !is_packed && !row_major_matrix_needs_conversion) { auto &c = get(index); if (c.specialization) { // If the index is a spec constant, we cannot turn extract into a swizzle. expr += join("[", to_expression(index), "]"); } else { expr += "."; expr += index_to_swizzle(c.scalar()); } } else if (is_literal) { // For packed vectors, we can only access them as an array, not by swizzle. expr += join("[", index, "]"); } else { expr += "["; expr += to_expression(index, register_expression_read); expr += "]"; } if (row_major_matrix_needs_conversion) { prepare_access_chain_for_scalar_access(expr, get(type->parent_type), effective_storage, is_packed); } expr += deferred_index; row_major_matrix_needs_conversion = false; is_packed = false; physical_type = 0; type_id = type->parent_type; type = &get(type_id); } else if (!backend.allow_truncated_access_chain) SPIRV_CROSS_THROW("Cannot subdivide a scalar value!"); } if (pending_array_enclose) { SPIRV_CROSS_THROW("Flattening of multidimensional arrays were enabled, " "but the access chain was terminated in the middle of a multidimensional array. " "This is not supported."); } if (meta) { meta->need_transpose = row_major_matrix_needs_conversion; meta->storage_is_packed = is_packed; meta->storage_is_invariant = is_invariant; meta->storage_physical_type = physical_type; } return expr; } void CompilerGLSL::prepare_access_chain_for_scalar_access(std::string &, const SPIRType &, spv::StorageClass, bool &) { } string CompilerGLSL::to_flattened_struct_member(const string &basename, const SPIRType &type, uint32_t index) { auto ret = join(basename, "_", to_member_name(type, index)); ParsedIR::sanitize_underscores(ret); return ret; } string CompilerGLSL::access_chain(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, AccessChainMeta *meta, bool ptr_chain) { if (flattened_buffer_blocks.count(base)) { uint32_t matrix_stride = 0; uint32_t array_stride = 0; bool need_transpose = false; flattened_access_chain_offset(expression_type(base), indices, count, 0, 16, &need_transpose, &matrix_stride, &array_stride, ptr_chain); if (meta) { meta->need_transpose = target_type.columns > 1 && need_transpose; meta->storage_is_packed = false; } return flattened_access_chain(base, indices, count, target_type, 0, matrix_stride, array_stride, need_transpose); } else if (flattened_structs.count(base) && count > 0) { AccessChainFlags flags = ACCESS_CHAIN_CHAIN_ONLY_BIT | ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT; if (ptr_chain) flags |= ACCESS_CHAIN_PTR_CHAIN_BIT; if (flattened_structs[base]) { flags |= ACCESS_CHAIN_FLATTEN_ALL_MEMBERS_BIT; if (meta) meta->flattened_struct = target_type.basetype == SPIRType::Struct; } auto chain = access_chain_internal(base, indices, count, flags, nullptr).substr(1); if (meta) { meta->need_transpose = false; meta->storage_is_packed = false; } auto basename = to_flattened_access_chain_expression(base); auto ret = join(basename, "_", chain); ParsedIR::sanitize_underscores(ret); return ret; } else { AccessChainFlags flags = ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT; if (ptr_chain) flags |= ACCESS_CHAIN_PTR_CHAIN_BIT; return access_chain_internal(base, indices, count, flags, meta); } } string CompilerGLSL::load_flattened_struct(const string &basename, const SPIRType &type) { auto expr = type_to_glsl_constructor(type); expr += '('; for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++) { if (i) expr += ", "; auto &member_type = get(type.member_types[i]); if (member_type.basetype == SPIRType::Struct) expr += load_flattened_struct(to_flattened_struct_member(basename, type, i), member_type); else expr += to_flattened_struct_member(basename, type, i); } expr += ')'; return expr; } std::string CompilerGLSL::to_flattened_access_chain_expression(uint32_t id) { // Do not use to_expression as that will unflatten access chains. string basename; if (const auto *var = maybe_get(id)) basename = to_name(var->self); else if (const auto *expr = maybe_get(id)) basename = expr->expression; else basename = to_expression(id); return basename; } void CompilerGLSL::store_flattened_struct(const string &basename, uint32_t rhs_id, const SPIRType &type, const SmallVector &indices) { SmallVector sub_indices = indices; sub_indices.push_back(0); auto *member_type = &type; for (auto &index : indices) member_type = &get(member_type->member_types[index]); for (uint32_t i = 0; i < uint32_t(member_type->member_types.size()); i++) { sub_indices.back() = i; auto lhs = join(basename, "_", to_member_name(*member_type, i)); ParsedIR::sanitize_underscores(lhs); if (get(member_type->member_types[i]).basetype == SPIRType::Struct) { store_flattened_struct(lhs, rhs_id, type, sub_indices); } else { auto rhs = to_expression(rhs_id) + to_multi_member_reference(type, sub_indices); statement(lhs, " = ", rhs, ";"); } } } void CompilerGLSL::store_flattened_struct(uint32_t lhs_id, uint32_t value) { auto &type = expression_type(lhs_id); auto basename = to_flattened_access_chain_expression(lhs_id); store_flattened_struct(basename, value, type, {}); } std::string CompilerGLSL::flattened_access_chain(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, uint32_t /* array_stride */, bool need_transpose) { if (!target_type.array.empty()) SPIRV_CROSS_THROW("Access chains that result in an array can not be flattened"); else if (target_type.basetype == SPIRType::Struct) return flattened_access_chain_struct(base, indices, count, target_type, offset); else if (target_type.columns > 1) return flattened_access_chain_matrix(base, indices, count, target_type, offset, matrix_stride, need_transpose); else return flattened_access_chain_vector(base, indices, count, target_type, offset, matrix_stride, need_transpose); } std::string CompilerGLSL::flattened_access_chain_struct(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset) { std::string expr; expr += type_to_glsl_constructor(target_type); expr += "("; for (uint32_t i = 0; i < uint32_t(target_type.member_types.size()); ++i) { if (i != 0) expr += ", "; const SPIRType &member_type = get(target_type.member_types[i]); uint32_t member_offset = type_struct_member_offset(target_type, i); // The access chain terminates at the struct, so we need to find matrix strides and row-major information // ahead of time. bool need_transpose = false; uint32_t matrix_stride = 0; if (member_type.columns > 1) { need_transpose = combined_decoration_for_member(target_type, i).get(DecorationRowMajor); matrix_stride = type_struct_member_matrix_stride(target_type, i); } auto tmp = flattened_access_chain(base, indices, count, member_type, offset + member_offset, matrix_stride, 0 /* array_stride */, need_transpose); // Cannot forward transpositions, so resolve them here. if (need_transpose) expr += convert_row_major_matrix(tmp, member_type, 0, false); else expr += tmp; } expr += ")"; return expr; } std::string CompilerGLSL::flattened_access_chain_matrix(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, bool need_transpose) { assert(matrix_stride); SPIRType tmp_type = target_type; if (need_transpose) swap(tmp_type.vecsize, tmp_type.columns); std::string expr; expr += type_to_glsl_constructor(tmp_type); expr += "("; for (uint32_t i = 0; i < tmp_type.columns; i++) { if (i != 0) expr += ", "; expr += flattened_access_chain_vector(base, indices, count, tmp_type, offset + i * matrix_stride, matrix_stride, /* need_transpose= */ false); } expr += ")"; return expr; } std::string CompilerGLSL::flattened_access_chain_vector(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, bool need_transpose) { auto result = flattened_access_chain_offset(expression_type(base), indices, count, offset, 16); auto buffer_name = to_name(expression_type(base).self); if (need_transpose) { std::string expr; if (target_type.vecsize > 1) { expr += type_to_glsl_constructor(target_type); expr += "("; } for (uint32_t i = 0; i < target_type.vecsize; ++i) { if (i != 0) expr += ", "; uint32_t component_offset = result.second + i * matrix_stride; assert(component_offset % (target_type.width / 8) == 0); uint32_t index = component_offset / (target_type.width / 8); expr += buffer_name; expr += "["; expr += result.first; // this is a series of N1 * k1 + N2 * k2 + ... that is either empty or ends with a + expr += convert_to_string(index / 4); expr += "]"; expr += vector_swizzle(1, index % 4); } if (target_type.vecsize > 1) { expr += ")"; } return expr; } else { assert(result.second % (target_type.width / 8) == 0); uint32_t index = result.second / (target_type.width / 8); std::string expr; expr += buffer_name; expr += "["; expr += result.first; // this is a series of N1 * k1 + N2 * k2 + ... that is either empty or ends with a + expr += convert_to_string(index / 4); expr += "]"; expr += vector_swizzle(target_type.vecsize, index % 4); return expr; } } std::pair CompilerGLSL::flattened_access_chain_offset( const SPIRType &basetype, const uint32_t *indices, uint32_t count, uint32_t offset, uint32_t word_stride, bool *need_transpose, uint32_t *out_matrix_stride, uint32_t *out_array_stride, bool ptr_chain) { // Start traversing type hierarchy at the proper non-pointer types. const auto *type = &get_pointee_type(basetype); std::string expr; // Inherit matrix information in case we are access chaining a vector which might have come from a row major layout. bool row_major_matrix_needs_conversion = need_transpose ? *need_transpose : false; uint32_t matrix_stride = out_matrix_stride ? *out_matrix_stride : 0; uint32_t array_stride = out_array_stride ? *out_array_stride : 0; for (uint32_t i = 0; i < count; i++) { uint32_t index = indices[i]; // Pointers if (ptr_chain && i == 0) { // Here, the pointer type will be decorated with an array stride. array_stride = get_decoration(basetype.self, DecorationArrayStride); if (!array_stride) SPIRV_CROSS_THROW("SPIR-V does not define ArrayStride for buffer block."); auto *constant = maybe_get(index); if (constant) { // Constant array access. offset += constant->scalar() * array_stride; } else { // Dynamic array access. if (array_stride % word_stride) { SPIRV_CROSS_THROW("Array stride for dynamic indexing must be divisible by the size " "of a 4-component vector. " "Likely culprit here is a float or vec2 array inside a push " "constant block which is std430. " "This cannot be flattened. Try using std140 layout instead."); } expr += to_enclosed_expression(index); expr += " * "; expr += convert_to_string(array_stride / word_stride); expr += " + "; } } // Arrays else if (!type->array.empty()) { auto *constant = maybe_get(index); if (constant) { // Constant array access. offset += constant->scalar() * array_stride; } else { // Dynamic array access. if (array_stride % word_stride) { SPIRV_CROSS_THROW("Array stride for dynamic indexing must be divisible by the size " "of a 4-component vector. " "Likely culprit here is a float or vec2 array inside a push " "constant block which is std430. " "This cannot be flattened. Try using std140 layout instead."); } expr += to_enclosed_expression(index, false); expr += " * "; expr += convert_to_string(array_stride / word_stride); expr += " + "; } uint32_t parent_type = type->parent_type; type = &get(parent_type); if (!type->array.empty()) array_stride = get_decoration(parent_type, DecorationArrayStride); } // For structs, the index refers to a constant, which indexes into the members. // We also check if this member is a builtin, since we then replace the entire expression with the builtin one. else if (type->basetype == SPIRType::Struct) { index = evaluate_constant_u32(index); if (index >= type->member_types.size()) SPIRV_CROSS_THROW("Member index is out of bounds!"); offset += type_struct_member_offset(*type, index); auto &struct_type = *type; type = &get(type->member_types[index]); if (type->columns > 1) { matrix_stride = type_struct_member_matrix_stride(struct_type, index); row_major_matrix_needs_conversion = combined_decoration_for_member(struct_type, index).get(DecorationRowMajor); } else row_major_matrix_needs_conversion = false; if (!type->array.empty()) array_stride = type_struct_member_array_stride(struct_type, index); } // Matrix -> Vector else if (type->columns > 1) { auto *constant = maybe_get(index); if (constant) { index = evaluate_constant_u32(index); offset += index * (row_major_matrix_needs_conversion ? (type->width / 8) : matrix_stride); } else { uint32_t indexing_stride = row_major_matrix_needs_conversion ? (type->width / 8) : matrix_stride; // Dynamic array access. if (indexing_stride % word_stride) { SPIRV_CROSS_THROW("Matrix stride for dynamic indexing must be divisible by the size of a " "4-component vector. " "Likely culprit here is a row-major matrix being accessed dynamically. " "This cannot be flattened. Try using std140 layout instead."); } expr += to_enclosed_expression(index, false); expr += " * "; expr += convert_to_string(indexing_stride / word_stride); expr += " + "; } type = &get(type->parent_type); } // Vector -> Scalar else if (type->vecsize > 1) { auto *constant = maybe_get(index); if (constant) { index = evaluate_constant_u32(index); offset += index * (row_major_matrix_needs_conversion ? matrix_stride : (type->width / 8)); } else { uint32_t indexing_stride = row_major_matrix_needs_conversion ? matrix_stride : (type->width / 8); // Dynamic array access. if (indexing_stride % word_stride) { SPIRV_CROSS_THROW("Stride for dynamic vector indexing must be divisible by the " "size of a 4-component vector. " "This cannot be flattened in legacy targets."); } expr += to_enclosed_expression(index, false); expr += " * "; expr += convert_to_string(indexing_stride / word_stride); expr += " + "; } type = &get(type->parent_type); } else SPIRV_CROSS_THROW("Cannot subdivide a scalar value!"); } if (need_transpose) *need_transpose = row_major_matrix_needs_conversion; if (out_matrix_stride) *out_matrix_stride = matrix_stride; if (out_array_stride) *out_array_stride = array_stride; return std::make_pair(expr, offset); } bool CompilerGLSL::should_dereference(uint32_t id) { const auto &type = expression_type(id); // Non-pointer expressions don't need to be dereferenced. if (!type.pointer) return false; // Handles shouldn't be dereferenced either. if (!expression_is_lvalue(id)) return false; // If id is a variable but not a phi variable, we should not dereference it. if (auto *var = maybe_get(id)) return var->phi_variable; // If id is an access chain, we should not dereference it. if (auto *expr = maybe_get(id)) return !expr->access_chain; // Otherwise, we should dereference this pointer expression. return true; } bool CompilerGLSL::should_forward(uint32_t id) const { // If id is a variable we will try to forward it regardless of force_temporary check below // This is important because otherwise we'll get local sampler copies (highp sampler2D foo = bar) that are invalid in OpenGL GLSL auto *var = maybe_get(id); if (var && var->forwardable) return true; // For debugging emit temporary variables for all expressions if (options.force_temporary) return false; // Immutable expression can always be forwarded. if (is_immutable(id)) return true; return false; } bool CompilerGLSL::should_suppress_usage_tracking(uint32_t id) const { // Used only by opcodes which don't do any real "work", they just swizzle data in some fashion. return !expression_is_forwarded(id) || expression_suppresses_usage_tracking(id); } void CompilerGLSL::track_expression_read(uint32_t id) { switch (ir.ids[id].get_type()) { case TypeExpression: { auto &e = get(id); for (auto implied_read : e.implied_read_expressions) track_expression_read(implied_read); break; } case TypeAccessChain: { auto &e = get(id); for (auto implied_read : e.implied_read_expressions) track_expression_read(implied_read); break; } default: break; } // If we try to read a forwarded temporary more than once we will stamp out possibly complex code twice. // In this case, it's better to just bind the complex expression to the temporary and read that temporary twice. if (expression_is_forwarded(id) && !expression_suppresses_usage_tracking(id)) { auto &v = expression_usage_counts[id]; v++; // If we create an expression outside a loop, // but access it inside a loop, we're implicitly reading it multiple times. // If the expression in question is expensive, we should hoist it out to avoid relying on loop-invariant code motion // working inside the backend compiler. if (expression_read_implies_multiple_reads(id)) v++; if (v >= 2) { //if (v == 2) // fprintf(stderr, "ID %u was forced to temporary due to more than 1 expression use!\n", id); forced_temporaries.insert(id); // Force a recompile after this pass to avoid forwarding this variable. force_recompile(); } } } bool CompilerGLSL::args_will_forward(uint32_t id, const uint32_t *args, uint32_t num_args, bool pure) { if (forced_temporaries.find(id) != end(forced_temporaries)) return false; for (uint32_t i = 0; i < num_args; i++) if (!should_forward(args[i])) return false; // We need to forward globals as well. if (!pure) { for (auto global : global_variables) if (!should_forward(global)) return false; for (auto aliased : aliased_variables) if (!should_forward(aliased)) return false; } return true; } void CompilerGLSL::register_impure_function_call() { // Impure functions can modify globals and aliased variables, so invalidate them as well. for (auto global : global_variables) flush_dependees(get(global)); for (auto aliased : aliased_variables) flush_dependees(get(aliased)); } void CompilerGLSL::register_call_out_argument(uint32_t id) { register_write(id); auto *var = maybe_get(id); if (var) flush_variable_declaration(var->self); } string CompilerGLSL::variable_decl_function_local(SPIRVariable &var) { // These variables are always function local, // so make sure we emit the variable without storage qualifiers. // Some backends will inject custom variables locally in a function // with a storage qualifier which is not function-local. auto old_storage = var.storage; var.storage = StorageClassFunction; auto expr = variable_decl(var); var.storage = old_storage; return expr; } void CompilerGLSL::emit_variable_temporary_copies(const SPIRVariable &var) { // Ensure that we declare phi-variable copies even if the original declaration isn't deferred if (var.allocate_temporary_copy && !flushed_phi_variables.count(var.self)) { auto &type = get(var.basetype); auto &flags = get_decoration_bitset(var.self); statement(flags_to_qualifiers_glsl(type, flags), variable_decl(type, join("_", var.self, "_copy")), ";"); flushed_phi_variables.insert(var.self); } } void CompilerGLSL::flush_variable_declaration(uint32_t id) { // Ensure that we declare phi-variable copies even if the original declaration isn't deferred auto *var = maybe_get(id); if (var && var->deferred_declaration) { string initializer; if (options.force_zero_initialized_variables && (var->storage == StorageClassFunction || var->storage == StorageClassGeneric || var->storage == StorageClassPrivate) && !var->initializer && type_can_zero_initialize(get_variable_data_type(*var))) { initializer = join(" = ", to_zero_initialized_expression(get_variable_data_type_id(*var))); } statement(variable_decl_function_local(*var), initializer, ";"); var->deferred_declaration = false; } if (var) { emit_variable_temporary_copies(*var); } } bool CompilerGLSL::remove_duplicate_swizzle(string &op) { auto pos = op.find_last_of('.'); if (pos == string::npos || pos == 0) return false; string final_swiz = op.substr(pos + 1, string::npos); if (backend.swizzle_is_function) { if (final_swiz.size() < 2) return false; if (final_swiz.substr(final_swiz.size() - 2, string::npos) == "()") final_swiz.erase(final_swiz.size() - 2, string::npos); else return false; } // Check if final swizzle is of form .x, .xy, .xyz, .xyzw or similar. // If so, and previous swizzle is of same length, // we can drop the final swizzle altogether. for (uint32_t i = 0; i < final_swiz.size(); i++) { static const char expected[] = { 'x', 'y', 'z', 'w' }; if (i >= 4 || final_swiz[i] != expected[i]) return false; } auto prevpos = op.find_last_of('.', pos - 1); if (prevpos == string::npos) return false; prevpos++; // Make sure there are only swizzles here ... for (auto i = prevpos; i < pos; i++) { if (op[i] < 'w' || op[i] > 'z') { // If swizzles are foo.xyz() like in C++ backend for example, check for that. if (backend.swizzle_is_function && i + 2 == pos && op[i] == '(' && op[i + 1] == ')') break; return false; } } // If original swizzle is large enough, just carve out the components we need. // E.g. foobar.wyx.xy will turn into foobar.wy. if (pos - prevpos >= final_swiz.size()) { op.erase(prevpos + final_swiz.size(), string::npos); // Add back the function call ... if (backend.swizzle_is_function) op += "()"; } return true; } // Optimizes away vector swizzles where we have something like // vec3 foo; // foo.xyz <-- swizzle expression does nothing. // This is a very common pattern after OpCompositeCombine. bool CompilerGLSL::remove_unity_swizzle(uint32_t base, string &op) { auto pos = op.find_last_of('.'); if (pos == string::npos || pos == 0) return false; string final_swiz = op.substr(pos + 1, string::npos); if (backend.swizzle_is_function) { if (final_swiz.size() < 2) return false; if (final_swiz.substr(final_swiz.size() - 2, string::npos) == "()") final_swiz.erase(final_swiz.size() - 2, string::npos); else return false; } // Check if final swizzle is of form .x, .xy, .xyz, .xyzw or similar. // If so, and previous swizzle is of same length, // we can drop the final swizzle altogether. for (uint32_t i = 0; i < final_swiz.size(); i++) { static const char expected[] = { 'x', 'y', 'z', 'w' }; if (i >= 4 || final_swiz[i] != expected[i]) return false; } auto &type = expression_type(base); // Sanity checking ... assert(type.columns == 1 && type.array.empty()); if (type.vecsize == final_swiz.size()) op.erase(pos, string::npos); return true; } string CompilerGLSL::build_composite_combiner(uint32_t return_type, const uint32_t *elems, uint32_t length) { ID base = 0; string op; string subop; // Can only merge swizzles for vectors. auto &type = get(return_type); bool can_apply_swizzle_opt = type.basetype != SPIRType::Struct && type.array.empty() && type.columns == 1; bool swizzle_optimization = false; for (uint32_t i = 0; i < length; i++) { auto *e = maybe_get(elems[i]); // If we're merging another scalar which belongs to the same base // object, just merge the swizzles to avoid triggering more than 1 expression read as much as possible! if (can_apply_swizzle_opt && e && e->base_expression && e->base_expression == base) { // Only supposed to be used for vector swizzle -> scalar. assert(!e->expression.empty() && e->expression.front() == '.'); subop += e->expression.substr(1, string::npos); swizzle_optimization = true; } else { // We'll likely end up with duplicated swizzles, e.g. // foobar.xyz.xyz from patterns like // OpVectorShuffle // OpCompositeExtract x 3 // OpCompositeConstruct 3x + other scalar. // Just modify op in-place. if (swizzle_optimization) { if (backend.swizzle_is_function) subop += "()"; // Don't attempt to remove unity swizzling if we managed to remove duplicate swizzles. // The base "foo" might be vec4, while foo.xyz is vec3 (OpVectorShuffle) and looks like a vec3 due to the .xyz tacked on. // We only want to remove the swizzles if we're certain that the resulting base will be the same vecsize. // Essentially, we can only remove one set of swizzles, since that's what we have control over ... // Case 1: // foo.yxz.xyz: Duplicate swizzle kicks in, giving foo.yxz, we are done. // foo.yxz was the result of OpVectorShuffle and we don't know the type of foo. // Case 2: // foo.xyz: Duplicate swizzle won't kick in. // If foo is vec3, we can remove xyz, giving just foo. if (!remove_duplicate_swizzle(subop)) remove_unity_swizzle(base, subop); // Strips away redundant parens if we created them during component extraction. strip_enclosed_expression(subop); swizzle_optimization = false; op += subop; } else op += subop; if (i) op += ", "; bool uses_buffer_offset = type.basetype == SPIRType::Struct && has_member_decoration(type.self, i, DecorationOffset); subop = to_composite_constructor_expression(elems[i], uses_buffer_offset); } base = e ? e->base_expression : ID(0); } if (swizzle_optimization) { if (backend.swizzle_is_function) subop += "()"; if (!remove_duplicate_swizzle(subop)) remove_unity_swizzle(base, subop); // Strips away redundant parens if we created them during component extraction. strip_enclosed_expression(subop); } op += subop; return op; } bool CompilerGLSL::skip_argument(uint32_t id) const { if (!combined_image_samplers.empty() || !options.vulkan_semantics) { auto &type = expression_type(id); if (type.basetype == SPIRType::Sampler || (type.basetype == SPIRType::Image && type.image.sampled == 1)) return true; } return false; } bool CompilerGLSL::optimize_read_modify_write(const SPIRType &type, const string &lhs, const string &rhs) { // Do this with strings because we have a very clear pattern we can check for and it avoids // adding lots of special cases to the code emission. if (rhs.size() < lhs.size() + 3) return false; // Do not optimize matrices. They are a bit awkward to reason about in general // (in which order does operation happen?), and it does not work on MSL anyways. if (type.vecsize > 1 && type.columns > 1) return false; auto index = rhs.find(lhs); if (index != 0) return false; // TODO: Shift operators, but it's not important for now. auto op = rhs.find_first_of("+-/*%|&^", lhs.size() + 1); if (op != lhs.size() + 1) return false; // Check that the op is followed by space. This excludes && and ||. if (rhs[op + 1] != ' ') return false; char bop = rhs[op]; auto expr = rhs.substr(lhs.size() + 3); // Try to find increments and decrements. Makes it look neater as += 1, -= 1 is fairly rare to see in real code. // Find some common patterns which are equivalent. if ((bop == '+' || bop == '-') && (expr == "1" || expr == "uint(1)" || expr == "1u" || expr == "int(1u)")) statement(lhs, bop, bop, ";"); else statement(lhs, " ", bop, "= ", expr, ";"); return true; } void CompilerGLSL::register_control_dependent_expression(uint32_t expr) { if (forwarded_temporaries.find(expr) == end(forwarded_temporaries)) return; assert(current_emitting_block); current_emitting_block->invalidate_expressions.push_back(expr); } void CompilerGLSL::emit_block_instructions(SPIRBlock &block) { current_emitting_block = █ for (auto &op : block.ops) emit_instruction(op); current_emitting_block = nullptr; } void CompilerGLSL::disallow_forwarding_in_expression_chain(const SPIRExpression &expr) { // Allow trivially forwarded expressions like OpLoad or trivial shuffles, // these will be marked as having suppressed usage tracking. // Our only concern is to make sure arithmetic operations are done in similar ways. if (expression_is_forwarded(expr.self) && !expression_suppresses_usage_tracking(expr.self) && forced_invariant_temporaries.count(expr.self) == 0) { forced_temporaries.insert(expr.self); forced_invariant_temporaries.insert(expr.self); force_recompile(); for (auto &dependent : expr.expression_dependencies) disallow_forwarding_in_expression_chain(get(dependent)); } } void CompilerGLSL::handle_store_to_invariant_variable(uint32_t store_id, uint32_t value_id) { // Variables or access chains marked invariant are complicated. We will need to make sure the code-gen leading up to // this variable is consistent. The failure case for SPIRV-Cross is when an expression is forced to a temporary // in one translation unit, but not another, e.g. due to multiple use of an expression. // This causes variance despite the output variable being marked invariant, so the solution here is to force all dependent // expressions to be temporaries. // It is uncertain if this is enough to support invariant in all possible cases, but it should be good enough // for all reasonable uses of invariant. if (!has_decoration(store_id, DecorationInvariant)) return; auto *expr = maybe_get(value_id); if (!expr) return; disallow_forwarding_in_expression_chain(*expr); } void CompilerGLSL::emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression) { auto rhs = to_pointer_expression(rhs_expression); // Statements to OpStore may be empty if it is a struct with zero members. Just forward the store to /dev/null. if (!rhs.empty()) { handle_store_to_invariant_variable(lhs_expression, rhs_expression); auto lhs = to_dereferenced_expression(lhs_expression); // We might need to cast in order to store to a builtin. cast_to_builtin_store(lhs_expression, rhs, expression_type(rhs_expression)); // Tries to optimize assignments like " = op expr". // While this is purely cosmetic, this is important for legacy ESSL where loop // variable increments must be in either i++ or i += const-expr. // Without this, we end up with i = i + 1, which is correct GLSL, but not correct GLES 2.0. if (!optimize_read_modify_write(expression_type(rhs_expression), lhs, rhs)) statement(lhs, " = ", rhs, ";"); register_write(lhs_expression); } } uint32_t CompilerGLSL::get_integer_width_for_instruction(const Instruction &instr) const { if (instr.length < 3) return 32; auto *ops = stream(instr); switch (instr.op) { case OpSConvert: case OpConvertSToF: case OpUConvert: case OpConvertUToF: case OpIEqual: case OpINotEqual: case OpSLessThan: case OpSLessThanEqual: case OpSGreaterThan: case OpSGreaterThanEqual: case OpULessThan: case OpULessThanEqual: case OpUGreaterThan: case OpUGreaterThanEqual: return expression_type(ops[2]).width; default: { // We can look at result type which is more robust. auto *type = maybe_get(ops[0]); if (type && type_is_integral(*type)) return type->width; else return 32; } } } uint32_t CompilerGLSL::get_integer_width_for_glsl_instruction(GLSLstd450 op, const uint32_t *ops, uint32_t length) const { if (length < 1) return 32; switch (op) { case GLSLstd450SAbs: case GLSLstd450SSign: case GLSLstd450UMin: case GLSLstd450SMin: case GLSLstd450UMax: case GLSLstd450SMax: case GLSLstd450UClamp: case GLSLstd450SClamp: case GLSLstd450FindSMsb: case GLSLstd450FindUMsb: return expression_type(ops[0]).width; default: { // We don't need to care about other opcodes, just return 32. return 32; } } } void CompilerGLSL::emit_instruction(const Instruction &instruction) { auto ops = stream(instruction); auto opcode = static_cast(instruction.op); uint32_t length = instruction.length; #define GLSL_BOP(op) emit_binary_op(ops[0], ops[1], ops[2], ops[3], #op) #define GLSL_BOP_CAST(op, type) \ emit_binary_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, opcode_is_sign_invariant(opcode)) #define GLSL_UOP(op) emit_unary_op(ops[0], ops[1], ops[2], #op) #define GLSL_QFOP(op) emit_quaternary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], ops[5], #op) #define GLSL_TFOP(op) emit_trinary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], #op) #define GLSL_BFOP(op) emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], #op) #define GLSL_BFOP_CAST(op, type) \ emit_binary_func_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, opcode_is_sign_invariant(opcode)) #define GLSL_BFOP(op) emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], #op) #define GLSL_UFOP(op) emit_unary_func_op(ops[0], ops[1], ops[2], #op) // If we need to do implicit bitcasts, make sure we do it with the correct type. uint32_t integer_width = get_integer_width_for_instruction(instruction); auto int_type = to_signed_basetype(integer_width); auto uint_type = to_unsigned_basetype(integer_width); switch (opcode) { // Dealing with memory case OpLoad: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t ptr = ops[2]; flush_variable_declaration(ptr); // If we're loading from memory that cannot be changed by the shader, // just forward the expression directly to avoid needless temporaries. // If an expression is mutable and forwardable, we speculate that it is immutable. bool forward = should_forward(ptr) && forced_temporaries.find(id) == end(forced_temporaries); // If loading a non-native row-major matrix, mark the expression as need_transpose. bool need_transpose = false; bool old_need_transpose = false; auto *ptr_expression = maybe_get(ptr); if (forward) { // If we're forwarding the load, we're also going to forward transpose state, so don't transpose while // taking the expression. if (ptr_expression && ptr_expression->need_transpose) { old_need_transpose = true; ptr_expression->need_transpose = false; need_transpose = true; } else if (is_non_native_row_major_matrix(ptr)) need_transpose = true; } // If we are forwarding this load, // don't register the read to access chain here, defer that to when we actually use the expression, // using the add_implied_read_expression mechanism. string expr; bool is_packed = has_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypePacked); bool is_remapped = has_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypeID); if (forward || (!is_packed && !is_remapped)) { // For the simple case, we do not need to deal with repacking. expr = to_dereferenced_expression(ptr, false); } else { // If we are not forwarding the expression, we need to unpack and resolve any physical type remapping here before // storing the expression to a temporary. expr = to_unpacked_expression(ptr); } auto &type = get(result_type); auto &expr_type = expression_type(ptr); // If the expression has more vector components than the result type, insert // a swizzle. This shouldn't happen normally on valid SPIR-V, but it might // happen with e.g. the MSL backend replacing the type of an input variable. if (expr_type.vecsize > type.vecsize) expr = enclose_expression(expr + vector_swizzle(type.vecsize, 0)); // We might need to cast in order to load from a builtin. cast_from_builtin_load(ptr, expr, type); // We might be trying to load a gl_Position[N], where we should be // doing float4[](gl_in[i].gl_Position, ...) instead. // Similar workarounds are required for input arrays in tessellation. unroll_array_from_complex_load(id, ptr, expr); // Shouldn't need to check for ID, but current glslang codegen requires it in some cases // when loading Image/Sampler descriptors. It does not hurt to check ID as well. if (has_decoration(id, DecorationNonUniformEXT) || has_decoration(ptr, DecorationNonUniformEXT)) { propagate_nonuniform_qualifier(ptr); convert_non_uniform_expression(type, expr); } if (forward && ptr_expression) ptr_expression->need_transpose = old_need_transpose; bool flattened = ptr_expression && flattened_buffer_blocks.count(ptr_expression->loaded_from) != 0; if (backend.needs_row_major_load_workaround && !is_non_native_row_major_matrix(ptr) && !flattened) rewrite_load_for_wrapped_row_major(expr, result_type, ptr); // By default, suppress usage tracking since using same expression multiple times does not imply any extra work. // However, if we try to load a complex, composite object from a flattened buffer, // we should avoid emitting the same code over and over and lower the result to a temporary. bool usage_tracking = flattened && (type.basetype == SPIRType::Struct || (type.columns > 1)); SPIRExpression *e = nullptr; if (!forward && expression_is_non_value_type_array(ptr)) { // Complicated load case where we need to make a copy of ptr, but we cannot, because // it is an array, and our backend does not support arrays as value types. // Emit the temporary, and copy it explicitly. e = &emit_uninitialized_temporary_expression(result_type, id); emit_array_copy(to_expression(id), ptr, StorageClassFunction, get_expression_effective_storage_class(ptr)); } else e = &emit_op(result_type, id, expr, forward, !usage_tracking); e->need_transpose = need_transpose; register_read(id, ptr, forward); if (forward) { // Pass through whether the result is of a packed type and the physical type ID. if (has_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypePacked)) set_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked); if (has_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypeID)) { set_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID, get_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypeID)); } } else { // This might have been set on an earlier compilation iteration, force it to be unset. unset_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked); unset_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID); } inherit_expression_dependencies(id, ptr); if (forward) add_implied_read_expression(*e, ptr); break; } case OpInBoundsAccessChain: case OpAccessChain: case OpPtrAccessChain: { auto *var = maybe_get(ops[2]); if (var) flush_variable_declaration(var->self); // If the base is immutable, the access chain pointer must also be. // If an expression is mutable and forwardable, we speculate that it is immutable. AccessChainMeta meta; bool ptr_chain = opcode == OpPtrAccessChain; auto e = access_chain(ops[2], &ops[3], length - 3, get(ops[0]), &meta, ptr_chain); auto &expr = set(ops[1], move(e), ops[0], should_forward(ops[2])); auto *backing_variable = maybe_get_backing_variable(ops[2]); expr.loaded_from = backing_variable ? backing_variable->self : ID(ops[2]); expr.need_transpose = meta.need_transpose; expr.access_chain = true; // Mark the result as being packed. Some platforms handled packed vectors differently than non-packed. if (meta.storage_is_packed) set_extended_decoration(ops[1], SPIRVCrossDecorationPhysicalTypePacked); if (meta.storage_physical_type != 0) set_extended_decoration(ops[1], SPIRVCrossDecorationPhysicalTypeID, meta.storage_physical_type); if (meta.storage_is_invariant) set_decoration(ops[1], DecorationInvariant); if (meta.flattened_struct) flattened_structs[ops[1]] = true; // If we have some expression dependencies in our access chain, this access chain is technically a forwarded // temporary which could be subject to invalidation. // Need to assume we're forwarded while calling inherit_expression_depdendencies. forwarded_temporaries.insert(ops[1]); // The access chain itself is never forced to a temporary, but its dependencies might. suppressed_usage_tracking.insert(ops[1]); for (uint32_t i = 2; i < length; i++) { inherit_expression_dependencies(ops[1], ops[i]); add_implied_read_expression(expr, ops[i]); } // If we have no dependencies after all, i.e., all indices in the access chain are immutable temporaries, // we're not forwarded after all. if (expr.expression_dependencies.empty()) forwarded_temporaries.erase(ops[1]); if (has_decoration(ops[1], DecorationNonUniformEXT)) propagate_nonuniform_qualifier(ops[1]); break; } case OpStore: { auto *var = maybe_get(ops[0]); if (var && var->statically_assigned) var->static_expression = ops[1]; else if (var && var->loop_variable && !var->loop_variable_enable) var->static_expression = ops[1]; else if (var && var->remapped_variable && var->static_expression) { // Skip the write. } else if (flattened_structs.count(ops[0])) { store_flattened_struct(ops[0], ops[1]); register_write(ops[0]); } else { emit_store_statement(ops[0], ops[1]); } // Storing a pointer results in a variable pointer, so we must conservatively assume // we can write through it. if (expression_type(ops[1]).pointer) register_write(ops[1]); break; } case OpArrayLength: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto e = access_chain_internal(ops[2], &ops[3], length - 3, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr); set(id, join(type_to_glsl(get(result_type)), "(", e, ".length())"), result_type, true); break; } // Function calls case OpFunctionCall: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t func = ops[2]; const auto *arg = &ops[3]; length -= 3; auto &callee = get(func); auto &return_type = get(callee.return_type); bool pure = function_is_pure(callee); bool callee_has_out_variables = false; bool emit_return_value_as_argument = false; // Invalidate out variables passed to functions since they can be OpStore'd to. for (uint32_t i = 0; i < length; i++) { if (callee.arguments[i].write_count) { register_call_out_argument(arg[i]); callee_has_out_variables = true; } flush_variable_declaration(arg[i]); } if (!return_type.array.empty() && !backend.can_return_array) { callee_has_out_variables = true; emit_return_value_as_argument = true; } if (!pure) register_impure_function_call(); string funexpr; SmallVector arglist; funexpr += to_name(func) + "("; if (emit_return_value_as_argument) { statement(type_to_glsl(return_type), " ", to_name(id), type_to_array_glsl(return_type), ";"); arglist.push_back(to_name(id)); } for (uint32_t i = 0; i < length; i++) { // Do not pass in separate images or samplers if we're remapping // to combined image samplers. if (skip_argument(arg[i])) continue; arglist.push_back(to_func_call_arg(callee.arguments[i], arg[i])); } for (auto &combined : callee.combined_parameters) { auto image_id = combined.global_image ? combined.image_id : VariableID(arg[combined.image_id]); auto sampler_id = combined.global_sampler ? combined.sampler_id : VariableID(arg[combined.sampler_id]); arglist.push_back(to_combined_image_sampler(image_id, sampler_id)); } append_global_func_args(callee, length, arglist); funexpr += merge(arglist); funexpr += ")"; // Check for function call constraints. check_function_call_constraints(arg, length); if (return_type.basetype != SPIRType::Void) { // If the function actually writes to an out variable, // take the conservative route and do not forward. // The problem is that we might not read the function // result (and emit the function) before an out variable // is read (common case when return value is ignored! // In order to avoid start tracking invalid variables, // just avoid the forwarding problem altogether. bool forward = args_will_forward(id, arg, length, pure) && !callee_has_out_variables && pure && (forced_temporaries.find(id) == end(forced_temporaries)); if (emit_return_value_as_argument) { statement(funexpr, ";"); set(id, to_name(id), result_type, true); } else emit_op(result_type, id, funexpr, forward); // Function calls are implicit loads from all variables in question. // Set dependencies for them. for (uint32_t i = 0; i < length; i++) register_read(id, arg[i], forward); // If we're going to forward the temporary result, // put dependencies on every variable that must not change. if (forward) register_global_read_dependencies(callee, id); } else statement(funexpr, ";"); break; } // Composite munging case OpCompositeConstruct: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; const auto *const elems = &ops[2]; length -= 2; bool forward = true; for (uint32_t i = 0; i < length; i++) forward = forward && should_forward(elems[i]); auto &out_type = get(result_type); auto *in_type = length > 0 ? &expression_type(elems[0]) : nullptr; // Only splat if we have vector constructors. // Arrays and structs must be initialized properly in full. bool composite = !out_type.array.empty() || out_type.basetype == SPIRType::Struct; bool splat = false; bool swizzle_splat = false; if (in_type) { splat = in_type->vecsize == 1 && in_type->columns == 1 && !composite && backend.use_constructor_splatting; swizzle_splat = in_type->vecsize == 1 && in_type->columns == 1 && backend.can_swizzle_scalar; if (ir.ids[elems[0]].get_type() == TypeConstant && !type_is_floating_point(*in_type)) { // Cannot swizzle literal integers as a special case. swizzle_splat = false; } } if (splat || swizzle_splat) { uint32_t input = elems[0]; for (uint32_t i = 0; i < length; i++) { if (input != elems[i]) { splat = false; swizzle_splat = false; } } } if (out_type.basetype == SPIRType::Struct && !backend.can_declare_struct_inline) forward = false; if (!out_type.array.empty() && !backend.can_declare_arrays_inline) forward = false; if (type_is_empty(out_type) && !backend.supports_empty_struct) forward = false; string constructor_op; if (backend.use_initializer_list && composite) { bool needs_trailing_tracket = false; // Only use this path if we are building composites. // This path cannot be used for arithmetic. if (backend.use_typed_initializer_list && out_type.basetype == SPIRType::Struct && out_type.array.empty()) constructor_op += type_to_glsl_constructor(get(result_type)); else if (backend.use_typed_initializer_list && backend.array_is_value_type && !out_type.array.empty()) { // MSL path. Array constructor is baked into type here, do not use _constructor variant. constructor_op += type_to_glsl_constructor(get(result_type)) + "("; needs_trailing_tracket = true; } constructor_op += "{ "; if (type_is_empty(out_type) && !backend.supports_empty_struct) constructor_op += "0"; else if (splat) constructor_op += to_unpacked_expression(elems[0]); else constructor_op += build_composite_combiner(result_type, elems, length); constructor_op += " }"; if (needs_trailing_tracket) constructor_op += ")"; } else if (swizzle_splat && !composite) { constructor_op = remap_swizzle(get(result_type), 1, to_unpacked_expression(elems[0])); } else { constructor_op = type_to_glsl_constructor(get(result_type)) + "("; if (type_is_empty(out_type) && !backend.supports_empty_struct) constructor_op += "0"; else if (splat) constructor_op += to_unpacked_expression(elems[0]); else constructor_op += build_composite_combiner(result_type, elems, length); constructor_op += ")"; } if (!constructor_op.empty()) { emit_op(result_type, id, constructor_op, forward); for (uint32_t i = 0; i < length; i++) inherit_expression_dependencies(id, elems[i]); } break; } case OpVectorInsertDynamic: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t vec = ops[2]; uint32_t comp = ops[3]; uint32_t index = ops[4]; flush_variable_declaration(vec); // Make a copy, then use access chain to store the variable. statement(declare_temporary(result_type, id), to_expression(vec), ";"); set(id, to_name(id), result_type, true); auto chain = access_chain_internal(id, &index, 1, 0, nullptr); statement(chain, " = ", to_unpacked_expression(comp), ";"); break; } case OpVectorExtractDynamic: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto expr = access_chain_internal(ops[2], &ops[3], 1, 0, nullptr); emit_op(result_type, id, expr, should_forward(ops[2])); inherit_expression_dependencies(id, ops[2]); inherit_expression_dependencies(id, ops[3]); break; } case OpCompositeExtract: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; length -= 3; auto &type = get(result_type); // We can only split the expression here if our expression is forwarded as a temporary. bool allow_base_expression = forced_temporaries.find(id) == end(forced_temporaries); // Do not allow base expression for struct members. We risk doing "swizzle" optimizations in this case. auto &composite_type = expression_type(ops[2]); if (composite_type.basetype == SPIRType::Struct || !composite_type.array.empty()) allow_base_expression = false; // Packed expressions or physical ID mapped expressions cannot be split up. if (has_extended_decoration(ops[2], SPIRVCrossDecorationPhysicalTypePacked) || has_extended_decoration(ops[2], SPIRVCrossDecorationPhysicalTypeID)) allow_base_expression = false; // Cannot use base expression for row-major matrix row-extraction since we need to interleave access pattern // into the base expression. if (is_non_native_row_major_matrix(ops[2])) allow_base_expression = false; AccessChainMeta meta; SPIRExpression *e = nullptr; // Only apply this optimization if result is scalar. if (allow_base_expression && should_forward(ops[2]) && type.vecsize == 1 && type.columns == 1 && length == 1) { // We want to split the access chain from the base. // This is so we can later combine different CompositeExtract results // with CompositeConstruct without emitting code like // // vec3 temp = texture(...).xyz // vec4(temp.x, temp.y, temp.z, 1.0). // // when we actually wanted to emit this // vec4(texture(...).xyz, 1.0). // // Including the base will prevent this and would trigger multiple reads // from expression causing it to be forced to an actual temporary in GLSL. auto expr = access_chain_internal(ops[2], &ops[3], length, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_CHAIN_ONLY_BIT, &meta); e = &emit_op(result_type, id, expr, true, should_suppress_usage_tracking(ops[2])); inherit_expression_dependencies(id, ops[2]); e->base_expression = ops[2]; } else { auto expr = access_chain_internal(ops[2], &ops[3], length, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &meta); e = &emit_op(result_type, id, expr, should_forward(ops[2]), should_suppress_usage_tracking(ops[2])); inherit_expression_dependencies(id, ops[2]); } // Pass through some meta information to the loaded expression. // We can still end up loading a buffer type to a variable, then CompositeExtract from it // instead of loading everything through an access chain. e->need_transpose = meta.need_transpose; if (meta.storage_is_packed) set_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked); if (meta.storage_physical_type != 0) set_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID, meta.storage_physical_type); if (meta.storage_is_invariant) set_decoration(id, DecorationInvariant); break; } case OpCompositeInsert: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t obj = ops[2]; uint32_t composite = ops[3]; const auto *elems = &ops[4]; length -= 4; flush_variable_declaration(composite); // Make a copy, then use access chain to store the variable. statement(declare_temporary(result_type, id), to_expression(composite), ";"); set(id, to_name(id), result_type, true); auto chain = access_chain_internal(id, elems, length, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr); statement(chain, " = ", to_unpacked_expression(obj), ";"); break; } case OpCopyMemory: { uint32_t lhs = ops[0]; uint32_t rhs = ops[1]; if (lhs != rhs) { flush_variable_declaration(lhs); flush_variable_declaration(rhs); statement(to_expression(lhs), " = ", to_unpacked_expression(rhs), ";"); register_write(lhs); } break; } case OpCopyLogical: { // This is used for copying object of different types, arrays and structs. // We need to unroll the copy, element-by-element. uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t rhs = ops[2]; emit_uninitialized_temporary_expression(result_type, id); emit_copy_logical_type(id, result_type, rhs, expression_type_id(rhs), {}); break; } case OpCopyObject: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t rhs = ops[2]; bool pointer = get(result_type).pointer; auto *chain = maybe_get(rhs); auto *imgsamp = maybe_get(rhs); if (chain) { // Cannot lower to a SPIRExpression, just copy the object. auto &e = set(id, *chain); e.self = id; } else if (imgsamp) { // Cannot lower to a SPIRExpression, just copy the object. // GLSL does not currently use this type and will never get here, but MSL does. // Handled here instead of CompilerMSL for better integration and general handling, // and in case GLSL or other subclasses require it in the future. auto &e = set(id, *imgsamp); e.self = id; } else if (expression_is_lvalue(rhs) && !pointer) { // Need a copy. // For pointer types, we copy the pointer itself. statement(declare_temporary(result_type, id), to_unpacked_expression(rhs), ";"); set(id, to_name(id), result_type, true); } else { // RHS expression is immutable, so just forward it. // Copying these things really make no sense, but // seems to be allowed anyways. auto &e = set(id, to_expression(rhs), result_type, true); if (pointer) { auto *var = maybe_get_backing_variable(rhs); e.loaded_from = var ? var->self : ID(0); } // If we're copying an access chain, need to inherit the read expressions. auto *rhs_expr = maybe_get(rhs); if (rhs_expr) { e.implied_read_expressions = rhs_expr->implied_read_expressions; e.expression_dependencies = rhs_expr->expression_dependencies; } } break; } case OpVectorShuffle: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t vec0 = ops[2]; uint32_t vec1 = ops[3]; const auto *elems = &ops[4]; length -= 4; auto &type0 = expression_type(vec0); // If we have the undefined swizzle index -1, we need to swizzle in undefined data, // or in our case, T(0). bool shuffle = false; for (uint32_t i = 0; i < length; i++) if (elems[i] >= type0.vecsize || elems[i] == 0xffffffffu) shuffle = true; // Cannot use swizzles with packed expressions, force shuffle path. if (!shuffle && has_extended_decoration(vec0, SPIRVCrossDecorationPhysicalTypePacked)) shuffle = true; string expr; bool should_fwd, trivial_forward; if (shuffle) { should_fwd = should_forward(vec0) && should_forward(vec1); trivial_forward = should_suppress_usage_tracking(vec0) && should_suppress_usage_tracking(vec1); // Constructor style and shuffling from two different vectors. SmallVector args; for (uint32_t i = 0; i < length; i++) { if (elems[i] == 0xffffffffu) { // Use a constant 0 here. // We could use the first component or similar, but then we risk propagating // a value we might not need, and bog down codegen. SPIRConstant c; c.constant_type = type0.parent_type; assert(type0.parent_type != ID(0)); args.push_back(constant_expression(c)); } else if (elems[i] >= type0.vecsize) args.push_back(to_extract_component_expression(vec1, elems[i] - type0.vecsize)); else args.push_back(to_extract_component_expression(vec0, elems[i])); } expr += join(type_to_glsl_constructor(get(result_type)), "(", merge(args), ")"); } else { should_fwd = should_forward(vec0); trivial_forward = should_suppress_usage_tracking(vec0); // We only source from first vector, so can use swizzle. // If the vector is packed, unpack it before applying a swizzle (needed for MSL) expr += to_enclosed_unpacked_expression(vec0); expr += "."; for (uint32_t i = 0; i < length; i++) { assert(elems[i] != 0xffffffffu); expr += index_to_swizzle(elems[i]); } if (backend.swizzle_is_function && length > 1) expr += "()"; } // A shuffle is trivial in that it doesn't actually *do* anything. // We inherit the forwardedness from our arguments to avoid flushing out to temporaries when it's not really needed. emit_op(result_type, id, expr, should_fwd, trivial_forward); inherit_expression_dependencies(id, vec0); if (vec0 != vec1) inherit_expression_dependencies(id, vec1); break; } // ALU case OpIsNan: GLSL_UFOP(isnan); break; case OpIsInf: GLSL_UFOP(isinf); break; case OpSNegate: case OpFNegate: GLSL_UOP(-); break; case OpIAdd: { // For simple arith ops, prefer the output type if there's a mismatch to avoid extra bitcasts. auto type = get(ops[0]).basetype; GLSL_BOP_CAST(+, type); break; } case OpFAdd: GLSL_BOP(+); break; case OpISub: { auto type = get(ops[0]).basetype; GLSL_BOP_CAST(-, type); break; } case OpFSub: GLSL_BOP(-); break; case OpIMul: { auto type = get(ops[0]).basetype; GLSL_BOP_CAST(*, type); break; } case OpVectorTimesMatrix: case OpMatrixTimesVector: { // If the matrix needs transpose, just flip the multiply order. auto *e = maybe_get(ops[opcode == OpMatrixTimesVector ? 2 : 3]); if (e && e->need_transpose) { e->need_transpose = false; string expr; if (opcode == OpMatrixTimesVector) expr = join(to_enclosed_unpacked_expression(ops[3]), " * ", enclose_expression(to_unpacked_row_major_matrix_expression(ops[2]))); else expr = join(enclose_expression(to_unpacked_row_major_matrix_expression(ops[3])), " * ", to_enclosed_unpacked_expression(ops[2])); bool forward = should_forward(ops[2]) && should_forward(ops[3]); emit_op(ops[0], ops[1], expr, forward); e->need_transpose = true; inherit_expression_dependencies(ops[1], ops[2]); inherit_expression_dependencies(ops[1], ops[3]); } else GLSL_BOP(*); break; } case OpMatrixTimesMatrix: { auto *a = maybe_get(ops[2]); auto *b = maybe_get(ops[3]); // If both matrices need transpose, we can multiply in flipped order and tag the expression as transposed. // a^T * b^T = (b * a)^T. if (a && b && a->need_transpose && b->need_transpose) { a->need_transpose = false; b->need_transpose = false; auto expr = join(enclose_expression(to_unpacked_row_major_matrix_expression(ops[3])), " * ", enclose_expression(to_unpacked_row_major_matrix_expression(ops[2]))); bool forward = should_forward(ops[2]) && should_forward(ops[3]); auto &e = emit_op(ops[0], ops[1], expr, forward); e.need_transpose = true; a->need_transpose = true; b->need_transpose = true; inherit_expression_dependencies(ops[1], ops[2]); inherit_expression_dependencies(ops[1], ops[3]); } else GLSL_BOP(*); break; } case OpFMul: case OpMatrixTimesScalar: case OpVectorTimesScalar: GLSL_BOP(*); break; case OpOuterProduct: GLSL_BFOP(outerProduct); break; case OpDot: GLSL_BFOP(dot); break; case OpTranspose: if (options.version < 120) // Matches GLSL 1.10 / ESSL 1.00 { // transpose() is not available, so instead, flip need_transpose, // which can later be turned into an emulated transpose op by // convert_row_major_matrix(), if necessary. uint32_t result_type = ops[0]; uint32_t result_id = ops[1]; uint32_t input = ops[2]; // Force need_transpose to false temporarily to prevent // to_expression() from doing the transpose. bool need_transpose = false; auto *input_e = maybe_get(input); if (input_e) swap(need_transpose, input_e->need_transpose); bool forward = should_forward(input); auto &e = emit_op(result_type, result_id, to_expression(input), forward); e.need_transpose = !need_transpose; // Restore the old need_transpose flag. if (input_e) input_e->need_transpose = need_transpose; } else GLSL_UFOP(transpose); break; case OpSRem: { uint32_t result_type = ops[0]; uint32_t result_id = ops[1]; uint32_t op0 = ops[2]; uint32_t op1 = ops[3]; // Needs special handling. bool forward = should_forward(op0) && should_forward(op1); auto expr = join(to_enclosed_expression(op0), " - ", to_enclosed_expression(op1), " * ", "(", to_enclosed_expression(op0), " / ", to_enclosed_expression(op1), ")"); emit_op(result_type, result_id, expr, forward); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); break; } case OpSDiv: GLSL_BOP_CAST(/, int_type); break; case OpUDiv: GLSL_BOP_CAST(/, uint_type); break; case OpIAddCarry: case OpISubBorrow: { if (options.es && options.version < 310) SPIRV_CROSS_THROW("Extended arithmetic is only available from ESSL 310."); else if (!options.es && options.version < 400) SPIRV_CROSS_THROW("Extended arithmetic is only available from GLSL 400."); uint32_t result_type = ops[0]; uint32_t result_id = ops[1]; uint32_t op0 = ops[2]; uint32_t op1 = ops[3]; auto &type = get(result_type); emit_uninitialized_temporary_expression(result_type, result_id); const char *op = opcode == OpIAddCarry ? "uaddCarry" : "usubBorrow"; statement(to_expression(result_id), ".", to_member_name(type, 0), " = ", op, "(", to_expression(op0), ", ", to_expression(op1), ", ", to_expression(result_id), ".", to_member_name(type, 1), ");"); break; } case OpUMulExtended: case OpSMulExtended: { if (options.es && options.version < 310) SPIRV_CROSS_THROW("Extended arithmetic is only available from ESSL 310."); else if (!options.es && options.version < 400) SPIRV_CROSS_THROW("Extended arithmetic is only available from GLSL 4000."); uint32_t result_type = ops[0]; uint32_t result_id = ops[1]; uint32_t op0 = ops[2]; uint32_t op1 = ops[3]; auto &type = get(result_type); emit_uninitialized_temporary_expression(result_type, result_id); const char *op = opcode == OpUMulExtended ? "umulExtended" : "imulExtended"; statement(op, "(", to_expression(op0), ", ", to_expression(op1), ", ", to_expression(result_id), ".", to_member_name(type, 1), ", ", to_expression(result_id), ".", to_member_name(type, 0), ");"); break; } case OpFDiv: GLSL_BOP(/); break; case OpShiftRightLogical: GLSL_BOP_CAST(>>, uint_type); break; case OpShiftRightArithmetic: GLSL_BOP_CAST(>>, int_type); break; case OpShiftLeftLogical: { auto type = get(ops[0]).basetype; GLSL_BOP_CAST(<<, type); break; } case OpBitwiseOr: { auto type = get(ops[0]).basetype; GLSL_BOP_CAST(|, type); break; } case OpBitwiseXor: { auto type = get(ops[0]).basetype; GLSL_BOP_CAST(^, type); break; } case OpBitwiseAnd: { auto type = get(ops[0]).basetype; GLSL_BOP_CAST(&, type); break; } case OpNot: GLSL_UOP(~); break; case OpUMod: GLSL_BOP_CAST(%, uint_type); break; case OpSMod: GLSL_BOP_CAST(%, int_type); break; case OpFMod: GLSL_BFOP(mod); break; case OpFRem: { if (is_legacy()) SPIRV_CROSS_THROW("OpFRem requires trunc() and is only supported on non-legacy targets. A workaround is " "needed for legacy."); uint32_t result_type = ops[0]; uint32_t result_id = ops[1]; uint32_t op0 = ops[2]; uint32_t op1 = ops[3]; // Needs special handling. bool forward = should_forward(op0) && should_forward(op1); auto expr = join(to_enclosed_expression(op0), " - ", to_enclosed_expression(op1), " * ", "trunc(", to_enclosed_expression(op0), " / ", to_enclosed_expression(op1), ")"); emit_op(result_type, result_id, expr, forward); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); break; } // Relational case OpAny: GLSL_UFOP(any); break; case OpAll: GLSL_UFOP(all); break; case OpSelect: emit_mix_op(ops[0], ops[1], ops[4], ops[3], ops[2]); break; case OpLogicalOr: { // No vector variant in GLSL for logical OR. auto result_type = ops[0]; auto id = ops[1]; auto &type = get(result_type); if (type.vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "||", false, SPIRType::Unknown); else GLSL_BOP(||); break; } case OpLogicalAnd: { // No vector variant in GLSL for logical AND. auto result_type = ops[0]; auto id = ops[1]; auto &type = get(result_type); if (type.vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "&&", false, SPIRType::Unknown); else GLSL_BOP(&&); break; } case OpLogicalNot: { auto &type = get(ops[0]); if (type.vecsize > 1) GLSL_UFOP(not ); else GLSL_UOP(!); break; } case OpIEqual: { if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP_CAST(equal, int_type); else GLSL_BOP_CAST(==, int_type); break; } case OpLogicalEqual: case OpFOrdEqual: { if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP(equal); else GLSL_BOP(==); break; } case OpINotEqual: { if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP_CAST(notEqual, int_type); else GLSL_BOP_CAST(!=, int_type); break; } case OpLogicalNotEqual: case OpFOrdNotEqual: { if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP(notEqual); else GLSL_BOP(!=); break; } case OpUGreaterThan: case OpSGreaterThan: { auto type = opcode == OpUGreaterThan ? uint_type : int_type; if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP_CAST(greaterThan, type); else GLSL_BOP_CAST(>, type); break; } case OpFOrdGreaterThan: { if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP(greaterThan); else GLSL_BOP(>); break; } case OpUGreaterThanEqual: case OpSGreaterThanEqual: { auto type = opcode == OpUGreaterThanEqual ? uint_type : int_type; if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP_CAST(greaterThanEqual, type); else GLSL_BOP_CAST(>=, type); break; } case OpFOrdGreaterThanEqual: { if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP(greaterThanEqual); else GLSL_BOP(>=); break; } case OpULessThan: case OpSLessThan: { auto type = opcode == OpULessThan ? uint_type : int_type; if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP_CAST(lessThan, type); else GLSL_BOP_CAST(<, type); break; } case OpFOrdLessThan: { if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP(lessThan); else GLSL_BOP(<); break; } case OpULessThanEqual: case OpSLessThanEqual: { auto type = opcode == OpULessThanEqual ? uint_type : int_type; if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP_CAST(lessThanEqual, type); else GLSL_BOP_CAST(<=, type); break; } case OpFOrdLessThanEqual: { if (expression_type(ops[2]).vecsize > 1) GLSL_BFOP(lessThanEqual); else GLSL_BOP(<=); break; } // Conversion case OpSConvert: case OpConvertSToF: case OpUConvert: case OpConvertUToF: { auto input_type = opcode == OpSConvert || opcode == OpConvertSToF ? int_type : uint_type; uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto &type = get(result_type); auto &arg_type = expression_type(ops[2]); auto func = type_to_glsl_constructor(type); if (arg_type.width < type.width || type_is_floating_point(type)) emit_unary_func_op_cast(result_type, id, ops[2], func.c_str(), input_type, type.basetype); else emit_unary_func_op(result_type, id, ops[2], func.c_str()); break; } case OpConvertFToU: case OpConvertFToS: { // Cast to expected arithmetic type, then potentially bitcast away to desired signedness. uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto &type = get(result_type); auto expected_type = type; auto &float_type = expression_type(ops[2]); expected_type.basetype = opcode == OpConvertFToS ? to_signed_basetype(type.width) : to_unsigned_basetype(type.width); auto func = type_to_glsl_constructor(expected_type); emit_unary_func_op_cast(result_type, id, ops[2], func.c_str(), float_type.basetype, expected_type.basetype); break; } case OpFConvert: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto func = type_to_glsl_constructor(get(result_type)); emit_unary_func_op(result_type, id, ops[2], func.c_str()); break; } case OpBitcast: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t arg = ops[2]; if (!emit_complex_bitcast(result_type, id, arg)) { auto op = bitcast_glsl_op(get(result_type), expression_type(arg)); emit_unary_func_op(result_type, id, arg, op.c_str()); } break; } case OpQuantizeToF16: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t arg = ops[2]; string op; auto &type = get(result_type); switch (type.vecsize) { case 1: op = join("unpackHalf2x16(packHalf2x16(vec2(", to_expression(arg), "))).x"); break; case 2: op = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), "))"); break; case 3: { auto op0 = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), ".xy))"); auto op1 = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), ".zz)).x"); op = join("vec3(", op0, ", ", op1, ")"); break; } case 4: { auto op0 = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), ".xy))"); auto op1 = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), ".zw))"); op = join("vec4(", op0, ", ", op1, ")"); break; } default: SPIRV_CROSS_THROW("Illegal argument to OpQuantizeToF16."); } emit_op(result_type, id, op, should_forward(arg)); inherit_expression_dependencies(id, arg); break; } // Derivatives case OpDPdx: GLSL_UFOP(dFdx); if (is_legacy_es()) require_extension_internal("GL_OES_standard_derivatives"); register_control_dependent_expression(ops[1]); break; case OpDPdy: GLSL_UFOP(dFdy); if (is_legacy_es()) require_extension_internal("GL_OES_standard_derivatives"); register_control_dependent_expression(ops[1]); break; case OpDPdxFine: GLSL_UFOP(dFdxFine); if (options.es) { SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES."); } if (options.version < 450) require_extension_internal("GL_ARB_derivative_control"); register_control_dependent_expression(ops[1]); break; case OpDPdyFine: GLSL_UFOP(dFdyFine); if (options.es) { SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES."); } if (options.version < 450) require_extension_internal("GL_ARB_derivative_control"); register_control_dependent_expression(ops[1]); break; case OpDPdxCoarse: if (options.es) { SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES."); } GLSL_UFOP(dFdxCoarse); if (options.version < 450) require_extension_internal("GL_ARB_derivative_control"); register_control_dependent_expression(ops[1]); break; case OpDPdyCoarse: GLSL_UFOP(dFdyCoarse); if (options.es) { SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES."); } if (options.version < 450) require_extension_internal("GL_ARB_derivative_control"); register_control_dependent_expression(ops[1]); break; case OpFwidth: GLSL_UFOP(fwidth); if (is_legacy_es()) require_extension_internal("GL_OES_standard_derivatives"); register_control_dependent_expression(ops[1]); break; case OpFwidthCoarse: GLSL_UFOP(fwidthCoarse); if (options.es) { SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES."); } if (options.version < 450) require_extension_internal("GL_ARB_derivative_control"); register_control_dependent_expression(ops[1]); break; case OpFwidthFine: GLSL_UFOP(fwidthFine); if (options.es) { SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES."); } if (options.version < 450) require_extension_internal("GL_ARB_derivative_control"); register_control_dependent_expression(ops[1]); break; // Bitfield case OpBitFieldInsert: { emit_bitfield_insert_op(ops[0], ops[1], ops[2], ops[3], ops[4], ops[5], "bitfieldInsert", SPIRType::Int); break; } case OpBitFieldSExtract: { emit_trinary_func_op_bitextract(ops[0], ops[1], ops[2], ops[3], ops[4], "bitfieldExtract", int_type, int_type, SPIRType::Int, SPIRType::Int); break; } case OpBitFieldUExtract: { emit_trinary_func_op_bitextract(ops[0], ops[1], ops[2], ops[3], ops[4], "bitfieldExtract", uint_type, uint_type, SPIRType::Int, SPIRType::Int); break; } case OpBitReverse: // BitReverse does not have issues with sign since result type must match input type. GLSL_UFOP(bitfieldReverse); break; case OpBitCount: { auto basetype = expression_type(ops[2]).basetype; emit_unary_func_op_cast(ops[0], ops[1], ops[2], "bitCount", basetype, int_type); break; } // Atomics case OpAtomicExchange: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t ptr = ops[2]; // Ignore semantics for now, probably only relevant to CL. uint32_t val = ops[5]; const char *op = check_atomic_image(ptr) ? "imageAtomicExchange" : "atomicExchange"; forced_temporaries.insert(id); emit_binary_func_op(result_type, id, ptr, val, op); flush_all_atomic_capable_variables(); break; } case OpAtomicCompareExchange: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t ptr = ops[2]; uint32_t val = ops[6]; uint32_t comp = ops[7]; const char *op = check_atomic_image(ptr) ? "imageAtomicCompSwap" : "atomicCompSwap"; forced_temporaries.insert(id); emit_trinary_func_op(result_type, id, ptr, comp, val, op); flush_all_atomic_capable_variables(); break; } case OpAtomicLoad: { // In plain GLSL, we have no atomic loads, so emulate this by fetch adding by 0 and hope compiler figures it out. // Alternatively, we could rely on KHR_memory_model, but that's not very helpful for GL. auto &type = expression_type(ops[2]); forced_temporaries.insert(ops[1]); bool atomic_image = check_atomic_image(ops[2]); bool unsigned_type = (type.basetype == SPIRType::UInt) || (atomic_image && get(type.image.type).basetype == SPIRType::UInt); const char *op = atomic_image ? "imageAtomicAdd" : "atomicAdd"; const char *increment = unsigned_type ? "0u" : "0"; emit_op(ops[0], ops[1], join(op, "(", to_expression(ops[2]), ", ", increment, ")"), false); flush_all_atomic_capable_variables(); break; } case OpAtomicStore: { // In plain GLSL, we have no atomic stores, so emulate this with an atomic exchange where we don't consume the result. // Alternatively, we could rely on KHR_memory_model, but that's not very helpful for GL. uint32_t ptr = ops[0]; // Ignore semantics for now, probably only relevant to CL. uint32_t val = ops[3]; const char *op = check_atomic_image(ptr) ? "imageAtomicExchange" : "atomicExchange"; statement(op, "(", to_expression(ptr), ", ", to_expression(val), ");"); flush_all_atomic_capable_variables(); break; } case OpAtomicIIncrement: case OpAtomicIDecrement: { forced_temporaries.insert(ops[1]); auto &type = expression_type(ops[2]); if (type.storage == StorageClassAtomicCounter) { // Legacy GLSL stuff, not sure if this is relevant to support. if (opcode == OpAtomicIIncrement) GLSL_UFOP(atomicCounterIncrement); else GLSL_UFOP(atomicCounterDecrement); } else { bool atomic_image = check_atomic_image(ops[2]); bool unsigned_type = (type.basetype == SPIRType::UInt) || (atomic_image && get(type.image.type).basetype == SPIRType::UInt); const char *op = atomic_image ? "imageAtomicAdd" : "atomicAdd"; const char *increment = nullptr; if (opcode == OpAtomicIIncrement && unsigned_type) increment = "1u"; else if (opcode == OpAtomicIIncrement) increment = "1"; else if (unsigned_type) increment = "uint(-1)"; else increment = "-1"; emit_op(ops[0], ops[1], join(op, "(", to_expression(ops[2]), ", ", increment, ")"), false); } flush_all_atomic_capable_variables(); break; } case OpAtomicIAdd: { const char *op = check_atomic_image(ops[2]) ? "imageAtomicAdd" : "atomicAdd"; forced_temporaries.insert(ops[1]); emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op); flush_all_atomic_capable_variables(); break; } case OpAtomicISub: { const char *op = check_atomic_image(ops[2]) ? "imageAtomicAdd" : "atomicAdd"; forced_temporaries.insert(ops[1]); auto expr = join(op, "(", to_expression(ops[2]), ", -", to_enclosed_expression(ops[5]), ")"); emit_op(ops[0], ops[1], expr, should_forward(ops[2]) && should_forward(ops[5])); flush_all_atomic_capable_variables(); break; } case OpAtomicSMin: case OpAtomicUMin: { const char *op = check_atomic_image(ops[2]) ? "imageAtomicMin" : "atomicMin"; forced_temporaries.insert(ops[1]); emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op); flush_all_atomic_capable_variables(); break; } case OpAtomicSMax: case OpAtomicUMax: { const char *op = check_atomic_image(ops[2]) ? "imageAtomicMax" : "atomicMax"; forced_temporaries.insert(ops[1]); emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op); flush_all_atomic_capable_variables(); break; } case OpAtomicAnd: { const char *op = check_atomic_image(ops[2]) ? "imageAtomicAnd" : "atomicAnd"; forced_temporaries.insert(ops[1]); emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op); flush_all_atomic_capable_variables(); break; } case OpAtomicOr: { const char *op = check_atomic_image(ops[2]) ? "imageAtomicOr" : "atomicOr"; forced_temporaries.insert(ops[1]); emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op); flush_all_atomic_capable_variables(); break; } case OpAtomicXor: { const char *op = check_atomic_image(ops[2]) ? "imageAtomicXor" : "atomicXor"; forced_temporaries.insert(ops[1]); emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op); flush_all_atomic_capable_variables(); break; } // Geometry shaders case OpEmitVertex: statement("EmitVertex();"); break; case OpEndPrimitive: statement("EndPrimitive();"); break; case OpEmitStreamVertex: { if (options.es) SPIRV_CROSS_THROW("Multi-stream geometry shaders not supported in ES."); else if (!options.es && options.version < 400) SPIRV_CROSS_THROW("Multi-stream geometry shaders only supported in GLSL 400."); auto stream_expr = to_expression(ops[0]); if (expression_type(ops[0]).basetype != SPIRType::Int) stream_expr = join("int(", stream_expr, ")"); statement("EmitStreamVertex(", stream_expr, ");"); break; } case OpEndStreamPrimitive: { if (options.es) SPIRV_CROSS_THROW("Multi-stream geometry shaders not supported in ES."); else if (!options.es && options.version < 400) SPIRV_CROSS_THROW("Multi-stream geometry shaders only supported in GLSL 400."); auto stream_expr = to_expression(ops[0]); if (expression_type(ops[0]).basetype != SPIRType::Int) stream_expr = join("int(", stream_expr, ")"); statement("EndStreamPrimitive(", stream_expr, ");"); break; } // Textures case OpImageSampleExplicitLod: case OpImageSampleProjExplicitLod: case OpImageSampleDrefExplicitLod: case OpImageSampleProjDrefExplicitLod: case OpImageSampleImplicitLod: case OpImageSampleProjImplicitLod: case OpImageSampleDrefImplicitLod: case OpImageSampleProjDrefImplicitLod: case OpImageFetch: case OpImageGather: case OpImageDrefGather: // Gets a bit hairy, so move this to a separate instruction. emit_texture_op(instruction, false); break; case OpImageSparseSampleExplicitLod: case OpImageSparseSampleProjExplicitLod: case OpImageSparseSampleDrefExplicitLod: case OpImageSparseSampleProjDrefExplicitLod: case OpImageSparseSampleImplicitLod: case OpImageSparseSampleProjImplicitLod: case OpImageSparseSampleDrefImplicitLod: case OpImageSparseSampleProjDrefImplicitLod: case OpImageSparseFetch: case OpImageSparseGather: case OpImageSparseDrefGather: // Gets a bit hairy, so move this to a separate instruction. emit_texture_op(instruction, true); break; case OpImageSparseTexelsResident: if (options.es) SPIRV_CROSS_THROW("Sparse feedback is not supported in GLSL."); require_extension_internal("GL_ARB_sparse_texture2"); emit_unary_func_op_cast(ops[0], ops[1], ops[2], "sparseTexelsResidentARB", int_type, SPIRType::Boolean); break; case OpImage: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; // Suppress usage tracking. auto &e = emit_op(result_type, id, to_expression(ops[2]), true, true); // When using the image, we need to know which variable it is actually loaded from. auto *var = maybe_get_backing_variable(ops[2]); e.loaded_from = var ? var->self : ID(0); break; } case OpImageQueryLod: { if (!options.es && options.version < 400) { require_extension_internal("GL_ARB_texture_query_lod"); // For some reason, the ARB spec is all-caps. GLSL_BFOP(textureQueryLOD); } else if (options.es) SPIRV_CROSS_THROW("textureQueryLod not supported in ES profile."); else GLSL_BFOP(textureQueryLod); register_control_dependent_expression(ops[1]); break; } case OpImageQueryLevels: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; if (!options.es && options.version < 430) require_extension_internal("GL_ARB_texture_query_levels"); if (options.es) SPIRV_CROSS_THROW("textureQueryLevels not supported in ES profile."); auto expr = join("textureQueryLevels(", convert_separate_image_to_expression(ops[2]), ")"); auto &restype = get(ops[0]); expr = bitcast_expression(restype, SPIRType::Int, expr); emit_op(result_type, id, expr, true); break; } case OpImageQuerySamples: { auto &type = expression_type(ops[2]); uint32_t result_type = ops[0]; uint32_t id = ops[1]; string expr; if (type.image.sampled == 2) expr = join("imageSamples(", to_expression(ops[2]), ")"); else expr = join("textureSamples(", convert_separate_image_to_expression(ops[2]), ")"); auto &restype = get(ops[0]); expr = bitcast_expression(restype, SPIRType::Int, expr); emit_op(result_type, id, expr, true); break; } case OpSampledImage: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; emit_sampled_image_op(result_type, id, ops[2], ops[3]); inherit_expression_dependencies(id, ops[2]); inherit_expression_dependencies(id, ops[3]); break; } case OpImageQuerySizeLod: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t img = ops[2]; std::string fname = "textureSize"; if (is_legacy_desktop()) { auto &type = expression_type(img); auto &imgtype = get(type.self); fname = legacy_tex_op(fname, imgtype, img); } else if (is_legacy_es()) SPIRV_CROSS_THROW("textureSize is not supported in ESSL 100."); auto expr = join(fname, "(", convert_separate_image_to_expression(img), ", ", bitcast_expression(SPIRType::Int, ops[3]), ")"); auto &restype = get(ops[0]); expr = bitcast_expression(restype, SPIRType::Int, expr); emit_op(result_type, id, expr, true); break; } // Image load/store case OpImageRead: case OpImageSparseRead: { // We added Nonreadable speculatively to the OpImage variable due to glslangValidator // not adding the proper qualifiers. // If it turns out we need to read the image after all, remove the qualifier and recompile. auto *var = maybe_get_backing_variable(ops[2]); if (var) { auto &flags = ir.meta[var->self].decoration.decoration_flags; if (flags.get(DecorationNonReadable)) { flags.clear(DecorationNonReadable); force_recompile(); } } uint32_t result_type = ops[0]; uint32_t id = ops[1]; bool pure; string imgexpr; auto &type = expression_type(ops[2]); if (var && var->remapped_variable) // Remapped input, just read as-is without any op-code { if (type.image.ms) SPIRV_CROSS_THROW("Trying to remap multisampled image to variable, this is not possible."); auto itr = find_if(begin(pls_inputs), end(pls_inputs), [var](const PlsRemap &pls) { return pls.id == var->self; }); if (itr == end(pls_inputs)) { // For non-PLS inputs, we rely on subpass type remapping information to get it right // since ImageRead always returns 4-component vectors and the backing type is opaque. if (!var->remapped_components) SPIRV_CROSS_THROW("subpassInput was remapped, but remap_components is not set correctly."); imgexpr = remap_swizzle(get(result_type), var->remapped_components, to_expression(ops[2])); } else { // PLS input could have different number of components than what the SPIR expects, swizzle to // the appropriate vector size. uint32_t components = pls_format_to_components(itr->format); imgexpr = remap_swizzle(get(result_type), components, to_expression(ops[2])); } pure = true; } else if (type.image.dim == DimSubpassData) { if (var && subpass_input_is_framebuffer_fetch(var->self)) { imgexpr = to_expression(var->self); } else if (options.vulkan_semantics) { // With Vulkan semantics, use the proper Vulkan GLSL construct. if (type.image.ms) { uint32_t operands = ops[4]; if (operands != ImageOperandsSampleMask || length != 6) SPIRV_CROSS_THROW("Multisampled image used in OpImageRead, but unexpected " "operand mask was used."); uint32_t samples = ops[5]; imgexpr = join("subpassLoad(", to_expression(ops[2]), ", ", to_expression(samples), ")"); } else imgexpr = join("subpassLoad(", to_expression(ops[2]), ")"); } else { if (type.image.ms) { uint32_t operands = ops[4]; if (operands != ImageOperandsSampleMask || length != 6) SPIRV_CROSS_THROW("Multisampled image used in OpImageRead, but unexpected " "operand mask was used."); uint32_t samples = ops[5]; imgexpr = join("texelFetch(", to_expression(ops[2]), ", ivec2(gl_FragCoord.xy), ", to_expression(samples), ")"); } else { // Implement subpass loads via texture barrier style sampling. imgexpr = join("texelFetch(", to_expression(ops[2]), ", ivec2(gl_FragCoord.xy), 0)"); } } imgexpr = remap_swizzle(get(result_type), 4, imgexpr); pure = true; } else { bool sparse = opcode == OpImageSparseRead; uint32_t sparse_code_id = 0; uint32_t sparse_texel_id = 0; if (sparse) emit_sparse_feedback_temporaries(ops[0], ops[1], sparse_code_id, sparse_texel_id); // imageLoad only accepts int coords, not uint. auto coord_expr = to_expression(ops[3]); auto target_coord_type = expression_type(ops[3]); target_coord_type.basetype = SPIRType::Int; coord_expr = bitcast_expression(target_coord_type, expression_type(ops[3]).basetype, coord_expr); // Plain image load/store. if (sparse) { if (type.image.ms) { uint32_t operands = ops[4]; if (operands != ImageOperandsSampleMask || length != 6) SPIRV_CROSS_THROW("Multisampled image used in OpImageRead, but unexpected " "operand mask was used."); uint32_t samples = ops[5]; statement(to_expression(sparse_code_id), " = sparseImageLoadARB(", to_expression(ops[2]), ", ", coord_expr, ", ", to_expression(samples), ", ", to_expression(sparse_texel_id), ");"); } else { statement(to_expression(sparse_code_id), " = sparseImageLoadARB(", to_expression(ops[2]), ", ", coord_expr, ", ", to_expression(sparse_texel_id), ");"); } imgexpr = join(type_to_glsl(get(result_type)), "(", to_expression(sparse_code_id), ", ", to_expression(sparse_texel_id), ")"); } else { if (type.image.ms) { uint32_t operands = ops[4]; if (operands != ImageOperandsSampleMask || length != 6) SPIRV_CROSS_THROW("Multisampled image used in OpImageRead, but unexpected " "operand mask was used."); uint32_t samples = ops[5]; imgexpr = join("imageLoad(", to_expression(ops[2]), ", ", coord_expr, ", ", to_expression(samples), ")"); } else imgexpr = join("imageLoad(", to_expression(ops[2]), ", ", coord_expr, ")"); } if (!sparse) imgexpr = remap_swizzle(get(result_type), 4, imgexpr); pure = false; } if (var && var->forwardable) { bool forward = forced_temporaries.find(id) == end(forced_temporaries); auto &e = emit_op(result_type, id, imgexpr, forward); // We only need to track dependencies if we're reading from image load/store. if (!pure) { e.loaded_from = var->self; if (forward) var->dependees.push_back(id); } } else emit_op(result_type, id, imgexpr, false); inherit_expression_dependencies(id, ops[2]); if (type.image.ms) inherit_expression_dependencies(id, ops[5]); break; } case OpImageTexelPointer: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto coord_expr = to_expression(ops[3]); auto target_coord_type = expression_type(ops[3]); target_coord_type.basetype = SPIRType::Int; coord_expr = bitcast_expression(target_coord_type, expression_type(ops[3]).basetype, coord_expr); auto expr = join(to_expression(ops[2]), ", ", coord_expr); if (has_decoration(id, DecorationNonUniformEXT) || has_decoration(ops[2], DecorationNonUniformEXT)) convert_non_uniform_expression(expression_type(ops[2]), expr); auto &e = set(id, expr, result_type, true); // When using the pointer, we need to know which variable it is actually loaded from. auto *var = maybe_get_backing_variable(ops[2]); e.loaded_from = var ? var->self : ID(0); inherit_expression_dependencies(id, ops[3]); break; } case OpImageWrite: { // We added Nonwritable speculatively to the OpImage variable due to glslangValidator // not adding the proper qualifiers. // If it turns out we need to write to the image after all, remove the qualifier and recompile. auto *var = maybe_get_backing_variable(ops[0]); if (var) { auto &flags = ir.meta[var->self].decoration.decoration_flags; if (flags.get(DecorationNonWritable)) { flags.clear(DecorationNonWritable); force_recompile(); } } auto &type = expression_type(ops[0]); auto &value_type = expression_type(ops[2]); auto store_type = value_type; store_type.vecsize = 4; // imageStore only accepts int coords, not uint. auto coord_expr = to_expression(ops[1]); auto target_coord_type = expression_type(ops[1]); target_coord_type.basetype = SPIRType::Int; coord_expr = bitcast_expression(target_coord_type, expression_type(ops[1]).basetype, coord_expr); if (type.image.ms) { uint32_t operands = ops[3]; if (operands != ImageOperandsSampleMask || length != 5) SPIRV_CROSS_THROW("Multisampled image used in OpImageWrite, but unexpected operand mask was used."); uint32_t samples = ops[4]; statement("imageStore(", to_expression(ops[0]), ", ", coord_expr, ", ", to_expression(samples), ", ", remap_swizzle(store_type, value_type.vecsize, to_expression(ops[2])), ");"); } else statement("imageStore(", to_expression(ops[0]), ", ", coord_expr, ", ", remap_swizzle(store_type, value_type.vecsize, to_expression(ops[2])), ");"); if (var && variable_storage_is_aliased(*var)) flush_all_aliased_variables(); break; } case OpImageQuerySize: { auto &type = expression_type(ops[2]); uint32_t result_type = ops[0]; uint32_t id = ops[1]; if (type.basetype == SPIRType::Image) { string expr; if (type.image.sampled == 2) { if (!options.es && options.version < 430) require_extension_internal("GL_ARB_shader_image_size"); else if (options.es && options.version < 310) SPIRV_CROSS_THROW("At least ESSL 3.10 required for imageSize."); // The size of an image is always constant. expr = join("imageSize(", to_expression(ops[2]), ")"); } else { // This path is hit for samplerBuffers and multisampled images which do not have LOD. std::string fname = "textureSize"; if (is_legacy()) { auto &imgtype = get(type.self); fname = legacy_tex_op(fname, imgtype, ops[2]); } expr = join(fname, "(", convert_separate_image_to_expression(ops[2]), ")"); } auto &restype = get(ops[0]); expr = bitcast_expression(restype, SPIRType::Int, expr); emit_op(result_type, id, expr, true); } else SPIRV_CROSS_THROW("Invalid type for OpImageQuerySize."); break; } // Compute case OpControlBarrier: case OpMemoryBarrier: { uint32_t execution_scope = 0; uint32_t memory; uint32_t semantics; if (opcode == OpMemoryBarrier) { memory = evaluate_constant_u32(ops[0]); semantics = evaluate_constant_u32(ops[1]); } else { execution_scope = evaluate_constant_u32(ops[0]); memory = evaluate_constant_u32(ops[1]); semantics = evaluate_constant_u32(ops[2]); } if (execution_scope == ScopeSubgroup || memory == ScopeSubgroup) { // OpControlBarrier with ScopeSubgroup is subgroupBarrier() if (opcode != OpControlBarrier) { request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMemBarrier); } else { request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBarrier); } } if (execution_scope != ScopeSubgroup && get_entry_point().model == ExecutionModelTessellationControl) { // Control shaders only have barriers, and it implies memory barriers. if (opcode == OpControlBarrier) statement("barrier();"); break; } // We only care about these flags, acquire/release and friends are not relevant to GLSL. semantics = mask_relevant_memory_semantics(semantics); if (opcode == OpMemoryBarrier) { // If we are a memory barrier, and the next instruction is a control barrier, check if that memory barrier // does what we need, so we avoid redundant barriers. const Instruction *next = get_next_instruction_in_block(instruction); if (next && next->op == OpControlBarrier) { auto *next_ops = stream(*next); uint32_t next_memory = evaluate_constant_u32(next_ops[1]); uint32_t next_semantics = evaluate_constant_u32(next_ops[2]); next_semantics = mask_relevant_memory_semantics(next_semantics); bool memory_scope_covered = false; if (next_memory == memory) memory_scope_covered = true; else if (next_semantics == MemorySemanticsWorkgroupMemoryMask) { // If we only care about workgroup memory, either Device or Workgroup scope is fine, // scope does not have to match. if ((next_memory == ScopeDevice || next_memory == ScopeWorkgroup) && (memory == ScopeDevice || memory == ScopeWorkgroup)) { memory_scope_covered = true; } } else if (memory == ScopeWorkgroup && next_memory == ScopeDevice) { // The control barrier has device scope, but the memory barrier just has workgroup scope. memory_scope_covered = true; } // If we have the same memory scope, and all memory types are covered, we're good. if (memory_scope_covered && (semantics & next_semantics) == semantics) break; } } // We are synchronizing some memory or syncing execution, // so we cannot forward any loads beyond the memory barrier. if (semantics || opcode == OpControlBarrier) { assert(current_emitting_block); flush_control_dependent_expressions(current_emitting_block->self); flush_all_active_variables(); } if (memory == ScopeWorkgroup) // Only need to consider memory within a group { if (semantics == MemorySemanticsWorkgroupMemoryMask) { // OpControlBarrier implies a memory barrier for shared memory as well. bool implies_shared_barrier = opcode == OpControlBarrier && execution_scope == ScopeWorkgroup; if (!implies_shared_barrier) statement("memoryBarrierShared();"); } else if (semantics != 0) statement("groupMemoryBarrier();"); } else if (memory == ScopeSubgroup) { const uint32_t all_barriers = MemorySemanticsWorkgroupMemoryMask | MemorySemanticsUniformMemoryMask | MemorySemanticsImageMemoryMask; if (semantics & (MemorySemanticsCrossWorkgroupMemoryMask | MemorySemanticsSubgroupMemoryMask)) { // These are not relevant for GLSL, but assume it means memoryBarrier(). // memoryBarrier() does everything, so no need to test anything else. statement("subgroupMemoryBarrier();"); } else if ((semantics & all_barriers) == all_barriers) { // Short-hand instead of emitting 3 barriers. statement("subgroupMemoryBarrier();"); } else { // Pick out individual barriers. if (semantics & MemorySemanticsWorkgroupMemoryMask) statement("subgroupMemoryBarrierShared();"); if (semantics & MemorySemanticsUniformMemoryMask) statement("subgroupMemoryBarrierBuffer();"); if (semantics & MemorySemanticsImageMemoryMask) statement("subgroupMemoryBarrierImage();"); } } else { const uint32_t all_barriers = MemorySemanticsWorkgroupMemoryMask | MemorySemanticsUniformMemoryMask | MemorySemanticsImageMemoryMask; if (semantics & (MemorySemanticsCrossWorkgroupMemoryMask | MemorySemanticsSubgroupMemoryMask)) { // These are not relevant for GLSL, but assume it means memoryBarrier(). // memoryBarrier() does everything, so no need to test anything else. statement("memoryBarrier();"); } else if ((semantics & all_barriers) == all_barriers) { // Short-hand instead of emitting 4 barriers. statement("memoryBarrier();"); } else { // Pick out individual barriers. if (semantics & MemorySemanticsWorkgroupMemoryMask) statement("memoryBarrierShared();"); if (semantics & MemorySemanticsUniformMemoryMask) statement("memoryBarrierBuffer();"); if (semantics & MemorySemanticsImageMemoryMask) statement("memoryBarrierImage();"); } } if (opcode == OpControlBarrier) { if (execution_scope == ScopeSubgroup) statement("subgroupBarrier();"); else statement("barrier();"); } break; } case OpExtInst: { uint32_t extension_set = ops[2]; if (get(extension_set).ext == SPIRExtension::GLSL) { emit_glsl_op(ops[0], ops[1], ops[3], &ops[4], length - 4); } else if (get(extension_set).ext == SPIRExtension::SPV_AMD_shader_ballot) { emit_spv_amd_shader_ballot_op(ops[0], ops[1], ops[3], &ops[4], length - 4); } else if (get(extension_set).ext == SPIRExtension::SPV_AMD_shader_explicit_vertex_parameter) { emit_spv_amd_shader_explicit_vertex_parameter_op(ops[0], ops[1], ops[3], &ops[4], length - 4); } else if (get(extension_set).ext == SPIRExtension::SPV_AMD_shader_trinary_minmax) { emit_spv_amd_shader_trinary_minmax_op(ops[0], ops[1], ops[3], &ops[4], length - 4); } else if (get(extension_set).ext == SPIRExtension::SPV_AMD_gcn_shader) { emit_spv_amd_gcn_shader_op(ops[0], ops[1], ops[3], &ops[4], length - 4); } else if (get(extension_set).ext == SPIRExtension::SPV_debug_info) { break; // Ignore SPIR-V debug information extended instructions. } else { statement("// unimplemented ext op ", instruction.op); break; } break; } // Legacy sub-group stuff ... case OpSubgroupBallotKHR: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; string expr; expr = join("uvec4(unpackUint2x32(ballotARB(" + to_expression(ops[2]) + ")), 0u, 0u)"); emit_op(result_type, id, expr, should_forward(ops[2])); require_extension_internal("GL_ARB_shader_ballot"); inherit_expression_dependencies(id, ops[2]); register_control_dependent_expression(ops[1]); break; } case OpSubgroupFirstInvocationKHR: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; emit_unary_func_op(result_type, id, ops[2], "readFirstInvocationARB"); require_extension_internal("GL_ARB_shader_ballot"); register_control_dependent_expression(ops[1]); break; } case OpSubgroupReadInvocationKHR: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; emit_binary_func_op(result_type, id, ops[2], ops[3], "readInvocationARB"); require_extension_internal("GL_ARB_shader_ballot"); register_control_dependent_expression(ops[1]); break; } case OpSubgroupAllKHR: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; emit_unary_func_op(result_type, id, ops[2], "allInvocationsARB"); require_extension_internal("GL_ARB_shader_group_vote"); register_control_dependent_expression(ops[1]); break; } case OpSubgroupAnyKHR: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; emit_unary_func_op(result_type, id, ops[2], "anyInvocationARB"); require_extension_internal("GL_ARB_shader_group_vote"); register_control_dependent_expression(ops[1]); break; } case OpSubgroupAllEqualKHR: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; emit_unary_func_op(result_type, id, ops[2], "allInvocationsEqualARB"); require_extension_internal("GL_ARB_shader_group_vote"); register_control_dependent_expression(ops[1]); break; } case OpGroupIAddNonUniformAMD: case OpGroupFAddNonUniformAMD: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; emit_unary_func_op(result_type, id, ops[4], "addInvocationsNonUniformAMD"); require_extension_internal("GL_AMD_shader_ballot"); register_control_dependent_expression(ops[1]); break; } case OpGroupFMinNonUniformAMD: case OpGroupUMinNonUniformAMD: case OpGroupSMinNonUniformAMD: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; emit_unary_func_op(result_type, id, ops[4], "minInvocationsNonUniformAMD"); require_extension_internal("GL_AMD_shader_ballot"); register_control_dependent_expression(ops[1]); break; } case OpGroupFMaxNonUniformAMD: case OpGroupUMaxNonUniformAMD: case OpGroupSMaxNonUniformAMD: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; emit_unary_func_op(result_type, id, ops[4], "maxInvocationsNonUniformAMD"); require_extension_internal("GL_AMD_shader_ballot"); register_control_dependent_expression(ops[1]); break; } case OpFragmentMaskFetchAMD: { auto &type = expression_type(ops[2]); uint32_t result_type = ops[0]; uint32_t id = ops[1]; if (type.image.dim == spv::DimSubpassData) { emit_unary_func_op(result_type, id, ops[2], "fragmentMaskFetchAMD"); } else { emit_binary_func_op(result_type, id, ops[2], ops[3], "fragmentMaskFetchAMD"); } require_extension_internal("GL_AMD_shader_fragment_mask"); break; } case OpFragmentFetchAMD: { auto &type = expression_type(ops[2]); uint32_t result_type = ops[0]; uint32_t id = ops[1]; if (type.image.dim == spv::DimSubpassData) { emit_binary_func_op(result_type, id, ops[2], ops[4], "fragmentFetchAMD"); } else { emit_trinary_func_op(result_type, id, ops[2], ops[3], ops[4], "fragmentFetchAMD"); } require_extension_internal("GL_AMD_shader_fragment_mask"); break; } // Vulkan 1.1 sub-group stuff ... case OpGroupNonUniformElect: case OpGroupNonUniformBroadcast: case OpGroupNonUniformBroadcastFirst: case OpGroupNonUniformBallot: case OpGroupNonUniformInverseBallot: case OpGroupNonUniformBallotBitExtract: case OpGroupNonUniformBallotBitCount: case OpGroupNonUniformBallotFindLSB: case OpGroupNonUniformBallotFindMSB: case OpGroupNonUniformShuffle: case OpGroupNonUniformShuffleXor: case OpGroupNonUniformShuffleUp: case OpGroupNonUniformShuffleDown: case OpGroupNonUniformAll: case OpGroupNonUniformAny: case OpGroupNonUniformAllEqual: case OpGroupNonUniformFAdd: case OpGroupNonUniformIAdd: case OpGroupNonUniformFMul: case OpGroupNonUniformIMul: case OpGroupNonUniformFMin: case OpGroupNonUniformFMax: case OpGroupNonUniformSMin: case OpGroupNonUniformSMax: case OpGroupNonUniformUMin: case OpGroupNonUniformUMax: case OpGroupNonUniformBitwiseAnd: case OpGroupNonUniformBitwiseOr: case OpGroupNonUniformBitwiseXor: case OpGroupNonUniformQuadSwap: case OpGroupNonUniformQuadBroadcast: emit_subgroup_op(instruction); break; case OpFUnordEqual: case OpFUnordNotEqual: case OpFUnordLessThan: case OpFUnordGreaterThan: case OpFUnordLessThanEqual: case OpFUnordGreaterThanEqual: { // GLSL doesn't specify if floating point comparisons are ordered or unordered, // but glslang always emits ordered floating point compares for GLSL. // To get unordered compares, we can test the opposite thing and invert the result. // This way, we force true when there is any NaN present. uint32_t op0 = ops[2]; uint32_t op1 = ops[3]; string expr; if (expression_type(op0).vecsize > 1) { const char *comp_op = nullptr; switch (opcode) { case OpFUnordEqual: comp_op = "notEqual"; break; case OpFUnordNotEqual: comp_op = "equal"; break; case OpFUnordLessThan: comp_op = "greaterThanEqual"; break; case OpFUnordLessThanEqual: comp_op = "greaterThan"; break; case OpFUnordGreaterThan: comp_op = "lessThanEqual"; break; case OpFUnordGreaterThanEqual: comp_op = "lessThan"; break; default: assert(0); break; } expr = join("not(", comp_op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), "))"); } else { const char *comp_op = nullptr; switch (opcode) { case OpFUnordEqual: comp_op = " != "; break; case OpFUnordNotEqual: comp_op = " == "; break; case OpFUnordLessThan: comp_op = " >= "; break; case OpFUnordLessThanEqual: comp_op = " > "; break; case OpFUnordGreaterThan: comp_op = " <= "; break; case OpFUnordGreaterThanEqual: comp_op = " < "; break; default: assert(0); break; } expr = join("!(", to_enclosed_unpacked_expression(op0), comp_op, to_enclosed_unpacked_expression(op1), ")"); } emit_op(ops[0], ops[1], expr, should_forward(op0) && should_forward(op1)); inherit_expression_dependencies(ops[1], op0); inherit_expression_dependencies(ops[1], op1); break; } case OpReportIntersectionKHR: // NV is same opcode. forced_temporaries.insert(ops[1]); if (ray_tracing_is_khr) GLSL_BFOP(reportIntersectionEXT); else GLSL_BFOP(reportIntersectionNV); flush_control_dependent_expressions(current_emitting_block->self); break; case OpIgnoreIntersectionNV: // KHR variant is a terminator. statement("ignoreIntersectionNV();"); flush_control_dependent_expressions(current_emitting_block->self); break; case OpTerminateRayNV: // KHR variant is a terminator. statement("terminateRayNV();"); flush_control_dependent_expressions(current_emitting_block->self); break; case OpTraceNV: statement("traceNV(", to_expression(ops[0]), ", ", to_expression(ops[1]), ", ", to_expression(ops[2]), ", ", to_expression(ops[3]), ", ", to_expression(ops[4]), ", ", to_expression(ops[5]), ", ", to_expression(ops[6]), ", ", to_expression(ops[7]), ", ", to_expression(ops[8]), ", ", to_expression(ops[9]), ", ", to_expression(ops[10]), ");"); flush_control_dependent_expressions(current_emitting_block->self); break; case OpTraceRayKHR: if (!has_decoration(ops[10], DecorationLocation)) SPIRV_CROSS_THROW("A memory declaration object must be used in TraceRayKHR."); statement("traceRayEXT(", to_expression(ops[0]), ", ", to_expression(ops[1]), ", ", to_expression(ops[2]), ", ", to_expression(ops[3]), ", ", to_expression(ops[4]), ", ", to_expression(ops[5]), ", ", to_expression(ops[6]), ", ", to_expression(ops[7]), ", ", to_expression(ops[8]), ", ", to_expression(ops[9]), ", ", get_decoration(ops[10], DecorationLocation), ");"); flush_control_dependent_expressions(current_emitting_block->self); break; case OpExecuteCallableNV: statement("executeCallableNV(", to_expression(ops[0]), ", ", to_expression(ops[1]), ");"); flush_control_dependent_expressions(current_emitting_block->self); break; case OpExecuteCallableKHR: if (!has_decoration(ops[1], DecorationLocation)) SPIRV_CROSS_THROW("A memory declaration object must be used in ExecuteCallableKHR."); statement("executeCallableEXT(", to_expression(ops[0]), ", ", get_decoration(ops[1], DecorationLocation), ");"); flush_control_dependent_expressions(current_emitting_block->self); break; case OpConvertUToAccelerationStructureKHR: GLSL_UFOP(accelerationStructureEXT); break; case OpConvertUToPtr: { auto &type = get(ops[0]); if (type.storage != StorageClassPhysicalStorageBufferEXT) SPIRV_CROSS_THROW("Only StorageClassPhysicalStorageBufferEXT is supported by OpConvertUToPtr."); auto op = type_to_glsl(type); emit_unary_func_op(ops[0], ops[1], ops[2], op.c_str()); break; } case OpConvertPtrToU: { auto &type = get(ops[0]); auto &ptr_type = expression_type(ops[2]); if (ptr_type.storage != StorageClassPhysicalStorageBufferEXT) SPIRV_CROSS_THROW("Only StorageClassPhysicalStorageBufferEXT is supported by OpConvertPtrToU."); auto op = type_to_glsl(type); emit_unary_func_op(ops[0], ops[1], ops[2], op.c_str()); break; } case OpUndef: // Undefined value has been declared. break; case OpLine: { emit_line_directive(ops[0], ops[1]); break; } case OpNoLine: break; case OpDemoteToHelperInvocationEXT: if (!options.vulkan_semantics) SPIRV_CROSS_THROW("GL_EXT_demote_to_helper_invocation is only supported in Vulkan GLSL."); require_extension_internal("GL_EXT_demote_to_helper_invocation"); statement(backend.demote_literal, ";"); break; case OpIsHelperInvocationEXT: if (!options.vulkan_semantics) SPIRV_CROSS_THROW("GL_EXT_demote_to_helper_invocation is only supported in Vulkan GLSL."); require_extension_internal("GL_EXT_demote_to_helper_invocation"); emit_op(ops[0], ops[1], "helperInvocationEXT()", false); break; case OpBeginInvocationInterlockEXT: // If the interlock is complex, we emit this elsewhere. if (!interlocked_is_complex) { if (options.es) statement("beginInvocationInterlockNV();"); else statement("beginInvocationInterlockARB();"); flush_all_active_variables(); // Make sure forwarding doesn't propagate outside interlock region. } break; case OpEndInvocationInterlockEXT: // If the interlock is complex, we emit this elsewhere. if (!interlocked_is_complex) { if (options.es) statement("endInvocationInterlockNV();"); else statement("endInvocationInterlockARB();"); flush_all_active_variables(); // Make sure forwarding doesn't propagate outside interlock region. } break; default: statement("// unimplemented op ", instruction.op); break; } } // Appends function arguments, mapped from global variables, beyond the specified arg index. // This is used when a function call uses fewer arguments than the function defines. // This situation may occur if the function signature has been dynamically modified to // extract global variables referenced from within the function, and convert them to // function arguments. This is necessary for shader languages that do not support global // access to shader input content from within a function (eg. Metal). Each additional // function args uses the name of the global variable. Function nesting will modify the // functions and function calls all the way up the nesting chain. void CompilerGLSL::append_global_func_args(const SPIRFunction &func, uint32_t index, SmallVector &arglist) { auto &args = func.arguments; uint32_t arg_cnt = uint32_t(args.size()); for (uint32_t arg_idx = index; arg_idx < arg_cnt; arg_idx++) { auto &arg = args[arg_idx]; assert(arg.alias_global_variable); // If the underlying variable needs to be declared // (ie. a local variable with deferred declaration), do so now. uint32_t var_id = get(arg.id).basevariable; if (var_id) flush_variable_declaration(var_id); arglist.push_back(to_func_call_arg(arg, arg.id)); } } string CompilerGLSL::to_member_name(const SPIRType &type, uint32_t index) { if (type.type_alias != TypeID(0) && !has_extended_decoration(type.type_alias, SPIRVCrossDecorationBufferBlockRepacked)) { return to_member_name(get(type.type_alias), index); } auto &memb = ir.meta[type.self].members; if (index < memb.size() && !memb[index].alias.empty()) return memb[index].alias; else return join("_m", index); } string CompilerGLSL::to_member_reference(uint32_t, const SPIRType &type, uint32_t index, bool) { return join(".", to_member_name(type, index)); } string CompilerGLSL::to_multi_member_reference(const SPIRType &type, const SmallVector &indices) { string ret; auto *member_type = &type; for (auto &index : indices) { ret += join(".", to_member_name(*member_type, index)); member_type = &get(member_type->member_types[index]); } return ret; } void CompilerGLSL::add_member_name(SPIRType &type, uint32_t index) { auto &memb = ir.meta[type.self].members; if (index < memb.size() && !memb[index].alias.empty()) { auto &name = memb[index].alias; if (name.empty()) return; ParsedIR::sanitize_identifier(name, true, true); update_name_cache(type.member_name_cache, name); } } // Checks whether the ID is a row_major matrix that requires conversion before use bool CompilerGLSL::is_non_native_row_major_matrix(uint32_t id) { // Natively supported row-major matrices do not need to be converted. // Legacy targets do not support row major. if (backend.native_row_major_matrix && !is_legacy()) return false; auto *e = maybe_get(id); if (e) return e->need_transpose; else return has_decoration(id, DecorationRowMajor); } // Checks whether the member is a row_major matrix that requires conversion before use bool CompilerGLSL::member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index) { // Natively supported row-major matrices do not need to be converted. if (backend.native_row_major_matrix && !is_legacy()) return false; // Non-matrix or column-major matrix types do not need to be converted. if (!has_member_decoration(type.self, index, DecorationRowMajor)) return false; // Only square row-major matrices can be converted at this time. // Converting non-square matrices will require defining custom GLSL function that // swaps matrix elements while retaining the original dimensional form of the matrix. const auto mbr_type = get(type.member_types[index]); if (mbr_type.columns != mbr_type.vecsize) SPIRV_CROSS_THROW("Row-major matrices must be square on this platform."); return true; } // Checks if we need to remap physical type IDs when declaring the type in a buffer. bool CompilerGLSL::member_is_remapped_physical_type(const SPIRType &type, uint32_t index) const { return has_extended_member_decoration(type.self, index, SPIRVCrossDecorationPhysicalTypeID); } // Checks whether the member is in packed data type, that might need to be unpacked. bool CompilerGLSL::member_is_packed_physical_type(const SPIRType &type, uint32_t index) const { return has_extended_member_decoration(type.self, index, SPIRVCrossDecorationPhysicalTypePacked); } // Wraps the expression string in a function call that converts the // row_major matrix result of the expression to a column_major matrix. // Base implementation uses the standard library transpose() function. // Subclasses may override to use a different function. string CompilerGLSL::convert_row_major_matrix(string exp_str, const SPIRType &exp_type, uint32_t /* physical_type_id */, bool /*is_packed*/) { strip_enclosed_expression(exp_str); if (!is_matrix(exp_type)) { auto column_index = exp_str.find_last_of('['); if (column_index == string::npos) return exp_str; auto column_expr = exp_str.substr(column_index); exp_str.resize(column_index); auto transposed_expr = type_to_glsl_constructor(exp_type) + "("; // Loading a column from a row-major matrix. Unroll the load. for (uint32_t c = 0; c < exp_type.vecsize; c++) { transposed_expr += join(exp_str, '[', c, ']', column_expr); if (c + 1 < exp_type.vecsize) transposed_expr += ", "; } transposed_expr += ")"; return transposed_expr; } else if (options.version < 120) { // GLSL 110, ES 100 do not have transpose(), so emulate it. Note that // these GLSL versions do not support non-square matrices. if (exp_type.vecsize == 2 && exp_type.columns == 2) { if (!requires_transpose_2x2) { requires_transpose_2x2 = true; force_recompile(); } } else if (exp_type.vecsize == 3 && exp_type.columns == 3) { if (!requires_transpose_3x3) { requires_transpose_3x3 = true; force_recompile(); } } else if (exp_type.vecsize == 4 && exp_type.columns == 4) { if (!requires_transpose_4x4) { requires_transpose_4x4 = true; force_recompile(); } } else SPIRV_CROSS_THROW("Non-square matrices are not supported in legacy GLSL, cannot transpose."); return join("spvTranspose(", exp_str, ")"); } else return join("transpose(", exp_str, ")"); } string CompilerGLSL::variable_decl(const SPIRType &type, const string &name, uint32_t id) { string type_name = type_to_glsl(type, id); remap_variable_type_name(type, name, type_name); return join(type_name, " ", name, type_to_array_glsl(type)); } // Emit a structure member. Subclasses may override to modify output, // or to dynamically add a padding member if needed. void CompilerGLSL::emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const string &qualifier, uint32_t) { auto &membertype = get(member_type_id); Bitset memberflags; auto &memb = ir.meta[type.self].members; if (index < memb.size()) memberflags = memb[index].decoration_flags; string qualifiers; bool is_block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) || ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock); if (is_block) qualifiers = to_interpolation_qualifiers(memberflags); statement(layout_for_member(type, index), qualifiers, qualifier, flags_to_qualifiers_glsl(membertype, memberflags), variable_decl(membertype, to_member_name(type, index)), ";"); } void CompilerGLSL::emit_struct_padding_target(const SPIRType &) { } const char *CompilerGLSL::flags_to_qualifiers_glsl(const SPIRType &type, const Bitset &flags) { // GL_EXT_buffer_reference variables can be marked as restrict. if (flags.get(DecorationRestrictPointerEXT)) return "restrict "; // Structs do not have precision qualifiers, neither do doubles (desktop only anyways, so no mediump/highp). if (type.basetype != SPIRType::Float && type.basetype != SPIRType::Int && type.basetype != SPIRType::UInt && type.basetype != SPIRType::Image && type.basetype != SPIRType::SampledImage && type.basetype != SPIRType::Sampler) return ""; if (options.es) { auto &execution = get_entry_point(); if (flags.get(DecorationRelaxedPrecision)) { bool implied_fmediump = type.basetype == SPIRType::Float && options.fragment.default_float_precision == Options::Mediump && execution.model == ExecutionModelFragment; bool implied_imediump = (type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt) && options.fragment.default_int_precision == Options::Mediump && execution.model == ExecutionModelFragment; return implied_fmediump || implied_imediump ? "" : "mediump "; } else { bool implied_fhighp = type.basetype == SPIRType::Float && ((options.fragment.default_float_precision == Options::Highp && execution.model == ExecutionModelFragment) || (execution.model != ExecutionModelFragment)); bool implied_ihighp = (type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt) && ((options.fragment.default_int_precision == Options::Highp && execution.model == ExecutionModelFragment) || (execution.model != ExecutionModelFragment)); return implied_fhighp || implied_ihighp ? "" : "highp "; } } else if (backend.allow_precision_qualifiers) { // Vulkan GLSL supports precision qualifiers, even in desktop profiles, which is convenient. // The default is highp however, so only emit mediump in the rare case that a shader has these. if (flags.get(DecorationRelaxedPrecision)) return "mediump "; else return ""; } else return ""; } const char *CompilerGLSL::to_precision_qualifiers_glsl(uint32_t id) { auto &type = expression_type(id); bool use_precision_qualifiers = backend.allow_precision_qualifiers || options.es; if (use_precision_qualifiers && (type.basetype == SPIRType::Image || type.basetype == SPIRType::SampledImage)) { // Force mediump for the sampler type. We cannot declare 16-bit or smaller image types. auto &result_type = get(type.image.type); if (result_type.width < 32) return "mediump "; } return flags_to_qualifiers_glsl(type, ir.meta[id].decoration.decoration_flags); } void CompilerGLSL::fixup_io_block_patch_qualifiers(const SPIRVariable &var) { // Works around weird behavior in glslangValidator where // a patch out block is translated to just block members getting the decoration. // To make glslang not complain when we compile again, we have to transform this back to a case where // the variable itself has Patch decoration, and not members. auto &type = get(var.basetype); if (has_decoration(type.self, DecorationBlock)) { uint32_t member_count = uint32_t(type.member_types.size()); for (uint32_t i = 0; i < member_count; i++) { if (has_member_decoration(type.self, i, DecorationPatch)) { set_decoration(var.self, DecorationPatch); break; } } if (has_decoration(var.self, DecorationPatch)) for (uint32_t i = 0; i < member_count; i++) unset_member_decoration(type.self, i, DecorationPatch); } } string CompilerGLSL::to_qualifiers_glsl(uint32_t id) { auto &flags = ir.meta[id].decoration.decoration_flags; string res; auto *var = maybe_get(id); if (var && var->storage == StorageClassWorkgroup && !backend.shared_is_implied) res += "shared "; res += to_interpolation_qualifiers(flags); if (var) res += to_storage_qualifiers_glsl(*var); auto &type = expression_type(id); if (type.image.dim != DimSubpassData && type.image.sampled == 2) { if (flags.get(DecorationCoherent)) res += "coherent "; if (flags.get(DecorationRestrict)) res += "restrict "; if (flags.get(DecorationNonWritable)) res += "readonly "; if (flags.get(DecorationNonReadable)) res += "writeonly "; } res += to_precision_qualifiers_glsl(id); return res; } string CompilerGLSL::argument_decl(const SPIRFunction::Parameter &arg) { // glslangValidator seems to make all arguments pointer no matter what which is rather bizarre ... auto &type = expression_type(arg.id); const char *direction = ""; if (type.pointer) { if (arg.write_count && arg.read_count) direction = "inout "; else if (arg.write_count) direction = "out "; } return join(direction, to_qualifiers_glsl(arg.id), variable_decl(type, to_name(arg.id), arg.id)); } string CompilerGLSL::to_initializer_expression(const SPIRVariable &var) { return to_expression(var.initializer); } string CompilerGLSL::to_zero_initialized_expression(uint32_t type_id) { #ifndef NDEBUG auto &type = get(type_id); assert(type.storage == StorageClassPrivate || type.storage == StorageClassFunction || type.storage == StorageClassGeneric); #endif uint32_t id = ir.increase_bound_by(1); ir.make_constant_null(id, type_id, false); return constant_expression(get(id)); } bool CompilerGLSL::type_can_zero_initialize(const SPIRType &type) const { if (type.pointer) return false; if (!type.array.empty() && options.flatten_multidimensional_arrays) return false; for (auto &literal : type.array_size_literal) if (!literal) return false; for (auto &memb : type.member_types) if (!type_can_zero_initialize(get(memb))) return false; return true; } string CompilerGLSL::variable_decl(const SPIRVariable &variable) { // Ignore the pointer type since GLSL doesn't have pointers. auto &type = get_variable_data_type(variable); if (type.pointer_depth > 1) SPIRV_CROSS_THROW("Cannot declare pointer-to-pointer types."); auto res = join(to_qualifiers_glsl(variable.self), variable_decl(type, to_name(variable.self), variable.self)); if (variable.loop_variable && variable.static_expression) { uint32_t expr = variable.static_expression; if (ir.ids[expr].get_type() != TypeUndef) res += join(" = ", to_expression(variable.static_expression)); else if (options.force_zero_initialized_variables && type_can_zero_initialize(type)) res += join(" = ", to_zero_initialized_expression(get_variable_data_type_id(variable))); } else if (variable.initializer) { uint32_t expr = variable.initializer; if (ir.ids[expr].get_type() != TypeUndef) res += join(" = ", to_initializer_expression(variable)); else if (options.force_zero_initialized_variables && type_can_zero_initialize(type)) res += join(" = ", to_zero_initialized_expression(get_variable_data_type_id(variable))); } return res; } const char *CompilerGLSL::to_pls_qualifiers_glsl(const SPIRVariable &variable) { auto &flags = ir.meta[variable.self].decoration.decoration_flags; if (flags.get(DecorationRelaxedPrecision)) return "mediump "; else return "highp "; } string CompilerGLSL::pls_decl(const PlsRemap &var) { auto &variable = get(var.id); SPIRType type; type.vecsize = pls_format_to_components(var.format); type.basetype = pls_format_to_basetype(var.format); return join(to_pls_layout(var.format), to_pls_qualifiers_glsl(variable), type_to_glsl(type), " ", to_name(variable.self)); } uint32_t CompilerGLSL::to_array_size_literal(const SPIRType &type) const { return to_array_size_literal(type, uint32_t(type.array.size() - 1)); } uint32_t CompilerGLSL::to_array_size_literal(const SPIRType &type, uint32_t index) const { assert(type.array.size() == type.array_size_literal.size()); if (type.array_size_literal[index]) { return type.array[index]; } else { // Use the default spec constant value. // This is the best we can do. return evaluate_constant_u32(type.array[index]); } } string CompilerGLSL::to_array_size(const SPIRType &type, uint32_t index) { assert(type.array.size() == type.array_size_literal.size()); auto &size = type.array[index]; if (!type.array_size_literal[index]) return to_expression(size); else if (size) return convert_to_string(size); else if (!backend.unsized_array_supported) { // For runtime-sized arrays, we can work around // lack of standard support for this by simply having // a single element array. // // Runtime length arrays must always be the last element // in an interface block. return "1"; } else return ""; } string CompilerGLSL::type_to_array_glsl(const SPIRType &type) { if (type.pointer && type.storage == StorageClassPhysicalStorageBufferEXT && type.basetype != SPIRType::Struct) { // We are using a wrapped pointer type, and we should not emit any array declarations here. return ""; } if (type.array.empty()) return ""; if (options.flatten_multidimensional_arrays) { string res; res += "["; for (auto i = uint32_t(type.array.size()); i; i--) { res += enclose_expression(to_array_size(type, i - 1)); if (i > 1) res += " * "; } res += "]"; return res; } else { if (type.array.size() > 1) { if (!options.es && options.version < 430) require_extension_internal("GL_ARB_arrays_of_arrays"); else if (options.es && options.version < 310) SPIRV_CROSS_THROW("Arrays of arrays not supported before ESSL version 310. " "Try using --flatten-multidimensional-arrays or set " "options.flatten_multidimensional_arrays to true."); } string res; for (auto i = uint32_t(type.array.size()); i; i--) { res += "["; res += to_array_size(type, i - 1); res += "]"; } return res; } } string CompilerGLSL::image_type_glsl(const SPIRType &type, uint32_t id) { auto &imagetype = get(type.image.type); string res; switch (imagetype.basetype) { case SPIRType::Int: case SPIRType::Short: case SPIRType::SByte: res = "i"; break; case SPIRType::UInt: case SPIRType::UShort: case SPIRType::UByte: res = "u"; break; default: break; } // For half image types, we will force mediump for the sampler, and cast to f16 after any sampling operation. // We cannot express a true half texture type in GLSL. Neither for short integer formats for that matter. if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData && options.vulkan_semantics) return res + "subpassInput" + (type.image.ms ? "MS" : ""); else if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData && subpass_input_is_framebuffer_fetch(id)) { SPIRType sampled_type = get(type.image.type); sampled_type.vecsize = 4; return type_to_glsl(sampled_type); } // If we're emulating subpassInput with samplers, force sampler2D // so we don't have to specify format. if (type.basetype == SPIRType::Image && type.image.dim != DimSubpassData) { // Sampler buffers are always declared as samplerBuffer even though they might be separate images in the SPIR-V. if (type.image.dim == DimBuffer && type.image.sampled == 1) res += "sampler"; else res += type.image.sampled == 2 ? "image" : "texture"; } else res += "sampler"; switch (type.image.dim) { case Dim1D: res += "1D"; break; case Dim2D: res += "2D"; break; case Dim3D: res += "3D"; break; case DimCube: res += "Cube"; break; case DimRect: if (options.es) SPIRV_CROSS_THROW("Rectangle textures are not supported on OpenGL ES."); if (is_legacy_desktop()) require_extension_internal("GL_ARB_texture_rectangle"); res += "2DRect"; break; case DimBuffer: if (options.es && options.version < 320) require_extension_internal("GL_OES_texture_buffer"); else if (!options.es && options.version < 300) require_extension_internal("GL_EXT_texture_buffer_object"); res += "Buffer"; break; case DimSubpassData: res += "2D"; break; default: SPIRV_CROSS_THROW("Only 1D, 2D, 2DRect, 3D, Buffer, InputTarget and Cube textures supported."); } if (type.image.ms) res += "MS"; if (type.image.arrayed) { if (is_legacy_desktop()) require_extension_internal("GL_EXT_texture_array"); res += "Array"; } // "Shadow" state in GLSL only exists for samplers and combined image samplers. if (((type.basetype == SPIRType::SampledImage) || (type.basetype == SPIRType::Sampler)) && image_is_comparison(type, id)) { res += "Shadow"; } return res; } string CompilerGLSL::type_to_glsl_constructor(const SPIRType &type) { if (backend.use_array_constructor && type.array.size() > 1) { if (options.flatten_multidimensional_arrays) SPIRV_CROSS_THROW("Cannot flatten constructors of multidimensional array constructors, " "e.g. float[][]()."); else if (!options.es && options.version < 430) require_extension_internal("GL_ARB_arrays_of_arrays"); else if (options.es && options.version < 310) SPIRV_CROSS_THROW("Arrays of arrays not supported before ESSL version 310."); } auto e = type_to_glsl(type); if (backend.use_array_constructor) { for (uint32_t i = 0; i < type.array.size(); i++) e += "[]"; } return e; } // The optional id parameter indicates the object whose type we are trying // to find the description for. It is optional. Most type descriptions do not // depend on a specific object's use of that type. string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id) { if (type.pointer && type.storage == StorageClassPhysicalStorageBufferEXT && type.basetype != SPIRType::Struct) { // Need to create a magic type name which compacts the entire type information. string name = type_to_glsl(get_pointee_type(type)); for (size_t i = 0; i < type.array.size(); i++) { if (type.array_size_literal[i]) name += join(type.array[i], "_"); else name += join("id", type.array[i], "_"); } name += "Pointer"; return name; } switch (type.basetype) { case SPIRType::Struct: // Need OpName lookup here to get a "sensible" name for a struct. if (backend.explicit_struct_type) return join("struct ", to_name(type.self)); else return to_name(type.self); case SPIRType::Image: case SPIRType::SampledImage: return image_type_glsl(type, id); case SPIRType::Sampler: // The depth field is set by calling code based on the variable ID of the sampler, effectively reintroducing // this distinction into the type system. return comparison_ids.count(id) ? "samplerShadow" : "sampler"; case SPIRType::AccelerationStructure: return ray_tracing_is_khr ? "accelerationStructureEXT" : "accelerationStructureNV"; case SPIRType::Void: return "void"; default: break; } if (type.basetype == SPIRType::UInt && is_legacy()) SPIRV_CROSS_THROW("Unsigned integers are not supported on legacy targets."); if (type.vecsize == 1 && type.columns == 1) // Scalar builtin { switch (type.basetype) { case SPIRType::Boolean: return "bool"; case SPIRType::SByte: return backend.basic_int8_type; case SPIRType::UByte: return backend.basic_uint8_type; case SPIRType::Short: return backend.basic_int16_type; case SPIRType::UShort: return backend.basic_uint16_type; case SPIRType::Int: return backend.basic_int_type; case SPIRType::UInt: return backend.basic_uint_type; case SPIRType::AtomicCounter: return "atomic_uint"; case SPIRType::Half: return "float16_t"; case SPIRType::Float: return "float"; case SPIRType::Double: return "double"; case SPIRType::Int64: return "int64_t"; case SPIRType::UInt64: return "uint64_t"; default: return "???"; } } else if (type.vecsize > 1 && type.columns == 1) // Vector builtin { switch (type.basetype) { case SPIRType::Boolean: return join("bvec", type.vecsize); case SPIRType::SByte: return join("i8vec", type.vecsize); case SPIRType::UByte: return join("u8vec", type.vecsize); case SPIRType::Short: return join("i16vec", type.vecsize); case SPIRType::UShort: return join("u16vec", type.vecsize); case SPIRType::Int: return join("ivec", type.vecsize); case SPIRType::UInt: return join("uvec", type.vecsize); case SPIRType::Half: return join("f16vec", type.vecsize); case SPIRType::Float: return join("vec", type.vecsize); case SPIRType::Double: return join("dvec", type.vecsize); case SPIRType::Int64: return join("i64vec", type.vecsize); case SPIRType::UInt64: return join("u64vec", type.vecsize); default: return "???"; } } else if (type.vecsize == type.columns) // Simple Matrix builtin { switch (type.basetype) { case SPIRType::Boolean: return join("bmat", type.vecsize); case SPIRType::Int: return join("imat", type.vecsize); case SPIRType::UInt: return join("umat", type.vecsize); case SPIRType::Half: return join("f16mat", type.vecsize); case SPIRType::Float: return join("mat", type.vecsize); case SPIRType::Double: return join("dmat", type.vecsize); // Matrix types not supported for int64/uint64. default: return "???"; } } else { switch (type.basetype) { case SPIRType::Boolean: return join("bmat", type.columns, "x", type.vecsize); case SPIRType::Int: return join("imat", type.columns, "x", type.vecsize); case SPIRType::UInt: return join("umat", type.columns, "x", type.vecsize); case SPIRType::Half: return join("f16mat", type.columns, "x", type.vecsize); case SPIRType::Float: return join("mat", type.columns, "x", type.vecsize); case SPIRType::Double: return join("dmat", type.columns, "x", type.vecsize); // Matrix types not supported for int64/uint64. default: return "???"; } } } void CompilerGLSL::add_variable(unordered_set &variables_primary, const unordered_set &variables_secondary, string &name) { if (name.empty()) return; ParsedIR::sanitize_underscores(name); if (ParsedIR::is_globally_reserved_identifier(name, true)) { name.clear(); return; } update_name_cache(variables_primary, variables_secondary, name); } void CompilerGLSL::add_local_variable_name(uint32_t id) { add_variable(local_variable_names, block_names, ir.meta[id].decoration.alias); } void CompilerGLSL::add_resource_name(uint32_t id) { add_variable(resource_names, block_names, ir.meta[id].decoration.alias); } void CompilerGLSL::add_header_line(const std::string &line) { header_lines.push_back(line); } bool CompilerGLSL::has_extension(const std::string &ext) const { auto itr = find(begin(forced_extensions), end(forced_extensions), ext); return itr != end(forced_extensions); } void CompilerGLSL::require_extension(const std::string &ext) { if (!has_extension(ext)) forced_extensions.push_back(ext); } void CompilerGLSL::require_extension_internal(const string &ext) { if (backend.supports_extensions && !has_extension(ext)) { forced_extensions.push_back(ext); force_recompile(); } } void CompilerGLSL::flatten_buffer_block(VariableID id) { auto &var = get(id); auto &type = get(var.basetype); auto name = to_name(type.self, false); auto &flags = ir.meta[type.self].decoration.decoration_flags; if (!type.array.empty()) SPIRV_CROSS_THROW(name + " is an array of UBOs."); if (type.basetype != SPIRType::Struct) SPIRV_CROSS_THROW(name + " is not a struct."); if (!flags.get(DecorationBlock)) SPIRV_CROSS_THROW(name + " is not a block."); if (type.member_types.empty()) SPIRV_CROSS_THROW(name + " is an empty struct."); flattened_buffer_blocks.insert(id); } bool CompilerGLSL::builtin_translates_to_nonarray(spv::BuiltIn /*builtin*/) const { return false; // GLSL itself does not need to translate array builtin types to non-array builtin types } bool CompilerGLSL::check_atomic_image(uint32_t id) { auto &type = expression_type(id); if (type.storage == StorageClassImage) { if (options.es && options.version < 320) require_extension_internal("GL_OES_shader_image_atomic"); auto *var = maybe_get_backing_variable(id); if (var) { auto &flags = ir.meta[var->self].decoration.decoration_flags; if (flags.get(DecorationNonWritable) || flags.get(DecorationNonReadable)) { flags.clear(DecorationNonWritable); flags.clear(DecorationNonReadable); force_recompile(); } } return true; } else return false; } void CompilerGLSL::add_function_overload(const SPIRFunction &func) { Hasher hasher; for (auto &arg : func.arguments) { // Parameters can vary with pointer type or not, // but that will not change the signature in GLSL/HLSL, // so strip the pointer type before hashing. uint32_t type_id = get_pointee_type_id(arg.type); auto &type = get(type_id); if (!combined_image_samplers.empty()) { // If we have combined image samplers, we cannot really trust the image and sampler arguments // we pass down to callees, because they may be shuffled around. // Ignore these arguments, to make sure that functions need to differ in some other way // to be considered different overloads. if (type.basetype == SPIRType::SampledImage || (type.basetype == SPIRType::Image && type.image.sampled == 1) || type.basetype == SPIRType::Sampler) { continue; } } hasher.u32(type_id); } uint64_t types_hash = hasher.get(); auto function_name = to_name(func.self); auto itr = function_overloads.find(function_name); if (itr != end(function_overloads)) { // There exists a function with this name already. auto &overloads = itr->second; if (overloads.count(types_hash) != 0) { // Overload conflict, assign a new name. add_resource_name(func.self); function_overloads[to_name(func.self)].insert(types_hash); } else { // Can reuse the name. overloads.insert(types_hash); } } else { // First time we see this function name. add_resource_name(func.self); function_overloads[to_name(func.self)].insert(types_hash); } } void CompilerGLSL::emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) { if (func.self != ir.default_entry_point) add_function_overload(func); // Avoid shadow declarations. local_variable_names = resource_names; string decl; auto &type = get(func.return_type); decl += flags_to_qualifiers_glsl(type, return_flags); decl += type_to_glsl(type); decl += type_to_array_glsl(type); decl += " "; if (func.self == ir.default_entry_point) { // If we need complex fallback in GLSL, we just wrap main() in a function // and interlock the entire shader ... if (interlocked_is_complex) decl += "spvMainInterlockedBody"; else decl += "main"; processing_entry_point = true; } else decl += to_name(func.self); decl += "("; SmallVector arglist; for (auto &arg : func.arguments) { // Do not pass in separate images or samplers if we're remapping // to combined image samplers. if (skip_argument(arg.id)) continue; // Might change the variable name if it already exists in this function. // SPIRV OpName doesn't have any semantic effect, so it's valid for an implementation // to use same name for variables. // Since we want to make the GLSL debuggable and somewhat sane, use fallback names for variables which are duplicates. add_local_variable_name(arg.id); arglist.push_back(argument_decl(arg)); // Hold a pointer to the parameter so we can invalidate the readonly field if needed. auto *var = maybe_get(arg.id); if (var) var->parameter = &arg; } for (auto &arg : func.shadow_arguments) { // Might change the variable name if it already exists in this function. // SPIRV OpName doesn't have any semantic effect, so it's valid for an implementation // to use same name for variables. // Since we want to make the GLSL debuggable and somewhat sane, use fallback names for variables which are duplicates. add_local_variable_name(arg.id); arglist.push_back(argument_decl(arg)); // Hold a pointer to the parameter so we can invalidate the readonly field if needed. auto *var = maybe_get(arg.id); if (var) var->parameter = &arg; } decl += merge(arglist); decl += ")"; statement(decl); } void CompilerGLSL::emit_function(SPIRFunction &func, const Bitset &return_flags) { // Avoid potential cycles. if (func.active) return; func.active = true; // If we depend on a function, emit that function before we emit our own function. for (auto block : func.blocks) { auto &b = get(block); for (auto &i : b.ops) { auto ops = stream(i); auto op = static_cast(i.op); if (op == OpFunctionCall) { // Recursively emit functions which are called. uint32_t id = ops[2]; emit_function(get(id), ir.meta[ops[1]].decoration.decoration_flags); } } } if (func.entry_line.file_id != 0) emit_line_directive(func.entry_line.file_id, func.entry_line.line_literal); emit_function_prototype(func, return_flags); begin_scope(); if (func.self == ir.default_entry_point) emit_entry_point_declarations(); current_function = &func; auto &entry_block = get(func.entry_block); sort(begin(func.constant_arrays_needed_on_stack), end(func.constant_arrays_needed_on_stack)); for (auto &array : func.constant_arrays_needed_on_stack) { auto &c = get(array); auto &type = get(c.constant_type); statement(variable_decl(type, join("_", array, "_array_copy")), " = ", constant_expression(c), ";"); } for (auto &v : func.local_variables) { auto &var = get(v); var.deferred_declaration = false; if (var.storage == StorageClassWorkgroup) { // Special variable type which cannot have initializer, // need to be declared as standalone variables. // Comes from MSL which can push global variables as local variables in main function. add_local_variable_name(var.self); statement(variable_decl(var), ";"); var.deferred_declaration = false; } else if (var.storage == StorageClassPrivate) { // These variables will not have had their CFG usage analyzed, so move it to the entry block. // Comes from MSL which can push global variables as local variables in main function. // We could just declare them right now, but we would miss out on an important initialization case which is // LUT declaration in MSL. // If we don't declare the variable when it is assigned we're forced to go through a helper function // which copies elements one by one. add_local_variable_name(var.self); if (var.initializer) { statement(variable_decl(var), ";"); var.deferred_declaration = false; } else { auto &dominated = entry_block.dominated_variables; if (find(begin(dominated), end(dominated), var.self) == end(dominated)) entry_block.dominated_variables.push_back(var.self); var.deferred_declaration = true; } } else if (var.storage == StorageClassFunction && var.remapped_variable && var.static_expression) { // No need to declare this variable, it has a static expression. var.deferred_declaration = false; } else if (expression_is_lvalue(v)) { add_local_variable_name(var.self); // Loop variables should never be declared early, they are explicitly emitted in a loop. if (var.initializer && !var.loop_variable) statement(variable_decl_function_local(var), ";"); else { // Don't declare variable until first use to declutter the GLSL output quite a lot. // If we don't touch the variable before first branch, // declare it then since we need variable declaration to be in top scope. var.deferred_declaration = true; } } else { // HACK: SPIR-V in older glslang output likes to use samplers and images as local variables, but GLSL does not allow this. // For these types (non-lvalue), we enforce forwarding through a shadowed variable. // This means that when we OpStore to these variables, we just write in the expression ID directly. // This breaks any kind of branching, since the variable must be statically assigned. // Branching on samplers and images would be pretty much impossible to fake in GLSL. var.statically_assigned = true; } var.loop_variable_enable = false; // Loop variables are never declared outside their for-loop, so block any implicit declaration. if (var.loop_variable) var.deferred_declaration = false; } // Enforce declaration order for regression testing purposes. for (auto &block_id : func.blocks) { auto &block = get(block_id); sort(begin(block.dominated_variables), end(block.dominated_variables)); } for (auto &line : current_function->fixup_hooks_in) line(); emit_block_chain(entry_block); end_scope(); processing_entry_point = false; statement(""); // Make sure deferred declaration state for local variables is cleared when we are done with function. // We risk declaring Private/Workgroup variables in places we are not supposed to otherwise. for (auto &v : func.local_variables) { auto &var = get(v); var.deferred_declaration = false; } } void CompilerGLSL::emit_fixup() { if (is_vertex_like_shader()) { if (options.vertex.fixup_clipspace) { const char *suffix = backend.float_literal_suffix ? "f" : ""; statement("gl_Position.z = 2.0", suffix, " * gl_Position.z - gl_Position.w;"); } if (options.vertex.flip_vert_y) statement("gl_Position.y = -gl_Position.y;"); } } void CompilerGLSL::flush_phi(BlockID from, BlockID to) { auto &child = get(to); if (child.ignore_phi_from_block == from) return; unordered_set temporary_phi_variables; for (auto itr = begin(child.phi_variables); itr != end(child.phi_variables); ++itr) { auto &phi = *itr; if (phi.parent == from) { auto &var = get(phi.function_variable); // A Phi variable might be a loop variable, so flush to static expression. if (var.loop_variable && !var.loop_variable_enable) var.static_expression = phi.local_variable; else { flush_variable_declaration(phi.function_variable); // Check if we are going to write to a Phi variable that another statement will read from // as part of another Phi node in our target block. // For this case, we will need to copy phi.function_variable to a temporary, and use that for future reads. // This is judged to be extremely rare, so deal with it here using a simple, but suboptimal algorithm. bool need_saved_temporary = find_if(itr + 1, end(child.phi_variables), [&](const SPIRBlock::Phi &future_phi) -> bool { return future_phi.local_variable == ID(phi.function_variable) && future_phi.parent == from; }) != end(child.phi_variables); if (need_saved_temporary) { // Need to make sure we declare the phi variable with a copy at the right scope. // We cannot safely declare a temporary here since we might be inside a continue block. if (!var.allocate_temporary_copy) { var.allocate_temporary_copy = true; force_recompile(); } statement("_", phi.function_variable, "_copy", " = ", to_name(phi.function_variable), ";"); temporary_phi_variables.insert(phi.function_variable); } // This might be called in continue block, so make sure we // use this to emit ESSL 1.0 compliant increments/decrements. auto lhs = to_expression(phi.function_variable); string rhs; if (temporary_phi_variables.count(phi.local_variable)) rhs = join("_", phi.local_variable, "_copy"); else rhs = to_pointer_expression(phi.local_variable); if (!optimize_read_modify_write(get(var.basetype), lhs, rhs)) statement(lhs, " = ", rhs, ";"); } register_write(phi.function_variable); } } } void CompilerGLSL::branch_to_continue(BlockID from, BlockID to) { auto &to_block = get(to); if (from == to) return; assert(is_continue(to)); if (to_block.complex_continue) { // Just emit the whole block chain as is. auto usage_counts = expression_usage_counts; emit_block_chain(to_block); // Expression usage counts are moot after returning from the continue block. expression_usage_counts = usage_counts; } else { auto &from_block = get(from); bool outside_control_flow = false; uint32_t loop_dominator = 0; // FIXME: Refactor this to not use the old loop_dominator tracking. if (from_block.merge_block) { // If we are a loop header, we don't set the loop dominator, // so just use "self" here. loop_dominator = from; } else if (from_block.loop_dominator != BlockID(SPIRBlock::NoDominator)) { loop_dominator = from_block.loop_dominator; } if (loop_dominator != 0) { auto &cfg = get_cfg_for_current_function(); // For non-complex continue blocks, we implicitly branch to the continue block // by having the continue block be part of the loop header in for (; ; continue-block). outside_control_flow = cfg.node_terminates_control_flow_in_sub_graph(loop_dominator, from); } // Some simplification for for-loops. We always end up with a useless continue; // statement since we branch to a loop block. // Walk the CFG, if we unconditionally execute the block calling continue assuming we're in the loop block, // we can avoid writing out an explicit continue statement. // Similar optimization to return statements if we know we're outside flow control. if (!outside_control_flow) statement("continue;"); } } void CompilerGLSL::branch(BlockID from, BlockID to) { flush_phi(from, to); flush_control_dependent_expressions(from); bool to_is_continue = is_continue(to); // This is only a continue if we branch to our loop dominator. if ((ir.block_meta[to] & ParsedIR::BLOCK_META_LOOP_HEADER_BIT) != 0 && get(from).loop_dominator == to) { // This can happen if we had a complex continue block which was emitted. // Once the continue block tries to branch to the loop header, just emit continue; // and end the chain here. statement("continue;"); } else if (from != to && is_break(to)) { // We cannot break to ourselves, so check explicitly for from != to. // This case can trigger if a loop header is all three of these things: // - Continue block // - Loop header // - Break merge target all at once ... // Very dirty workaround. // Switch constructs are able to break, but they cannot break out of a loop at the same time. // Only sensible solution is to make a ladder variable, which we declare at the top of the switch block, // write to the ladder here, and defer the break. // The loop we're breaking out of must dominate the switch block, or there is no ladder breaking case. if (current_emitting_switch && is_loop_break(to) && current_emitting_switch->loop_dominator != BlockID(SPIRBlock::NoDominator) && get(current_emitting_switch->loop_dominator).merge_block == to) { if (!current_emitting_switch->need_ladder_break) { force_recompile(); current_emitting_switch->need_ladder_break = true; } statement("_", current_emitting_switch->self, "_ladder_break = true;"); } statement("break;"); } else if (to_is_continue || from == to) { // For from == to case can happen for a do-while loop which branches into itself. // We don't mark these cases as continue blocks, but the only possible way to branch into // ourselves is through means of continue blocks. // If we are merging to a continue block, there is no need to emit the block chain for continue here. // We can branch to the continue block after we merge execution. // Here we make use of structured control flow rules from spec: // 2.11: - the merge block declared by a header block cannot be a merge block declared by any other header block // - each header block must strictly dominate its merge block, unless the merge block is unreachable in the CFG // If we are branching to a merge block, we must be inside a construct which dominates the merge block. auto &block_meta = ir.block_meta[to]; bool branching_to_merge = (block_meta & (ParsedIR::BLOCK_META_SELECTION_MERGE_BIT | ParsedIR::BLOCK_META_MULTISELECT_MERGE_BIT | ParsedIR::BLOCK_META_LOOP_MERGE_BIT)) != 0; if (!to_is_continue || !branching_to_merge) branch_to_continue(from, to); } else if (!is_conditional(to)) emit_block_chain(get(to)); // It is important that we check for break before continue. // A block might serve two purposes, a break block for the inner scope, and // a continue block in the outer scope. // Inner scope always takes precedence. } void CompilerGLSL::branch(BlockID from, uint32_t cond, BlockID true_block, BlockID false_block) { auto &from_block = get(from); BlockID merge_block = from_block.merge == SPIRBlock::MergeSelection ? from_block.next_block : BlockID(0); // If we branch directly to our selection merge target, we don't need a code path. bool true_block_needs_code = true_block != merge_block || flush_phi_required(from, true_block); bool false_block_needs_code = false_block != merge_block || flush_phi_required(from, false_block); if (!true_block_needs_code && !false_block_needs_code) return; emit_block_hints(get(from)); if (true_block_needs_code) { statement("if (", to_expression(cond), ")"); begin_scope(); branch(from, true_block); end_scope(); if (false_block_needs_code) { statement("else"); begin_scope(); branch(from, false_block); end_scope(); } } else if (false_block_needs_code) { // Only need false path, use negative conditional. statement("if (!", to_enclosed_expression(cond), ")"); begin_scope(); branch(from, false_block); end_scope(); } } // FIXME: This currently cannot handle complex continue blocks // as in do-while. // This should be seen as a "trivial" continue block. string CompilerGLSL::emit_continue_block(uint32_t continue_block, bool follow_true_block, bool follow_false_block) { auto *block = &get(continue_block); // While emitting the continue block, declare_temporary will check this // if we have to emit temporaries. current_continue_block = block; SmallVector statements; // Capture all statements into our list. auto *old = redirect_statement; redirect_statement = &statements; // Stamp out all blocks one after each other. while ((ir.block_meta[block->self] & ParsedIR::BLOCK_META_LOOP_HEADER_BIT) == 0) { // Write out all instructions we have in this block. emit_block_instructions(*block); // For plain branchless for/while continue blocks. if (block->next_block) { flush_phi(continue_block, block->next_block); block = &get(block->next_block); } // For do while blocks. The last block will be a select block. else if (block->true_block && follow_true_block) { flush_phi(continue_block, block->true_block); block = &get(block->true_block); } else if (block->false_block && follow_false_block) { flush_phi(continue_block, block->false_block); block = &get(block->false_block); } else { SPIRV_CROSS_THROW("Invalid continue block detected!"); } } // Restore old pointer. redirect_statement = old; // Somewhat ugly, strip off the last ';' since we use ',' instead. // Ideally, we should select this behavior in statement(). for (auto &s : statements) { if (!s.empty() && s.back() == ';') s.erase(s.size() - 1, 1); } current_continue_block = nullptr; return merge(statements); } void CompilerGLSL::emit_while_loop_initializers(const SPIRBlock &block) { // While loops do not take initializers, so declare all of them outside. for (auto &loop_var : block.loop_variables) { auto &var = get(loop_var); statement(variable_decl(var), ";"); } } string CompilerGLSL::emit_for_loop_initializers(const SPIRBlock &block) { if (block.loop_variables.empty()) return ""; bool same_types = for_loop_initializers_are_same_type(block); // We can only declare for loop initializers if all variables are of same type. // If we cannot do this, declare individual variables before the loop header. // We might have a loop variable candidate which was not assigned to for some reason. uint32_t missing_initializers = 0; for (auto &variable : block.loop_variables) { uint32_t expr = get(variable).static_expression; // Sometimes loop variables are initialized with OpUndef, but we can just declare // a plain variable without initializer in this case. if (expr == 0 || ir.ids[expr].get_type() == TypeUndef) missing_initializers++; } if (block.loop_variables.size() == 1 && missing_initializers == 0) { return variable_decl(get(block.loop_variables.front())); } else if (!same_types || missing_initializers == uint32_t(block.loop_variables.size())) { for (auto &loop_var : block.loop_variables) statement(variable_decl(get(loop_var)), ";"); return ""; } else { // We have a mix of loop variables, either ones with a clear initializer, or ones without. // Separate the two streams. string expr; for (auto &loop_var : block.loop_variables) { uint32_t static_expr = get(loop_var).static_expression; if (static_expr == 0 || ir.ids[static_expr].get_type() == TypeUndef) { statement(variable_decl(get(loop_var)), ";"); } else { auto &var = get(loop_var); auto &type = get_variable_data_type(var); if (expr.empty()) { // For loop initializers are of the form (block.true_block), get(block.merge_block))) condition = join("!", enclose_expression(condition)); statement("while (", condition, ")"); break; } default: block.disable_block_optimization = true; force_recompile(); begin_scope(); // We'll see an end_scope() later. return false; } begin_scope(); return true; } else { block.disable_block_optimization = true; force_recompile(); begin_scope(); // We'll see an end_scope() later. return false; } } else if (method == SPIRBlock::MergeToDirectForLoop) { auto &child = get(block.next_block); // This block may be a dominating block, so make sure we flush undeclared variables before building the for loop header. flush_undeclared_variables(child); uint32_t current_count = statement_count; // If we're trying to create a true for loop, // we need to make sure that all opcodes before branch statement do not actually emit any code. // We can then take the condition expression and create a for (; cond ; ) { body; } structure instead. emit_block_instructions(child); bool condition_is_temporary = forced_temporaries.find(child.condition) == end(forced_temporaries); if (current_count == statement_count && condition_is_temporary) { uint32_t target_block = child.true_block; switch (continue_type) { case SPIRBlock::ForLoop: { // Important that we do this in this order because // emitting the continue block can invalidate the condition expression. auto initializer = emit_for_loop_initializers(block); auto condition = to_expression(child.condition); // Condition might have to be inverted. if (execution_is_noop(get(child.true_block), get(block.merge_block))) { condition = join("!", enclose_expression(condition)); target_block = child.false_block; } auto continue_block = emit_continue_block(block.continue_block, false, false); emit_block_hints(block); statement("for (", initializer, "; ", condition, "; ", continue_block, ")"); break; } case SPIRBlock::WhileLoop: { emit_while_loop_initializers(block); emit_block_hints(block); auto condition = to_expression(child.condition); // Condition might have to be inverted. if (execution_is_noop(get(child.true_block), get(block.merge_block))) { condition = join("!", enclose_expression(condition)); target_block = child.false_block; } statement("while (", condition, ")"); break; } default: block.disable_block_optimization = true; force_recompile(); begin_scope(); // We'll see an end_scope() later. return false; } begin_scope(); branch(child.self, target_block); return true; } else { block.disable_block_optimization = true; force_recompile(); begin_scope(); // We'll see an end_scope() later. return false; } } else return false; } void CompilerGLSL::flush_undeclared_variables(SPIRBlock &block) { for (auto &v : block.dominated_variables) flush_variable_declaration(v); } void CompilerGLSL::emit_hoisted_temporaries(SmallVector> &temporaries) { // If we need to force temporaries for certain IDs due to continue blocks, do it before starting loop header. // Need to sort these to ensure that reference output is stable. sort(begin(temporaries), end(temporaries), [](const pair &a, const pair &b) { return a.second < b.second; }); for (auto &tmp : temporaries) { add_local_variable_name(tmp.second); auto &flags = ir.meta[tmp.second].decoration.decoration_flags; auto &type = get(tmp.first); // Not all targets support pointer literals, so don't bother with that case. string initializer; if (options.force_zero_initialized_variables && type_can_zero_initialize(type)) initializer = join(" = ", to_zero_initialized_expression(tmp.first)); statement(flags_to_qualifiers_glsl(type, flags), variable_decl(type, to_name(tmp.second)), initializer, ";"); hoisted_temporaries.insert(tmp.second); forced_temporaries.insert(tmp.second); // The temporary might be read from before it's assigned, set up the expression now. set(tmp.second, to_name(tmp.second), tmp.first, true); } } void CompilerGLSL::emit_block_chain(SPIRBlock &block) { bool select_branch_to_true_block = false; bool select_branch_to_false_block = false; bool skip_direct_branch = false; bool emitted_loop_header_variables = false; bool force_complex_continue_block = false; ValueSaver loop_level_saver(current_loop_level); if (block.merge == SPIRBlock::MergeLoop) add_loop_level(); emit_hoisted_temporaries(block.declare_temporary); SPIRBlock::ContinueBlockType continue_type = SPIRBlock::ContinueNone; if (block.continue_block) { continue_type = continue_block_type(get(block.continue_block)); // If we know we cannot emit a loop, mark the block early as a complex loop so we don't force unnecessary recompiles. if (continue_type == SPIRBlock::ComplexLoop) block.complex_continue = true; } // If we have loop variables, stop masking out access to the variable now. for (auto var_id : block.loop_variables) { auto &var = get(var_id); var.loop_variable_enable = true; // We're not going to declare the variable directly, so emit a copy here. emit_variable_temporary_copies(var); } // Remember deferred declaration state. We will restore it before returning. SmallVector rearm_dominated_variables(block.dominated_variables.size()); for (size_t i = 0; i < block.dominated_variables.size(); i++) { uint32_t var_id = block.dominated_variables[i]; auto &var = get(var_id); rearm_dominated_variables[i] = var.deferred_declaration; } // This is the method often used by spirv-opt to implement loops. // The loop header goes straight into the continue block. // However, don't attempt this on ESSL 1.0, because if a loop variable is used in a continue block, // it *MUST* be used in the continue block. This loop method will not work. if (!is_legacy_es() && block_is_loop_candidate(block, SPIRBlock::MergeToSelectContinueForLoop)) { flush_undeclared_variables(block); if (attempt_emit_loop_header(block, SPIRBlock::MergeToSelectContinueForLoop)) { if (execution_is_noop(get(block.true_block), get(block.merge_block))) select_branch_to_false_block = true; else select_branch_to_true_block = true; emitted_loop_header_variables = true; force_complex_continue_block = true; } } // This is the older loop behavior in glslang which branches to loop body directly from the loop header. else if (block_is_loop_candidate(block, SPIRBlock::MergeToSelectForLoop)) { flush_undeclared_variables(block); if (attempt_emit_loop_header(block, SPIRBlock::MergeToSelectForLoop)) { // The body of while, is actually just the true (or false) block, so always branch there unconditionally. if (execution_is_noop(get(block.true_block), get(block.merge_block))) select_branch_to_false_block = true; else select_branch_to_true_block = true; emitted_loop_header_variables = true; } } // This is the newer loop behavior in glslang which branches from Loop header directly to // a new block, which in turn has a OpBranchSelection without a selection merge. else if (block_is_loop_candidate(block, SPIRBlock::MergeToDirectForLoop)) { flush_undeclared_variables(block); if (attempt_emit_loop_header(block, SPIRBlock::MergeToDirectForLoop)) { skip_direct_branch = true; emitted_loop_header_variables = true; } } else if (continue_type == SPIRBlock::DoWhileLoop) { flush_undeclared_variables(block); emit_while_loop_initializers(block); emitted_loop_header_variables = true; // We have some temporaries where the loop header is the dominator. // We risk a case where we have code like: // for (;;) { create-temporary; break; } consume-temporary; // so force-declare temporaries here. emit_hoisted_temporaries(block.potential_declare_temporary); statement("do"); begin_scope(); emit_block_instructions(block); } else if (block.merge == SPIRBlock::MergeLoop) { flush_undeclared_variables(block); emit_while_loop_initializers(block); emitted_loop_header_variables = true; // We have a generic loop without any distinguishable pattern like for, while or do while. get(block.continue_block).complex_continue = true; continue_type = SPIRBlock::ComplexLoop; // We have some temporaries where the loop header is the dominator. // We risk a case where we have code like: // for (;;) { create-temporary; break; } consume-temporary; // so force-declare temporaries here. emit_hoisted_temporaries(block.potential_declare_temporary); statement("for (;;)"); begin_scope(); emit_block_instructions(block); } else { emit_block_instructions(block); } // If we didn't successfully emit a loop header and we had loop variable candidates, we have a problem // as writes to said loop variables might have been masked out, we need a recompile. if (!emitted_loop_header_variables && !block.loop_variables.empty()) { force_recompile(); for (auto var : block.loop_variables) get(var).loop_variable = false; block.loop_variables.clear(); } flush_undeclared_variables(block); bool emit_next_block = true; // Handle end of block. switch (block.terminator) { case SPIRBlock::Direct: // True when emitting complex continue block. if (block.loop_dominator == block.next_block) { branch(block.self, block.next_block); emit_next_block = false; } // True if MergeToDirectForLoop succeeded. else if (skip_direct_branch) emit_next_block = false; else if (is_continue(block.next_block) || is_break(block.next_block) || is_conditional(block.next_block)) { branch(block.self, block.next_block); emit_next_block = false; } break; case SPIRBlock::Select: // True if MergeToSelectForLoop or MergeToSelectContinueForLoop succeeded. if (select_branch_to_true_block) { if (force_complex_continue_block) { assert(block.true_block == block.continue_block); // We're going to emit a continue block directly here, so make sure it's marked as complex. auto &complex_continue = get(block.continue_block).complex_continue; bool old_complex = complex_continue; complex_continue = true; branch(block.self, block.true_block); complex_continue = old_complex; } else branch(block.self, block.true_block); } else if (select_branch_to_false_block) { if (force_complex_continue_block) { assert(block.false_block == block.continue_block); // We're going to emit a continue block directly here, so make sure it's marked as complex. auto &complex_continue = get(block.continue_block).complex_continue; bool old_complex = complex_continue; complex_continue = true; branch(block.self, block.false_block); complex_continue = old_complex; } else branch(block.self, block.false_block); } else branch(block.self, block.condition, block.true_block, block.false_block); break; case SPIRBlock::MultiSelect: { auto &type = expression_type(block.condition); bool unsigned_case = type.basetype == SPIRType::UInt || type.basetype == SPIRType::UShort || type.basetype == SPIRType::UByte; if (block.merge == SPIRBlock::MergeNone) SPIRV_CROSS_THROW("Switch statement is not structured"); if (type.basetype == SPIRType::UInt64 || type.basetype == SPIRType::Int64) { // SPIR-V spec suggests this is allowed, but we cannot support it in higher level languages. SPIRV_CROSS_THROW("Cannot use 64-bit switch selectors."); } const char *label_suffix = ""; if (type.basetype == SPIRType::UInt && backend.uint32_t_literal_suffix) label_suffix = "u"; else if (type.basetype == SPIRType::UShort) label_suffix = backend.uint16_t_literal_suffix; else if (type.basetype == SPIRType::Short) label_suffix = backend.int16_t_literal_suffix; SPIRBlock *old_emitting_switch = current_emitting_switch; current_emitting_switch = █ if (block.need_ladder_break) statement("bool _", block.self, "_ladder_break = false;"); // Find all unique case constructs. unordered_map> case_constructs; SmallVector block_declaration_order; SmallVector literals_to_merge; // If a switch case branches to the default block for some reason, we can just remove that literal from consideration // and let the default: block handle it. // 2.11 in SPIR-V spec states that for fall-through cases, there is a very strict declaration order which we can take advantage of here. // We only need to consider possible fallthrough if order[i] branches to order[i + 1]. for (auto &c : block.cases) { if (c.block != block.next_block && c.block != block.default_block) { if (!case_constructs.count(c.block)) block_declaration_order.push_back(c.block); case_constructs[c.block].push_back(c.value); } else if (c.block == block.next_block && block.default_block != block.next_block) { // We might have to flush phi inside specific case labels. // If we can piggyback on default:, do so instead. literals_to_merge.push_back(c.value); } } // Empty literal array -> default. if (block.default_block != block.next_block) { auto &default_block = get(block.default_block); // We need to slide in the default block somewhere in this chain // if there are fall-through scenarios since the default is declared separately in OpSwitch. // Only consider trivial fall-through cases here. size_t num_blocks = block_declaration_order.size(); bool injected_block = false; for (size_t i = 0; i < num_blocks; i++) { auto &case_block = get(block_declaration_order[i]); if (execution_is_direct_branch(case_block, default_block)) { // Fallthrough to default block, we must inject the default block here. block_declaration_order.insert(begin(block_declaration_order) + i + 1, block.default_block); injected_block = true; break; } else if (execution_is_direct_branch(default_block, case_block)) { // Default case is falling through to another case label, we must inject the default block here. block_declaration_order.insert(begin(block_declaration_order) + i, block.default_block); injected_block = true; break; } } // Order does not matter. if (!injected_block) block_declaration_order.push_back(block.default_block); else if (is_legacy_es()) SPIRV_CROSS_THROW("Default case label fallthrough to other case label is not supported in ESSL 1.0."); case_constructs[block.default_block] = {}; } size_t num_blocks = block_declaration_order.size(); const auto to_case_label = [](uint32_t literal, bool is_unsigned_case) -> string { return is_unsigned_case ? convert_to_string(literal) : convert_to_string(int32_t(literal)); }; const auto to_legacy_case_label = [&](uint32_t condition, const SmallVector &labels, const char *suffix) -> string { string ret; size_t count = labels.size(); for (size_t i = 0; i < count; i++) { if (i) ret += " || "; ret += join(count > 1 ? "(" : "", to_enclosed_expression(condition), " == ", labels[i], suffix, count > 1 ? ")" : ""); } return ret; }; // We need to deal with a complex scenario for OpPhi. If we have case-fallthrough and Phi in the picture, // we need to flush phi nodes outside the switch block in a branch, // and skip any Phi handling inside the case label to make fall-through work as expected. // This kind of code-gen is super awkward and it's a last resort. Normally we would want to handle this // inside the case label if at all possible. for (size_t i = 1; backend.support_case_fallthrough && i < num_blocks; i++) { if (flush_phi_required(block.self, block_declaration_order[i]) && flush_phi_required(block_declaration_order[i - 1], block_declaration_order[i])) { uint32_t target_block = block_declaration_order[i]; // Make sure we flush Phi, it might have been marked to be ignored earlier. get(target_block).ignore_phi_from_block = 0; auto &literals = case_constructs[target_block]; if (literals.empty()) { // Oh boy, gotta make a complete negative test instead! o.o // Find all possible literals that would *not* make us enter the default block. // If none of those literals match, we flush Phi ... SmallVector conditions; for (size_t j = 0; j < num_blocks; j++) { auto &negative_literals = case_constructs[block_declaration_order[j]]; for (auto &case_label : negative_literals) conditions.push_back(join(to_enclosed_expression(block.condition), " != ", to_case_label(case_label, unsigned_case))); } statement("if (", merge(conditions, " && "), ")"); begin_scope(); flush_phi(block.self, target_block); end_scope(); } else { SmallVector conditions; conditions.reserve(literals.size()); for (auto &case_label : literals) conditions.push_back(join(to_enclosed_expression(block.condition), " == ", to_case_label(case_label, unsigned_case))); statement("if (", merge(conditions, " || "), ")"); begin_scope(); flush_phi(block.self, target_block); end_scope(); } // Mark the block so that we don't flush Phi from header to case label. get(target_block).ignore_phi_from_block = block.self; } } // If there is only one default block, and no cases, this is a case where SPIRV-opt decided to emulate // non-structured exits with the help of a switch block. // This is buggy on FXC, so just emit the logical equivalent of a do { } while(false), which is more idiomatic. bool degenerate_switch = block.default_block != block.merge_block && block.cases.empty(); if (degenerate_switch || is_legacy_es()) { // ESSL 1.0 is not guaranteed to support do/while. if (is_legacy_es()) { uint32_t counter = statement_count; statement("for (int spvDummy", counter, " = 0; spvDummy", counter, " < 1; spvDummy", counter, "++)"); } else statement("do"); } else { emit_block_hints(block); statement("switch (", to_expression(block.condition), ")"); } begin_scope(); for (size_t i = 0; i < num_blocks; i++) { uint32_t target_block = block_declaration_order[i]; auto &literals = case_constructs[target_block]; if (literals.empty()) { // Default case. if (!degenerate_switch) { if (is_legacy_es()) statement("else"); else statement("default:"); } } else { if (is_legacy_es()) { statement((i ? "else " : ""), "if (", to_legacy_case_label(block.condition, literals, label_suffix), ")"); } else { for (auto &case_literal : literals) { // The case label value must be sign-extended properly in SPIR-V, so we can assume 32-bit values here. statement("case ", to_case_label(case_literal, unsigned_case), label_suffix, ":"); } } } auto &case_block = get(target_block); if (backend.support_case_fallthrough && i + 1 < num_blocks && execution_is_direct_branch(case_block, get(block_declaration_order[i + 1]))) { // We will fall through here, so just terminate the block chain early. // We still need to deal with Phi potentially. // No need for a stack-like thing here since we only do fall-through when there is a // single trivial branch to fall-through target.. current_emitting_switch_fallthrough = true; } else current_emitting_switch_fallthrough = false; if (!degenerate_switch) begin_scope(); branch(block.self, target_block); if (!degenerate_switch) end_scope(); current_emitting_switch_fallthrough = false; } // Might still have to flush phi variables if we branch from loop header directly to merge target. if (flush_phi_required(block.self, block.next_block)) { if (block.default_block == block.next_block || !literals_to_merge.empty()) { for (auto &case_literal : literals_to_merge) statement("case ", to_case_label(case_literal, unsigned_case), label_suffix, ":"); if (block.default_block == block.next_block) { if (is_legacy_es()) statement("else"); else statement("default:"); } begin_scope(); flush_phi(block.self, block.next_block); statement("break;"); end_scope(); } } if (degenerate_switch && !is_legacy_es()) end_scope_decl("while(false)"); else end_scope(); if (block.need_ladder_break) { statement("if (_", block.self, "_ladder_break)"); begin_scope(); statement("break;"); end_scope(); } current_emitting_switch = old_emitting_switch; break; } case SPIRBlock::Return: { for (auto &line : current_function->fixup_hooks_out) line(); if (processing_entry_point) emit_fixup(); auto &cfg = get_cfg_for_current_function(); if (block.return_value) { auto &type = expression_type(block.return_value); if (!type.array.empty() && !backend.can_return_array) { // If we cannot return arrays, we will have a special out argument we can write to instead. // The backend is responsible for setting this up, and redirection the return values as appropriate. if (ir.ids[block.return_value].get_type() != TypeUndef) { emit_array_copy("spvReturnValue", block.return_value, StorageClassFunction, get_expression_effective_storage_class(block.return_value)); } if (!cfg.node_terminates_control_flow_in_sub_graph(current_function->entry_block, block.self) || block.loop_dominator != BlockID(SPIRBlock::NoDominator)) { statement("return;"); } } else { // OpReturnValue can return Undef, so don't emit anything for this case. if (ir.ids[block.return_value].get_type() != TypeUndef) statement("return ", to_expression(block.return_value), ";"); } } else if (!cfg.node_terminates_control_flow_in_sub_graph(current_function->entry_block, block.self) || block.loop_dominator != BlockID(SPIRBlock::NoDominator)) { // If this block is the very final block and not called from control flow, // we do not need an explicit return which looks out of place. Just end the function here. // In the very weird case of for(;;) { return; } executing return is unconditional, // but we actually need a return here ... statement("return;"); } break; } case SPIRBlock::Kill: statement(backend.discard_literal, ";"); break; case SPIRBlock::Unreachable: emit_next_block = false; break; case SPIRBlock::IgnoreIntersection: statement("ignoreIntersectionEXT;"); break; case SPIRBlock::TerminateRay: statement("terminateRayEXT;"); break; default: SPIRV_CROSS_THROW("Unimplemented block terminator."); } if (block.next_block && emit_next_block) { // If we hit this case, we're dealing with an unconditional branch, which means we will output // that block after this. If we had selection merge, we already flushed phi variables. if (block.merge != SPIRBlock::MergeSelection) { flush_phi(block.self, block.next_block); // For a direct branch, need to remember to invalidate expressions in the next linear block instead. get(block.next_block).invalidate_expressions = block.invalidate_expressions; } // For switch fallthrough cases, we terminate the chain here, but we still need to handle Phi. if (!current_emitting_switch_fallthrough) { // For merge selects we might have ignored the fact that a merge target // could have been a break; or continue; // We will need to deal with it here. if (is_loop_break(block.next_block)) { // Cannot check for just break, because switch statements will also use break. assert(block.merge == SPIRBlock::MergeSelection); statement("break;"); } else if (is_continue(block.next_block)) { assert(block.merge == SPIRBlock::MergeSelection); branch_to_continue(block.self, block.next_block); } else if (BlockID(block.self) != block.next_block) emit_block_chain(get(block.next_block)); } } if (block.merge == SPIRBlock::MergeLoop) { if (continue_type == SPIRBlock::DoWhileLoop) { // Make sure that we run the continue block to get the expressions set, but this // should become an empty string. // We have no fallbacks if we cannot forward everything to temporaries ... const auto &continue_block = get(block.continue_block); bool positive_test = execution_is_noop(get(continue_block.true_block), get(continue_block.loop_dominator)); uint32_t current_count = statement_count; auto statements = emit_continue_block(block.continue_block, positive_test, !positive_test); if (statement_count != current_count) { // The DoWhile block has side effects, force ComplexLoop pattern next pass. get(block.continue_block).complex_continue = true; force_recompile(); } // Might have to invert the do-while test here. auto condition = to_expression(continue_block.condition); if (!positive_test) condition = join("!", enclose_expression(condition)); end_scope_decl(join("while (", condition, ")")); } else end_scope(); loop_level_saver.release(); // We cannot break out of two loops at once, so don't check for break; here. // Using block.self as the "from" block isn't quite right, but it has the same scope // and dominance structure, so it's fine. if (is_continue(block.merge_block)) branch_to_continue(block.self, block.merge_block); else emit_block_chain(get(block.merge_block)); } // Forget about control dependent expressions now. block.invalidate_expressions.clear(); // After we return, we must be out of scope, so if we somehow have to re-emit this function, // re-declare variables if necessary. assert(rearm_dominated_variables.size() == block.dominated_variables.size()); for (size_t i = 0; i < block.dominated_variables.size(); i++) { uint32_t var = block.dominated_variables[i]; get(var).deferred_declaration = rearm_dominated_variables[i]; } // Just like for deferred declaration, we need to forget about loop variable enable // if our block chain is reinstantiated later. for (auto &var_id : block.loop_variables) get(var_id).loop_variable_enable = false; } void CompilerGLSL::begin_scope() { statement("{"); indent++; } void CompilerGLSL::end_scope() { if (!indent) SPIRV_CROSS_THROW("Popping empty indent stack."); indent--; statement("}"); } void CompilerGLSL::end_scope(const string &trailer) { if (!indent) SPIRV_CROSS_THROW("Popping empty indent stack."); indent--; statement("}", trailer); } void CompilerGLSL::end_scope_decl() { if (!indent) SPIRV_CROSS_THROW("Popping empty indent stack."); indent--; statement("};"); } void CompilerGLSL::end_scope_decl(const string &decl) { if (!indent) SPIRV_CROSS_THROW("Popping empty indent stack."); indent--; statement("} ", decl, ";"); } void CompilerGLSL::check_function_call_constraints(const uint32_t *args, uint32_t length) { // If our variable is remapped, and we rely on type-remapping information as // well, then we cannot pass the variable as a function parameter. // Fixing this is non-trivial without stamping out variants of the same function, // so for now warn about this and suggest workarounds instead. for (uint32_t i = 0; i < length; i++) { auto *var = maybe_get(args[i]); if (!var || !var->remapped_variable) continue; auto &type = get(var->basetype); if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData) { SPIRV_CROSS_THROW("Tried passing a remapped subpassInput variable to a function. " "This will not work correctly because type-remapping information is lost. " "To workaround, please consider not passing the subpass input as a function parameter, " "or use in/out variables instead which do not need type remapping information."); } } } const Instruction *CompilerGLSL::get_next_instruction_in_block(const Instruction &instr) { // FIXME: This is kind of hacky. There should be a cleaner way. auto offset = uint32_t(&instr - current_emitting_block->ops.data()); if ((offset + 1) < current_emitting_block->ops.size()) return ¤t_emitting_block->ops[offset + 1]; else return nullptr; } uint32_t CompilerGLSL::mask_relevant_memory_semantics(uint32_t semantics) { return semantics & (MemorySemanticsAtomicCounterMemoryMask | MemorySemanticsImageMemoryMask | MemorySemanticsWorkgroupMemoryMask | MemorySemanticsUniformMemoryMask | MemorySemanticsCrossWorkgroupMemoryMask | MemorySemanticsSubgroupMemoryMask); } void CompilerGLSL::emit_array_copy(const string &lhs, uint32_t rhs_id, StorageClass, StorageClass) { statement(lhs, " = ", to_expression(rhs_id), ";"); } void CompilerGLSL::unroll_array_from_complex_load(uint32_t target_id, uint32_t source_id, std::string &expr) { if (!backend.force_gl_in_out_block) return; // This path is only relevant for GL backends. auto *var = maybe_get(source_id); if (!var) return; if (var->storage != StorageClassInput) return; auto &type = get_variable_data_type(*var); if (type.array.empty()) return; auto builtin = BuiltIn(get_decoration(var->self, DecorationBuiltIn)); bool is_builtin = is_builtin_variable(*var) && (builtin == BuiltInPointSize || builtin == BuiltInPosition); bool is_tess = is_tessellation_shader(); bool is_patch = has_decoration(var->self, DecorationPatch); // Tessellation input arrays are special in that they are unsized, so we cannot directly copy from it. // We must unroll the array load. // For builtins, we couldn't catch this case normally, // because this is resolved in the OpAccessChain in most cases. // If we load the entire array, we have no choice but to unroll here. if (!is_patch && (is_builtin || is_tess)) { auto new_expr = join("_", target_id, "_unrolled"); statement(variable_decl(type, new_expr, target_id), ";"); string array_expr; if (type.array_size_literal.back()) { array_expr = convert_to_string(type.array.back()); if (type.array.back() == 0) SPIRV_CROSS_THROW("Cannot unroll an array copy from unsized array."); } else array_expr = to_expression(type.array.back()); // The array size might be a specialization constant, so use a for-loop instead. statement("for (int i = 0; i < int(", array_expr, "); i++)"); begin_scope(); if (is_builtin) statement(new_expr, "[i] = gl_in[i].", expr, ";"); else statement(new_expr, "[i] = ", expr, "[i];"); end_scope(); expr = move(new_expr); } } void CompilerGLSL::cast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type) { auto *var = maybe_get_backing_variable(source_id); if (var) source_id = var->self; // Only interested in standalone builtin variables. if (!has_decoration(source_id, DecorationBuiltIn)) return; auto builtin = static_cast(get_decoration(source_id, DecorationBuiltIn)); auto expected_type = expr_type.basetype; // TODO: Fill in for more builtins. switch (builtin) { case BuiltInLayer: case BuiltInPrimitiveId: case BuiltInViewportIndex: case BuiltInInstanceId: case BuiltInInstanceIndex: case BuiltInVertexId: case BuiltInVertexIndex: case BuiltInSampleId: case BuiltInBaseVertex: case BuiltInBaseInstance: case BuiltInDrawIndex: case BuiltInFragStencilRefEXT: case BuiltInInstanceCustomIndexNV: expected_type = SPIRType::Int; break; case BuiltInGlobalInvocationId: case BuiltInLocalInvocationId: case BuiltInWorkgroupId: case BuiltInLocalInvocationIndex: case BuiltInWorkgroupSize: case BuiltInNumWorkgroups: case BuiltInIncomingRayFlagsNV: case BuiltInLaunchIdNV: case BuiltInLaunchSizeNV: expected_type = SPIRType::UInt; break; default: break; } if (expected_type != expr_type.basetype) expr = bitcast_expression(expr_type, expected_type, expr); } void CompilerGLSL::cast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type) { // Only interested in standalone builtin variables. if (!has_decoration(target_id, DecorationBuiltIn)) return; auto builtin = static_cast(get_decoration(target_id, DecorationBuiltIn)); auto expected_type = expr_type.basetype; // TODO: Fill in for more builtins. switch (builtin) { case BuiltInLayer: case BuiltInPrimitiveId: case BuiltInViewportIndex: case BuiltInFragStencilRefEXT: expected_type = SPIRType::Int; break; default: break; } if (expected_type != expr_type.basetype) { auto type = expr_type; type.basetype = expected_type; expr = bitcast_expression(type, expr_type.basetype, expr); } } void CompilerGLSL::convert_non_uniform_expression(const SPIRType &type, std::string &expr) { if (*backend.nonuniform_qualifier == '\0') return; // Handle SPV_EXT_descriptor_indexing. if (type.basetype == SPIRType::Sampler || type.basetype == SPIRType::SampledImage || type.basetype == SPIRType::Image) { // The image/sampler ID must be declared as non-uniform. // However, it is not legal GLSL to have // nonuniformEXT(samplers[index]), so we must move the nonuniform qualifier // to the array indexing, like // samplers[nonuniformEXT(index)]. // While the access chain will generally be nonuniformEXT, it's not necessarily so, // so we might have to fixup the OpLoad-ed expression late. auto start_array_index = expr.find_first_of('['); if (start_array_index == string::npos) return; // Check for the edge case that a non-arrayed resource was marked to be nonuniform, // and the bracket we found is actually part of non-resource related data. if (expr.find_first_of(',') < start_array_index) return; // We've opened a bracket, track expressions until we can close the bracket. // This must be our image index. size_t end_array_index = string::npos; unsigned bracket_count = 1; for (size_t index = start_array_index + 1; index < expr.size(); index++) { if (expr[index] == ']') { if (--bracket_count == 0) { end_array_index = index; break; } } else if (expr[index] == '[') bracket_count++; } assert(bracket_count == 0); // Doesn't really make sense to declare a non-arrayed image with nonuniformEXT, but there's // nothing we can do here to express that. if (start_array_index == string::npos || end_array_index == string::npos || end_array_index < start_array_index) return; start_array_index++; expr = join(expr.substr(0, start_array_index), backend.nonuniform_qualifier, "(", expr.substr(start_array_index, end_array_index - start_array_index), ")", expr.substr(end_array_index, string::npos)); } } void CompilerGLSL::emit_block_hints(const SPIRBlock &) { } void CompilerGLSL::preserve_alias_on_reset(uint32_t id) { preserved_aliases[id] = get_name(id); } void CompilerGLSL::reset_name_caches() { for (auto &preserved : preserved_aliases) set_name(preserved.first, preserved.second); preserved_aliases.clear(); resource_names.clear(); block_input_names.clear(); block_output_names.clear(); block_ubo_names.clear(); block_ssbo_names.clear(); block_names.clear(); function_overloads.clear(); } void CompilerGLSL::fixup_type_alias() { // Due to how some backends work, the "master" type of type_alias must be a block-like type if it exists. ir.for_each_typed_id([&](uint32_t self, SPIRType &type) { if (!type.type_alias) return; if (has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock)) { // Top-level block types should never alias anything else. type.type_alias = 0; } else if (type_is_block_like(type) && type.self == ID(self)) { // A block-like type is any type which contains Offset decoration, but not top-level blocks, // i.e. blocks which are placed inside buffers. // Become the master. ir.for_each_typed_id([&](uint32_t other_id, SPIRType &other_type) { if (other_id == self) return; if (other_type.type_alias == type.type_alias) other_type.type_alias = self; }); this->get(type.type_alias).type_alias = self; type.type_alias = 0; } }); } void CompilerGLSL::reorder_type_alias() { // Reorder declaration of types so that the master of the type alias is always emitted first. // We need this in case a type B depends on type A (A must come before in the vector), but A is an alias of a type Abuffer, which // means declaration of A doesn't happen (yet), and order would be B, ABuffer and not ABuffer, B. Fix this up here. auto loop_lock = ir.create_loop_hard_lock(); auto &type_ids = ir.ids_for_type[TypeType]; for (auto alias_itr = begin(type_ids); alias_itr != end(type_ids); ++alias_itr) { auto &type = get(*alias_itr); if (type.type_alias != TypeID(0) && !has_extended_decoration(type.type_alias, SPIRVCrossDecorationBufferBlockRepacked)) { // We will skip declaring this type, so make sure the type_alias type comes before. auto master_itr = find(begin(type_ids), end(type_ids), ID(type.type_alias)); assert(master_itr != end(type_ids)); if (alias_itr < master_itr) { // Must also swap the type order for the constant-type joined array. auto &joined_types = ir.ids_for_constant_or_type; auto alt_alias_itr = find(begin(joined_types), end(joined_types), *alias_itr); auto alt_master_itr = find(begin(joined_types), end(joined_types), *master_itr); assert(alt_alias_itr != end(joined_types)); assert(alt_master_itr != end(joined_types)); swap(*alias_itr, *master_itr); swap(*alt_alias_itr, *alt_master_itr); } } } } void CompilerGLSL::emit_line_directive(uint32_t file_id, uint32_t line_literal) { // If we are redirecting statements, ignore the line directive. // Common case here is continue blocks. if (redirect_statement) return; if (options.emit_line_directives) { require_extension_internal("GL_GOOGLE_cpp_style_line_directive"); statement_no_indent("#line ", line_literal, " \"", get(file_id).str, "\""); } } void CompilerGLSL::propagate_nonuniform_qualifier(uint32_t id) { // SPIR-V might only tag the very last ID with NonUniformEXT, but for codegen, // we need to know NonUniformEXT a little earlier, when the resource is actually loaded. // Back-propagate the qualifier based on the expression dependency chain. if (!has_decoration(id, DecorationNonUniformEXT)) { set_decoration(id, DecorationNonUniformEXT); force_recompile(); } auto *e = maybe_get(id); auto *combined = maybe_get(id); auto *chain = maybe_get(id); if (e) { for (auto &expr : e->expression_dependencies) propagate_nonuniform_qualifier(expr); for (auto &expr : e->implied_read_expressions) propagate_nonuniform_qualifier(expr); } else if (combined) { propagate_nonuniform_qualifier(combined->image); propagate_nonuniform_qualifier(combined->sampler); } else if (chain) { for (auto &expr : chain->implied_read_expressions) propagate_nonuniform_qualifier(expr); } } void CompilerGLSL::emit_copy_logical_type(uint32_t lhs_id, uint32_t lhs_type_id, uint32_t rhs_id, uint32_t rhs_type_id, SmallVector chain) { // Fully unroll all member/array indices one by one. auto &lhs_type = get(lhs_type_id); auto &rhs_type = get(rhs_type_id); if (!lhs_type.array.empty()) { // Could use a loop here to support specialization constants, but it gets rather complicated with nested array types, // and this is a rather obscure opcode anyways, keep it simple unless we are forced to. uint32_t array_size = to_array_size_literal(lhs_type); chain.push_back(0); for (uint32_t i = 0; i < array_size; i++) { chain.back() = i; emit_copy_logical_type(lhs_id, lhs_type.parent_type, rhs_id, rhs_type.parent_type, chain); } } else if (lhs_type.basetype == SPIRType::Struct) { chain.push_back(0); uint32_t member_count = uint32_t(lhs_type.member_types.size()); for (uint32_t i = 0; i < member_count; i++) { chain.back() = i; emit_copy_logical_type(lhs_id, lhs_type.member_types[i], rhs_id, rhs_type.member_types[i], chain); } } else { // Need to handle unpack/packing fixups since this can differ wildly between the logical types, // particularly in MSL. // To deal with this, we emit access chains and go through emit_store_statement // to deal with all the special cases we can encounter. AccessChainMeta lhs_meta, rhs_meta; auto lhs = access_chain_internal(lhs_id, chain.data(), uint32_t(chain.size()), ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &lhs_meta); auto rhs = access_chain_internal(rhs_id, chain.data(), uint32_t(chain.size()), ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &rhs_meta); uint32_t id = ir.increase_bound_by(2); lhs_id = id; rhs_id = id + 1; { auto &lhs_expr = set(lhs_id, move(lhs), lhs_type_id, true); lhs_expr.need_transpose = lhs_meta.need_transpose; if (lhs_meta.storage_is_packed) set_extended_decoration(lhs_id, SPIRVCrossDecorationPhysicalTypePacked); if (lhs_meta.storage_physical_type != 0) set_extended_decoration(lhs_id, SPIRVCrossDecorationPhysicalTypeID, lhs_meta.storage_physical_type); forwarded_temporaries.insert(lhs_id); suppressed_usage_tracking.insert(lhs_id); } { auto &rhs_expr = set(rhs_id, move(rhs), rhs_type_id, true); rhs_expr.need_transpose = rhs_meta.need_transpose; if (rhs_meta.storage_is_packed) set_extended_decoration(rhs_id, SPIRVCrossDecorationPhysicalTypePacked); if (rhs_meta.storage_physical_type != 0) set_extended_decoration(rhs_id, SPIRVCrossDecorationPhysicalTypeID, rhs_meta.storage_physical_type); forwarded_temporaries.insert(rhs_id); suppressed_usage_tracking.insert(rhs_id); } emit_store_statement(lhs_id, rhs_id); } } bool CompilerGLSL::subpass_input_is_framebuffer_fetch(uint32_t id) const { if (!has_decoration(id, DecorationInputAttachmentIndex)) return false; uint32_t input_attachment_index = get_decoration(id, DecorationInputAttachmentIndex); for (auto &remap : subpass_to_framebuffer_fetch_attachment) if (remap.first == input_attachment_index) return true; return false; } const SPIRVariable *CompilerGLSL::find_subpass_input_by_attachment_index(uint32_t index) const { const SPIRVariable *ret = nullptr; ir.for_each_typed_id([&](uint32_t, const SPIRVariable &var) { if (has_decoration(var.self, DecorationInputAttachmentIndex) && get_decoration(var.self, DecorationInputAttachmentIndex) == index) { ret = &var; } }); return ret; } const SPIRVariable *CompilerGLSL::find_color_output_by_location(uint32_t location) const { const SPIRVariable *ret = nullptr; ir.for_each_typed_id([&](uint32_t, const SPIRVariable &var) { if (var.storage == StorageClassOutput && get_decoration(var.self, DecorationLocation) == location) ret = &var; }); return ret; } void CompilerGLSL::emit_inout_fragment_outputs_copy_to_subpass_inputs() { for (auto &remap : subpass_to_framebuffer_fetch_attachment) { auto *subpass_var = find_subpass_input_by_attachment_index(remap.first); auto *output_var = find_color_output_by_location(remap.second); if (!subpass_var) continue; if (!output_var) SPIRV_CROSS_THROW("Need to declare the corresponding fragment output variable to be able " "to read from it."); if (is_array(get(output_var->basetype))) SPIRV_CROSS_THROW("Cannot use GL_EXT_shader_framebuffer_fetch with arrays of color outputs."); auto &func = get(get_entry_point().self); func.fixup_hooks_in.push_back([=]() { if (is_legacy()) { statement(to_expression(subpass_var->self), " = ", "gl_LastFragData[", get_decoration(output_var->self, DecorationLocation), "];"); } else { uint32_t num_rt_components = this->get(output_var->basetype).vecsize; statement(to_expression(subpass_var->self), vector_swizzle(num_rt_components, 0), " = ", to_expression(output_var->self), ";"); } }); } } bool CompilerGLSL::variable_is_depth_or_compare(VariableID id) const { return image_is_comparison(get(get(id).basetype), id); } const char *CompilerGLSL::ShaderSubgroupSupportHelper::get_extension_name(Candidate c) { static const char *const retval[CandidateCount] = { "GL_KHR_shader_subgroup_ballot", "GL_KHR_shader_subgroup_basic", "GL_KHR_shader_subgroup_vote", "GL_NV_gpu_shader_5", "GL_NV_shader_thread_group", "GL_NV_shader_thread_shuffle", "GL_ARB_shader_ballot", "GL_ARB_shader_group_vote", "GL_AMD_gcn_shader" }; return retval[c]; } SmallVector CompilerGLSL::ShaderSubgroupSupportHelper::get_extra_required_extension_names(Candidate c) { switch (c) { case ARB_shader_ballot: return { "GL_ARB_shader_int64" }; case AMD_gcn_shader: return { "GL_AMD_gpu_shader_int64", "GL_NV_gpu_shader5" }; default: return {}; } } const char *CompilerGLSL::ShaderSubgroupSupportHelper::get_extra_required_extension_predicate(Candidate c) { switch (c) { case ARB_shader_ballot: return "defined(GL_ARB_shader_int64)"; case AMD_gcn_shader: return "(defined(GL_AMD_gpu_shader_int64) || defined(GL_NV_gpu_shader5))"; default: return ""; } } CompilerGLSL::ShaderSubgroupSupportHelper::FeatureVector CompilerGLSL::ShaderSubgroupSupportHelper:: get_feature_dependencies(Feature feature) { switch (feature) { case SubgroupAllEqualT: return { SubgroupBroadcast_First, SubgroupAll_Any_AllEqualBool }; case SubgroupElect: return { SubgroupBallotFindLSB_MSB, SubgroupBallot, SubgroupInvocationID }; case SubgroupInverseBallot_InclBitCount_ExclBitCout: return { SubgroupMask }; case SubgroupBallotBitCount: return { SubgroupBallot }; default: return {}; } } CompilerGLSL::ShaderSubgroupSupportHelper::FeatureMask CompilerGLSL::ShaderSubgroupSupportHelper:: get_feature_dependency_mask(Feature feature) { return build_mask(get_feature_dependencies(feature)); } bool CompilerGLSL::ShaderSubgroupSupportHelper::can_feature_be_implemented_without_extensions(Feature feature) { static const bool retval[FeatureCount] = { false, false, false, false, false, false, true, // SubgroupBalloFindLSB_MSB false, false, false, false, true, // SubgroupMemBarrier - replaced with workgroup memory barriers false, false, true, false }; return retval[feature]; } CompilerGLSL::ShaderSubgroupSupportHelper::Candidate CompilerGLSL::ShaderSubgroupSupportHelper:: get_KHR_extension_for_feature(Feature feature) { static const Candidate extensions[FeatureCount] = { KHR_shader_subgroup_ballot, KHR_shader_subgroup_basic, KHR_shader_subgroup_basic, KHR_shader_subgroup_basic, KHR_shader_subgroup_basic, KHR_shader_subgroup_ballot, KHR_shader_subgroup_ballot, KHR_shader_subgroup_vote, KHR_shader_subgroup_vote, KHR_shader_subgroup_basic, KHR_shader_subgroup_basic, KHR_shader_subgroup_basic, KHR_shader_subgroup_ballot, KHR_shader_subgroup_ballot, KHR_shader_subgroup_ballot, KHR_shader_subgroup_ballot }; return extensions[feature]; } void CompilerGLSL::ShaderSubgroupSupportHelper::request_feature(Feature feature) { feature_mask |= (FeatureMask(1) << feature) | get_feature_dependency_mask(feature); } bool CompilerGLSL::ShaderSubgroupSupportHelper::is_feature_requested(Feature feature) const { return (feature_mask & (1u << feature)) != 0; } CompilerGLSL::ShaderSubgroupSupportHelper::Result CompilerGLSL::ShaderSubgroupSupportHelper::resolve() const { Result res; for (uint32_t i = 0u; i < FeatureCount; ++i) { if (feature_mask & (1u << i)) { auto feature = static_cast(i); std::unordered_set unique_candidates; auto candidates = get_candidates_for_feature(feature); unique_candidates.insert(candidates.begin(), candidates.end()); auto deps = get_feature_dependencies(feature); for (Feature d : deps) { candidates = get_candidates_for_feature(d); if (!candidates.empty()) unique_candidates.insert(candidates.begin(), candidates.end()); } for (uint32_t c : unique_candidates) ++res.weights[static_cast(c)]; } } return res; } CompilerGLSL::ShaderSubgroupSupportHelper::CandidateVector CompilerGLSL::ShaderSubgroupSupportHelper:: get_candidates_for_feature(Feature ft, const Result &r) { auto c = get_candidates_for_feature(ft); auto cmp = [&r](Candidate a, Candidate b) { if (r.weights[a] == r.weights[b]) return a < b; // Prefer candidates with lower enum value return r.weights[a] > r.weights[b]; }; std::sort(c.begin(), c.end(), cmp); return c; } CompilerGLSL::ShaderSubgroupSupportHelper::CandidateVector CompilerGLSL::ShaderSubgroupSupportHelper:: get_candidates_for_feature(Feature feature) { switch (feature) { case SubgroupMask: return { KHR_shader_subgroup_ballot, NV_shader_thread_group, ARB_shader_ballot }; case SubgroupSize: return { KHR_shader_subgroup_basic, NV_shader_thread_group, AMD_gcn_shader, ARB_shader_ballot }; case SubgroupInvocationID: return { KHR_shader_subgroup_basic, NV_shader_thread_group, ARB_shader_ballot }; case SubgroupID: return { KHR_shader_subgroup_basic, NV_shader_thread_group }; case NumSubgroups: return { KHR_shader_subgroup_basic, NV_shader_thread_group }; case SubgroupBroadcast_First: return { KHR_shader_subgroup_ballot, NV_shader_thread_shuffle, ARB_shader_ballot }; case SubgroupBallotFindLSB_MSB: return { KHR_shader_subgroup_ballot, NV_shader_thread_group }; case SubgroupAll_Any_AllEqualBool: return { KHR_shader_subgroup_vote, NV_gpu_shader_5, ARB_shader_group_vote, AMD_gcn_shader }; case SubgroupAllEqualT: return {}; // depends on other features only case SubgroupElect: return {}; // depends on other features only case SubgroupBallot: return { KHR_shader_subgroup_ballot, NV_shader_thread_group, ARB_shader_ballot }; case SubgroupBarrier: return { KHR_shader_subgroup_basic, NV_shader_thread_group, ARB_shader_ballot, AMD_gcn_shader }; case SubgroupMemBarrier: return { KHR_shader_subgroup_basic }; case SubgroupInverseBallot_InclBitCount_ExclBitCout: return {}; case SubgroupBallotBitExtract: return { NV_shader_thread_group }; case SubgroupBallotBitCount: return {}; default: return {}; } } CompilerGLSL::ShaderSubgroupSupportHelper::FeatureMask CompilerGLSL::ShaderSubgroupSupportHelper::build_mask( const SmallVector &features) { FeatureMask mask = 0; for (Feature f : features) mask |= FeatureMask(1) << f; return mask; } CompilerGLSL::ShaderSubgroupSupportHelper::Result::Result() { for (auto &weight : weights) weight = 0; // Make sure KHR_shader_subgroup extensions are always prefered. const uint32_t big_num = FeatureCount; weights[KHR_shader_subgroup_ballot] = big_num; weights[KHR_shader_subgroup_basic] = big_num; weights[KHR_shader_subgroup_vote] = big_num; } void CompilerGLSL::request_workaround_wrapper_overload(TypeID id) { // Must be ordered to maintain deterministic output, so vector is appropriate. if (find(begin(workaround_ubo_load_overload_types), end(workaround_ubo_load_overload_types), id) == end(workaround_ubo_load_overload_types)) { force_recompile(); workaround_ubo_load_overload_types.push_back(id); } } void CompilerGLSL::rewrite_load_for_wrapped_row_major(std::string &expr, TypeID loaded_type, ID ptr) { // Loading row-major matrices from UBOs on older AMD Windows OpenGL drivers is problematic. // To load these types correctly, we must first wrap them in a dummy function which only purpose is to // ensure row_major decoration is actually respected. auto *var = maybe_get_backing_variable(ptr); if (!var) return; auto &backing_type = get(var->basetype); bool is_ubo = backing_type.basetype == SPIRType::Struct && backing_type.storage == StorageClassUniform && has_decoration(backing_type.self, DecorationBlock); if (!is_ubo) return; auto *type = &get(loaded_type); bool rewrite = false; if (is_matrix(*type)) { // To avoid adding a lot of unnecessary meta tracking to forward the row_major state, // we will simply look at the base struct itself. It is exceptionally rare to mix and match row-major/col-major state. // If there is any row-major action going on, we apply the workaround. // It is harmless to apply the workaround to column-major matrices, so this is still a valid solution. // If an access chain occurred, the workaround is not required, so loading vectors or scalars don't need workaround. type = &backing_type; } if (type->basetype == SPIRType::Struct) { // If we're loading a struct where any member is a row-major matrix, apply the workaround. for (uint32_t i = 0; i < uint32_t(type->member_types.size()); i++) { if (combined_decoration_for_member(*type, i).get(DecorationRowMajor)) { rewrite = true; break; } } } if (rewrite) { request_workaround_wrapper_overload(loaded_type); expr = join("spvWorkaroundRowMajor(", expr, ")"); } } spirv-cross-2021.01.15/spirv_glsl.hpp000066400000000000000000001206741400026215700173010ustar00rootroot00000000000000/* * Copyright 2015-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_GLSL_HPP #define SPIRV_CROSS_GLSL_HPP #include "GLSL.std.450.h" #include "spirv_cross.hpp" #include #include #include namespace SPIRV_CROSS_NAMESPACE { enum PlsFormat { PlsNone = 0, PlsR11FG11FB10F, PlsR32F, PlsRG16F, PlsRGB10A2, PlsRGBA8, PlsRG16, PlsRGBA8I, PlsRG16I, PlsRGB10A2UI, PlsRGBA8UI, PlsRG16UI, PlsR32UI }; struct PlsRemap { uint32_t id; PlsFormat format; }; enum AccessChainFlagBits { ACCESS_CHAIN_INDEX_IS_LITERAL_BIT = 1 << 0, ACCESS_CHAIN_CHAIN_ONLY_BIT = 1 << 1, ACCESS_CHAIN_PTR_CHAIN_BIT = 1 << 2, ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT = 1 << 3, ACCESS_CHAIN_LITERAL_MSB_FORCE_ID = 1 << 4, ACCESS_CHAIN_FLATTEN_ALL_MEMBERS_BIT = 1 << 5 }; typedef uint32_t AccessChainFlags; class CompilerGLSL : public Compiler { public: struct Options { // The shading language version. Corresponds to #version $VALUE. uint32_t version = 450; // Emit the OpenGL ES shading language instead of desktop OpenGL. bool es = false; // Debug option to always emit temporary variables for all expressions. bool force_temporary = false; // If true, Vulkan GLSL features are used instead of GL-compatible features. // Mostly useful for debugging SPIR-V files. bool vulkan_semantics = false; // If true, gl_PerVertex is explicitly redeclared in vertex, geometry and tessellation shaders. // The members of gl_PerVertex is determined by which built-ins are declared by the shader. // This option is ignored in ES versions, as redeclaration in ES is not required, and it depends on a different extension // (EXT_shader_io_blocks) which makes things a bit more fuzzy. bool separate_shader_objects = false; // Flattens multidimensional arrays, e.g. float foo[a][b][c] into single-dimensional arrays, // e.g. float foo[a * b * c]. // This function does not change the actual SPIRType of any object. // Only the generated code, including declarations of interface variables are changed to be single array dimension. bool flatten_multidimensional_arrays = false; // For older desktop GLSL targets than version 420, the // GL_ARB_shading_language_420pack extensions is used to be able to support // layout(binding) on UBOs and samplers. // If disabled on older targets, binding decorations will be stripped. bool enable_420pack_extension = true; // In non-Vulkan GLSL, emit push constant blocks as UBOs rather than plain uniforms. bool emit_push_constant_as_uniform_buffer = false; // Always emit uniform blocks as plain uniforms, regardless of the GLSL version, even when UBOs are supported. // Does not apply to shader storage or push constant blocks. bool emit_uniform_buffer_as_plain_uniforms = false; // Emit OpLine directives if present in the module. // May not correspond exactly to original source, but should be a good approximation. bool emit_line_directives = false; // In cases where readonly/writeonly decoration are not used at all, // we try to deduce which qualifier(s) we should actually used, since actually emitting // read-write decoration is very rare, and older glslang/HLSL compilers tend to just emit readwrite as a matter of fact. // The default (true) is to enable automatic deduction for these cases, but if you trust the decorations set // by the SPIR-V, it's recommended to set this to false. bool enable_storage_image_qualifier_deduction = true; // On some targets (WebGPU), uninitialized variables are banned. // If this is enabled, all variables (temporaries, Private, Function) // which would otherwise be uninitialized will now be initialized to 0 instead. bool force_zero_initialized_variables = false; // In GLSL, force use of I/O block flattening, similar to // what happens on legacy GLSL targets for blocks and structs. bool force_flattened_io_blocks = false; enum Precision { DontCare, Lowp, Mediump, Highp }; struct VertexOptions { // "Vertex-like shader" here is any shader stage that can write BuiltInPosition. // GLSL: In vertex-like shaders, rewrite [0, w] depth (Vulkan/D3D style) to [-w, w] depth (GL style). // MSL: In vertex-like shaders, rewrite [-w, w] depth (GL style) to [0, w] depth. // HLSL: In vertex-like shaders, rewrite [-w, w] depth (GL style) to [0, w] depth. bool fixup_clipspace = false; // In vertex-like shaders, inverts gl_Position.y or equivalent. bool flip_vert_y = false; // GLSL only, for HLSL version of this option, see CompilerHLSL. // If true, the backend will assume that InstanceIndex will need to apply // a base instance offset. Set to false if you know you will never use base instance // functionality as it might remove some internal uniforms. bool support_nonzero_base_instance = true; } vertex; struct FragmentOptions { // Add precision mediump float in ES targets when emitting GLES source. // Add precision highp int in ES targets when emitting GLES source. Precision default_float_precision = Mediump; Precision default_int_precision = Highp; } fragment; }; void remap_pixel_local_storage(std::vector inputs, std::vector outputs) { pls_inputs = std::move(inputs); pls_outputs = std::move(outputs); remap_pls_variables(); } // Redirect a subpassInput reading from input_attachment_index to instead load its value from // the color attachment at location = color_location. Requires ESSL. void remap_ext_framebuffer_fetch(uint32_t input_attachment_index, uint32_t color_location); explicit CompilerGLSL(std::vector spirv_) : Compiler(std::move(spirv_)) { init(); } CompilerGLSL(const uint32_t *ir_, size_t word_count) : Compiler(ir_, word_count) { init(); } explicit CompilerGLSL(const ParsedIR &ir_) : Compiler(ir_) { init(); } explicit CompilerGLSL(ParsedIR &&ir_) : Compiler(std::move(ir_)) { init(); } const Options &get_common_options() const { return options; } void set_common_options(const Options &opts) { options = opts; } std::string compile() override; // Returns the current string held in the conversion buffer. Useful for // capturing what has been converted so far when compile() throws an error. std::string get_partial_source(); // Adds a line to be added right after #version in GLSL backend. // This is useful for enabling custom extensions which are outside the scope of SPIRV-Cross. // This can be combined with variable remapping. // A new-line will be added. // // While add_header_line() is a more generic way of adding arbitrary text to the header // of a GLSL file, require_extension() should be used when adding extensions since it will // avoid creating collisions with SPIRV-Cross generated extensions. // // Code added via add_header_line() is typically backend-specific. void add_header_line(const std::string &str); // Adds an extension which is required to run this shader, e.g. // require_extension("GL_KHR_my_extension"); void require_extension(const std::string &ext); // Legacy GLSL compatibility method. // Takes a uniform or push constant variable and flattens it into a (i|u)vec4 array[N]; array instead. // For this to work, all types in the block must be the same basic type, e.g. mixing vec2 and vec4 is fine, but // mixing int and float is not. // The name of the uniform array will be the same as the interface block name. void flatten_buffer_block(VariableID id); // After compilation, query if a variable ID was used as a depth resource. // This is meaningful for MSL since descriptor types depend on this knowledge. // Cases which return true: // - Images which are declared with depth = 1 image type. // - Samplers which are statically used at least once with Dref opcodes. // - Images which are statically used at least once with Dref opcodes. bool variable_is_depth_or_compare(VariableID id) const; protected: struct ShaderSubgroupSupportHelper { // lower enum value = greater priority enum Candidate { KHR_shader_subgroup_ballot, KHR_shader_subgroup_basic, KHR_shader_subgroup_vote, NV_gpu_shader_5, NV_shader_thread_group, NV_shader_thread_shuffle, ARB_shader_ballot, ARB_shader_group_vote, AMD_gcn_shader, CandidateCount }; static const char *get_extension_name(Candidate c); static SmallVector get_extra_required_extension_names(Candidate c); static const char *get_extra_required_extension_predicate(Candidate c); enum Feature { SubgroupMask = 0, SubgroupSize = 1, SubgroupInvocationID = 2, SubgroupID = 3, NumSubgroups = 4, SubgroupBroadcast_First = 5, SubgroupBallotFindLSB_MSB = 6, SubgroupAll_Any_AllEqualBool = 7, SubgroupAllEqualT = 8, SubgroupElect = 9, SubgroupBarrier = 10, SubgroupMemBarrier = 11, SubgroupBallot = 12, SubgroupInverseBallot_InclBitCount_ExclBitCout = 13, SubgroupBallotBitExtract = 14, SubgroupBallotBitCount = 15, FeatureCount }; using FeatureMask = uint32_t; static_assert(sizeof(FeatureMask) * 8u >= FeatureCount, "Mask type needs more bits."); using CandidateVector = SmallVector; using FeatureVector = SmallVector; static FeatureVector get_feature_dependencies(Feature feature); static FeatureMask get_feature_dependency_mask(Feature feature); static bool can_feature_be_implemented_without_extensions(Feature feature); static Candidate get_KHR_extension_for_feature(Feature feature); struct Result { Result(); uint32_t weights[CandidateCount]; }; void request_feature(Feature feature); bool is_feature_requested(Feature feature) const; Result resolve() const; static CandidateVector get_candidates_for_feature(Feature ft, const Result &r); private: static CandidateVector get_candidates_for_feature(Feature ft); static FeatureMask build_mask(const SmallVector &features); FeatureMask feature_mask = 0; }; // TODO remove this function when all subgroup ops are supported (or make it always return true) static bool is_supported_subgroup_op_in_opengl(spv::Op op); void reset(); void emit_function(SPIRFunction &func, const Bitset &return_flags); bool has_extension(const std::string &ext) const; void require_extension_internal(const std::string &ext); // Virtualize methods which need to be overridden by subclass targets like C++ and such. virtual void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags); SPIRBlock *current_emitting_block = nullptr; SPIRBlock *current_emitting_switch = nullptr; bool current_emitting_switch_fallthrough = false; virtual void emit_instruction(const Instruction &instr); void emit_block_instructions(SPIRBlock &block); virtual void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count); virtual void emit_spv_amd_shader_ballot_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count); virtual void emit_spv_amd_shader_explicit_vertex_parameter_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count); virtual void emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count); virtual void emit_spv_amd_gcn_shader_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count); virtual void emit_header(); void emit_line_directive(uint32_t file_id, uint32_t line_literal); void build_workgroup_size(SmallVector &arguments, const SpecializationConstant &x, const SpecializationConstant &y, const SpecializationConstant &z); void request_subgroup_feature(ShaderSubgroupSupportHelper::Feature feature); virtual void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id); virtual void emit_texture_op(const Instruction &i, bool sparse); virtual std::string to_texture_op(const Instruction &i, bool sparse, bool *forward, SmallVector &inherited_expressions); virtual void emit_subgroup_op(const Instruction &i); virtual std::string type_to_glsl(const SPIRType &type, uint32_t id = 0); virtual std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage); virtual void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const std::string &qualifier = "", uint32_t base_offset = 0); virtual void emit_struct_padding_target(const SPIRType &type); virtual std::string image_type_glsl(const SPIRType &type, uint32_t id = 0); std::string constant_expression(const SPIRConstant &c); std::string constant_op_expression(const SPIRConstantOp &cop); virtual std::string constant_expression_vector(const SPIRConstant &c, uint32_t vector); virtual void emit_fixup(); virtual std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id = 0); virtual std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id); struct TextureFunctionBaseArguments { // GCC 4.8 workarounds, it doesn't understand '{}' constructor here, use explicit default constructor. TextureFunctionBaseArguments() = default; VariableID img = 0; const SPIRType *imgtype = nullptr; bool is_fetch = false, is_gather = false, is_proj = false; }; struct TextureFunctionNameArguments { // GCC 4.8 workarounds, it doesn't understand '{}' constructor here, use explicit default constructor. TextureFunctionNameArguments() = default; TextureFunctionBaseArguments base; bool has_array_offsets = false, has_offset = false, has_grad = false; bool has_dref = false, is_sparse_feedback = false, has_min_lod = false; uint32_t lod = 0; }; virtual std::string to_function_name(const TextureFunctionNameArguments &args); struct TextureFunctionArguments { // GCC 4.8 workarounds, it doesn't understand '{}' constructor here, use explicit default constructor. TextureFunctionArguments() = default; TextureFunctionBaseArguments base; uint32_t coord = 0, coord_components = 0, dref = 0; uint32_t grad_x = 0, grad_y = 0, lod = 0, coffset = 0, offset = 0; uint32_t bias = 0, component = 0, sample = 0, sparse_texel = 0, min_lod = 0; bool nonuniform_expression = false; }; virtual std::string to_function_args(const TextureFunctionArguments &args, bool *p_forward); void emit_sparse_feedback_temporaries(uint32_t result_type_id, uint32_t id, uint32_t &feedback_id, uint32_t &texel_id); uint32_t get_sparse_feedback_texel_id(uint32_t id) const; virtual void emit_buffer_block(const SPIRVariable &type); virtual void emit_push_constant_block(const SPIRVariable &var); virtual void emit_uniform(const SPIRVariable &var); virtual std::string unpack_expression_type(std::string expr_str, const SPIRType &type, uint32_t physical_type_id, bool packed_type, bool row_major); virtual bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const; void emit_copy_logical_type(uint32_t lhs_id, uint32_t lhs_type_id, uint32_t rhs_id, uint32_t rhs_type_id, SmallVector chain); StringStream<> buffer; template inline void statement_inner(T &&t) { buffer << std::forward(t); statement_count++; } template inline void statement_inner(T &&t, Ts &&... ts) { buffer << std::forward(t); statement_count++; statement_inner(std::forward(ts)...); } template inline void statement(Ts &&... ts) { if (is_forcing_recompilation()) { // Do not bother emitting code while force_recompile is active. // We will compile again. statement_count++; return; } if (redirect_statement) { redirect_statement->push_back(join(std::forward(ts)...)); statement_count++; } else { for (uint32_t i = 0; i < indent; i++) buffer << " "; statement_inner(std::forward(ts)...); buffer << '\n'; } } template inline void statement_no_indent(Ts &&... ts) { auto old_indent = indent; indent = 0; statement(std::forward(ts)...); indent = old_indent; } // Used for implementing continue blocks where // we want to obtain a list of statements we can merge // on a single line separated by comma. SmallVector *redirect_statement = nullptr; const SPIRBlock *current_continue_block = nullptr; void begin_scope(); void end_scope(); void end_scope(const std::string &trailer); void end_scope_decl(); void end_scope_decl(const std::string &decl); Options options; virtual std::string type_to_array_glsl( const SPIRType &type); // Allow Metal to use the array template to make arrays a value type std::string to_array_size(const SPIRType &type, uint32_t index); uint32_t to_array_size_literal(const SPIRType &type, uint32_t index) const; uint32_t to_array_size_literal(const SPIRType &type) const; virtual std::string variable_decl(const SPIRVariable &variable); // Threadgroup arrays can't have a wrapper type std::string variable_decl_function_local(SPIRVariable &variable); void add_local_variable_name(uint32_t id); void add_resource_name(uint32_t id); void add_member_name(SPIRType &type, uint32_t name); void add_function_overload(const SPIRFunction &func); virtual bool is_non_native_row_major_matrix(uint32_t id); virtual bool member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index); bool member_is_remapped_physical_type(const SPIRType &type, uint32_t index) const; bool member_is_packed_physical_type(const SPIRType &type, uint32_t index) const; virtual std::string convert_row_major_matrix(std::string exp_str, const SPIRType &exp_type, uint32_t physical_type_id, bool is_packed); std::unordered_set local_variable_names; std::unordered_set resource_names; std::unordered_set block_input_names; std::unordered_set block_output_names; std::unordered_set block_ubo_names; std::unordered_set block_ssbo_names; std::unordered_set block_names; // A union of all block_*_names. std::unordered_map> function_overloads; std::unordered_map preserved_aliases; void preserve_alias_on_reset(uint32_t id); void reset_name_caches(); bool processing_entry_point = false; // Can be overriden by subclass backends for trivial things which // shouldn't need polymorphism. struct BackendVariations { std::string discard_literal = "discard"; std::string demote_literal = "demote"; std::string null_pointer_literal = ""; bool float_literal_suffix = false; bool double_literal_suffix = true; bool uint32_t_literal_suffix = true; bool long_long_literal_suffix = false; const char *basic_int_type = "int"; const char *basic_uint_type = "uint"; const char *basic_int8_type = "int8_t"; const char *basic_uint8_type = "uint8_t"; const char *basic_int16_type = "int16_t"; const char *basic_uint16_type = "uint16_t"; const char *int16_t_literal_suffix = "s"; const char *uint16_t_literal_suffix = "us"; const char *nonuniform_qualifier = "nonuniformEXT"; const char *boolean_mix_function = "mix"; bool swizzle_is_function = false; bool shared_is_implied = false; bool unsized_array_supported = true; bool explicit_struct_type = false; bool use_initializer_list = false; bool use_typed_initializer_list = false; bool can_declare_struct_inline = true; bool can_declare_arrays_inline = true; bool native_row_major_matrix = true; bool use_constructor_splatting = true; bool allow_precision_qualifiers = false; bool can_swizzle_scalar = false; bool force_gl_in_out_block = false; bool can_return_array = true; bool allow_truncated_access_chain = false; bool supports_extensions = false; bool supports_empty_struct = false; bool array_is_value_type = true; bool buffer_offset_array_is_value_type = true; bool comparison_image_samples_scalar = false; bool native_pointers = false; bool support_small_type_sampling_result = false; bool support_case_fallthrough = true; bool use_array_constructor = false; bool needs_row_major_load_workaround = false; } backend; void emit_struct(SPIRType &type); void emit_resources(); void emit_extension_workarounds(spv::ExecutionModel model); void emit_buffer_block_native(const SPIRVariable &var); void emit_buffer_reference_block(SPIRType &type, bool forward_declaration); void emit_buffer_block_legacy(const SPIRVariable &var); void emit_buffer_block_flattened(const SPIRVariable &type); void fixup_implicit_builtin_block_names(); void emit_declared_builtin_block(spv::StorageClass storage, spv::ExecutionModel model); bool should_force_emit_builtin_block(spv::StorageClass storage); void emit_push_constant_block_vulkan(const SPIRVariable &var); void emit_push_constant_block_glsl(const SPIRVariable &var); void emit_interface_block(const SPIRVariable &type); void emit_flattened_io_block(const SPIRVariable &var, const char *qual); void emit_flattened_io_block_struct(const std::string &basename, const SPIRType &type, const char *qual, const SmallVector &indices); void emit_flattened_io_block_member(const std::string &basename, const SPIRType &type, const char *qual, const SmallVector &indices); void emit_block_chain(SPIRBlock &block); void emit_hoisted_temporaries(SmallVector> &temporaries); std::string constant_value_macro_name(uint32_t id); void emit_constant(const SPIRConstant &constant); void emit_specialization_constant_op(const SPIRConstantOp &constant); std::string emit_continue_block(uint32_t continue_block, bool follow_true_block, bool follow_false_block); bool attempt_emit_loop_header(SPIRBlock &block, SPIRBlock::Method method); void branch(BlockID from, BlockID to); void branch_to_continue(BlockID from, BlockID to); void branch(BlockID from, uint32_t cond, BlockID true_block, BlockID false_block); void flush_phi(BlockID from, BlockID to); void flush_variable_declaration(uint32_t id); void flush_undeclared_variables(SPIRBlock &block); void emit_variable_temporary_copies(const SPIRVariable &var); bool should_dereference(uint32_t id); bool should_forward(uint32_t id) const; bool should_suppress_usage_tracking(uint32_t id) const; void emit_mix_op(uint32_t result_type, uint32_t id, uint32_t left, uint32_t right, uint32_t lerp); void emit_nminmax_op(uint32_t result_type, uint32_t id, uint32_t op0, uint32_t op1, GLSLstd450 op); bool to_trivial_mix_op(const SPIRType &type, std::string &op, uint32_t left, uint32_t right, uint32_t lerp); void emit_quaternary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, uint32_t op3, const char *op); void emit_trinary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, const char *op); void emit_binary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op); void emit_unary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op, SPIRType::BaseType input_type, SPIRType::BaseType expected_result_type); void emit_binary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, SPIRType::BaseType input_type, bool skip_cast_if_equal_type); void emit_binary_func_op_cast_clustered(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, SPIRType::BaseType input_type); void emit_trinary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, const char *op, SPIRType::BaseType input_type); void emit_trinary_func_op_bitextract(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, const char *op, SPIRType::BaseType expected_result_type, SPIRType::BaseType input_type0, SPIRType::BaseType input_type1, SPIRType::BaseType input_type2); void emit_bitfield_insert_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, uint32_t op3, const char *op, SPIRType::BaseType offset_count_type); void emit_unary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op); void emit_unrolled_unary_op(uint32_t result_type, uint32_t result_id, uint32_t operand, const char *op); void emit_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op); void emit_unrolled_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, bool negate, SPIRType::BaseType expected_type); void emit_binary_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, SPIRType::BaseType input_type, bool skip_cast_if_equal_type); SPIRType binary_op_bitcast_helper(std::string &cast_op0, std::string &cast_op1, SPIRType::BaseType &input_type, uint32_t op0, uint32_t op1, bool skip_cast_if_equal_type); virtual bool emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0); std::string to_ternary_expression(const SPIRType &result_type, uint32_t select, uint32_t true_value, uint32_t false_value); void emit_unary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op); bool expression_is_forwarded(uint32_t id) const; bool expression_suppresses_usage_tracking(uint32_t id) const; bool expression_read_implies_multiple_reads(uint32_t id) const; SPIRExpression &emit_op(uint32_t result_type, uint32_t result_id, const std::string &rhs, bool forward_rhs, bool suppress_usage_tracking = false); void access_chain_internal_append_index(std::string &expr, uint32_t base, const SPIRType *type, AccessChainFlags flags, bool &access_chain_is_arrayed, uint32_t index); std::string access_chain_internal(uint32_t base, const uint32_t *indices, uint32_t count, AccessChainFlags flags, AccessChainMeta *meta); virtual void prepare_access_chain_for_scalar_access(std::string &expr, const SPIRType &type, spv::StorageClass storage, bool &is_packed); std::string access_chain(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, AccessChainMeta *meta = nullptr, bool ptr_chain = false); std::string flattened_access_chain(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, uint32_t array_stride, bool need_transpose); std::string flattened_access_chain_struct(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset); std::string flattened_access_chain_matrix(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, bool need_transpose); std::string flattened_access_chain_vector(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, bool need_transpose); std::pair flattened_access_chain_offset(const SPIRType &basetype, const uint32_t *indices, uint32_t count, uint32_t offset, uint32_t word_stride, bool *need_transpose = nullptr, uint32_t *matrix_stride = nullptr, uint32_t *array_stride = nullptr, bool ptr_chain = false); const char *index_to_swizzle(uint32_t index); std::string remap_swizzle(const SPIRType &result_type, uint32_t input_components, const std::string &expr); std::string declare_temporary(uint32_t type, uint32_t id); void emit_uninitialized_temporary(uint32_t type, uint32_t id); SPIRExpression &emit_uninitialized_temporary_expression(uint32_t type, uint32_t id); void append_global_func_args(const SPIRFunction &func, uint32_t index, SmallVector &arglist); std::string to_expression(uint32_t id, bool register_expression_read = true); std::string to_composite_constructor_expression(uint32_t id, bool uses_buffer_offset); std::string to_rerolled_array_expression(const std::string &expr, const SPIRType &type); std::string to_enclosed_expression(uint32_t id, bool register_expression_read = true); std::string to_unpacked_expression(uint32_t id, bool register_expression_read = true); std::string to_unpacked_row_major_matrix_expression(uint32_t id); std::string to_enclosed_unpacked_expression(uint32_t id, bool register_expression_read = true); std::string to_dereferenced_expression(uint32_t id, bool register_expression_read = true); std::string to_pointer_expression(uint32_t id, bool register_expression_read = true); std::string to_enclosed_pointer_expression(uint32_t id, bool register_expression_read = true); std::string to_extract_component_expression(uint32_t id, uint32_t index); std::string enclose_expression(const std::string &expr); std::string dereference_expression(const SPIRType &expression_type, const std::string &expr); std::string address_of_expression(const std::string &expr); void strip_enclosed_expression(std::string &expr); std::string to_member_name(const SPIRType &type, uint32_t index); virtual std::string to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool ptr_chain); std::string to_multi_member_reference(const SPIRType &type, const SmallVector &indices); std::string type_to_glsl_constructor(const SPIRType &type); std::string argument_decl(const SPIRFunction::Parameter &arg); virtual std::string to_qualifiers_glsl(uint32_t id); void fixup_io_block_patch_qualifiers(const SPIRVariable &var); void emit_output_variable_initializer(const SPIRVariable &var); const char *to_precision_qualifiers_glsl(uint32_t id); virtual const char *to_storage_qualifiers_glsl(const SPIRVariable &var); const char *flags_to_qualifiers_glsl(const SPIRType &type, const Bitset &flags); const char *format_to_glsl(spv::ImageFormat format); virtual std::string layout_for_member(const SPIRType &type, uint32_t index); virtual std::string to_interpolation_qualifiers(const Bitset &flags); std::string layout_for_variable(const SPIRVariable &variable); std::string to_combined_image_sampler(VariableID image_id, VariableID samp_id); virtual bool skip_argument(uint32_t id) const; virtual void emit_array_copy(const std::string &lhs, uint32_t rhs_id, spv::StorageClass lhs_storage, spv::StorageClass rhs_storage); virtual void emit_block_hints(const SPIRBlock &block); virtual std::string to_initializer_expression(const SPIRVariable &var); virtual std::string to_zero_initialized_expression(uint32_t type_id); bool type_can_zero_initialize(const SPIRType &type) const; bool buffer_is_packing_standard(const SPIRType &type, BufferPackingStandard packing, uint32_t *failed_index = nullptr, uint32_t start_offset = 0, uint32_t end_offset = ~(0u)); std::string buffer_to_packing_standard(const SPIRType &type, bool support_std430_without_scalar_layout); uint32_t type_to_packed_base_size(const SPIRType &type, BufferPackingStandard packing); uint32_t type_to_packed_alignment(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing); uint32_t type_to_packed_array_stride(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing); uint32_t type_to_packed_size(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing); std::string bitcast_glsl(const SPIRType &result_type, uint32_t arg); virtual std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type); std::string bitcast_expression(SPIRType::BaseType target_type, uint32_t arg); std::string bitcast_expression(const SPIRType &target_type, SPIRType::BaseType expr_type, const std::string &expr); std::string build_composite_combiner(uint32_t result_type, const uint32_t *elems, uint32_t length); bool remove_duplicate_swizzle(std::string &op); bool remove_unity_swizzle(uint32_t base, std::string &op); // Can modify flags to remote readonly/writeonly if image type // and force recompile. bool check_atomic_image(uint32_t id); virtual void replace_illegal_names(); void replace_illegal_names(const std::unordered_set &keywords); virtual void emit_entry_point_declarations(); void replace_fragment_output(SPIRVariable &var); void replace_fragment_outputs(); std::string legacy_tex_op(const std::string &op, const SPIRType &imgtype, uint32_t id); uint32_t indent = 0; std::unordered_set emitted_functions; // Ensure that we declare phi-variable copies even if the original declaration isn't deferred std::unordered_set flushed_phi_variables; std::unordered_set flattened_buffer_blocks; std::unordered_map flattened_structs; ShaderSubgroupSupportHelper shader_subgroup_supporter; std::string load_flattened_struct(const std::string &basename, const SPIRType &type); std::string to_flattened_struct_member(const std::string &basename, const SPIRType &type, uint32_t index); void store_flattened_struct(uint32_t lhs_id, uint32_t value); void store_flattened_struct(const std::string &basename, uint32_t rhs, const SPIRType &type, const SmallVector &indices); std::string to_flattened_access_chain_expression(uint32_t id); // Usage tracking. If a temporary is used more than once, use the temporary instead to // avoid AST explosion when SPIRV is generated with pure SSA and doesn't write stuff to variables. std::unordered_map expression_usage_counts; void track_expression_read(uint32_t id); SmallVector forced_extensions; SmallVector header_lines; // Used when expressions emit extra opcodes with their own unique IDs, // and we need to reuse the IDs across recompilation loops. // Currently used by NMin/Max/Clamp implementations. std::unordered_map extra_sub_expressions; SmallVector workaround_ubo_load_overload_types; void request_workaround_wrapper_overload(TypeID id); void rewrite_load_for_wrapped_row_major(std::string &expr, TypeID loaded_type, ID ptr); uint32_t statement_count = 0; inline bool is_legacy() const { return (options.es && options.version < 300) || (!options.es && options.version < 130); } inline bool is_legacy_es() const { return options.es && options.version < 300; } inline bool is_legacy_desktop() const { return !options.es && options.version < 130; } bool requires_transpose_2x2 = false; bool requires_transpose_3x3 = false; bool requires_transpose_4x4 = false; bool ray_tracing_is_khr = false; void ray_tracing_khr_fixup_locations(); bool args_will_forward(uint32_t id, const uint32_t *args, uint32_t num_args, bool pure); void register_call_out_argument(uint32_t id); void register_impure_function_call(); void register_control_dependent_expression(uint32_t expr); // GL_EXT_shader_pixel_local_storage support. std::vector pls_inputs; std::vector pls_outputs; std::string pls_decl(const PlsRemap &variable); const char *to_pls_qualifiers_glsl(const SPIRVariable &variable); void emit_pls(); void remap_pls_variables(); // GL_EXT_shader_framebuffer_fetch support. std::vector> subpass_to_framebuffer_fetch_attachment; std::unordered_set inout_color_attachments; bool subpass_input_is_framebuffer_fetch(uint32_t id) const; void emit_inout_fragment_outputs_copy_to_subpass_inputs(); const SPIRVariable *find_subpass_input_by_attachment_index(uint32_t index) const; const SPIRVariable *find_color_output_by_location(uint32_t location) const; // A variant which takes two sets of name. The secondary is only used to verify there are no collisions, // but the set is not updated when we have found a new name. // Used primarily when adding block interface names. void add_variable(std::unordered_set &variables_primary, const std::unordered_set &variables_secondary, std::string &name); void check_function_call_constraints(const uint32_t *args, uint32_t length); void handle_invalid_expression(uint32_t id); void find_static_extensions(); std::string emit_for_loop_initializers(const SPIRBlock &block); void emit_while_loop_initializers(const SPIRBlock &block); bool for_loop_initializers_are_same_type(const SPIRBlock &block); bool optimize_read_modify_write(const SPIRType &type, const std::string &lhs, const std::string &rhs); void fixup_image_load_store_access(); bool type_is_empty(const SPIRType &type); virtual void declare_undefined_values(); bool can_use_io_location(spv::StorageClass storage, bool block); const Instruction *get_next_instruction_in_block(const Instruction &instr); static uint32_t mask_relevant_memory_semantics(uint32_t semantics); std::string convert_half_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); std::string convert_float_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); std::string convert_double_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); std::string convert_separate_image_to_expression(uint32_t id); // Builtins in GLSL are always specific signedness, but the SPIR-V can declare them // as either unsigned or signed. // Sometimes we will need to automatically perform casts on load and store to make this work. virtual void cast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type); virtual void cast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type); void unroll_array_from_complex_load(uint32_t target_id, uint32_t source_id, std::string &expr); void convert_non_uniform_expression(const SPIRType &type, std::string &expr); void handle_store_to_invariant_variable(uint32_t store_id, uint32_t value_id); void disallow_forwarding_in_expression_chain(const SPIRExpression &expr); bool expression_is_constant_null(uint32_t id) const; bool expression_is_non_value_type_array(uint32_t ptr); virtual void emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression); uint32_t get_integer_width_for_instruction(const Instruction &instr) const; uint32_t get_integer_width_for_glsl_instruction(GLSLstd450 op, const uint32_t *arguments, uint32_t length) const; bool variable_is_lut(const SPIRVariable &var) const; char current_locale_radix_character = '.'; void fixup_type_alias(); void reorder_type_alias(); void propagate_nonuniform_qualifier(uint32_t id); static const char *vector_swizzle(int vecsize, int index); private: void init(); }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_hlsl.cpp000066400000000000000000005233441400026215700172760ustar00rootroot00000000000000/* * Copyright 2016-2021 Robert Konrad * * 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. * */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_hlsl.hpp" #include "GLSL.std.450.h" #include #include using namespace spv; using namespace SPIRV_CROSS_NAMESPACE; using namespace std; enum class ImageFormatNormalizedState { None = 0, Unorm = 1, Snorm = 2 }; static ImageFormatNormalizedState image_format_to_normalized_state(ImageFormat fmt) { switch (fmt) { case ImageFormatR8: case ImageFormatR16: case ImageFormatRg8: case ImageFormatRg16: case ImageFormatRgba8: case ImageFormatRgba16: case ImageFormatRgb10A2: return ImageFormatNormalizedState::Unorm; case ImageFormatR8Snorm: case ImageFormatR16Snorm: case ImageFormatRg8Snorm: case ImageFormatRg16Snorm: case ImageFormatRgba8Snorm: case ImageFormatRgba16Snorm: return ImageFormatNormalizedState::Snorm; default: break; } return ImageFormatNormalizedState::None; } static unsigned image_format_to_components(ImageFormat fmt) { switch (fmt) { case ImageFormatR8: case ImageFormatR16: case ImageFormatR8Snorm: case ImageFormatR16Snorm: case ImageFormatR16f: case ImageFormatR32f: case ImageFormatR8i: case ImageFormatR16i: case ImageFormatR32i: case ImageFormatR8ui: case ImageFormatR16ui: case ImageFormatR32ui: return 1; case ImageFormatRg8: case ImageFormatRg16: case ImageFormatRg8Snorm: case ImageFormatRg16Snorm: case ImageFormatRg16f: case ImageFormatRg32f: case ImageFormatRg8i: case ImageFormatRg16i: case ImageFormatRg32i: case ImageFormatRg8ui: case ImageFormatRg16ui: case ImageFormatRg32ui: return 2; case ImageFormatR11fG11fB10f: return 3; case ImageFormatRgba8: case ImageFormatRgba16: case ImageFormatRgb10A2: case ImageFormatRgba8Snorm: case ImageFormatRgba16Snorm: case ImageFormatRgba16f: case ImageFormatRgba32f: case ImageFormatRgba8i: case ImageFormatRgba16i: case ImageFormatRgba32i: case ImageFormatRgba8ui: case ImageFormatRgba16ui: case ImageFormatRgba32ui: case ImageFormatRgb10a2ui: return 4; case ImageFormatUnknown: return 4; // Assume 4. default: SPIRV_CROSS_THROW("Unrecognized typed image format."); } } static string image_format_to_type(ImageFormat fmt, SPIRType::BaseType basetype) { switch (fmt) { case ImageFormatR8: case ImageFormatR16: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "unorm float"; case ImageFormatRg8: case ImageFormatRg16: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "unorm float2"; case ImageFormatRgba8: case ImageFormatRgba16: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "unorm float4"; case ImageFormatRgb10A2: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "unorm float4"; case ImageFormatR8Snorm: case ImageFormatR16Snorm: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "snorm float"; case ImageFormatRg8Snorm: case ImageFormatRg16Snorm: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "snorm float2"; case ImageFormatRgba8Snorm: case ImageFormatRgba16Snorm: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "snorm float4"; case ImageFormatR16f: case ImageFormatR32f: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "float"; case ImageFormatRg16f: case ImageFormatRg32f: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "float2"; case ImageFormatRgba16f: case ImageFormatRgba32f: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "float4"; case ImageFormatR11fG11fB10f: if (basetype != SPIRType::Float) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "float3"; case ImageFormatR8i: case ImageFormatR16i: case ImageFormatR32i: if (basetype != SPIRType::Int) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "int"; case ImageFormatRg8i: case ImageFormatRg16i: case ImageFormatRg32i: if (basetype != SPIRType::Int) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "int2"; case ImageFormatRgba8i: case ImageFormatRgba16i: case ImageFormatRgba32i: if (basetype != SPIRType::Int) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "int4"; case ImageFormatR8ui: case ImageFormatR16ui: case ImageFormatR32ui: if (basetype != SPIRType::UInt) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "uint"; case ImageFormatRg8ui: case ImageFormatRg16ui: case ImageFormatRg32ui: if (basetype != SPIRType::UInt) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "uint2"; case ImageFormatRgba8ui: case ImageFormatRgba16ui: case ImageFormatRgba32ui: if (basetype != SPIRType::UInt) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "uint4"; case ImageFormatRgb10a2ui: if (basetype != SPIRType::UInt) SPIRV_CROSS_THROW("Mismatch in image type and base type of image."); return "uint4"; case ImageFormatUnknown: switch (basetype) { case SPIRType::Float: return "float4"; case SPIRType::Int: return "int4"; case SPIRType::UInt: return "uint4"; default: SPIRV_CROSS_THROW("Unsupported base type for image."); } default: SPIRV_CROSS_THROW("Unrecognized typed image format."); } } string CompilerHLSL::image_type_hlsl_modern(const SPIRType &type, uint32_t id) { auto &imagetype = get(type.image.type); const char *dim = nullptr; bool typed_load = false; uint32_t components = 4; bool force_image_srv = hlsl_options.nonwritable_uav_texture_as_srv && has_decoration(id, DecorationNonWritable); switch (type.image.dim) { case Dim1D: typed_load = type.image.sampled == 2; dim = "1D"; break; case Dim2D: typed_load = type.image.sampled == 2; dim = "2D"; break; case Dim3D: typed_load = type.image.sampled == 2; dim = "3D"; break; case DimCube: if (type.image.sampled == 2) SPIRV_CROSS_THROW("RWTextureCube does not exist in HLSL."); dim = "Cube"; break; case DimRect: SPIRV_CROSS_THROW("Rectangle texture support is not yet implemented for HLSL."); // TODO case DimBuffer: if (type.image.sampled == 1) return join("Buffer<", type_to_glsl(imagetype), components, ">"); else if (type.image.sampled == 2) { if (interlocked_resources.count(id)) return join("RasterizerOrderedBuffer<", image_format_to_type(type.image.format, imagetype.basetype), ">"); typed_load = !force_image_srv && type.image.sampled == 2; const char *rw = force_image_srv ? "" : "RW"; return join(rw, "Buffer<", typed_load ? image_format_to_type(type.image.format, imagetype.basetype) : join(type_to_glsl(imagetype), components), ">"); } else SPIRV_CROSS_THROW("Sampler buffers must be either sampled or unsampled. Cannot deduce in runtime."); case DimSubpassData: dim = "2D"; typed_load = false; break; default: SPIRV_CROSS_THROW("Invalid dimension."); } const char *arrayed = type.image.arrayed ? "Array" : ""; const char *ms = type.image.ms ? "MS" : ""; const char *rw = typed_load && !force_image_srv ? "RW" : ""; if (force_image_srv) typed_load = false; if (typed_load && interlocked_resources.count(id)) rw = "RasterizerOrdered"; return join(rw, "Texture", dim, ms, arrayed, "<", typed_load ? image_format_to_type(type.image.format, imagetype.basetype) : join(type_to_glsl(imagetype), components), ">"); } string CompilerHLSL::image_type_hlsl_legacy(const SPIRType &type, uint32_t /*id*/) { auto &imagetype = get(type.image.type); string res; switch (imagetype.basetype) { case SPIRType::Int: res = "i"; break; case SPIRType::UInt: res = "u"; break; default: break; } if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData) return res + "subpassInput" + (type.image.ms ? "MS" : ""); // If we're emulating subpassInput with samplers, force sampler2D // so we don't have to specify format. if (type.basetype == SPIRType::Image && type.image.dim != DimSubpassData) { // Sampler buffers are always declared as samplerBuffer even though they might be separate images in the SPIR-V. if (type.image.dim == DimBuffer && type.image.sampled == 1) res += "sampler"; else res += type.image.sampled == 2 ? "image" : "texture"; } else res += "sampler"; switch (type.image.dim) { case Dim1D: res += "1D"; break; case Dim2D: res += "2D"; break; case Dim3D: res += "3D"; break; case DimCube: res += "CUBE"; break; case DimBuffer: res += "Buffer"; break; case DimSubpassData: res += "2D"; break; default: SPIRV_CROSS_THROW("Only 1D, 2D, 3D, Buffer, InputTarget and Cube textures supported."); } if (type.image.ms) res += "MS"; if (type.image.arrayed) res += "Array"; return res; } string CompilerHLSL::image_type_hlsl(const SPIRType &type, uint32_t id) { if (hlsl_options.shader_model <= 30) return image_type_hlsl_legacy(type, id); else return image_type_hlsl_modern(type, id); } // The optional id parameter indicates the object whose type we are trying // to find the description for. It is optional. Most type descriptions do not // depend on a specific object's use of that type. string CompilerHLSL::type_to_glsl(const SPIRType &type, uint32_t id) { // Ignore the pointer type since GLSL doesn't have pointers. switch (type.basetype) { case SPIRType::Struct: // Need OpName lookup here to get a "sensible" name for a struct. if (backend.explicit_struct_type) return join("struct ", to_name(type.self)); else return to_name(type.self); case SPIRType::Image: case SPIRType::SampledImage: return image_type_hlsl(type, id); case SPIRType::Sampler: return comparison_ids.count(id) ? "SamplerComparisonState" : "SamplerState"; case SPIRType::Void: return "void"; default: break; } if (type.vecsize == 1 && type.columns == 1) // Scalar builtin { switch (type.basetype) { case SPIRType::Boolean: return "bool"; case SPIRType::Int: return backend.basic_int_type; case SPIRType::UInt: return backend.basic_uint_type; case SPIRType::AtomicCounter: return "atomic_uint"; case SPIRType::Half: if (hlsl_options.enable_16bit_types) return "half"; else return "min16float"; case SPIRType::Short: if (hlsl_options.enable_16bit_types) return "int16_t"; else return "min16int"; case SPIRType::UShort: if (hlsl_options.enable_16bit_types) return "uint16_t"; else return "min16uint"; case SPIRType::Float: return "float"; case SPIRType::Double: return "double"; case SPIRType::Int64: if (hlsl_options.shader_model < 60) SPIRV_CROSS_THROW("64-bit integers only supported in SM 6.0."); return "int64_t"; case SPIRType::UInt64: if (hlsl_options.shader_model < 60) SPIRV_CROSS_THROW("64-bit integers only supported in SM 6.0."); return "uint64_t"; default: return "???"; } } else if (type.vecsize > 1 && type.columns == 1) // Vector builtin { switch (type.basetype) { case SPIRType::Boolean: return join("bool", type.vecsize); case SPIRType::Int: return join("int", type.vecsize); case SPIRType::UInt: return join("uint", type.vecsize); case SPIRType::Half: return join(hlsl_options.enable_16bit_types ? "half" : "min16float", type.vecsize); case SPIRType::Short: return join(hlsl_options.enable_16bit_types ? "int16_t" : "min16int", type.vecsize); case SPIRType::UShort: return join(hlsl_options.enable_16bit_types ? "uint16_t" : "min16uint", type.vecsize); case SPIRType::Float: return join("float", type.vecsize); case SPIRType::Double: return join("double", type.vecsize); case SPIRType::Int64: return join("i64vec", type.vecsize); case SPIRType::UInt64: return join("u64vec", type.vecsize); default: return "???"; } } else { switch (type.basetype) { case SPIRType::Boolean: return join("bool", type.columns, "x", type.vecsize); case SPIRType::Int: return join("int", type.columns, "x", type.vecsize); case SPIRType::UInt: return join("uint", type.columns, "x", type.vecsize); case SPIRType::Half: return join(hlsl_options.enable_16bit_types ? "half" : "min16float", type.columns, "x", type.vecsize); case SPIRType::Short: return join(hlsl_options.enable_16bit_types ? "int16_t" : "min16int", type.columns, "x", type.vecsize); case SPIRType::UShort: return join(hlsl_options.enable_16bit_types ? "uint16_t" : "min16uint", type.columns, "x", type.vecsize); case SPIRType::Float: return join("float", type.columns, "x", type.vecsize); case SPIRType::Double: return join("double", type.columns, "x", type.vecsize); // Matrix types not supported for int64/uint64. default: return "???"; } } } void CompilerHLSL::emit_header() { for (auto &header : header_lines) statement(header); if (header_lines.size() > 0) { statement(""); } } void CompilerHLSL::emit_interface_block_globally(const SPIRVariable &var) { add_resource_name(var.self); // The global copies of I/O variables should not contain interpolation qualifiers. // These are emitted inside the interface structs. auto &flags = ir.meta[var.self].decoration.decoration_flags; auto old_flags = flags; flags.reset(); statement("static ", variable_decl(var), ";"); flags = old_flags; } const char *CompilerHLSL::to_storage_qualifiers_glsl(const SPIRVariable &var) { // Input and output variables are handled specially in HLSL backend. // The variables are declared as global, private variables, and do not need any qualifiers. if (var.storage == StorageClassUniformConstant || var.storage == StorageClassUniform || var.storage == StorageClassPushConstant) { return "uniform "; } return ""; } void CompilerHLSL::emit_builtin_outputs_in_struct() { auto &execution = get_entry_point(); bool legacy = hlsl_options.shader_model <= 30; active_output_builtins.for_each_bit([&](uint32_t i) { const char *type = nullptr; const char *semantic = nullptr; auto builtin = static_cast(i); switch (builtin) { case BuiltInPosition: type = "float4"; semantic = legacy ? "POSITION" : "SV_Position"; break; case BuiltInSampleMask: if (hlsl_options.shader_model < 41 || execution.model != ExecutionModelFragment) SPIRV_CROSS_THROW("Sample Mask output is only supported in PS 4.1 or higher."); type = "uint"; semantic = "SV_Coverage"; break; case BuiltInFragDepth: type = "float"; if (legacy) { semantic = "DEPTH"; } else { if (hlsl_options.shader_model >= 50 && execution.flags.get(ExecutionModeDepthGreater)) semantic = "SV_DepthGreaterEqual"; else if (hlsl_options.shader_model >= 50 && execution.flags.get(ExecutionModeDepthLess)) semantic = "SV_DepthLessEqual"; else semantic = "SV_Depth"; } break; case BuiltInClipDistance: // HLSL is a bit weird here, use SV_ClipDistance0, SV_ClipDistance1 and so on with vectors. for (uint32_t clip = 0; clip < clip_distance_count; clip += 4) { uint32_t to_declare = clip_distance_count - clip; if (to_declare > 4) to_declare = 4; uint32_t semantic_index = clip / 4; static const char *types[] = { "float", "float2", "float3", "float4" }; statement(types[to_declare - 1], " ", builtin_to_glsl(builtin, StorageClassOutput), semantic_index, " : SV_ClipDistance", semantic_index, ";"); } break; case BuiltInCullDistance: // HLSL is a bit weird here, use SV_CullDistance0, SV_CullDistance1 and so on with vectors. for (uint32_t cull = 0; cull < cull_distance_count; cull += 4) { uint32_t to_declare = cull_distance_count - cull; if (to_declare > 4) to_declare = 4; uint32_t semantic_index = cull / 4; static const char *types[] = { "float", "float2", "float3", "float4" }; statement(types[to_declare - 1], " ", builtin_to_glsl(builtin, StorageClassOutput), semantic_index, " : SV_CullDistance", semantic_index, ";"); } break; case BuiltInPointSize: // If point_size_compat is enabled, just ignore PointSize. // PointSize does not exist in HLSL, but some code bases might want to be able to use these shaders, // even if it means working around the missing feature. if (hlsl_options.point_size_compat) break; else SPIRV_CROSS_THROW("Unsupported builtin in HLSL."); default: SPIRV_CROSS_THROW("Unsupported builtin in HLSL."); break; } if (type && semantic) statement(type, " ", builtin_to_glsl(builtin, StorageClassOutput), " : ", semantic, ";"); }); } void CompilerHLSL::emit_builtin_inputs_in_struct() { bool legacy = hlsl_options.shader_model <= 30; active_input_builtins.for_each_bit([&](uint32_t i) { const char *type = nullptr; const char *semantic = nullptr; auto builtin = static_cast(i); switch (builtin) { case BuiltInFragCoord: type = "float4"; semantic = legacy ? "VPOS" : "SV_Position"; break; case BuiltInVertexId: case BuiltInVertexIndex: if (legacy) SPIRV_CROSS_THROW("Vertex index not supported in SM 3.0 or lower."); type = "uint"; semantic = "SV_VertexID"; break; case BuiltInInstanceId: case BuiltInInstanceIndex: if (legacy) SPIRV_CROSS_THROW("Instance index not supported in SM 3.0 or lower."); type = "uint"; semantic = "SV_InstanceID"; break; case BuiltInSampleId: if (legacy) SPIRV_CROSS_THROW("Sample ID not supported in SM 3.0 or lower."); type = "uint"; semantic = "SV_SampleIndex"; break; case BuiltInSampleMask: if (hlsl_options.shader_model < 50 || get_entry_point().model != ExecutionModelFragment) SPIRV_CROSS_THROW("Sample Mask input is only supported in PS 5.0 or higher."); type = "uint"; semantic = "SV_Coverage"; break; case BuiltInGlobalInvocationId: type = "uint3"; semantic = "SV_DispatchThreadID"; break; case BuiltInLocalInvocationId: type = "uint3"; semantic = "SV_GroupThreadID"; break; case BuiltInLocalInvocationIndex: type = "uint"; semantic = "SV_GroupIndex"; break; case BuiltInWorkgroupId: type = "uint3"; semantic = "SV_GroupID"; break; case BuiltInFrontFacing: type = "bool"; semantic = "SV_IsFrontFace"; break; case BuiltInNumWorkgroups: case BuiltInSubgroupSize: case BuiltInSubgroupLocalInvocationId: case BuiltInSubgroupEqMask: case BuiltInSubgroupLtMask: case BuiltInSubgroupLeMask: case BuiltInSubgroupGtMask: case BuiltInSubgroupGeMask: // Handled specially. break; case BuiltInClipDistance: // HLSL is a bit weird here, use SV_ClipDistance0, SV_ClipDistance1 and so on with vectors. for (uint32_t clip = 0; clip < clip_distance_count; clip += 4) { uint32_t to_declare = clip_distance_count - clip; if (to_declare > 4) to_declare = 4; uint32_t semantic_index = clip / 4; static const char *types[] = { "float", "float2", "float3", "float4" }; statement(types[to_declare - 1], " ", builtin_to_glsl(builtin, StorageClassInput), semantic_index, " : SV_ClipDistance", semantic_index, ";"); } break; case BuiltInCullDistance: // HLSL is a bit weird here, use SV_CullDistance0, SV_CullDistance1 and so on with vectors. for (uint32_t cull = 0; cull < cull_distance_count; cull += 4) { uint32_t to_declare = cull_distance_count - cull; if (to_declare > 4) to_declare = 4; uint32_t semantic_index = cull / 4; static const char *types[] = { "float", "float2", "float3", "float4" }; statement(types[to_declare - 1], " ", builtin_to_glsl(builtin, StorageClassInput), semantic_index, " : SV_CullDistance", semantic_index, ";"); } break; case BuiltInPointCoord: // PointCoord is not supported, but provide a way to just ignore that, similar to PointSize. if (hlsl_options.point_coord_compat) break; else SPIRV_CROSS_THROW("Unsupported builtin in HLSL."); default: SPIRV_CROSS_THROW("Unsupported builtin in HLSL."); break; } if (type && semantic) statement(type, " ", builtin_to_glsl(builtin, StorageClassInput), " : ", semantic, ";"); }); } uint32_t CompilerHLSL::type_to_consumed_locations(const SPIRType &type) const { // TODO: Need to verify correctness. uint32_t elements = 0; if (type.basetype == SPIRType::Struct) { for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++) elements += type_to_consumed_locations(get(type.member_types[i])); } else { uint32_t array_multiplier = 1; for (uint32_t i = 0; i < uint32_t(type.array.size()); i++) { if (type.array_size_literal[i]) array_multiplier *= type.array[i]; else array_multiplier *= evaluate_constant_u32(type.array[i]); } elements += array_multiplier * type.columns; } return elements; } string CompilerHLSL::to_interpolation_qualifiers(const Bitset &flags) { string res; //if (flags & (1ull << DecorationSmooth)) // res += "linear "; if (flags.get(DecorationFlat)) res += "nointerpolation "; if (flags.get(DecorationNoPerspective)) res += "noperspective "; if (flags.get(DecorationCentroid)) res += "centroid "; if (flags.get(DecorationPatch)) res += "patch "; // Seems to be different in actual HLSL. if (flags.get(DecorationSample)) res += "sample "; if (flags.get(DecorationInvariant)) res += "invariant "; // Not supported? return res; } std::string CompilerHLSL::to_semantic(uint32_t location, ExecutionModel em, StorageClass sc) { if (em == ExecutionModelVertex && sc == StorageClassInput) { // We have a vertex attribute - we should look at remapping it if the user provided // vertex attribute hints. for (auto &attribute : remap_vertex_attributes) if (attribute.location == location) return attribute.semantic; } // Not a vertex attribute, or no remap_vertex_attributes entry. return join("TEXCOORD", location); } std::string CompilerHLSL::to_initializer_expression(const SPIRVariable &var) { // We cannot emit static const initializer for block constants for practical reasons, // so just inline the initializer. // FIXME: There is a theoretical problem here if someone tries to composite extract // into this initializer since we don't declare it properly, but that is somewhat non-sensical. auto &type = get(var.basetype); bool is_block = has_decoration(type.self, DecorationBlock); auto *c = maybe_get(var.initializer); if (is_block && c) return constant_expression(*c); else return CompilerGLSL::to_initializer_expression(var); } void CompilerHLSL::emit_io_block(const SPIRVariable &var) { auto &execution = get_entry_point(); auto &type = get(var.basetype); add_resource_name(type.self); statement("struct ", to_name(type.self)); begin_scope(); type.member_name_cache.clear(); uint32_t base_location = get_decoration(var.self, DecorationLocation); for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++) { string semantic; if (has_member_decoration(type.self, i, DecorationLocation)) { uint32_t location = get_member_decoration(type.self, i, DecorationLocation); semantic = join(" : ", to_semantic(location, execution.model, var.storage)); } else { // If the block itself has a location, but not its members, use the implicit location. // There could be a conflict if the block members partially specialize the locations. // It is unclear how SPIR-V deals with this. Assume this does not happen for now. uint32_t location = base_location + i; semantic = join(" : ", to_semantic(location, execution.model, var.storage)); } add_member_name(type, i); auto &membertype = get(type.member_types[i]); statement(to_interpolation_qualifiers(get_member_decoration_bitset(type.self, i)), variable_decl(membertype, to_member_name(type, i)), semantic, ";"); } end_scope_decl(); statement(""); statement("static ", variable_decl(var), ";"); statement(""); } void CompilerHLSL::emit_interface_block_in_struct(const SPIRVariable &var, unordered_set &active_locations) { auto &execution = get_entry_point(); auto type = get(var.basetype); string binding; bool use_location_number = true; bool legacy = hlsl_options.shader_model <= 30; if (execution.model == ExecutionModelFragment && var.storage == StorageClassOutput) { // Dual-source blending is achieved in HLSL by emitting to SV_Target0 and 1. uint32_t index = get_decoration(var.self, DecorationIndex); uint32_t location = get_decoration(var.self, DecorationLocation); if (index != 0 && location != 0) SPIRV_CROSS_THROW("Dual-source blending is only supported on MRT #0 in HLSL."); binding = join(legacy ? "COLOR" : "SV_Target", location + index); use_location_number = false; if (legacy) // COLOR must be a four-component vector on legacy shader model targets (HLSL ERR_COLOR_4COMP) type.vecsize = 4; } const auto get_vacant_location = [&]() -> uint32_t { for (uint32_t i = 0; i < 64; i++) if (!active_locations.count(i)) return i; SPIRV_CROSS_THROW("All locations from 0 to 63 are exhausted."); }; bool need_matrix_unroll = var.storage == StorageClassInput && execution.model == ExecutionModelVertex; auto &m = ir.meta[var.self].decoration; auto name = to_name(var.self); if (use_location_number) { uint32_t location_number; // If an explicit location exists, use it with TEXCOORD[N] semantic. // Otherwise, pick a vacant location. if (m.decoration_flags.get(DecorationLocation)) location_number = m.location; else location_number = get_vacant_location(); // Allow semantic remap if specified. auto semantic = to_semantic(location_number, execution.model, var.storage); if (need_matrix_unroll && type.columns > 1) { if (!type.array.empty()) SPIRV_CROSS_THROW("Arrays of matrices used as input/output. This is not supported."); // Unroll matrices. for (uint32_t i = 0; i < type.columns; i++) { SPIRType newtype = type; newtype.columns = 1; string effective_semantic; if (hlsl_options.flatten_matrix_vertex_input_semantics) effective_semantic = to_semantic(location_number, execution.model, var.storage); else effective_semantic = join(semantic, "_", i); statement(to_interpolation_qualifiers(get_decoration_bitset(var.self)), variable_decl(newtype, join(name, "_", i)), " : ", effective_semantic, ";"); active_locations.insert(location_number++); } } else { statement(to_interpolation_qualifiers(get_decoration_bitset(var.self)), variable_decl(type, name), " : ", semantic, ";"); // Structs and arrays should consume more locations. uint32_t consumed_locations = type_to_consumed_locations(type); for (uint32_t i = 0; i < consumed_locations; i++) active_locations.insert(location_number + i); } } else statement(variable_decl(type, name), " : ", binding, ";"); } std::string CompilerHLSL::builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage) { switch (builtin) { case BuiltInVertexId: return "gl_VertexID"; case BuiltInInstanceId: return "gl_InstanceID"; case BuiltInNumWorkgroups: { if (!num_workgroups_builtin) SPIRV_CROSS_THROW("NumWorkgroups builtin is used, but remap_num_workgroups_builtin() was not called. " "Cannot emit code for this builtin."); auto &var = get(num_workgroups_builtin); auto &type = get(var.basetype); auto ret = join(to_name(num_workgroups_builtin), "_", get_member_name(type.self, 0)); ParsedIR::sanitize_underscores(ret); return ret; } case BuiltInPointCoord: // Crude hack, but there is no real alternative. This path is only enabled if point_coord_compat is set. return "float2(0.5f, 0.5f)"; case BuiltInSubgroupLocalInvocationId: return "WaveGetLaneIndex()"; case BuiltInSubgroupSize: return "WaveGetLaneCount()"; default: return CompilerGLSL::builtin_to_glsl(builtin, storage); } } void CompilerHLSL::emit_builtin_variables() { Bitset builtins = active_input_builtins; builtins.merge_or(active_output_builtins); bool need_base_vertex_info = false; std::unordered_map builtin_to_initializer; ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { if (!is_builtin_variable(var) || var.storage != StorageClassOutput || !var.initializer) return; auto *c = this->maybe_get(var.initializer); if (!c) return; auto &type = this->get(var.basetype); if (type.basetype == SPIRType::Struct) { uint32_t member_count = uint32_t(type.member_types.size()); for (uint32_t i = 0; i < member_count; i++) { if (has_member_decoration(type.self, i, DecorationBuiltIn)) { builtin_to_initializer[get_member_decoration(type.self, i, DecorationBuiltIn)] = c->subconstants[i]; } } } else if (has_decoration(var.self, DecorationBuiltIn)) builtin_to_initializer[get_decoration(var.self, DecorationBuiltIn)] = var.initializer; }); // Emit global variables for the interface variables which are statically used by the shader. builtins.for_each_bit([&](uint32_t i) { const char *type = nullptr; auto builtin = static_cast(i); uint32_t array_size = 0; string init_expr; auto init_itr = builtin_to_initializer.find(builtin); if (init_itr != builtin_to_initializer.end()) init_expr = join(" = ", to_expression(init_itr->second)); switch (builtin) { case BuiltInFragCoord: case BuiltInPosition: type = "float4"; break; case BuiltInFragDepth: type = "float"; break; case BuiltInVertexId: case BuiltInVertexIndex: case BuiltInInstanceIndex: type = "int"; if (hlsl_options.support_nonzero_base_vertex_base_instance) need_base_vertex_info = true; break; case BuiltInInstanceId: case BuiltInSampleId: type = "int"; break; case BuiltInPointSize: if (hlsl_options.point_size_compat) { // Just emit the global variable, it will be ignored. type = "float"; break; } else SPIRV_CROSS_THROW(join("Unsupported builtin in HLSL: ", unsigned(builtin))); case BuiltInGlobalInvocationId: case BuiltInLocalInvocationId: case BuiltInWorkgroupId: type = "uint3"; break; case BuiltInLocalInvocationIndex: type = "uint"; break; case BuiltInFrontFacing: type = "bool"; break; case BuiltInNumWorkgroups: case BuiltInPointCoord: // Handled specially. break; case BuiltInSubgroupLocalInvocationId: case BuiltInSubgroupSize: if (hlsl_options.shader_model < 60) SPIRV_CROSS_THROW("Need SM 6.0 for Wave ops."); break; case BuiltInSubgroupEqMask: case BuiltInSubgroupLtMask: case BuiltInSubgroupLeMask: case BuiltInSubgroupGtMask: case BuiltInSubgroupGeMask: if (hlsl_options.shader_model < 60) SPIRV_CROSS_THROW("Need SM 6.0 for Wave ops."); type = "uint4"; break; case BuiltInClipDistance: array_size = clip_distance_count; type = "float"; break; case BuiltInCullDistance: array_size = cull_distance_count; type = "float"; break; case BuiltInSampleMask: type = "int"; break; default: SPIRV_CROSS_THROW(join("Unsupported builtin in HLSL: ", unsigned(builtin))); } StorageClass storage = active_input_builtins.get(i) ? StorageClassInput : StorageClassOutput; if (type) { if (array_size) statement("static ", type, " ", builtin_to_glsl(builtin, storage), "[", array_size, "]", init_expr, ";"); else statement("static ", type, " ", builtin_to_glsl(builtin, storage), init_expr, ";"); } // SampleMask can be both in and out with sample builtin, in this case we have already // declared the input variable and we need to add the output one now. if (builtin == BuiltInSampleMask && storage == StorageClassInput && this->active_output_builtins.get(i)) { statement("static ", type, " ", this->builtin_to_glsl(builtin, StorageClassOutput), init_expr, ";"); } }); if (need_base_vertex_info) { statement("cbuffer SPIRV_Cross_VertexInfo"); begin_scope(); statement("int SPIRV_Cross_BaseVertex;"); statement("int SPIRV_Cross_BaseInstance;"); end_scope_decl(); statement(""); } } void CompilerHLSL::emit_composite_constants() { // HLSL cannot declare structs or arrays inline, so we must move them out to // global constants directly. bool emitted = false; ir.for_each_typed_id([&](uint32_t, SPIRConstant &c) { if (c.specialization) return; auto &type = this->get(c.constant_type); // Cannot declare block type constants here. // We do not have the struct type yet. bool is_block = has_decoration(type.self, DecorationBlock); if (!is_block && (type.basetype == SPIRType::Struct || !type.array.empty())) { auto name = to_name(c.self); statement("static const ", variable_decl(type, name), " = ", constant_expression(c), ";"); emitted = true; } }); if (emitted) statement(""); } void CompilerHLSL::emit_specialization_constants_and_structs() { bool emitted = false; SpecializationConstant wg_x, wg_y, wg_z; ID workgroup_size_id = get_work_group_size_specialization_constants(wg_x, wg_y, wg_z); auto loop_lock = ir.create_loop_hard_lock(); for (auto &id_ : ir.ids_for_constant_or_type) { auto &id = ir.ids[id_]; if (id.get_type() == TypeConstant) { auto &c = id.get(); if (c.self == workgroup_size_id) { statement("static const uint3 gl_WorkGroupSize = ", constant_expression(get(workgroup_size_id)), ";"); emitted = true; } else if (c.specialization) { auto &type = get(c.constant_type); auto name = to_name(c.self); // HLSL does not support specialization constants, so fallback to macros. c.specialization_constant_macro_name = constant_value_macro_name(get_decoration(c.self, DecorationSpecId)); statement("#ifndef ", c.specialization_constant_macro_name); statement("#define ", c.specialization_constant_macro_name, " ", constant_expression(c)); statement("#endif"); statement("static const ", variable_decl(type, name), " = ", c.specialization_constant_macro_name, ";"); emitted = true; } } else if (id.get_type() == TypeConstantOp) { auto &c = id.get(); auto &type = get(c.basetype); auto name = to_name(c.self); statement("static const ", variable_decl(type, name), " = ", constant_op_expression(c), ";"); emitted = true; } else if (id.get_type() == TypeType) { auto &type = id.get(); if (type.basetype == SPIRType::Struct && type.array.empty() && !type.pointer && (!ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) && !ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock))) { if (emitted) statement(""); emitted = false; emit_struct(type); } } } if (emitted) statement(""); } void CompilerHLSL::replace_illegal_names() { static const unordered_set keywords = { // Additional HLSL specific keywords. "line", "linear", "matrix", "point", "row_major", "sampler", }; CompilerGLSL::replace_illegal_names(keywords); CompilerGLSL::replace_illegal_names(); } void CompilerHLSL::declare_undefined_values() { bool emitted = false; ir.for_each_typed_id([&](uint32_t, const SPIRUndef &undef) { auto &type = this->get(undef.basetype); // OpUndef can be void for some reason ... if (type.basetype == SPIRType::Void) return; string initializer; if (options.force_zero_initialized_variables && type_can_zero_initialize(type)) initializer = join(" = ", to_zero_initialized_expression(undef.basetype)); statement("static ", variable_decl(type, to_name(undef.self), undef.self), initializer, ";"); emitted = true; }); if (emitted) statement(""); } void CompilerHLSL::emit_resources() { auto &execution = get_entry_point(); replace_illegal_names(); emit_specialization_constants_and_structs(); emit_composite_constants(); bool emitted = false; // Output UBOs and SSBOs ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool is_block_storage = type.storage == StorageClassStorageBuffer || type.storage == StorageClassUniform; bool has_block_flags = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) || ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock); if (var.storage != StorageClassFunction && type.pointer && is_block_storage && !is_hidden_variable(var) && has_block_flags) { emit_buffer_block(var); emitted = true; } }); // Output push constant blocks ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); if (var.storage != StorageClassFunction && type.pointer && type.storage == StorageClassPushConstant && !is_hidden_variable(var)) { emit_push_constant_block(var); emitted = true; } }); if (execution.model == ExecutionModelVertex && hlsl_options.shader_model <= 30) { statement("uniform float4 gl_HalfPixel;"); emitted = true; } bool skip_separate_image_sampler = !combined_image_samplers.empty() || hlsl_options.shader_model <= 30; // Output Uniform Constants (values, samplers, images, etc). ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); // If we're remapping separate samplers and images, only emit the combined samplers. if (skip_separate_image_sampler) { // Sampler buffers are always used without a sampler, and they will also work in regular D3D. bool sampler_buffer = type.basetype == SPIRType::Image && type.image.dim == DimBuffer; bool separate_image = type.basetype == SPIRType::Image && type.image.sampled == 1; bool separate_sampler = type.basetype == SPIRType::Sampler; if (!sampler_buffer && (separate_image || separate_sampler)) return; } if (var.storage != StorageClassFunction && !is_builtin_variable(var) && !var.remapped_variable && type.pointer && (type.storage == StorageClassUniformConstant || type.storage == StorageClassAtomicCounter)) { emit_uniform(var); emitted = true; } }); if (emitted) statement(""); emitted = false; // Emit builtin input and output variables here. emit_builtin_variables(); ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock); // Do not emit I/O blocks here. // I/O blocks can be arrayed, so we must deal with them separately to support geometry shaders // and tessellation down the line. if (!block && var.storage != StorageClassFunction && !var.remapped_variable && type.pointer && (var.storage == StorageClassInput || var.storage == StorageClassOutput) && !is_builtin_variable(var) && interface_variable_exists_in_entry_point(var.self)) { // Only emit non-builtins which are not blocks here. Builtin variables are handled separately. emit_interface_block_globally(var); emitted = true; } }); if (emitted) statement(""); emitted = false; require_input = false; require_output = false; unordered_set active_inputs; unordered_set active_outputs; SmallVector input_variables; SmallVector output_variables; ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock); if (var.storage != StorageClassInput && var.storage != StorageClassOutput) return; // Do not emit I/O blocks here. // I/O blocks can be arrayed, so we must deal with them separately to support geometry shaders // and tessellation down the line. if (!block && !var.remapped_variable && type.pointer && !is_builtin_variable(var) && interface_variable_exists_in_entry_point(var.self)) { if (var.storage == StorageClassInput) input_variables.push_back(&var); else output_variables.push_back(&var); } // Reserve input and output locations for block variables as necessary. if (block && !is_builtin_variable(var) && interface_variable_exists_in_entry_point(var.self)) { auto &active = var.storage == StorageClassInput ? active_inputs : active_outputs; for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++) { if (has_member_decoration(type.self, i, DecorationLocation)) { uint32_t location = get_member_decoration(type.self, i, DecorationLocation); active.insert(location); } } // Emit the block struct and a global variable here. emit_io_block(var); } }); const auto variable_compare = [&](const SPIRVariable *a, const SPIRVariable *b) -> bool { // Sort input and output variables based on, from more robust to less robust: // - Location // - Variable has a location // - Name comparison // - Variable has a name // - Fallback: ID bool has_location_a = has_decoration(a->self, DecorationLocation); bool has_location_b = has_decoration(b->self, DecorationLocation); if (has_location_a && has_location_b) { return get_decoration(a->self, DecorationLocation) < get_decoration(b->self, DecorationLocation); } else if (has_location_a && !has_location_b) return true; else if (!has_location_a && has_location_b) return false; const auto &name1 = to_name(a->self); const auto &name2 = to_name(b->self); if (name1.empty() && name2.empty()) return a->self < b->self; else if (name1.empty()) return true; else if (name2.empty()) return false; return name1.compare(name2) < 0; }; auto input_builtins = active_input_builtins; input_builtins.clear(BuiltInNumWorkgroups); input_builtins.clear(BuiltInPointCoord); input_builtins.clear(BuiltInSubgroupSize); input_builtins.clear(BuiltInSubgroupLocalInvocationId); input_builtins.clear(BuiltInSubgroupEqMask); input_builtins.clear(BuiltInSubgroupLtMask); input_builtins.clear(BuiltInSubgroupLeMask); input_builtins.clear(BuiltInSubgroupGtMask); input_builtins.clear(BuiltInSubgroupGeMask); if (!input_variables.empty() || !input_builtins.empty()) { require_input = true; statement("struct SPIRV_Cross_Input"); begin_scope(); sort(input_variables.begin(), input_variables.end(), variable_compare); for (auto var : input_variables) emit_interface_block_in_struct(*var, active_inputs); emit_builtin_inputs_in_struct(); end_scope_decl(); statement(""); } if (!output_variables.empty() || !active_output_builtins.empty()) { require_output = true; statement("struct SPIRV_Cross_Output"); begin_scope(); // FIXME: Use locations properly if they exist. sort(output_variables.begin(), output_variables.end(), variable_compare); for (auto var : output_variables) emit_interface_block_in_struct(*var, active_outputs); emit_builtin_outputs_in_struct(); end_scope_decl(); statement(""); } // Global variables. for (auto global : global_variables) { auto &var = get(global); if (var.storage != StorageClassOutput) { if (!variable_is_lut(var)) { add_resource_name(var.self); const char *storage = nullptr; switch (var.storage) { case StorageClassWorkgroup: storage = "groupshared"; break; default: storage = "static"; break; } string initializer; if (options.force_zero_initialized_variables && var.storage == StorageClassPrivate && !var.initializer && !var.static_expression && type_can_zero_initialize(get_variable_data_type(var))) { initializer = join(" = ", to_zero_initialized_expression(get_variable_data_type_id(var))); } statement(storage, " ", variable_decl(var), initializer, ";"); emitted = true; } } } if (emitted) statement(""); declare_undefined_values(); if (requires_op_fmod) { static const char *types[] = { "float", "float2", "float3", "float4", }; for (auto &type : types) { statement(type, " mod(", type, " x, ", type, " y)"); begin_scope(); statement("return x - y * floor(x / y);"); end_scope(); statement(""); } } emit_texture_size_variants(required_texture_size_variants.srv, "4", false, ""); for (uint32_t norm = 0; norm < 3; norm++) { for (uint32_t comp = 0; comp < 4; comp++) { static const char *qualifiers[] = { "", "unorm ", "snorm " }; static const char *vecsizes[] = { "", "2", "3", "4" }; emit_texture_size_variants(required_texture_size_variants.uav[norm][comp], vecsizes[comp], true, qualifiers[norm]); } } if (requires_fp16_packing) { // HLSL does not pack into a single word sadly :( statement("uint spvPackHalf2x16(float2 value)"); begin_scope(); statement("uint2 Packed = f32tof16(value);"); statement("return Packed.x | (Packed.y << 16);"); end_scope(); statement(""); statement("float2 spvUnpackHalf2x16(uint value)"); begin_scope(); statement("return f16tof32(uint2(value & 0xffff, value >> 16));"); end_scope(); statement(""); } if (requires_uint2_packing) { statement("uint64_t spvPackUint2x32(uint2 value)"); begin_scope(); statement("return (uint64_t(value.y) << 32) | uint64_t(value.x);"); end_scope(); statement(""); statement("uint2 spvUnpackUint2x32(uint64_t value)"); begin_scope(); statement("uint2 Unpacked;"); statement("Unpacked.x = uint(value & 0xffffffff);"); statement("Unpacked.y = uint(value >> 32);"); statement("return Unpacked;"); end_scope(); statement(""); } if (requires_explicit_fp16_packing) { // HLSL does not pack into a single word sadly :( statement("uint spvPackFloat2x16(min16float2 value)"); begin_scope(); statement("uint2 Packed = f32tof16(value);"); statement("return Packed.x | (Packed.y << 16);"); end_scope(); statement(""); statement("min16float2 spvUnpackFloat2x16(uint value)"); begin_scope(); statement("return min16float2(f16tof32(uint2(value & 0xffff, value >> 16)));"); end_scope(); statement(""); } // HLSL does not seem to have builtins for these operation, so roll them by hand ... if (requires_unorm8_packing) { statement("uint spvPackUnorm4x8(float4 value)"); begin_scope(); statement("uint4 Packed = uint4(round(saturate(value) * 255.0));"); statement("return Packed.x | (Packed.y << 8) | (Packed.z << 16) | (Packed.w << 24);"); end_scope(); statement(""); statement("float4 spvUnpackUnorm4x8(uint value)"); begin_scope(); statement("uint4 Packed = uint4(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, value >> 24);"); statement("return float4(Packed) / 255.0;"); end_scope(); statement(""); } if (requires_snorm8_packing) { statement("uint spvPackSnorm4x8(float4 value)"); begin_scope(); statement("int4 Packed = int4(round(clamp(value, -1.0, 1.0) * 127.0)) & 0xff;"); statement("return uint(Packed.x | (Packed.y << 8) | (Packed.z << 16) | (Packed.w << 24));"); end_scope(); statement(""); statement("float4 spvUnpackSnorm4x8(uint value)"); begin_scope(); statement("int SignedValue = int(value);"); statement("int4 Packed = int4(SignedValue << 24, SignedValue << 16, SignedValue << 8, SignedValue) >> 24;"); statement("return clamp(float4(Packed) / 127.0, -1.0, 1.0);"); end_scope(); statement(""); } if (requires_unorm16_packing) { statement("uint spvPackUnorm2x16(float2 value)"); begin_scope(); statement("uint2 Packed = uint2(round(saturate(value) * 65535.0));"); statement("return Packed.x | (Packed.y << 16);"); end_scope(); statement(""); statement("float2 spvUnpackUnorm2x16(uint value)"); begin_scope(); statement("uint2 Packed = uint2(value & 0xffff, value >> 16);"); statement("return float2(Packed) / 65535.0;"); end_scope(); statement(""); } if (requires_snorm16_packing) { statement("uint spvPackSnorm2x16(float2 value)"); begin_scope(); statement("int2 Packed = int2(round(clamp(value, -1.0, 1.0) * 32767.0)) & 0xffff;"); statement("return uint(Packed.x | (Packed.y << 16));"); end_scope(); statement(""); statement("float2 spvUnpackSnorm2x16(uint value)"); begin_scope(); statement("int SignedValue = int(value);"); statement("int2 Packed = int2(SignedValue << 16, SignedValue) >> 16;"); statement("return clamp(float2(Packed) / 32767.0, -1.0, 1.0);"); end_scope(); statement(""); } if (requires_bitfield_insert) { static const char *types[] = { "uint", "uint2", "uint3", "uint4" }; for (auto &type : types) { statement(type, " spvBitfieldInsert(", type, " Base, ", type, " Insert, uint Offset, uint Count)"); begin_scope(); statement("uint Mask = Count == 32 ? 0xffffffff : (((1u << Count) - 1) << (Offset & 31));"); statement("return (Base & ~Mask) | ((Insert << Offset) & Mask);"); end_scope(); statement(""); } } if (requires_bitfield_extract) { static const char *unsigned_types[] = { "uint", "uint2", "uint3", "uint4" }; for (auto &type : unsigned_types) { statement(type, " spvBitfieldUExtract(", type, " Base, uint Offset, uint Count)"); begin_scope(); statement("uint Mask = Count == 32 ? 0xffffffff : ((1 << Count) - 1);"); statement("return (Base >> Offset) & Mask;"); end_scope(); statement(""); } // In this overload, we will have to do sign-extension, which we will emulate by shifting up and down. static const char *signed_types[] = { "int", "int2", "int3", "int4" }; for (auto &type : signed_types) { statement(type, " spvBitfieldSExtract(", type, " Base, int Offset, int Count)"); begin_scope(); statement("int Mask = Count == 32 ? -1 : ((1 << Count) - 1);"); statement(type, " Masked = (Base >> Offset) & Mask;"); statement("int ExtendShift = (32 - Count) & 31;"); statement("return (Masked << ExtendShift) >> ExtendShift;"); end_scope(); statement(""); } } if (requires_inverse_2x2) { statement("// Returns the inverse of a matrix, by using the algorithm of calculating the classical"); statement("// adjoint and dividing by the determinant. The contents of the matrix are changed."); statement("float2x2 spvInverse(float2x2 m)"); begin_scope(); statement("float2x2 adj; // The adjoint matrix (inverse after dividing by determinant)"); statement_no_indent(""); statement("// Create the transpose of the cofactors, as the classical adjoint of the matrix."); statement("adj[0][0] = m[1][1];"); statement("adj[0][1] = -m[0][1];"); statement_no_indent(""); statement("adj[1][0] = -m[1][0];"); statement("adj[1][1] = m[0][0];"); statement_no_indent(""); statement("// Calculate the determinant as a combination of the cofactors of the first row."); statement("float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]);"); statement_no_indent(""); statement("// Divide the classical adjoint matrix by the determinant."); statement("// If determinant is zero, matrix is not invertable, so leave it unchanged."); statement("return (det != 0.0f) ? (adj * (1.0f / det)) : m;"); end_scope(); statement(""); } if (requires_inverse_3x3) { statement("// Returns the determinant of a 2x2 matrix."); statement("float spvDet2x2(float a1, float a2, float b1, float b2)"); begin_scope(); statement("return a1 * b2 - b1 * a2;"); end_scope(); statement_no_indent(""); statement("// Returns the inverse of a matrix, by using the algorithm of calculating the classical"); statement("// adjoint and dividing by the determinant. The contents of the matrix are changed."); statement("float3x3 spvInverse(float3x3 m)"); begin_scope(); statement("float3x3 adj; // The adjoint matrix (inverse after dividing by determinant)"); statement_no_indent(""); statement("// Create the transpose of the cofactors, as the classical adjoint of the matrix."); statement("adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]);"); statement("adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]);"); statement("adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]);"); statement_no_indent(""); statement("adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]);"); statement("adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]);"); statement("adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]);"); statement_no_indent(""); statement("adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]);"); statement("adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]);"); statement("adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]);"); statement_no_indent(""); statement("// Calculate the determinant as a combination of the cofactors of the first row."); statement("float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]);"); statement_no_indent(""); statement("// Divide the classical adjoint matrix by the determinant."); statement("// If determinant is zero, matrix is not invertable, so leave it unchanged."); statement("return (det != 0.0f) ? (adj * (1.0f / det)) : m;"); end_scope(); statement(""); } if (requires_inverse_4x4) { if (!requires_inverse_3x3) { statement("// Returns the determinant of a 2x2 matrix."); statement("float spvDet2x2(float a1, float a2, float b1, float b2)"); begin_scope(); statement("return a1 * b2 - b1 * a2;"); end_scope(); statement(""); } statement("// Returns the determinant of a 3x3 matrix."); statement("float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, " "float c2, float c3)"); begin_scope(); statement("return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * " "spvDet2x2(a2, a3, " "b2, b3);"); end_scope(); statement_no_indent(""); statement("// Returns the inverse of a matrix, by using the algorithm of calculating the classical"); statement("// adjoint and dividing by the determinant. The contents of the matrix are changed."); statement("float4x4 spvInverse(float4x4 m)"); begin_scope(); statement("float4x4 adj; // The adjoint matrix (inverse after dividing by determinant)"); statement_no_indent(""); statement("// Create the transpose of the cofactors, as the classical adjoint of the matrix."); statement( "adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], " "m[3][3]);"); statement( "adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], " "m[3][3]);"); statement( "adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], " "m[3][3]);"); statement( "adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], " "m[2][3]);"); statement_no_indent(""); statement( "adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], " "m[3][3]);"); statement( "adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], " "m[3][3]);"); statement( "adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], " "m[3][3]);"); statement( "adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], " "m[2][3]);"); statement_no_indent(""); statement( "adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], " "m[3][3]);"); statement( "adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], " "m[3][3]);"); statement( "adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], " "m[3][3]);"); statement( "adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], " "m[2][3]);"); statement_no_indent(""); statement( "adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], " "m[3][2]);"); statement( "adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], " "m[3][2]);"); statement( "adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], " "m[3][2]);"); statement( "adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], " "m[2][2]);"); statement_no_indent(""); statement("// Calculate the determinant as a combination of the cofactors of the first row."); statement("float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] " "* m[3][0]);"); statement_no_indent(""); statement("// Divide the classical adjoint matrix by the determinant."); statement("// If determinant is zero, matrix is not invertable, so leave it unchanged."); statement("return (det != 0.0f) ? (adj * (1.0f / det)) : m;"); end_scope(); statement(""); } if (requires_scalar_reflect) { // FP16/FP64? No templates in HLSL. statement("float spvReflect(float i, float n)"); begin_scope(); statement("return i - 2.0 * dot(n, i) * n;"); end_scope(); statement(""); } if (requires_scalar_refract) { // FP16/FP64? No templates in HLSL. statement("float spvRefract(float i, float n, float eta)"); begin_scope(); statement("float NoI = n * i;"); statement("float NoI2 = NoI * NoI;"); statement("float k = 1.0 - eta * eta * (1.0 - NoI2);"); statement("if (k < 0.0)"); begin_scope(); statement("return 0.0;"); end_scope(); statement("else"); begin_scope(); statement("return eta * i - (eta * NoI + sqrt(k)) * n;"); end_scope(); end_scope(); statement(""); } if (requires_scalar_faceforward) { // FP16/FP64? No templates in HLSL. statement("float spvFaceForward(float n, float i, float nref)"); begin_scope(); statement("return i * nref < 0.0 ? n : -n;"); end_scope(); statement(""); } } void CompilerHLSL::emit_texture_size_variants(uint64_t variant_mask, const char *vecsize_qualifier, bool uav, const char *type_qualifier) { if (variant_mask == 0) return; static const char *types[QueryTypeCount] = { "float", "int", "uint" }; static const char *dims[QueryDimCount] = { "Texture1D", "Texture1DArray", "Texture2D", "Texture2DArray", "Texture3D", "Buffer", "TextureCube", "TextureCubeArray", "Texture2DMS", "Texture2DMSArray" }; static const bool has_lod[QueryDimCount] = { true, true, true, true, true, false, true, true, false, false }; static const char *ret_types[QueryDimCount] = { "uint", "uint2", "uint2", "uint3", "uint3", "uint", "uint2", "uint3", "uint2", "uint3", }; static const uint32_t return_arguments[QueryDimCount] = { 1, 2, 2, 3, 3, 1, 2, 3, 2, 3, }; for (uint32_t index = 0; index < QueryDimCount; index++) { for (uint32_t type_index = 0; type_index < QueryTypeCount; type_index++) { uint32_t bit = 16 * type_index + index; uint64_t mask = 1ull << bit; if ((variant_mask & mask) == 0) continue; statement(ret_types[index], " spv", (uav ? "Image" : "Texture"), "Size(", (uav ? "RW" : ""), dims[index], "<", type_qualifier, types[type_index], vecsize_qualifier, "> Tex, ", (uav ? "" : "uint Level, "), "out uint Param)"); begin_scope(); statement(ret_types[index], " ret;"); switch (return_arguments[index]) { case 1: if (has_lod[index] && !uav) statement("Tex.GetDimensions(Level, ret.x, Param);"); else { statement("Tex.GetDimensions(ret.x);"); statement("Param = 0u;"); } break; case 2: if (has_lod[index] && !uav) statement("Tex.GetDimensions(Level, ret.x, ret.y, Param);"); else if (!uav) statement("Tex.GetDimensions(ret.x, ret.y, Param);"); else { statement("Tex.GetDimensions(ret.x, ret.y);"); statement("Param = 0u;"); } break; case 3: if (has_lod[index] && !uav) statement("Tex.GetDimensions(Level, ret.x, ret.y, ret.z, Param);"); else if (!uav) statement("Tex.GetDimensions(ret.x, ret.y, ret.z, Param);"); else { statement("Tex.GetDimensions(ret.x, ret.y, ret.z);"); statement("Param = 0u;"); } break; } statement("return ret;"); end_scope(); statement(""); } } } string CompilerHLSL::layout_for_member(const SPIRType &type, uint32_t index) { auto &flags = get_member_decoration_bitset(type.self, index); // HLSL can emit row_major or column_major decoration in any struct. // Do not try to merge combined decorations for children like in GLSL. // Flip the convention. HLSL is a bit odd in that the memory layout is column major ... but the language API is "row-major". // The way to deal with this is to multiply everything in inverse order, and reverse the memory layout. if (flags.get(DecorationColMajor)) return "row_major "; else if (flags.get(DecorationRowMajor)) return "column_major "; return ""; } void CompilerHLSL::emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const string &qualifier, uint32_t base_offset) { auto &membertype = get(member_type_id); Bitset memberflags; auto &memb = ir.meta[type.self].members; if (index < memb.size()) memberflags = memb[index].decoration_flags; string qualifiers; bool is_block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) || ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock); if (is_block) qualifiers = to_interpolation_qualifiers(memberflags); string packing_offset; bool is_push_constant = type.storage == StorageClassPushConstant; if ((has_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset) || is_push_constant) && has_member_decoration(type.self, index, DecorationOffset)) { uint32_t offset = memb[index].offset - base_offset; if (offset & 3) SPIRV_CROSS_THROW("Cannot pack on tighter bounds than 4 bytes in HLSL."); static const char *packing_swizzle[] = { "", ".y", ".z", ".w" }; packing_offset = join(" : packoffset(c", offset / 16, packing_swizzle[(offset & 15) >> 2], ")"); } statement(layout_for_member(type, index), qualifiers, qualifier, variable_decl(membertype, to_member_name(type, index)), packing_offset, ";"); } void CompilerHLSL::emit_buffer_block(const SPIRVariable &var) { auto &type = get(var.basetype); bool is_uav = var.storage == StorageClassStorageBuffer || has_decoration(type.self, DecorationBufferBlock); if (is_uav) { Bitset flags = ir.get_buffer_block_flags(var); bool is_readonly = flags.get(DecorationNonWritable) && !is_hlsl_force_storage_buffer_as_uav(var.self); bool is_coherent = flags.get(DecorationCoherent) && !is_readonly; bool is_interlocked = interlocked_resources.count(var.self) > 0; const char *type_name = "ByteAddressBuffer "; if (!is_readonly) type_name = is_interlocked ? "RasterizerOrderedByteAddressBuffer " : "RWByteAddressBuffer "; add_resource_name(var.self); statement(is_coherent ? "globallycoherent " : "", type_name, to_name(var.self), type_to_array_glsl(type), to_resource_binding(var), ";"); } else { if (type.array.empty()) { // Flatten the top-level struct so we can use packoffset, // this restriction is similar to GLSL where layout(offset) is not possible on sub-structs. flattened_structs[var.self] = false; // Prefer the block name if possible. auto buffer_name = to_name(type.self, false); if (ir.meta[type.self].decoration.alias.empty() || resource_names.find(buffer_name) != end(resource_names) || block_names.find(buffer_name) != end(block_names)) { buffer_name = get_block_fallback_name(var.self); } add_variable(block_names, resource_names, buffer_name); // If for some reason buffer_name is an illegal name, make a final fallback to a workaround name. // This cannot conflict with anything else, so we're safe now. if (buffer_name.empty()) buffer_name = join("_", get(var.basetype).self, "_", var.self); uint32_t failed_index = 0; if (buffer_is_packing_standard(type, BufferPackingHLSLCbufferPackOffset, &failed_index)) set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset); else { SPIRV_CROSS_THROW(join("cbuffer ID ", var.self, " (name: ", buffer_name, "), member index ", failed_index, " (name: ", to_member_name(type, failed_index), ") cannot be expressed with either HLSL packing layout or packoffset.")); } block_names.insert(buffer_name); // Save for post-reflection later. declared_block_names[var.self] = buffer_name; type.member_name_cache.clear(); // var.self can be used as a backup name for the block name, // so we need to make sure we don't disturb the name here on a recompile. // It will need to be reset if we have to recompile. preserve_alias_on_reset(var.self); add_resource_name(var.self); statement("cbuffer ", buffer_name, to_resource_binding(var)); begin_scope(); uint32_t i = 0; for (auto &member : type.member_types) { add_member_name(type, i); auto backup_name = get_member_name(type.self, i); auto member_name = to_member_name(type, i); member_name = join(to_name(var.self), "_", member_name); ParsedIR::sanitize_underscores(member_name); set_member_name(type.self, i, member_name); emit_struct_member(type, member, i, ""); set_member_name(type.self, i, backup_name); i++; } end_scope_decl(); statement(""); } else { if (hlsl_options.shader_model < 51) SPIRV_CROSS_THROW( "Need ConstantBuffer to use arrays of UBOs, but this is only supported in SM 5.1."); add_resource_name(type.self); add_resource_name(var.self); // ConstantBuffer does not support packoffset, so it is unuseable unless everything aligns as we expect. uint32_t failed_index = 0; if (!buffer_is_packing_standard(type, BufferPackingHLSLCbuffer, &failed_index)) { SPIRV_CROSS_THROW(join("HLSL ConstantBuffer ID ", var.self, " (name: ", to_name(type.self), "), member index ", failed_index, " (name: ", to_member_name(type, failed_index), ") cannot be expressed with normal HLSL packing rules.")); } emit_struct(get(type.self)); statement("ConstantBuffer<", to_name(type.self), "> ", to_name(var.self), type_to_array_glsl(type), to_resource_binding(var), ";"); } } } void CompilerHLSL::emit_push_constant_block(const SPIRVariable &var) { if (root_constants_layout.empty()) { emit_buffer_block(var); } else { for (const auto &layout : root_constants_layout) { auto &type = get(var.basetype); uint32_t failed_index = 0; if (buffer_is_packing_standard(type, BufferPackingHLSLCbufferPackOffset, &failed_index, layout.start, layout.end)) set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset); else { SPIRV_CROSS_THROW(join("Root constant cbuffer ID ", var.self, " (name: ", to_name(type.self), ")", ", member index ", failed_index, " (name: ", to_member_name(type, failed_index), ") cannot be expressed with either HLSL packing layout or packoffset.")); } flattened_structs[var.self] = false; type.member_name_cache.clear(); add_resource_name(var.self); auto &memb = ir.meta[type.self].members; statement("cbuffer SPIRV_CROSS_RootConstant_", to_name(var.self), to_resource_register(HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT, 'b', layout.binding, layout.space)); begin_scope(); // Index of the next field in the generated root constant constant buffer auto constant_index = 0u; // Iterate over all member of the push constant and check which of the fields // fit into the given root constant layout. for (auto i = 0u; i < memb.size(); i++) { const auto offset = memb[i].offset; if (layout.start <= offset && offset < layout.end) { const auto &member = type.member_types[i]; add_member_name(type, constant_index); auto backup_name = get_member_name(type.self, i); auto member_name = to_member_name(type, i); member_name = join(to_name(var.self), "_", member_name); ParsedIR::sanitize_underscores(member_name); set_member_name(type.self, constant_index, member_name); emit_struct_member(type, member, i, "", layout.start); set_member_name(type.self, constant_index, backup_name); constant_index++; } } end_scope_decl(); } } } string CompilerHLSL::to_sampler_expression(uint32_t id) { auto expr = join("_", to_expression(id)); auto index = expr.find_first_of('['); if (index == string::npos) { return expr + "_sampler"; } else { // We have an expression like _ident[array], so we cannot tack on _sampler, insert it inside the string instead. return expr.insert(index, "_sampler"); } } void CompilerHLSL::emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) { if (hlsl_options.shader_model >= 40 && combined_image_samplers.empty()) { set(result_id, result_type, image_id, samp_id); } else { // Make sure to suppress usage tracking. It is illegal to create temporaries of opaque types. emit_op(result_type, result_id, to_combined_image_sampler(image_id, samp_id), true, true); } } string CompilerHLSL::to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) { string arg_str = CompilerGLSL::to_func_call_arg(arg, id); if (hlsl_options.shader_model <= 30) return arg_str; // Manufacture automatic sampler arg if the arg is a SampledImage texture and we're in modern HLSL. auto &type = expression_type(id); // We don't have to consider combined image samplers here via OpSampledImage because // those variables cannot be passed as arguments to functions. // Only global SampledImage variables may be used as arguments. if (type.basetype == SPIRType::SampledImage && type.image.dim != DimBuffer) arg_str += ", " + to_sampler_expression(id); return arg_str; } void CompilerHLSL::emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) { if (func.self != ir.default_entry_point) add_function_overload(func); auto &execution = get_entry_point(); // Avoid shadow declarations. local_variable_names = resource_names; string decl; auto &type = get(func.return_type); if (type.array.empty()) { decl += flags_to_qualifiers_glsl(type, return_flags); decl += type_to_glsl(type); decl += " "; } else { // We cannot return arrays in HLSL, so "return" through an out variable. decl = "void "; } if (func.self == ir.default_entry_point) { if (execution.model == ExecutionModelVertex) decl += "vert_main"; else if (execution.model == ExecutionModelFragment) decl += "frag_main"; else if (execution.model == ExecutionModelGLCompute) decl += "comp_main"; else SPIRV_CROSS_THROW("Unsupported execution model."); processing_entry_point = true; } else decl += to_name(func.self); decl += "("; SmallVector arglist; if (!type.array.empty()) { // Fake array returns by writing to an out array instead. string out_argument; out_argument += "out "; out_argument += type_to_glsl(type); out_argument += " "; out_argument += "spvReturnValue"; out_argument += type_to_array_glsl(type); arglist.push_back(move(out_argument)); } for (auto &arg : func.arguments) { // Do not pass in separate images or samplers if we're remapping // to combined image samplers. if (skip_argument(arg.id)) continue; // Might change the variable name if it already exists in this function. // SPIRV OpName doesn't have any semantic effect, so it's valid for an implementation // to use same name for variables. // Since we want to make the GLSL debuggable and somewhat sane, use fallback names for variables which are duplicates. add_local_variable_name(arg.id); arglist.push_back(argument_decl(arg)); // Flatten a combined sampler to two separate arguments in modern HLSL. auto &arg_type = get(arg.type); if (hlsl_options.shader_model > 30 && arg_type.basetype == SPIRType::SampledImage && arg_type.image.dim != DimBuffer) { // Manufacture automatic sampler arg for SampledImage texture arglist.push_back(join(image_is_comparison(arg_type, arg.id) ? "SamplerComparisonState " : "SamplerState ", to_sampler_expression(arg.id), type_to_array_glsl(arg_type))); } // Hold a pointer to the parameter so we can invalidate the readonly field if needed. auto *var = maybe_get(arg.id); if (var) var->parameter = &arg; } for (auto &arg : func.shadow_arguments) { // Might change the variable name if it already exists in this function. // SPIRV OpName doesn't have any semantic effect, so it's valid for an implementation // to use same name for variables. // Since we want to make the GLSL debuggable and somewhat sane, use fallback names for variables which are duplicates. add_local_variable_name(arg.id); arglist.push_back(argument_decl(arg)); // Hold a pointer to the parameter so we can invalidate the readonly field if needed. auto *var = maybe_get(arg.id); if (var) var->parameter = &arg; } decl += merge(arglist); decl += ")"; statement(decl); } void CompilerHLSL::emit_hlsl_entry_point() { SmallVector arguments; if (require_input) arguments.push_back("SPIRV_Cross_Input stage_input"); // Add I/O blocks as separate arguments with appropriate storage qualifier. ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock); if (var.storage != StorageClassInput && var.storage != StorageClassOutput) return; if (block && !is_builtin_variable(var) && interface_variable_exists_in_entry_point(var.self)) { if (var.storage == StorageClassInput) { arguments.push_back(join("in ", variable_decl(type, join("stage_input", to_name(var.self))))); } else if (var.storage == StorageClassOutput) { arguments.push_back(join("out ", variable_decl(type, join("stage_output", to_name(var.self))))); } } }); auto &execution = get_entry_point(); switch (execution.model) { case ExecutionModelGLCompute: { SpecializationConstant wg_x, wg_y, wg_z; get_work_group_size_specialization_constants(wg_x, wg_y, wg_z); uint32_t x = execution.workgroup_size.x; uint32_t y = execution.workgroup_size.y; uint32_t z = execution.workgroup_size.z; auto x_expr = wg_x.id ? get(wg_x.id).specialization_constant_macro_name : to_string(x); auto y_expr = wg_y.id ? get(wg_y.id).specialization_constant_macro_name : to_string(y); auto z_expr = wg_z.id ? get(wg_z.id).specialization_constant_macro_name : to_string(z); statement("[numthreads(", x_expr, ", ", y_expr, ", ", z_expr, ")]"); break; } case ExecutionModelFragment: if (execution.flags.get(ExecutionModeEarlyFragmentTests)) statement("[earlydepthstencil]"); break; default: break; } statement(require_output ? "SPIRV_Cross_Output " : "void ", "main(", merge(arguments), ")"); begin_scope(); bool legacy = hlsl_options.shader_model <= 30; // Copy builtins from entry point arguments to globals. active_input_builtins.for_each_bit([&](uint32_t i) { auto builtin = builtin_to_glsl(static_cast(i), StorageClassInput); switch (static_cast(i)) { case BuiltInFragCoord: // VPOS in D3D9 is sampled at integer locations, apply half-pixel offset to be consistent. // TODO: Do we need an option here? Any reason why a D3D9 shader would be used // on a D3D10+ system with a different rasterization config? if (legacy) statement(builtin, " = stage_input.", builtin, " + float4(0.5f, 0.5f, 0.0f, 0.0f);"); else { statement(builtin, " = stage_input.", builtin, ";"); // ZW are undefined in D3D9, only do this fixup here. statement(builtin, ".w = 1.0 / ", builtin, ".w;"); } break; case BuiltInVertexId: case BuiltInVertexIndex: case BuiltInInstanceIndex: // D3D semantics are uint, but shader wants int. if (hlsl_options.support_nonzero_base_vertex_base_instance) { if (static_cast(i) == BuiltInInstanceIndex) statement(builtin, " = int(stage_input.", builtin, ") + SPIRV_Cross_BaseInstance;"); else statement(builtin, " = int(stage_input.", builtin, ") + SPIRV_Cross_BaseVertex;"); } else statement(builtin, " = int(stage_input.", builtin, ");"); break; case BuiltInInstanceId: // D3D semantics are uint, but shader wants int. statement(builtin, " = int(stage_input.", builtin, ");"); break; case BuiltInNumWorkgroups: case BuiltInPointCoord: case BuiltInSubgroupSize: case BuiltInSubgroupLocalInvocationId: break; case BuiltInSubgroupEqMask: // Emulate these ... // No 64-bit in HLSL, so have to do it in 32-bit and unroll. statement("gl_SubgroupEqMask = 1u << (WaveGetLaneIndex() - uint4(0, 32, 64, 96));"); statement("if (WaveGetLaneIndex() >= 32) gl_SubgroupEqMask.x = 0;"); statement("if (WaveGetLaneIndex() >= 64 || WaveGetLaneIndex() < 32) gl_SubgroupEqMask.y = 0;"); statement("if (WaveGetLaneIndex() >= 96 || WaveGetLaneIndex() < 64) gl_SubgroupEqMask.z = 0;"); statement("if (WaveGetLaneIndex() < 96) gl_SubgroupEqMask.w = 0;"); break; case BuiltInSubgroupGeMask: // Emulate these ... // No 64-bit in HLSL, so have to do it in 32-bit and unroll. statement("gl_SubgroupGeMask = ~((1u << (WaveGetLaneIndex() - uint4(0, 32, 64, 96))) - 1u);"); statement("if (WaveGetLaneIndex() >= 32) gl_SubgroupGeMask.x = 0u;"); statement("if (WaveGetLaneIndex() >= 64) gl_SubgroupGeMask.y = 0u;"); statement("if (WaveGetLaneIndex() >= 96) gl_SubgroupGeMask.z = 0u;"); statement("if (WaveGetLaneIndex() < 32) gl_SubgroupGeMask.y = ~0u;"); statement("if (WaveGetLaneIndex() < 64) gl_SubgroupGeMask.z = ~0u;"); statement("if (WaveGetLaneIndex() < 96) gl_SubgroupGeMask.w = ~0u;"); break; case BuiltInSubgroupGtMask: // Emulate these ... // No 64-bit in HLSL, so have to do it in 32-bit and unroll. statement("uint gt_lane_index = WaveGetLaneIndex() + 1;"); statement("gl_SubgroupGtMask = ~((1u << (gt_lane_index - uint4(0, 32, 64, 96))) - 1u);"); statement("if (gt_lane_index >= 32) gl_SubgroupGtMask.x = 0u;"); statement("if (gt_lane_index >= 64) gl_SubgroupGtMask.y = 0u;"); statement("if (gt_lane_index >= 96) gl_SubgroupGtMask.z = 0u;"); statement("if (gt_lane_index >= 128) gl_SubgroupGtMask.w = 0u;"); statement("if (gt_lane_index < 32) gl_SubgroupGtMask.y = ~0u;"); statement("if (gt_lane_index < 64) gl_SubgroupGtMask.z = ~0u;"); statement("if (gt_lane_index < 96) gl_SubgroupGtMask.w = ~0u;"); break; case BuiltInSubgroupLeMask: // Emulate these ... // No 64-bit in HLSL, so have to do it in 32-bit and unroll. statement("uint le_lane_index = WaveGetLaneIndex() + 1;"); statement("gl_SubgroupLeMask = (1u << (le_lane_index - uint4(0, 32, 64, 96))) - 1u;"); statement("if (le_lane_index >= 32) gl_SubgroupLeMask.x = ~0u;"); statement("if (le_lane_index >= 64) gl_SubgroupLeMask.y = ~0u;"); statement("if (le_lane_index >= 96) gl_SubgroupLeMask.z = ~0u;"); statement("if (le_lane_index >= 128) gl_SubgroupLeMask.w = ~0u;"); statement("if (le_lane_index < 32) gl_SubgroupLeMask.y = 0u;"); statement("if (le_lane_index < 64) gl_SubgroupLeMask.z = 0u;"); statement("if (le_lane_index < 96) gl_SubgroupLeMask.w = 0u;"); break; case BuiltInSubgroupLtMask: // Emulate these ... // No 64-bit in HLSL, so have to do it in 32-bit and unroll. statement("gl_SubgroupLtMask = (1u << (WaveGetLaneIndex() - uint4(0, 32, 64, 96))) - 1u;"); statement("if (WaveGetLaneIndex() >= 32) gl_SubgroupLtMask.x = ~0u;"); statement("if (WaveGetLaneIndex() >= 64) gl_SubgroupLtMask.y = ~0u;"); statement("if (WaveGetLaneIndex() >= 96) gl_SubgroupLtMask.z = ~0u;"); statement("if (WaveGetLaneIndex() < 32) gl_SubgroupLtMask.y = 0u;"); statement("if (WaveGetLaneIndex() < 64) gl_SubgroupLtMask.z = 0u;"); statement("if (WaveGetLaneIndex() < 96) gl_SubgroupLtMask.w = 0u;"); break; case BuiltInClipDistance: for (uint32_t clip = 0; clip < clip_distance_count; clip++) statement("gl_ClipDistance[", clip, "] = stage_input.gl_ClipDistance", clip / 4, ".", "xyzw"[clip & 3], ";"); break; case BuiltInCullDistance: for (uint32_t cull = 0; cull < cull_distance_count; cull++) statement("gl_CullDistance[", cull, "] = stage_input.gl_CullDistance", cull / 4, ".", "xyzw"[cull & 3], ";"); break; default: statement(builtin, " = stage_input.", builtin, ";"); break; } }); // Copy from stage input struct to globals. ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock); if (var.storage != StorageClassInput) return; bool need_matrix_unroll = var.storage == StorageClassInput && execution.model == ExecutionModelVertex; if (!block && !var.remapped_variable && type.pointer && !is_builtin_variable(var) && interface_variable_exists_in_entry_point(var.self)) { auto name = to_name(var.self); auto &mtype = this->get(var.basetype); if (need_matrix_unroll && mtype.columns > 1) { // Unroll matrices. for (uint32_t col = 0; col < mtype.columns; col++) statement(name, "[", col, "] = stage_input.", name, "_", col, ";"); } else { statement(name, " = stage_input.", name, ";"); } } // I/O blocks don't use the common stage input/output struct, but separate outputs. if (block && !is_builtin_variable(var) && interface_variable_exists_in_entry_point(var.self)) { auto name = to_name(var.self); statement(name, " = stage_input", name, ";"); } }); // Run the shader. if (execution.model == ExecutionModelVertex) statement("vert_main();"); else if (execution.model == ExecutionModelFragment) statement("frag_main();"); else if (execution.model == ExecutionModelGLCompute) statement("comp_main();"); else SPIRV_CROSS_THROW("Unsupported shader stage."); // Copy block outputs. ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock); if (var.storage != StorageClassOutput) return; // I/O blocks don't use the common stage input/output struct, but separate outputs. if (block && !is_builtin_variable(var) && interface_variable_exists_in_entry_point(var.self)) { auto name = to_name(var.self); statement("stage_output", name, " = ", name, ";"); } }); // Copy stage outputs. if (require_output) { statement("SPIRV_Cross_Output stage_output;"); // Copy builtins from globals to return struct. active_output_builtins.for_each_bit([&](uint32_t i) { // PointSize doesn't exist in HLSL. if (i == BuiltInPointSize) return; switch (static_cast(i)) { case BuiltInClipDistance: for (uint32_t clip = 0; clip < clip_distance_count; clip++) statement("stage_output.gl_ClipDistance", clip / 4, ".", "xyzw"[clip & 3], " = gl_ClipDistance[", clip, "];"); break; case BuiltInCullDistance: for (uint32_t cull = 0; cull < cull_distance_count; cull++) statement("stage_output.gl_CullDistance", cull / 4, ".", "xyzw"[cull & 3], " = gl_CullDistance[", cull, "];"); break; default: { auto builtin_expr = builtin_to_glsl(static_cast(i), StorageClassOutput); statement("stage_output.", builtin_expr, " = ", builtin_expr, ";"); break; } } }); ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = this->get(var.basetype); bool block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock); if (var.storage != StorageClassOutput) return; if (!block && var.storage != StorageClassFunction && !var.remapped_variable && type.pointer && !is_builtin_variable(var) && interface_variable_exists_in_entry_point(var.self)) { auto name = to_name(var.self); if (legacy && execution.model == ExecutionModelFragment) { string output_filler; for (uint32_t size = type.vecsize; size < 4; ++size) output_filler += ", 0.0"; statement("stage_output.", name, " = float4(", name, output_filler, ");"); } else { statement("stage_output.", name, " = ", name, ";"); } } }); statement("return stage_output;"); } end_scope(); } void CompilerHLSL::emit_fixup() { if (is_vertex_like_shader()) { // Do various mangling on the gl_Position. if (hlsl_options.shader_model <= 30) { statement("gl_Position.x = gl_Position.x - gl_HalfPixel.x * " "gl_Position.w;"); statement("gl_Position.y = gl_Position.y + gl_HalfPixel.y * " "gl_Position.w;"); } if (options.vertex.flip_vert_y) statement("gl_Position.y = -gl_Position.y;"); if (options.vertex.fixup_clipspace) statement("gl_Position.z = (gl_Position.z + gl_Position.w) * 0.5;"); } } void CompilerHLSL::emit_texture_op(const Instruction &i, bool sparse) { if (sparse) SPIRV_CROSS_THROW("Sparse feedback not yet supported in HLSL."); auto *ops = stream(i); auto op = static_cast(i.op); uint32_t length = i.length; SmallVector inherited_expressions; uint32_t result_type = ops[0]; uint32_t id = ops[1]; VariableID img = ops[2]; uint32_t coord = ops[3]; uint32_t dref = 0; uint32_t comp = 0; bool gather = false; bool proj = false; const uint32_t *opt = nullptr; auto *combined_image = maybe_get(img); auto img_expr = to_expression(combined_image ? combined_image->image : img); inherited_expressions.push_back(coord); // Make sure non-uniform decoration is back-propagated to where it needs to be. if (has_decoration(img, DecorationNonUniformEXT)) propagate_nonuniform_qualifier(img); switch (op) { case OpImageSampleDrefImplicitLod: case OpImageSampleDrefExplicitLod: dref = ops[4]; opt = &ops[5]; length -= 5; break; case OpImageSampleProjDrefImplicitLod: case OpImageSampleProjDrefExplicitLod: dref = ops[4]; proj = true; opt = &ops[5]; length -= 5; break; case OpImageDrefGather: dref = ops[4]; opt = &ops[5]; gather = true; length -= 5; break; case OpImageGather: comp = ops[4]; opt = &ops[5]; gather = true; length -= 5; break; case OpImageSampleProjImplicitLod: case OpImageSampleProjExplicitLod: opt = &ops[4]; length -= 4; proj = true; break; case OpImageQueryLod: opt = &ops[4]; length -= 4; break; default: opt = &ops[4]; length -= 4; break; } auto &imgtype = expression_type(img); uint32_t coord_components = 0; switch (imgtype.image.dim) { case spv::Dim1D: coord_components = 1; break; case spv::Dim2D: coord_components = 2; break; case spv::Dim3D: coord_components = 3; break; case spv::DimCube: coord_components = 3; break; case spv::DimBuffer: coord_components = 1; break; default: coord_components = 2; break; } if (dref) inherited_expressions.push_back(dref); if (imgtype.image.arrayed) coord_components++; uint32_t bias = 0; uint32_t lod = 0; uint32_t grad_x = 0; uint32_t grad_y = 0; uint32_t coffset = 0; uint32_t offset = 0; uint32_t coffsets = 0; uint32_t sample = 0; uint32_t minlod = 0; uint32_t flags = 0; if (length) { flags = opt[0]; opt++; length--; } auto test = [&](uint32_t &v, uint32_t flag) { if (length && (flags & flag)) { v = *opt++; inherited_expressions.push_back(v); length--; } }; test(bias, ImageOperandsBiasMask); test(lod, ImageOperandsLodMask); test(grad_x, ImageOperandsGradMask); test(grad_y, ImageOperandsGradMask); test(coffset, ImageOperandsConstOffsetMask); test(offset, ImageOperandsOffsetMask); test(coffsets, ImageOperandsConstOffsetsMask); test(sample, ImageOperandsSampleMask); test(minlod, ImageOperandsMinLodMask); string expr; string texop; if (minlod != 0) SPIRV_CROSS_THROW("MinLod texture operand not supported in HLSL."); if (op == OpImageFetch) { if (hlsl_options.shader_model < 40) { SPIRV_CROSS_THROW("texelFetch is not supported in HLSL shader model 2/3."); } texop += img_expr; texop += ".Load"; } else if (op == OpImageQueryLod) { texop += img_expr; texop += ".CalculateLevelOfDetail"; } else { auto &imgformat = get(imgtype.image.type); if (imgformat.basetype != SPIRType::Float) { SPIRV_CROSS_THROW("Sampling non-float textures is not supported in HLSL."); } if (hlsl_options.shader_model >= 40) { texop += img_expr; if (image_is_comparison(imgtype, img)) { if (gather) { SPIRV_CROSS_THROW("GatherCmp does not exist in HLSL."); } else if (lod || grad_x || grad_y) { // Assume we want a fixed level, and the only thing we can get in HLSL is SampleCmpLevelZero. texop += ".SampleCmpLevelZero"; } else texop += ".SampleCmp"; } else if (gather) { uint32_t comp_num = evaluate_constant_u32(comp); if (hlsl_options.shader_model >= 50) { switch (comp_num) { case 0: texop += ".GatherRed"; break; case 1: texop += ".GatherGreen"; break; case 2: texop += ".GatherBlue"; break; case 3: texop += ".GatherAlpha"; break; default: SPIRV_CROSS_THROW("Invalid component."); } } else { if (comp_num == 0) texop += ".Gather"; else SPIRV_CROSS_THROW("HLSL shader model 4 can only gather from the red component."); } } else if (bias) texop += ".SampleBias"; else if (grad_x || grad_y) texop += ".SampleGrad"; else if (lod) texop += ".SampleLevel"; else texop += ".Sample"; } else { switch (imgtype.image.dim) { case Dim1D: texop += "tex1D"; break; case Dim2D: texop += "tex2D"; break; case Dim3D: texop += "tex3D"; break; case DimCube: texop += "texCUBE"; break; case DimRect: case DimBuffer: case DimSubpassData: SPIRV_CROSS_THROW("Buffer texture support is not yet implemented for HLSL"); // TODO default: SPIRV_CROSS_THROW("Invalid dimension."); } if (gather) SPIRV_CROSS_THROW("textureGather is not supported in HLSL shader model 2/3."); if (offset || coffset) SPIRV_CROSS_THROW("textureOffset is not supported in HLSL shader model 2/3."); if (grad_x || grad_y) texop += "grad"; else if (lod) texop += "lod"; else if (bias) texop += "bias"; else if (proj || dref) texop += "proj"; } } expr += texop; expr += "("; if (hlsl_options.shader_model < 40) { if (combined_image) SPIRV_CROSS_THROW("Separate images/samplers are not supported in HLSL shader model 2/3."); expr += to_expression(img); } else if (op != OpImageFetch) { string sampler_expr; if (combined_image) sampler_expr = to_expression(combined_image->sampler); else sampler_expr = to_sampler_expression(img); expr += sampler_expr; } auto swizzle = [](uint32_t comps, uint32_t in_comps) -> const char * { if (comps == in_comps) return ""; switch (comps) { case 1: return ".x"; case 2: return ".xy"; case 3: return ".xyz"; default: return ""; } }; bool forward = should_forward(coord); // The IR can give us more components than we need, so chop them off as needed. string coord_expr; auto &coord_type = expression_type(coord); if (coord_components != coord_type.vecsize) coord_expr = to_enclosed_expression(coord) + swizzle(coord_components, expression_type(coord).vecsize); else coord_expr = to_expression(coord); if (proj && hlsl_options.shader_model >= 40) // Legacy HLSL has "proj" operations which do this for us. coord_expr = coord_expr + " / " + to_extract_component_expression(coord, coord_components); if (hlsl_options.shader_model < 40) { if (dref) { if (imgtype.image.dim != spv::Dim1D && imgtype.image.dim != spv::Dim2D) { SPIRV_CROSS_THROW( "Depth comparison is only supported for 1D and 2D textures in HLSL shader model 2/3."); } if (grad_x || grad_y) SPIRV_CROSS_THROW("Depth comparison is not supported for grad sampling in HLSL shader model 2/3."); for (uint32_t size = coord_components; size < 2; ++size) coord_expr += ", 0.0"; forward = forward && should_forward(dref); coord_expr += ", " + to_expression(dref); } else if (lod || bias || proj) { for (uint32_t size = coord_components; size < 3; ++size) coord_expr += ", 0.0"; } if (lod) { coord_expr = "float4(" + coord_expr + ", " + to_expression(lod) + ")"; } else if (bias) { coord_expr = "float4(" + coord_expr + ", " + to_expression(bias) + ")"; } else if (proj) { coord_expr = "float4(" + coord_expr + ", " + to_extract_component_expression(coord, coord_components) + ")"; } else if (dref) { // A "normal" sample gets fed into tex2Dproj as well, because the // regular tex2D accepts only two coordinates. coord_expr = "float4(" + coord_expr + ", 1.0)"; } if (!!lod + !!bias + !!proj > 1) SPIRV_CROSS_THROW("Legacy HLSL can only use one of lod/bias/proj modifiers."); } if (op == OpImageFetch) { if (imgtype.image.dim != DimBuffer && !imgtype.image.ms) coord_expr = join("int", coord_components + 1, "(", coord_expr, ", ", lod ? to_expression(lod) : string("0"), ")"); } else expr += ", "; expr += coord_expr; if (dref && hlsl_options.shader_model >= 40) { forward = forward && should_forward(dref); expr += ", "; if (proj) expr += to_enclosed_expression(dref) + " / " + to_extract_component_expression(coord, coord_components); else expr += to_expression(dref); } if (!dref && (grad_x || grad_y)) { forward = forward && should_forward(grad_x); forward = forward && should_forward(grad_y); expr += ", "; expr += to_expression(grad_x); expr += ", "; expr += to_expression(grad_y); } if (!dref && lod && hlsl_options.shader_model >= 40 && op != OpImageFetch) { forward = forward && should_forward(lod); expr += ", "; expr += to_expression(lod); } if (!dref && bias && hlsl_options.shader_model >= 40) { forward = forward && should_forward(bias); expr += ", "; expr += to_expression(bias); } if (coffset) { forward = forward && should_forward(coffset); expr += ", "; expr += to_expression(coffset); } else if (offset) { forward = forward && should_forward(offset); expr += ", "; expr += to_expression(offset); } if (sample) { expr += ", "; expr += to_expression(sample); } expr += ")"; if (dref && hlsl_options.shader_model < 40) expr += ".x"; if (op == OpImageQueryLod) { // This is rather awkward. // textureQueryLod returns two values, the "accessed level", // as well as the actual LOD lambda. // As far as I can tell, there is no way to get the .x component // according to GLSL spec, and it depends on the sampler itself. // Just assume X == Y, so we will need to splat the result to a float2. statement("float _", id, "_tmp = ", expr, ";"); statement("float2 _", id, " = _", id, "_tmp.xx;"); set(id, join("_", id), result_type, true); } else { emit_op(result_type, id, expr, forward, false); } for (auto &inherit : inherited_expressions) inherit_expression_dependencies(id, inherit); switch (op) { case OpImageSampleDrefImplicitLod: case OpImageSampleImplicitLod: case OpImageSampleProjImplicitLod: case OpImageSampleProjDrefImplicitLod: register_control_dependent_expression(id); break; default: break; } } string CompilerHLSL::to_resource_binding(const SPIRVariable &var) { const auto &type = get(var.basetype); // We can remap push constant blocks, even if they don't have any binding decoration. if (type.storage != StorageClassPushConstant && !has_decoration(var.self, DecorationBinding)) return ""; char space = '\0'; HLSLBindingFlagBits resource_flags = HLSL_BINDING_AUTO_NONE_BIT; switch (type.basetype) { case SPIRType::SampledImage: space = 't'; // SRV resource_flags = HLSL_BINDING_AUTO_SRV_BIT; break; case SPIRType::Image: if (type.image.sampled == 2 && type.image.dim != DimSubpassData) { if (has_decoration(var.self, DecorationNonWritable) && hlsl_options.nonwritable_uav_texture_as_srv) { space = 't'; // SRV resource_flags = HLSL_BINDING_AUTO_SRV_BIT; } else { space = 'u'; // UAV resource_flags = HLSL_BINDING_AUTO_UAV_BIT; } } else { space = 't'; // SRV resource_flags = HLSL_BINDING_AUTO_SRV_BIT; } break; case SPIRType::Sampler: space = 's'; resource_flags = HLSL_BINDING_AUTO_SAMPLER_BIT; break; case SPIRType::Struct: { auto storage = type.storage; if (storage == StorageClassUniform) { if (has_decoration(type.self, DecorationBufferBlock)) { Bitset flags = ir.get_buffer_block_flags(var); bool is_readonly = flags.get(DecorationNonWritable) && !is_hlsl_force_storage_buffer_as_uav(var.self); space = is_readonly ? 't' : 'u'; // UAV resource_flags = is_readonly ? HLSL_BINDING_AUTO_SRV_BIT : HLSL_BINDING_AUTO_UAV_BIT; } else if (has_decoration(type.self, DecorationBlock)) { space = 'b'; // Constant buffers resource_flags = HLSL_BINDING_AUTO_CBV_BIT; } } else if (storage == StorageClassPushConstant) { space = 'b'; // Constant buffers resource_flags = HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT; } else if (storage == StorageClassStorageBuffer) { // UAV or SRV depending on readonly flag. Bitset flags = ir.get_buffer_block_flags(var); bool is_readonly = flags.get(DecorationNonWritable) && !is_hlsl_force_storage_buffer_as_uav(var.self); space = is_readonly ? 't' : 'u'; resource_flags = is_readonly ? HLSL_BINDING_AUTO_SRV_BIT : HLSL_BINDING_AUTO_UAV_BIT; } break; } default: break; } if (!space) return ""; uint32_t desc_set = resource_flags == HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT ? ResourceBindingPushConstantDescriptorSet : 0u; uint32_t binding = resource_flags == HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT ? ResourceBindingPushConstantBinding : 0u; if (has_decoration(var.self, DecorationBinding)) binding = get_decoration(var.self, DecorationBinding); if (has_decoration(var.self, DecorationDescriptorSet)) desc_set = get_decoration(var.self, DecorationDescriptorSet); return to_resource_register(resource_flags, space, binding, desc_set); } string CompilerHLSL::to_resource_binding_sampler(const SPIRVariable &var) { // For combined image samplers. if (!has_decoration(var.self, DecorationBinding)) return ""; return to_resource_register(HLSL_BINDING_AUTO_SAMPLER_BIT, 's', get_decoration(var.self, DecorationBinding), get_decoration(var.self, DecorationDescriptorSet)); } void CompilerHLSL::remap_hlsl_resource_binding(HLSLBindingFlagBits type, uint32_t &desc_set, uint32_t &binding) { auto itr = resource_bindings.find({ get_execution_model(), desc_set, binding }); if (itr != end(resource_bindings)) { auto &remap = itr->second; remap.second = true; switch (type) { case HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT: case HLSL_BINDING_AUTO_CBV_BIT: desc_set = remap.first.cbv.register_space; binding = remap.first.cbv.register_binding; break; case HLSL_BINDING_AUTO_SRV_BIT: desc_set = remap.first.srv.register_space; binding = remap.first.srv.register_binding; break; case HLSL_BINDING_AUTO_SAMPLER_BIT: desc_set = remap.first.sampler.register_space; binding = remap.first.sampler.register_binding; break; case HLSL_BINDING_AUTO_UAV_BIT: desc_set = remap.first.uav.register_space; binding = remap.first.uav.register_binding; break; default: break; } } } string CompilerHLSL::to_resource_register(HLSLBindingFlagBits flag, char space, uint32_t binding, uint32_t space_set) { if ((flag & resource_binding_flags) == 0) { remap_hlsl_resource_binding(flag, space_set, binding); // The push constant block did not have a binding, and there were no remap for it, // so, declare without register binding. if (flag == HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT && space_set == ResourceBindingPushConstantDescriptorSet) return ""; if (hlsl_options.shader_model >= 51) return join(" : register(", space, binding, ", space", space_set, ")"); else return join(" : register(", space, binding, ")"); } else return ""; } void CompilerHLSL::emit_modern_uniform(const SPIRVariable &var) { auto &type = get(var.basetype); switch (type.basetype) { case SPIRType::SampledImage: case SPIRType::Image: { bool is_coherent = false; if (type.basetype == SPIRType::Image && type.image.sampled == 2) is_coherent = has_decoration(var.self, DecorationCoherent); statement(is_coherent ? "globallycoherent " : "", image_type_hlsl_modern(type, var.self), " ", to_name(var.self), type_to_array_glsl(type), to_resource_binding(var), ";"); if (type.basetype == SPIRType::SampledImage && type.image.dim != DimBuffer) { // For combined image samplers, also emit a combined image sampler. if (image_is_comparison(type, var.self)) statement("SamplerComparisonState ", to_sampler_expression(var.self), type_to_array_glsl(type), to_resource_binding_sampler(var), ";"); else statement("SamplerState ", to_sampler_expression(var.self), type_to_array_glsl(type), to_resource_binding_sampler(var), ";"); } break; } case SPIRType::Sampler: if (comparison_ids.count(var.self)) statement("SamplerComparisonState ", to_name(var.self), type_to_array_glsl(type), to_resource_binding(var), ";"); else statement("SamplerState ", to_name(var.self), type_to_array_glsl(type), to_resource_binding(var), ";"); break; default: statement(variable_decl(var), to_resource_binding(var), ";"); break; } } void CompilerHLSL::emit_legacy_uniform(const SPIRVariable &var) { auto &type = get(var.basetype); switch (type.basetype) { case SPIRType::Sampler: case SPIRType::Image: SPIRV_CROSS_THROW("Separate image and samplers not supported in legacy HLSL."); default: statement(variable_decl(var), ";"); break; } } void CompilerHLSL::emit_uniform(const SPIRVariable &var) { add_resource_name(var.self); if (hlsl_options.shader_model >= 40) emit_modern_uniform(var); else emit_legacy_uniform(var); } bool CompilerHLSL::emit_complex_bitcast(uint32_t, uint32_t, uint32_t) { return false; } string CompilerHLSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in_type) { if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Int) return type_to_glsl(out_type); else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Int64) return type_to_glsl(out_type); else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Float) return "asuint"; else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::UInt) return type_to_glsl(out_type); else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::UInt64) return type_to_glsl(out_type); else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::Float) return "asint"; else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::UInt) return "asfloat"; else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::Int) return "asfloat"; else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::Double) SPIRV_CROSS_THROW("Double to Int64 is not supported in HLSL."); else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Double) SPIRV_CROSS_THROW("Double to UInt64 is not supported in HLSL."); else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::Int64) return "asdouble"; else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::UInt64) return "asdouble"; else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UInt && in_type.vecsize == 1) { if (!requires_explicit_fp16_packing) { requires_explicit_fp16_packing = true; force_recompile(); } return "spvUnpackFloat2x16"; } else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Half && in_type.vecsize == 2) { if (!requires_explicit_fp16_packing) { requires_explicit_fp16_packing = true; force_recompile(); } return "spvPackFloat2x16"; } else return ""; } void CompilerHLSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t count) { auto op = static_cast(eop); // If we need to do implicit bitcasts, make sure we do it with the correct type. uint32_t integer_width = get_integer_width_for_glsl_instruction(op, args, count); auto int_type = to_signed_basetype(integer_width); auto uint_type = to_unsigned_basetype(integer_width); switch (op) { case GLSLstd450InverseSqrt: emit_unary_func_op(result_type, id, args[0], "rsqrt"); break; case GLSLstd450Fract: emit_unary_func_op(result_type, id, args[0], "frac"); break; case GLSLstd450RoundEven: if (hlsl_options.shader_model < 40) SPIRV_CROSS_THROW("roundEven is not supported in HLSL shader model 2/3."); emit_unary_func_op(result_type, id, args[0], "round"); break; case GLSLstd450Acosh: case GLSLstd450Asinh: case GLSLstd450Atanh: SPIRV_CROSS_THROW("Inverse hyperbolics are not supported on HLSL."); case GLSLstd450FMix: case GLSLstd450IMix: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "lerp"); break; case GLSLstd450Atan2: emit_binary_func_op(result_type, id, args[0], args[1], "atan2"); break; case GLSLstd450Fma: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "mad"); break; case GLSLstd450InterpolateAtCentroid: emit_unary_func_op(result_type, id, args[0], "EvaluateAttributeAtCentroid"); break; case GLSLstd450InterpolateAtSample: emit_binary_func_op(result_type, id, args[0], args[1], "EvaluateAttributeAtSample"); break; case GLSLstd450InterpolateAtOffset: emit_binary_func_op(result_type, id, args[0], args[1], "EvaluateAttributeSnapped"); break; case GLSLstd450PackHalf2x16: if (!requires_fp16_packing) { requires_fp16_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvPackHalf2x16"); break; case GLSLstd450UnpackHalf2x16: if (!requires_fp16_packing) { requires_fp16_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvUnpackHalf2x16"); break; case GLSLstd450PackSnorm4x8: if (!requires_snorm8_packing) { requires_snorm8_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvPackSnorm4x8"); break; case GLSLstd450UnpackSnorm4x8: if (!requires_snorm8_packing) { requires_snorm8_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvUnpackSnorm4x8"); break; case GLSLstd450PackUnorm4x8: if (!requires_unorm8_packing) { requires_unorm8_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvPackUnorm4x8"); break; case GLSLstd450UnpackUnorm4x8: if (!requires_unorm8_packing) { requires_unorm8_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvUnpackUnorm4x8"); break; case GLSLstd450PackSnorm2x16: if (!requires_snorm16_packing) { requires_snorm16_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvPackSnorm2x16"); break; case GLSLstd450UnpackSnorm2x16: if (!requires_snorm16_packing) { requires_snorm16_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvUnpackSnorm2x16"); break; case GLSLstd450PackUnorm2x16: if (!requires_unorm16_packing) { requires_unorm16_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvPackUnorm2x16"); break; case GLSLstd450UnpackUnorm2x16: if (!requires_unorm16_packing) { requires_unorm16_packing = true; force_recompile(); } emit_unary_func_op(result_type, id, args[0], "spvUnpackUnorm2x16"); break; case GLSLstd450PackDouble2x32: case GLSLstd450UnpackDouble2x32: SPIRV_CROSS_THROW("packDouble2x32/unpackDouble2x32 not supported in HLSL."); case GLSLstd450FindILsb: { auto basetype = expression_type(args[0]).basetype; emit_unary_func_op_cast(result_type, id, args[0], "firstbitlow", basetype, basetype); break; } case GLSLstd450FindSMsb: emit_unary_func_op_cast(result_type, id, args[0], "firstbithigh", int_type, int_type); break; case GLSLstd450FindUMsb: emit_unary_func_op_cast(result_type, id, args[0], "firstbithigh", uint_type, uint_type); break; case GLSLstd450MatrixInverse: { auto &type = get(result_type); if (type.vecsize == 2 && type.columns == 2) { if (!requires_inverse_2x2) { requires_inverse_2x2 = true; force_recompile(); } } else if (type.vecsize == 3 && type.columns == 3) { if (!requires_inverse_3x3) { requires_inverse_3x3 = true; force_recompile(); } } else if (type.vecsize == 4 && type.columns == 4) { if (!requires_inverse_4x4) { requires_inverse_4x4 = true; force_recompile(); } } emit_unary_func_op(result_type, id, args[0], "spvInverse"); break; } case GLSLstd450Normalize: // HLSL does not support scalar versions here. if (expression_type(args[0]).vecsize == 1) { // Returns -1 or 1 for valid input, sign() does the job. emit_unary_func_op(result_type, id, args[0], "sign"); } else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; case GLSLstd450Reflect: if (get(result_type).vecsize == 1) { if (!requires_scalar_reflect) { requires_scalar_reflect = true; force_recompile(); } emit_binary_func_op(result_type, id, args[0], args[1], "spvReflect"); } else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; case GLSLstd450Refract: if (get(result_type).vecsize == 1) { if (!requires_scalar_refract) { requires_scalar_refract = true; force_recompile(); } emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "spvRefract"); } else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; case GLSLstd450FaceForward: if (get(result_type).vecsize == 1) { if (!requires_scalar_faceforward) { requires_scalar_faceforward = true; force_recompile(); } emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "spvFaceForward"); } else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; default: CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; } } void CompilerHLSL::read_access_chain_array(const string &lhs, const SPIRAccessChain &chain) { auto &type = get(chain.basetype); // Need to use a reserved identifier here since it might shadow an identifier in the access chain input or other loops. auto ident = get_unique_identifier(); statement("[unroll]"); statement("for (int ", ident, " = 0; ", ident, " < ", to_array_size(type, uint32_t(type.array.size() - 1)), "; ", ident, "++)"); begin_scope(); auto subchain = chain; subchain.dynamic_index = join(ident, " * ", chain.array_stride, " + ", chain.dynamic_index); subchain.basetype = type.parent_type; if (!get(subchain.basetype).array.empty()) subchain.array_stride = get_decoration(subchain.basetype, DecorationArrayStride); read_access_chain(nullptr, join(lhs, "[", ident, "]"), subchain); end_scope(); } void CompilerHLSL::read_access_chain_struct(const string &lhs, const SPIRAccessChain &chain) { auto &type = get(chain.basetype); auto subchain = chain; uint32_t member_count = uint32_t(type.member_types.size()); for (uint32_t i = 0; i < member_count; i++) { uint32_t offset = type_struct_member_offset(type, i); subchain.static_index = chain.static_index + offset; subchain.basetype = type.member_types[i]; subchain.matrix_stride = 0; subchain.array_stride = 0; subchain.row_major_matrix = false; auto &member_type = get(subchain.basetype); if (member_type.columns > 1) { subchain.matrix_stride = type_struct_member_matrix_stride(type, i); subchain.row_major_matrix = has_member_decoration(type.self, i, DecorationRowMajor); } if (!member_type.array.empty()) subchain.array_stride = type_struct_member_array_stride(type, i); read_access_chain(nullptr, join(lhs, ".", to_member_name(type, i)), subchain); } } void CompilerHLSL::read_access_chain(string *expr, const string &lhs, const SPIRAccessChain &chain) { auto &type = get(chain.basetype); SPIRType target_type; target_type.basetype = SPIRType::UInt; target_type.vecsize = type.vecsize; target_type.columns = type.columns; if (!type.array.empty()) { read_access_chain_array(lhs, chain); return; } else if (type.basetype == SPIRType::Struct) { read_access_chain_struct(lhs, chain); return; } else if (type.width != 32 && !hlsl_options.enable_16bit_types) SPIRV_CROSS_THROW("Reading types other than 32-bit from ByteAddressBuffer not yet supported, unless SM 6.2 and " "native 16-bit types are enabled."); bool templated_load = hlsl_options.shader_model >= 62; string load_expr; string template_expr; if (templated_load) template_expr = join("<", type_to_glsl(type), ">"); // Load a vector or scalar. if (type.columns == 1 && !chain.row_major_matrix) { const char *load_op = nullptr; switch (type.vecsize) { case 1: load_op = "Load"; break; case 2: load_op = "Load2"; break; case 3: load_op = "Load3"; break; case 4: load_op = "Load4"; break; default: SPIRV_CROSS_THROW("Unknown vector size."); } if (templated_load) load_op = "Load"; load_expr = join(chain.base, ".", load_op, template_expr, "(", chain.dynamic_index, chain.static_index, ")"); } else if (type.columns == 1) { // Strided load since we are loading a column from a row-major matrix. if (templated_load) { auto scalar_type = type; scalar_type.vecsize = 1; scalar_type.columns = 1; template_expr = join("<", type_to_glsl(scalar_type), ">"); if (type.vecsize > 1) load_expr += type_to_glsl(type) + "("; } else if (type.vecsize > 1) { load_expr = type_to_glsl(target_type); load_expr += "("; } for (uint32_t r = 0; r < type.vecsize; r++) { load_expr += join(chain.base, ".Load", template_expr, "(", chain.dynamic_index, chain.static_index + r * chain.matrix_stride, ")"); if (r + 1 < type.vecsize) load_expr += ", "; } if (type.vecsize > 1) load_expr += ")"; } else if (!chain.row_major_matrix) { // Load a matrix, column-major, the easy case. const char *load_op = nullptr; switch (type.vecsize) { case 1: load_op = "Load"; break; case 2: load_op = "Load2"; break; case 3: load_op = "Load3"; break; case 4: load_op = "Load4"; break; default: SPIRV_CROSS_THROW("Unknown vector size."); } if (templated_load) { auto vector_type = type; vector_type.columns = 1; template_expr = join("<", type_to_glsl(vector_type), ">"); load_expr = type_to_glsl(type); load_op = "Load"; } else { // Note, this loading style in HLSL is *actually* row-major, but we always treat matrices as transposed in this backend, // so row-major is technically column-major ... load_expr = type_to_glsl(target_type); } load_expr += "("; for (uint32_t c = 0; c < type.columns; c++) { load_expr += join(chain.base, ".", load_op, template_expr, "(", chain.dynamic_index, chain.static_index + c * chain.matrix_stride, ")"); if (c + 1 < type.columns) load_expr += ", "; } load_expr += ")"; } else { // Pick out elements one by one ... Hopefully compilers are smart enough to recognize this pattern // considering HLSL is "row-major decl", but "column-major" memory layout (basically implicit transpose model, ugh) ... if (templated_load) { load_expr = type_to_glsl(type); auto scalar_type = type; scalar_type.vecsize = 1; scalar_type.columns = 1; template_expr = join("<", type_to_glsl(scalar_type), ">"); } else load_expr = type_to_glsl(target_type); load_expr += "("; for (uint32_t c = 0; c < type.columns; c++) { for (uint32_t r = 0; r < type.vecsize; r++) { load_expr += join(chain.base, ".Load", template_expr, "(", chain.dynamic_index, chain.static_index + c * (type.width / 8) + r * chain.matrix_stride, ")"); if ((r + 1 < type.vecsize) || (c + 1 < type.columns)) load_expr += ", "; } } load_expr += ")"; } if (!templated_load) { auto bitcast_op = bitcast_glsl_op(type, target_type); if (!bitcast_op.empty()) load_expr = join(bitcast_op, "(", load_expr, ")"); } if (lhs.empty()) { assert(expr); *expr = move(load_expr); } else statement(lhs, " = ", load_expr, ";"); } void CompilerHLSL::emit_load(const Instruction &instruction) { auto ops = stream(instruction); auto *chain = maybe_get(ops[2]); if (chain) { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t ptr = ops[2]; if (has_decoration(ptr, DecorationNonUniformEXT)) propagate_nonuniform_qualifier(ptr); auto &type = get(result_type); bool composite_load = !type.array.empty() || type.basetype == SPIRType::Struct; if (composite_load) { // We cannot make this work in one single expression as we might have nested structures and arrays, // so unroll the load to an uninitialized temporary. emit_uninitialized_temporary_expression(result_type, id); read_access_chain(nullptr, to_expression(id), *chain); track_expression_read(chain->self); } else { string load_expr; read_access_chain(&load_expr, "", *chain); bool forward = should_forward(ptr) && forced_temporaries.find(id) == end(forced_temporaries); // If we are forwarding this load, // don't register the read to access chain here, defer that to when we actually use the expression, // using the add_implied_read_expression mechanism. if (!forward) track_expression_read(chain->self); // Do not forward complex load sequences like matrices, structs and arrays. if (type.columns > 1) forward = false; auto &e = emit_op(result_type, id, load_expr, forward, true); e.need_transpose = false; register_read(id, ptr, forward); inherit_expression_dependencies(id, ptr); if (forward) add_implied_read_expression(e, chain->self); } } else CompilerGLSL::emit_instruction(instruction); } void CompilerHLSL::write_access_chain_array(const SPIRAccessChain &chain, uint32_t value, const SmallVector &composite_chain) { auto &type = get(chain.basetype); // Need to use a reserved identifier here since it might shadow an identifier in the access chain input or other loops. auto ident = get_unique_identifier(); uint32_t id = ir.increase_bound_by(2); uint32_t int_type_id = id + 1; SPIRType int_type; int_type.basetype = SPIRType::Int; int_type.width = 32; set(int_type_id, int_type); set(id, ident, int_type_id, true); set_name(id, ident); suppressed_usage_tracking.insert(id); statement("[unroll]"); statement("for (int ", ident, " = 0; ", ident, " < ", to_array_size(type, uint32_t(type.array.size() - 1)), "; ", ident, "++)"); begin_scope(); auto subchain = chain; subchain.dynamic_index = join(ident, " * ", chain.array_stride, " + ", chain.dynamic_index); subchain.basetype = type.parent_type; // Forcefully allow us to use an ID here by setting MSB. auto subcomposite_chain = composite_chain; subcomposite_chain.push_back(0x80000000u | id); if (!get(subchain.basetype).array.empty()) subchain.array_stride = get_decoration(subchain.basetype, DecorationArrayStride); write_access_chain(subchain, value, subcomposite_chain); end_scope(); } void CompilerHLSL::write_access_chain_struct(const SPIRAccessChain &chain, uint32_t value, const SmallVector &composite_chain) { auto &type = get(chain.basetype); uint32_t member_count = uint32_t(type.member_types.size()); auto subchain = chain; auto subcomposite_chain = composite_chain; subcomposite_chain.push_back(0); for (uint32_t i = 0; i < member_count; i++) { uint32_t offset = type_struct_member_offset(type, i); subchain.static_index = chain.static_index + offset; subchain.basetype = type.member_types[i]; subchain.matrix_stride = 0; subchain.array_stride = 0; subchain.row_major_matrix = false; auto &member_type = get(subchain.basetype); if (member_type.columns > 1) { subchain.matrix_stride = type_struct_member_matrix_stride(type, i); subchain.row_major_matrix = has_member_decoration(type.self, i, DecorationRowMajor); } if (!member_type.array.empty()) subchain.array_stride = type_struct_member_array_stride(type, i); subcomposite_chain.back() = i; write_access_chain(subchain, value, subcomposite_chain); } } string CompilerHLSL::write_access_chain_value(uint32_t value, const SmallVector &composite_chain, bool enclose) { string ret; if (composite_chain.empty()) ret = to_expression(value); else { AccessChainMeta meta; ret = access_chain_internal(value, composite_chain.data(), uint32_t(composite_chain.size()), ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_LITERAL_MSB_FORCE_ID, &meta); } if (enclose) ret = enclose_expression(ret); return ret; } void CompilerHLSL::write_access_chain(const SPIRAccessChain &chain, uint32_t value, const SmallVector &composite_chain) { auto &type = get(chain.basetype); // Make sure we trigger a read of the constituents in the access chain. track_expression_read(chain.self); if (has_decoration(chain.self, DecorationNonUniformEXT)) propagate_nonuniform_qualifier(chain.self); SPIRType target_type; target_type.basetype = SPIRType::UInt; target_type.vecsize = type.vecsize; target_type.columns = type.columns; if (!type.array.empty()) { write_access_chain_array(chain, value, composite_chain); register_write(chain.self); return; } else if (type.basetype == SPIRType::Struct) { write_access_chain_struct(chain, value, composite_chain); register_write(chain.self); return; } else if (type.width != 32 && !hlsl_options.enable_16bit_types) SPIRV_CROSS_THROW("Writing types other than 32-bit to RWByteAddressBuffer not yet supported, unless SM 6.2 and " "native 16-bit types are enabled."); bool templated_store = hlsl_options.shader_model >= 62; string template_expr; if (templated_store) template_expr = join("<", type_to_glsl(type), ">"); if (type.columns == 1 && !chain.row_major_matrix) { const char *store_op = nullptr; switch (type.vecsize) { case 1: store_op = "Store"; break; case 2: store_op = "Store2"; break; case 3: store_op = "Store3"; break; case 4: store_op = "Store4"; break; default: SPIRV_CROSS_THROW("Unknown vector size."); } auto store_expr = write_access_chain_value(value, composite_chain, false); if (!templated_store) { auto bitcast_op = bitcast_glsl_op(target_type, type); if (!bitcast_op.empty()) store_expr = join(bitcast_op, "(", store_expr, ")"); } else store_op = "Store"; statement(chain.base, ".", store_op, template_expr, "(", chain.dynamic_index, chain.static_index, ", ", store_expr, ");"); } else if (type.columns == 1) { if (templated_store) { auto scalar_type = type; scalar_type.vecsize = 1; scalar_type.columns = 1; template_expr = join("<", type_to_glsl(scalar_type), ">"); } // Strided store. for (uint32_t r = 0; r < type.vecsize; r++) { auto store_expr = write_access_chain_value(value, composite_chain, true); if (type.vecsize > 1) { store_expr += "."; store_expr += index_to_swizzle(r); } remove_duplicate_swizzle(store_expr); if (!templated_store) { auto bitcast_op = bitcast_glsl_op(target_type, type); if (!bitcast_op.empty()) store_expr = join(bitcast_op, "(", store_expr, ")"); } statement(chain.base, ".Store", template_expr, "(", chain.dynamic_index, chain.static_index + chain.matrix_stride * r, ", ", store_expr, ");"); } } else if (!chain.row_major_matrix) { const char *store_op = nullptr; switch (type.vecsize) { case 1: store_op = "Store"; break; case 2: store_op = "Store2"; break; case 3: store_op = "Store3"; break; case 4: store_op = "Store4"; break; default: SPIRV_CROSS_THROW("Unknown vector size."); } if (templated_store) { store_op = "Store"; auto vector_type = type; vector_type.columns = 1; template_expr = join("<", type_to_glsl(vector_type), ">"); } for (uint32_t c = 0; c < type.columns; c++) { auto store_expr = join(write_access_chain_value(value, composite_chain, true), "[", c, "]"); if (!templated_store) { auto bitcast_op = bitcast_glsl_op(target_type, type); if (!bitcast_op.empty()) store_expr = join(bitcast_op, "(", store_expr, ")"); } statement(chain.base, ".", store_op, template_expr, "(", chain.dynamic_index, chain.static_index + c * chain.matrix_stride, ", ", store_expr, ");"); } } else { if (templated_store) { auto scalar_type = type; scalar_type.vecsize = 1; scalar_type.columns = 1; template_expr = join("<", type_to_glsl(scalar_type), ">"); } for (uint32_t r = 0; r < type.vecsize; r++) { for (uint32_t c = 0; c < type.columns; c++) { auto store_expr = join(write_access_chain_value(value, composite_chain, true), "[", c, "].", index_to_swizzle(r)); remove_duplicate_swizzle(store_expr); auto bitcast_op = bitcast_glsl_op(target_type, type); if (!bitcast_op.empty()) store_expr = join(bitcast_op, "(", store_expr, ")"); statement(chain.base, ".Store", template_expr, "(", chain.dynamic_index, chain.static_index + c * (type.width / 8) + r * chain.matrix_stride, ", ", store_expr, ");"); } } } register_write(chain.self); } void CompilerHLSL::emit_store(const Instruction &instruction) { auto ops = stream(instruction); auto *chain = maybe_get(ops[0]); if (chain) write_access_chain(*chain, ops[1], {}); else CompilerGLSL::emit_instruction(instruction); } void CompilerHLSL::emit_access_chain(const Instruction &instruction) { auto ops = stream(instruction); uint32_t length = instruction.length; bool need_byte_access_chain = false; auto &type = expression_type(ops[2]); const auto *chain = maybe_get(ops[2]); if (chain) { // Keep tacking on an existing access chain. need_byte_access_chain = true; } else if (type.storage == StorageClassStorageBuffer || has_decoration(type.self, DecorationBufferBlock)) { // If we are starting to poke into an SSBO, we are dealing with ByteAddressBuffers, and we need // to emit SPIRAccessChain rather than a plain SPIRExpression. uint32_t chain_arguments = length - 3; if (chain_arguments > type.array.size()) need_byte_access_chain = true; } if (need_byte_access_chain) { // If we have a chain variable, we are already inside the SSBO, and any array type will refer to arrays within a block, // and not array of SSBO. uint32_t to_plain_buffer_length = chain ? 0u : static_cast(type.array.size()); auto *backing_variable = maybe_get_backing_variable(ops[2]); string base; if (to_plain_buffer_length != 0) base = access_chain(ops[2], &ops[3], to_plain_buffer_length, get(ops[0])); else if (chain) base = chain->base; else base = to_expression(ops[2]); // Start traversing type hierarchy at the proper non-pointer types. auto *basetype = &get_pointee_type(type); // Traverse the type hierarchy down to the actual buffer types. for (uint32_t i = 0; i < to_plain_buffer_length; i++) { assert(basetype->parent_type); basetype = &get(basetype->parent_type); } uint32_t matrix_stride = 0; uint32_t array_stride = 0; bool row_major_matrix = false; // Inherit matrix information. if (chain) { matrix_stride = chain->matrix_stride; row_major_matrix = chain->row_major_matrix; array_stride = chain->array_stride; } auto offsets = flattened_access_chain_offset(*basetype, &ops[3 + to_plain_buffer_length], length - 3 - to_plain_buffer_length, 0, 1, &row_major_matrix, &matrix_stride, &array_stride); auto &e = set(ops[1], ops[0], type.storage, base, offsets.first, offsets.second); e.row_major_matrix = row_major_matrix; e.matrix_stride = matrix_stride; e.array_stride = array_stride; e.immutable = should_forward(ops[2]); e.loaded_from = backing_variable ? backing_variable->self : ID(0); if (chain) { e.dynamic_index += chain->dynamic_index; e.static_index += chain->static_index; } for (uint32_t i = 2; i < length; i++) { inherit_expression_dependencies(ops[1], ops[i]); add_implied_read_expression(e, ops[i]); } if (has_decoration(ops[1], DecorationNonUniformEXT)) propagate_nonuniform_qualifier(ops[1]); } else { CompilerGLSL::emit_instruction(instruction); } } void CompilerHLSL::emit_atomic(const uint32_t *ops, uint32_t length, spv::Op op) { const char *atomic_op = nullptr; string value_expr; if (op != OpAtomicIDecrement && op != OpAtomicIIncrement && op != OpAtomicLoad && op != OpAtomicStore) value_expr = to_expression(ops[op == OpAtomicCompareExchange ? 6 : 5]); bool is_atomic_store = false; switch (op) { case OpAtomicIIncrement: atomic_op = "InterlockedAdd"; value_expr = "1"; break; case OpAtomicIDecrement: atomic_op = "InterlockedAdd"; value_expr = "-1"; break; case OpAtomicLoad: atomic_op = "InterlockedAdd"; value_expr = "0"; break; case OpAtomicISub: atomic_op = "InterlockedAdd"; value_expr = join("-", enclose_expression(value_expr)); break; case OpAtomicSMin: case OpAtomicUMin: atomic_op = "InterlockedMin"; break; case OpAtomicSMax: case OpAtomicUMax: atomic_op = "InterlockedMax"; break; case OpAtomicAnd: atomic_op = "InterlockedAnd"; break; case OpAtomicOr: atomic_op = "InterlockedOr"; break; case OpAtomicXor: atomic_op = "InterlockedXor"; break; case OpAtomicIAdd: atomic_op = "InterlockedAdd"; break; case OpAtomicExchange: atomic_op = "InterlockedExchange"; break; case OpAtomicStore: atomic_op = "InterlockedExchange"; is_atomic_store = true; break; case OpAtomicCompareExchange: if (length < 8) SPIRV_CROSS_THROW("Not enough data for opcode."); atomic_op = "InterlockedCompareExchange"; value_expr = join(to_expression(ops[7]), ", ", value_expr); break; default: SPIRV_CROSS_THROW("Unknown atomic opcode."); } if (is_atomic_store) { auto &data_type = expression_type(ops[0]); auto *chain = maybe_get(ops[0]); auto &tmp_id = extra_sub_expressions[ops[0]]; if (!tmp_id) { tmp_id = ir.increase_bound_by(1); emit_uninitialized_temporary_expression(get_pointee_type(data_type).self, tmp_id); } if (data_type.storage == StorageClassImage || !chain) { statement(atomic_op, "(", to_expression(ops[0]), ", ", to_expression(ops[3]), ", ", to_expression(tmp_id), ");"); } else { // RWByteAddress buffer is always uint in its underlying type. statement(chain->base, ".", atomic_op, "(", chain->dynamic_index, chain->static_index, ", ", to_expression(ops[3]), ", ", to_expression(tmp_id), ");"); } } else { uint32_t result_type = ops[0]; uint32_t id = ops[1]; forced_temporaries.insert(ops[1]); auto &type = get(result_type); statement(variable_decl(type, to_name(id)), ";"); auto &data_type = expression_type(ops[2]); auto *chain = maybe_get(ops[2]); SPIRType::BaseType expr_type; if (data_type.storage == StorageClassImage || !chain) { statement(atomic_op, "(", to_expression(ops[2]), ", ", value_expr, ", ", to_name(id), ");"); expr_type = data_type.basetype; } else { // RWByteAddress buffer is always uint in its underlying type. expr_type = SPIRType::UInt; statement(chain->base, ".", atomic_op, "(", chain->dynamic_index, chain->static_index, ", ", value_expr, ", ", to_name(id), ");"); } auto expr = bitcast_expression(type, expr_type, to_name(id)); set(id, expr, result_type, true); } flush_all_atomic_capable_variables(); } void CompilerHLSL::emit_subgroup_op(const Instruction &i) { if (hlsl_options.shader_model < 60) SPIRV_CROSS_THROW("Wave ops requires SM 6.0 or higher."); const uint32_t *ops = stream(i); auto op = static_cast(i.op); uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto scope = static_cast(evaluate_constant_u32(ops[2])); if (scope != ScopeSubgroup) SPIRV_CROSS_THROW("Only subgroup scope is supported."); const auto make_inclusive_Sum = [&](const string &expr) -> string { return join(expr, " + ", to_expression(ops[4])); }; const auto make_inclusive_Product = [&](const string &expr) -> string { return join(expr, " * ", to_expression(ops[4])); }; // If we need to do implicit bitcasts, make sure we do it with the correct type. uint32_t integer_width = get_integer_width_for_instruction(i); auto int_type = to_signed_basetype(integer_width); auto uint_type = to_unsigned_basetype(integer_width); #define make_inclusive_BitAnd(expr) "" #define make_inclusive_BitOr(expr) "" #define make_inclusive_BitXor(expr) "" #define make_inclusive_Min(expr) "" #define make_inclusive_Max(expr) "" switch (op) { case OpGroupNonUniformElect: emit_op(result_type, id, "WaveIsFirstLane()", true); break; case OpGroupNonUniformBroadcast: emit_binary_func_op(result_type, id, ops[3], ops[4], "WaveReadLaneAt"); break; case OpGroupNonUniformBroadcastFirst: emit_unary_func_op(result_type, id, ops[3], "WaveReadLaneFirst"); break; case OpGroupNonUniformBallot: emit_unary_func_op(result_type, id, ops[3], "WaveActiveBallot"); break; case OpGroupNonUniformInverseBallot: SPIRV_CROSS_THROW("Cannot trivially implement InverseBallot in HLSL."); break; case OpGroupNonUniformBallotBitExtract: SPIRV_CROSS_THROW("Cannot trivially implement BallotBitExtract in HLSL."); break; case OpGroupNonUniformBallotFindLSB: SPIRV_CROSS_THROW("Cannot trivially implement BallotFindLSB in HLSL."); break; case OpGroupNonUniformBallotFindMSB: SPIRV_CROSS_THROW("Cannot trivially implement BallotFindMSB in HLSL."); break; case OpGroupNonUniformBallotBitCount: { auto operation = static_cast(ops[3]); if (operation == GroupOperationReduce) { bool forward = should_forward(ops[4]); auto left = join("countbits(", to_enclosed_expression(ops[4]), ".x) + countbits(", to_enclosed_expression(ops[4]), ".y)"); auto right = join("countbits(", to_enclosed_expression(ops[4]), ".z) + countbits(", to_enclosed_expression(ops[4]), ".w)"); emit_op(result_type, id, join(left, " + ", right), forward); inherit_expression_dependencies(id, ops[4]); } else if (operation == GroupOperationInclusiveScan) SPIRV_CROSS_THROW("Cannot trivially implement BallotBitCount Inclusive Scan in HLSL."); else if (operation == GroupOperationExclusiveScan) SPIRV_CROSS_THROW("Cannot trivially implement BallotBitCount Exclusive Scan in HLSL."); else SPIRV_CROSS_THROW("Invalid BitCount operation."); break; } case OpGroupNonUniformShuffle: SPIRV_CROSS_THROW("Cannot trivially implement Shuffle in HLSL."); case OpGroupNonUniformShuffleXor: SPIRV_CROSS_THROW("Cannot trivially implement ShuffleXor in HLSL."); case OpGroupNonUniformShuffleUp: SPIRV_CROSS_THROW("Cannot trivially implement ShuffleUp in HLSL."); case OpGroupNonUniformShuffleDown: SPIRV_CROSS_THROW("Cannot trivially implement ShuffleDown in HLSL."); case OpGroupNonUniformAll: emit_unary_func_op(result_type, id, ops[3], "WaveActiveAllTrue"); break; case OpGroupNonUniformAny: emit_unary_func_op(result_type, id, ops[3], "WaveActiveAnyTrue"); break; case OpGroupNonUniformAllEqual: { auto &type = get(result_type); emit_unary_func_op(result_type, id, ops[3], type.basetype == SPIRType::Boolean ? "WaveActiveAllEqualBool" : "WaveActiveAllEqual"); break; } // clang-format off #define HLSL_GROUP_OP(op, hlsl_op, supports_scan) \ case OpGroupNonUniform##op: \ { \ auto operation = static_cast(ops[3]); \ if (operation == GroupOperationReduce) \ emit_unary_func_op(result_type, id, ops[4], "WaveActive" #hlsl_op); \ else if (operation == GroupOperationInclusiveScan && supports_scan) \ { \ bool forward = should_forward(ops[4]); \ emit_op(result_type, id, make_inclusive_##hlsl_op (join("WavePrefix" #hlsl_op, "(", to_expression(ops[4]), ")")), forward); \ inherit_expression_dependencies(id, ops[4]); \ } \ else if (operation == GroupOperationExclusiveScan && supports_scan) \ emit_unary_func_op(result_type, id, ops[4], "WavePrefix" #hlsl_op); \ else if (operation == GroupOperationClusteredReduce) \ SPIRV_CROSS_THROW("Cannot trivially implement ClusteredReduce in HLSL."); \ else \ SPIRV_CROSS_THROW("Invalid group operation."); \ break; \ } #define HLSL_GROUP_OP_CAST(op, hlsl_op, type) \ case OpGroupNonUniform##op: \ { \ auto operation = static_cast(ops[3]); \ if (operation == GroupOperationReduce) \ emit_unary_func_op_cast(result_type, id, ops[4], "WaveActive" #hlsl_op, type, type); \ else \ SPIRV_CROSS_THROW("Invalid group operation."); \ break; \ } HLSL_GROUP_OP(FAdd, Sum, true) HLSL_GROUP_OP(FMul, Product, true) HLSL_GROUP_OP(FMin, Min, false) HLSL_GROUP_OP(FMax, Max, false) HLSL_GROUP_OP(IAdd, Sum, true) HLSL_GROUP_OP(IMul, Product, true) HLSL_GROUP_OP_CAST(SMin, Min, int_type) HLSL_GROUP_OP_CAST(SMax, Max, int_type) HLSL_GROUP_OP_CAST(UMin, Min, uint_type) HLSL_GROUP_OP_CAST(UMax, Max, uint_type) HLSL_GROUP_OP(BitwiseAnd, BitAnd, false) HLSL_GROUP_OP(BitwiseOr, BitOr, false) HLSL_GROUP_OP(BitwiseXor, BitXor, false) #undef HLSL_GROUP_OP #undef HLSL_GROUP_OP_CAST // clang-format on case OpGroupNonUniformQuadSwap: { uint32_t direction = evaluate_constant_u32(ops[4]); if (direction == 0) emit_unary_func_op(result_type, id, ops[3], "QuadReadAcrossX"); else if (direction == 1) emit_unary_func_op(result_type, id, ops[3], "QuadReadAcrossY"); else if (direction == 2) emit_unary_func_op(result_type, id, ops[3], "QuadReadAcrossDiagonal"); else SPIRV_CROSS_THROW("Invalid quad swap direction."); break; } case OpGroupNonUniformQuadBroadcast: { emit_binary_func_op(result_type, id, ops[3], ops[4], "QuadReadLaneAt"); break; } default: SPIRV_CROSS_THROW("Invalid opcode for subgroup."); } register_control_dependent_expression(id); } void CompilerHLSL::emit_instruction(const Instruction &instruction) { auto ops = stream(instruction); auto opcode = static_cast(instruction.op); #define HLSL_BOP(op) emit_binary_op(ops[0], ops[1], ops[2], ops[3], #op) #define HLSL_BOP_CAST(op, type) \ emit_binary_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, opcode_is_sign_invariant(opcode)) #define HLSL_UOP(op) emit_unary_op(ops[0], ops[1], ops[2], #op) #define HLSL_QFOP(op) emit_quaternary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], ops[5], #op) #define HLSL_TFOP(op) emit_trinary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], #op) #define HLSL_BFOP(op) emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], #op) #define HLSL_BFOP_CAST(op, type) \ emit_binary_func_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, opcode_is_sign_invariant(opcode)) #define HLSL_BFOP(op) emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], #op) #define HLSL_UFOP(op) emit_unary_func_op(ops[0], ops[1], ops[2], #op) // If we need to do implicit bitcasts, make sure we do it with the correct type. uint32_t integer_width = get_integer_width_for_instruction(instruction); auto int_type = to_signed_basetype(integer_width); auto uint_type = to_unsigned_basetype(integer_width); switch (opcode) { case OpAccessChain: case OpInBoundsAccessChain: { emit_access_chain(instruction); break; } case OpBitcast: { auto bitcast_type = get_bitcast_type(ops[0], ops[2]); if (bitcast_type == CompilerHLSL::TypeNormal) CompilerGLSL::emit_instruction(instruction); else { if (!requires_uint2_packing) { requires_uint2_packing = true; force_recompile(); } if (bitcast_type == CompilerHLSL::TypePackUint2x32) emit_unary_func_op(ops[0], ops[1], ops[2], "spvPackUint2x32"); else emit_unary_func_op(ops[0], ops[1], ops[2], "spvUnpackUint2x32"); } break; } case OpStore: { emit_store(instruction); break; } case OpLoad: { emit_load(instruction); break; } case OpMatrixTimesVector: { // Matrices are kept in a transposed state all the time, flip multiplication order always. emit_binary_func_op(ops[0], ops[1], ops[3], ops[2], "mul"); break; } case OpVectorTimesMatrix: { // Matrices are kept in a transposed state all the time, flip multiplication order always. emit_binary_func_op(ops[0], ops[1], ops[3], ops[2], "mul"); break; } case OpMatrixTimesMatrix: { // Matrices are kept in a transposed state all the time, flip multiplication order always. emit_binary_func_op(ops[0], ops[1], ops[3], ops[2], "mul"); break; } case OpOuterProduct: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t a = ops[2]; uint32_t b = ops[3]; auto &type = get(result_type); string expr = type_to_glsl_constructor(type); expr += "("; for (uint32_t col = 0; col < type.columns; col++) { expr += to_enclosed_expression(a); expr += " * "; expr += to_extract_component_expression(b, col); if (col + 1 < type.columns) expr += ", "; } expr += ")"; emit_op(result_type, id, expr, should_forward(a) && should_forward(b)); inherit_expression_dependencies(id, a); inherit_expression_dependencies(id, b); break; } case OpFMod: { if (!requires_op_fmod) { requires_op_fmod = true; force_recompile(); } CompilerGLSL::emit_instruction(instruction); break; } case OpFRem: emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], "fmod"); break; case OpImage: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto *combined = maybe_get(ops[2]); if (combined) { auto &e = emit_op(result_type, id, to_expression(combined->image), true, true); auto *var = maybe_get_backing_variable(combined->image); if (var) e.loaded_from = var->self; } else { auto &e = emit_op(result_type, id, to_expression(ops[2]), true, true); auto *var = maybe_get_backing_variable(ops[2]); if (var) e.loaded_from = var->self; } break; } case OpDPdx: HLSL_UFOP(ddx); register_control_dependent_expression(ops[1]); break; case OpDPdy: HLSL_UFOP(ddy); register_control_dependent_expression(ops[1]); break; case OpDPdxFine: HLSL_UFOP(ddx_fine); register_control_dependent_expression(ops[1]); break; case OpDPdyFine: HLSL_UFOP(ddy_fine); register_control_dependent_expression(ops[1]); break; case OpDPdxCoarse: HLSL_UFOP(ddx_coarse); register_control_dependent_expression(ops[1]); break; case OpDPdyCoarse: HLSL_UFOP(ddy_coarse); register_control_dependent_expression(ops[1]); break; case OpFwidth: case OpFwidthCoarse: case OpFwidthFine: HLSL_UFOP(fwidth); register_control_dependent_expression(ops[1]); break; case OpLogicalNot: { auto result_type = ops[0]; auto id = ops[1]; auto &type = get(result_type); if (type.vecsize > 1) emit_unrolled_unary_op(result_type, id, ops[2], "!"); else HLSL_UOP(!); break; } case OpIEqual: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "==", false, SPIRType::Unknown); else HLSL_BOP_CAST(==, int_type); break; } case OpLogicalEqual: case OpFOrdEqual: case OpFUnordEqual: { // HLSL != operator is unordered. // https://docs.microsoft.com/en-us/windows/win32/direct3d10/d3d10-graphics-programming-guide-resources-float-rules. // isnan() is apparently implemented as x != x as well. // We cannot implement UnordEqual as !(OrdNotEqual), as HLSL cannot express OrdNotEqual. // HACK: FUnordEqual will be implemented as FOrdEqual. auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "==", false, SPIRType::Unknown); else HLSL_BOP(==); break; } case OpINotEqual: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "!=", false, SPIRType::Unknown); else HLSL_BOP_CAST(!=, int_type); break; } case OpLogicalNotEqual: case OpFOrdNotEqual: case OpFUnordNotEqual: { // HLSL != operator is unordered. // https://docs.microsoft.com/en-us/windows/win32/direct3d10/d3d10-graphics-programming-guide-resources-float-rules. // isnan() is apparently implemented as x != x as well. // FIXME: FOrdNotEqual cannot be implemented in a crisp and simple way here. // We would need to do something like not(UnordEqual), but that cannot be expressed either. // Adding a lot of NaN checks would be a breaking change from perspective of performance. // SPIR-V will generally use isnan() checks when this even matters. // HACK: FOrdNotEqual will be implemented as FUnordEqual. auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "!=", false, SPIRType::Unknown); else HLSL_BOP(!=); break; } case OpUGreaterThan: case OpSGreaterThan: { auto result_type = ops[0]; auto id = ops[1]; auto type = opcode == OpUGreaterThan ? uint_type : int_type; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], ">", false, type); else HLSL_BOP_CAST(>, type); break; } case OpFOrdGreaterThan: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], ">", false, SPIRType::Unknown); else HLSL_BOP(>); break; } case OpFUnordGreaterThan: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "<=", true, SPIRType::Unknown); else CompilerGLSL::emit_instruction(instruction); break; } case OpUGreaterThanEqual: case OpSGreaterThanEqual: { auto result_type = ops[0]; auto id = ops[1]; auto type = opcode == OpUGreaterThanEqual ? uint_type : int_type; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], ">=", false, type); else HLSL_BOP_CAST(>=, type); break; } case OpFOrdGreaterThanEqual: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], ">=", false, SPIRType::Unknown); else HLSL_BOP(>=); break; } case OpFUnordGreaterThanEqual: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "<", true, SPIRType::Unknown); else CompilerGLSL::emit_instruction(instruction); break; } case OpULessThan: case OpSLessThan: { auto result_type = ops[0]; auto id = ops[1]; auto type = opcode == OpULessThan ? uint_type : int_type; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "<", false, type); else HLSL_BOP_CAST(<, type); break; } case OpFOrdLessThan: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "<", false, SPIRType::Unknown); else HLSL_BOP(<); break; } case OpFUnordLessThan: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], ">=", true, SPIRType::Unknown); else CompilerGLSL::emit_instruction(instruction); break; } case OpULessThanEqual: case OpSLessThanEqual: { auto result_type = ops[0]; auto id = ops[1]; auto type = opcode == OpULessThanEqual ? uint_type : int_type; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "<=", false, type); else HLSL_BOP_CAST(<=, type); break; } case OpFOrdLessThanEqual: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "<=", false, SPIRType::Unknown); else HLSL_BOP(<=); break; } case OpFUnordLessThanEqual: { auto result_type = ops[0]; auto id = ops[1]; if (expression_type(ops[2]).vecsize > 1) emit_unrolled_binary_op(result_type, id, ops[2], ops[3], ">", true, SPIRType::Unknown); else CompilerGLSL::emit_instruction(instruction); break; } case OpImageQueryLod: emit_texture_op(instruction, false); break; case OpImageQuerySizeLod: { auto result_type = ops[0]; auto id = ops[1]; require_texture_query_variant(ops[2]); auto dummy_samples_levels = join(get_fallback_name(id), "_dummy_parameter"); statement("uint ", dummy_samples_levels, ";"); auto expr = join("spvTextureSize(", to_expression(ops[2]), ", ", bitcast_expression(SPIRType::UInt, ops[3]), ", ", dummy_samples_levels, ")"); auto &restype = get(ops[0]); expr = bitcast_expression(restype, SPIRType::UInt, expr); emit_op(result_type, id, expr, true); break; } case OpImageQuerySize: { auto result_type = ops[0]; auto id = ops[1]; require_texture_query_variant(ops[2]); bool uav = expression_type(ops[2]).image.sampled == 2; if (const auto *var = maybe_get_backing_variable(ops[2])) if (hlsl_options.nonwritable_uav_texture_as_srv && has_decoration(var->self, DecorationNonWritable)) uav = false; auto dummy_samples_levels = join(get_fallback_name(id), "_dummy_parameter"); statement("uint ", dummy_samples_levels, ";"); string expr; if (uav) expr = join("spvImageSize(", to_expression(ops[2]), ", ", dummy_samples_levels, ")"); else expr = join("spvTextureSize(", to_expression(ops[2]), ", 0u, ", dummy_samples_levels, ")"); auto &restype = get(ops[0]); expr = bitcast_expression(restype, SPIRType::UInt, expr); emit_op(result_type, id, expr, true); break; } case OpImageQuerySamples: case OpImageQueryLevels: { auto result_type = ops[0]; auto id = ops[1]; require_texture_query_variant(ops[2]); bool uav = expression_type(ops[2]).image.sampled == 2; if (opcode == OpImageQueryLevels && uav) SPIRV_CROSS_THROW("Cannot query levels for UAV images."); if (const auto *var = maybe_get_backing_variable(ops[2])) if (hlsl_options.nonwritable_uav_texture_as_srv && has_decoration(var->self, DecorationNonWritable)) uav = false; // Keep it simple and do not emit special variants to make this look nicer ... // This stuff is barely, if ever, used. forced_temporaries.insert(id); auto &type = get(result_type); statement(variable_decl(type, to_name(id)), ";"); if (uav) statement("spvImageSize(", to_expression(ops[2]), ", ", to_name(id), ");"); else statement("spvTextureSize(", to_expression(ops[2]), ", 0u, ", to_name(id), ");"); auto &restype = get(ops[0]); auto expr = bitcast_expression(restype, SPIRType::UInt, to_name(id)); set(id, expr, result_type, true); break; } case OpImageRead: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto *var = maybe_get_backing_variable(ops[2]); auto &type = expression_type(ops[2]); bool subpass_data = type.image.dim == DimSubpassData; bool pure = false; string imgexpr; if (subpass_data) { if (hlsl_options.shader_model < 40) SPIRV_CROSS_THROW("Subpass loads are not supported in HLSL shader model 2/3."); // Similar to GLSL, implement subpass loads using texelFetch. if (type.image.ms) { uint32_t operands = ops[4]; if (operands != ImageOperandsSampleMask || instruction.length != 6) SPIRV_CROSS_THROW("Multisampled image used in OpImageRead, but unexpected operand mask was used."); uint32_t sample = ops[5]; imgexpr = join(to_expression(ops[2]), ".Load(int2(gl_FragCoord.xy), ", to_expression(sample), ")"); } else imgexpr = join(to_expression(ops[2]), ".Load(int3(int2(gl_FragCoord.xy), 0))"); pure = true; } else { imgexpr = join(to_expression(ops[2]), "[", to_expression(ops[3]), "]"); // The underlying image type in HLSL depends on the image format, unlike GLSL, where all images are "vec4", // except that the underlying type changes how the data is interpreted. bool force_srv = hlsl_options.nonwritable_uav_texture_as_srv && var && has_decoration(var->self, DecorationNonWritable); pure = force_srv; if (var && !subpass_data && !force_srv) imgexpr = remap_swizzle(get(result_type), image_format_to_components(get(var->basetype).image.format), imgexpr); } if (var && var->forwardable) { bool forward = forced_temporaries.find(id) == end(forced_temporaries); auto &e = emit_op(result_type, id, imgexpr, forward); if (!pure) { e.loaded_from = var->self; if (forward) var->dependees.push_back(id); } } else emit_op(result_type, id, imgexpr, false); inherit_expression_dependencies(id, ops[2]); if (type.image.ms) inherit_expression_dependencies(id, ops[5]); break; } case OpImageWrite: { auto *var = maybe_get_backing_variable(ops[0]); // The underlying image type in HLSL depends on the image format, unlike GLSL, where all images are "vec4", // except that the underlying type changes how the data is interpreted. auto value_expr = to_expression(ops[2]); if (var) { auto &type = get(var->basetype); auto narrowed_type = get(type.image.type); narrowed_type.vecsize = image_format_to_components(type.image.format); value_expr = remap_swizzle(narrowed_type, expression_type(ops[2]).vecsize, value_expr); } statement(to_expression(ops[0]), "[", to_expression(ops[1]), "] = ", value_expr, ";"); if (var && variable_storage_is_aliased(*var)) flush_all_aliased_variables(); break; } case OpImageTexelPointer: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto expr = to_expression(ops[2]); if (has_decoration(id, DecorationNonUniformEXT) || has_decoration(ops[2], DecorationNonUniformEXT)) convert_non_uniform_expression(expression_type(ops[2]), expr); expr += join("[", to_expression(ops[3]), "]"); auto &e = set(id, expr, result_type, true); // When using the pointer, we need to know which variable it is actually loaded from. auto *var = maybe_get_backing_variable(ops[2]); e.loaded_from = var ? var->self : ID(0); inherit_expression_dependencies(id, ops[3]); break; } case OpAtomicCompareExchange: case OpAtomicExchange: case OpAtomicISub: case OpAtomicSMin: case OpAtomicUMin: case OpAtomicSMax: case OpAtomicUMax: case OpAtomicAnd: case OpAtomicOr: case OpAtomicXor: case OpAtomicIAdd: case OpAtomicIIncrement: case OpAtomicIDecrement: case OpAtomicLoad: case OpAtomicStore: { emit_atomic(ops, instruction.length, opcode); break; } case OpControlBarrier: case OpMemoryBarrier: { uint32_t memory; uint32_t semantics; if (opcode == OpMemoryBarrier) { memory = evaluate_constant_u32(ops[0]); semantics = evaluate_constant_u32(ops[1]); } else { memory = evaluate_constant_u32(ops[1]); semantics = evaluate_constant_u32(ops[2]); } if (memory == ScopeSubgroup) { // No Wave-barriers in HLSL. break; } // We only care about these flags, acquire/release and friends are not relevant to GLSL. semantics = mask_relevant_memory_semantics(semantics); if (opcode == OpMemoryBarrier) { // If we are a memory barrier, and the next instruction is a control barrier, check if that memory barrier // does what we need, so we avoid redundant barriers. const Instruction *next = get_next_instruction_in_block(instruction); if (next && next->op == OpControlBarrier) { auto *next_ops = stream(*next); uint32_t next_memory = evaluate_constant_u32(next_ops[1]); uint32_t next_semantics = evaluate_constant_u32(next_ops[2]); next_semantics = mask_relevant_memory_semantics(next_semantics); // There is no "just execution barrier" in HLSL. // If there are no memory semantics for next instruction, we will imply group shared memory is synced. if (next_semantics == 0) next_semantics = MemorySemanticsWorkgroupMemoryMask; bool memory_scope_covered = false; if (next_memory == memory) memory_scope_covered = true; else if (next_semantics == MemorySemanticsWorkgroupMemoryMask) { // If we only care about workgroup memory, either Device or Workgroup scope is fine, // scope does not have to match. if ((next_memory == ScopeDevice || next_memory == ScopeWorkgroup) && (memory == ScopeDevice || memory == ScopeWorkgroup)) { memory_scope_covered = true; } } else if (memory == ScopeWorkgroup && next_memory == ScopeDevice) { // The control barrier has device scope, but the memory barrier just has workgroup scope. memory_scope_covered = true; } // If we have the same memory scope, and all memory types are covered, we're good. if (memory_scope_covered && (semantics & next_semantics) == semantics) break; } } // We are synchronizing some memory or syncing execution, // so we cannot forward any loads beyond the memory barrier. if (semantics || opcode == OpControlBarrier) { assert(current_emitting_block); flush_control_dependent_expressions(current_emitting_block->self); flush_all_active_variables(); } if (opcode == OpControlBarrier) { // We cannot emit just execution barrier, for no memory semantics pick the cheapest option. if (semantics == MemorySemanticsWorkgroupMemoryMask || semantics == 0) statement("GroupMemoryBarrierWithGroupSync();"); else if (semantics != 0 && (semantics & MemorySemanticsWorkgroupMemoryMask) == 0) statement("DeviceMemoryBarrierWithGroupSync();"); else statement("AllMemoryBarrierWithGroupSync();"); } else { if (semantics == MemorySemanticsWorkgroupMemoryMask) statement("GroupMemoryBarrier();"); else if (semantics != 0 && (semantics & MemorySemanticsWorkgroupMemoryMask) == 0) statement("DeviceMemoryBarrier();"); else statement("AllMemoryBarrier();"); } break; } case OpBitFieldInsert: { if (!requires_bitfield_insert) { requires_bitfield_insert = true; force_recompile(); } auto expr = join("spvBitfieldInsert(", to_expression(ops[2]), ", ", to_expression(ops[3]), ", ", to_expression(ops[4]), ", ", to_expression(ops[5]), ")"); bool forward = should_forward(ops[2]) && should_forward(ops[3]) && should_forward(ops[4]) && should_forward(ops[5]); auto &restype = get(ops[0]); expr = bitcast_expression(restype, SPIRType::UInt, expr); emit_op(ops[0], ops[1], expr, forward); break; } case OpBitFieldSExtract: case OpBitFieldUExtract: { if (!requires_bitfield_extract) { requires_bitfield_extract = true; force_recompile(); } if (opcode == OpBitFieldSExtract) HLSL_TFOP(spvBitfieldSExtract); else HLSL_TFOP(spvBitfieldUExtract); break; } case OpBitCount: { auto basetype = expression_type(ops[2]).basetype; emit_unary_func_op_cast(ops[0], ops[1], ops[2], "countbits", basetype, basetype); break; } case OpBitReverse: HLSL_UFOP(reversebits); break; case OpArrayLength: { auto *var = maybe_get(ops[2]); if (!var) SPIRV_CROSS_THROW("Array length must point directly to an SSBO block."); auto &type = get(var->basetype); if (!has_decoration(type.self, DecorationBlock) && !has_decoration(type.self, DecorationBufferBlock)) SPIRV_CROSS_THROW("Array length expression must point to a block type."); // This must be 32-bit uint, so we're good to go. emit_uninitialized_temporary_expression(ops[0], ops[1]); statement(to_expression(ops[2]), ".GetDimensions(", to_expression(ops[1]), ");"); uint32_t offset = type_struct_member_offset(type, ops[3]); uint32_t stride = type_struct_member_array_stride(type, ops[3]); statement(to_expression(ops[1]), " = (", to_expression(ops[1]), " - ", offset, ") / ", stride, ";"); break; } case OpIsHelperInvocationEXT: SPIRV_CROSS_THROW("helperInvocationEXT() is not supported in HLSL."); case OpBeginInvocationInterlockEXT: case OpEndInvocationInterlockEXT: if (hlsl_options.shader_model < 51) SPIRV_CROSS_THROW("Rasterizer order views require Shader Model 5.1."); break; // Nothing to do in the body default: CompilerGLSL::emit_instruction(instruction); break; } } void CompilerHLSL::require_texture_query_variant(uint32_t var_id) { if (const auto *var = maybe_get_backing_variable(var_id)) var_id = var->self; auto &type = expression_type(var_id); bool uav = type.image.sampled == 2; if (hlsl_options.nonwritable_uav_texture_as_srv && has_decoration(var_id, DecorationNonWritable)) uav = false; uint32_t bit = 0; switch (type.image.dim) { case Dim1D: bit = type.image.arrayed ? Query1DArray : Query1D; break; case Dim2D: if (type.image.ms) bit = type.image.arrayed ? Query2DMSArray : Query2DMS; else bit = type.image.arrayed ? Query2DArray : Query2D; break; case Dim3D: bit = Query3D; break; case DimCube: bit = type.image.arrayed ? QueryCubeArray : QueryCube; break; case DimBuffer: bit = QueryBuffer; break; default: SPIRV_CROSS_THROW("Unsupported query type."); } switch (get(type.image.type).basetype) { case SPIRType::Float: bit += QueryTypeFloat; break; case SPIRType::Int: bit += QueryTypeInt; break; case SPIRType::UInt: bit += QueryTypeUInt; break; default: SPIRV_CROSS_THROW("Unsupported query type."); } auto norm_state = image_format_to_normalized_state(type.image.format); auto &variant = uav ? required_texture_size_variants .uav[uint32_t(norm_state)][image_format_to_components(type.image.format) - 1] : required_texture_size_variants.srv; uint64_t mask = 1ull << bit; if ((variant & mask) == 0) { force_recompile(); variant |= mask; } } void CompilerHLSL::set_root_constant_layouts(std::vector layout) { root_constants_layout = move(layout); } void CompilerHLSL::add_vertex_attribute_remap(const HLSLVertexAttributeRemap &vertex_attributes) { remap_vertex_attributes.push_back(vertex_attributes); } VariableID CompilerHLSL::remap_num_workgroups_builtin() { update_active_builtins(); if (!active_input_builtins.get(BuiltInNumWorkgroups)) return 0; // Create a new, fake UBO. uint32_t offset = ir.increase_bound_by(4); uint32_t uint_type_id = offset; uint32_t block_type_id = offset + 1; uint32_t block_pointer_type_id = offset + 2; uint32_t variable_id = offset + 3; SPIRType uint_type; uint_type.basetype = SPIRType::UInt; uint_type.width = 32; uint_type.vecsize = 3; uint_type.columns = 1; set(uint_type_id, uint_type); SPIRType block_type; block_type.basetype = SPIRType::Struct; block_type.member_types.push_back(uint_type_id); set(block_type_id, block_type); set_decoration(block_type_id, DecorationBlock); set_member_name(block_type_id, 0, "count"); set_member_decoration(block_type_id, 0, DecorationOffset, 0); SPIRType block_pointer_type = block_type; block_pointer_type.pointer = true; block_pointer_type.storage = StorageClassUniform; block_pointer_type.parent_type = block_type_id; auto &ptr_type = set(block_pointer_type_id, block_pointer_type); // Preserve self. ptr_type.self = block_type_id; set(variable_id, block_pointer_type_id, StorageClassUniform); ir.meta[variable_id].decoration.alias = "SPIRV_Cross_NumWorkgroups"; num_workgroups_builtin = variable_id; return variable_id; } void CompilerHLSL::set_resource_binding_flags(HLSLBindingFlags flags) { resource_binding_flags = flags; } void CompilerHLSL::validate_shader_model() { // Check for nonuniform qualifier. // Instead of looping over all decorations to find this, just look at capabilities. for (auto &cap : ir.declared_capabilities) { switch (cap) { case CapabilityShaderNonUniformEXT: case CapabilityRuntimeDescriptorArrayEXT: if (hlsl_options.shader_model < 51) SPIRV_CROSS_THROW( "Shader model 5.1 or higher is required to use bindless resources or NonUniformResourceIndex."); break; case CapabilityVariablePointers: case CapabilityVariablePointersStorageBuffer: SPIRV_CROSS_THROW("VariablePointers capability is not supported in HLSL."); default: break; } } if (ir.addressing_model != AddressingModelLogical) SPIRV_CROSS_THROW("Only Logical addressing model can be used with HLSL."); if (hlsl_options.enable_16bit_types && hlsl_options.shader_model < 62) SPIRV_CROSS_THROW("Need at least shader model 6.2 when enabling native 16-bit type support."); } string CompilerHLSL::compile() { ir.fixup_reserved_names(); // Do not deal with ES-isms like precision, older extensions and such. options.es = false; options.version = 450; options.vulkan_semantics = true; backend.float_literal_suffix = true; backend.double_literal_suffix = false; backend.long_long_literal_suffix = true; backend.uint32_t_literal_suffix = true; backend.int16_t_literal_suffix = ""; backend.uint16_t_literal_suffix = "u"; backend.basic_int_type = "int"; backend.basic_uint_type = "uint"; backend.demote_literal = "discard"; backend.boolean_mix_function = ""; backend.swizzle_is_function = false; backend.shared_is_implied = true; backend.unsized_array_supported = true; backend.explicit_struct_type = false; backend.use_initializer_list = true; backend.use_constructor_splatting = false; backend.can_swizzle_scalar = true; backend.can_declare_struct_inline = false; backend.can_declare_arrays_inline = false; backend.can_return_array = false; backend.nonuniform_qualifier = "NonUniformResourceIndex"; backend.support_case_fallthrough = false; fixup_type_alias(); reorder_type_alias(); build_function_control_flow_graphs_and_analyze(); validate_shader_model(); update_active_builtins(); analyze_image_and_sampler_usage(); analyze_interlocked_resource_usage(); // Subpass input needs SV_Position. if (need_subpass_input) active_input_builtins.set(BuiltInFragCoord); uint32_t pass_count = 0; do { if (pass_count >= 3) SPIRV_CROSS_THROW("Over 3 compilation loops detected. Must be a bug!"); reset(); // Move constructor for this type is broken on GCC 4.9 ... buffer.reset(); emit_header(); emit_resources(); emit_function(get(ir.default_entry_point), Bitset()); emit_hlsl_entry_point(); pass_count++; } while (is_forcing_recompilation()); // Entry point in HLSL is always main() for the time being. get_entry_point().name = "main"; return buffer.str(); } void CompilerHLSL::emit_block_hints(const SPIRBlock &block) { switch (block.hint) { case SPIRBlock::HintFlatten: statement("[flatten]"); break; case SPIRBlock::HintDontFlatten: statement("[branch]"); break; case SPIRBlock::HintUnroll: statement("[unroll]"); break; case SPIRBlock::HintDontUnroll: statement("[loop]"); break; default: break; } } string CompilerHLSL::get_unique_identifier() { return join("_", unique_identifier_count++, "ident"); } void CompilerHLSL::add_hlsl_resource_binding(const HLSLResourceBinding &binding) { StageSetBinding tuple = { binding.stage, binding.desc_set, binding.binding }; resource_bindings[tuple] = { binding, false }; } bool CompilerHLSL::is_hlsl_resource_binding_used(ExecutionModel model, uint32_t desc_set, uint32_t binding) const { StageSetBinding tuple = { model, desc_set, binding }; auto itr = resource_bindings.find(tuple); return itr != end(resource_bindings) && itr->second.second; } CompilerHLSL::BitcastType CompilerHLSL::get_bitcast_type(uint32_t result_type, uint32_t op0) { auto &rslt_type = get(result_type); auto &expr_type = expression_type(op0); if (rslt_type.basetype == SPIRType::BaseType::UInt64 && expr_type.basetype == SPIRType::BaseType::UInt && expr_type.vecsize == 2) return BitcastType::TypePackUint2x32; else if (rslt_type.basetype == SPIRType::BaseType::UInt && rslt_type.vecsize == 2 && expr_type.basetype == SPIRType::BaseType::UInt64) return BitcastType::TypeUnpackUint64; return BitcastType::TypeNormal; } bool CompilerHLSL::is_hlsl_force_storage_buffer_as_uav(ID id) const { if (hlsl_options.force_storage_buffer_as_uav) { return true; } const uint32_t desc_set = get_decoration(id, spv::DecorationDescriptorSet); const uint32_t binding = get_decoration(id, spv::DecorationBinding); return (force_uav_buffer_bindings.find({ desc_set, binding }) != force_uav_buffer_bindings.end()); } void CompilerHLSL::set_hlsl_force_storage_buffer_as_uav(uint32_t desc_set, uint32_t binding) { SetBindingPair pair = { desc_set, binding }; force_uav_buffer_bindings.insert(pair); } bool CompilerHLSL::builtin_translates_to_nonarray(spv::BuiltIn builtin) const { return (builtin == BuiltInSampleMask); } spirv-cross-2021.01.15/spirv_hlsl.hpp000066400000000000000000000354641400026215700173040ustar00rootroot00000000000000/* * Copyright 2016-2021 Robert Konrad * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_HLSL_HPP #define SPIRV_HLSL_HPP #include "spirv_glsl.hpp" #include namespace SPIRV_CROSS_NAMESPACE { // Interface which remaps vertex inputs to a fixed semantic name to make linking easier. struct HLSLVertexAttributeRemap { uint32_t location; std::string semantic; }; // Specifying a root constant (d3d12) or push constant range (vulkan). // // `start` and `end` denotes the range of the root constant in bytes. // Both values need to be multiple of 4. struct RootConstants { uint32_t start; uint32_t end; uint32_t binding; uint32_t space; }; // For finer control, decorations may be removed from specific resources instead with unset_decoration(). enum HLSLBindingFlagBits { HLSL_BINDING_AUTO_NONE_BIT = 0, // Push constant (root constant) resources will be declared as CBVs (b-space) without a register() declaration. // A register will be automatically assigned by the D3D compiler, but must therefore be reflected in D3D-land. // Push constants do not normally have a DecorationBinding set, but if they do, this can be used to ignore it. HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT = 1 << 0, // cbuffer resources will be declared as CBVs (b-space) without a register() declaration. // A register will be automatically assigned, but must be reflected in D3D-land. HLSL_BINDING_AUTO_CBV_BIT = 1 << 1, // All SRVs (t-space) will be declared without a register() declaration. HLSL_BINDING_AUTO_SRV_BIT = 1 << 2, // All UAVs (u-space) will be declared without a register() declaration. HLSL_BINDING_AUTO_UAV_BIT = 1 << 3, // All samplers (s-space) will be declared without a register() declaration. HLSL_BINDING_AUTO_SAMPLER_BIT = 1 << 4, // No resources will be declared with register(). HLSL_BINDING_AUTO_ALL = 0x7fffffff }; using HLSLBindingFlags = uint32_t; // By matching stage, desc_set and binding for a SPIR-V resource, // register bindings are set based on whether the HLSL resource is a // CBV, UAV, SRV or Sampler. A single binding in SPIR-V might contain multiple // resource types, e.g. COMBINED_IMAGE_SAMPLER, and SRV/Sampler bindings will be used respectively. // On SM 5.0 and lower, register_space is ignored. // // To remap a push constant block which does not have any desc_set/binding associated with it, // use ResourceBindingPushConstant{DescriptorSet,Binding} as values for desc_set/binding. // For deeper control of push constants, set_root_constant_layouts() can be used instead. struct HLSLResourceBinding { spv::ExecutionModel stage = spv::ExecutionModelMax; uint32_t desc_set = 0; uint32_t binding = 0; struct Binding { uint32_t register_space = 0; uint32_t register_binding = 0; } cbv, uav, srv, sampler; }; class CompilerHLSL : public CompilerGLSL { public: struct Options { uint32_t shader_model = 30; // TODO: map ps_4_0_level_9_0,... somehow // Allows the PointSize builtin, and ignores it, as PointSize is not supported in HLSL. bool point_size_compat = false; // Allows the PointCoord builtin, returns float2(0.5, 0.5), as PointCoord is not supported in HLSL. bool point_coord_compat = false; // If true, the backend will assume that VertexIndex and InstanceIndex will need to apply // a base offset, and you will need to fill in a cbuffer with offsets. // Set to false if you know you will never use base instance or base vertex // functionality as it might remove an internal cbuffer. bool support_nonzero_base_vertex_base_instance = false; // Forces a storage buffer to always be declared as UAV, even if the readonly decoration is used. // By default, a readonly storage buffer will be declared as ByteAddressBuffer (SRV) instead. // Alternatively, use set_hlsl_force_storage_buffer_as_uav to specify individually. bool force_storage_buffer_as_uav = false; // Forces any storage image type marked as NonWritable to be considered an SRV instead. // For this to work with function call parameters, NonWritable must be considered to be part of the type system // so that NonWritable image arguments are also translated to Texture rather than RWTexture. bool nonwritable_uav_texture_as_srv = false; // Enables native 16-bit types. Needs SM 6.2. // Uses half/int16_t/uint16_t instead of min16* types. // Also adds support for 16-bit load-store from (RW)ByteAddressBuffer. bool enable_16bit_types = false; // If matrices are used as IO variables, flatten the attribute declaration to use // TEXCOORD{N,N+1,N+2,...} rather than TEXCOORDN_{0,1,2,3}. // If add_vertex_attribute_remap is used and this feature is used, // the semantic name will be queried once per active location. bool flatten_matrix_vertex_input_semantics = false; }; explicit CompilerHLSL(std::vector spirv_) : CompilerGLSL(std::move(spirv_)) { } CompilerHLSL(const uint32_t *ir_, size_t size) : CompilerGLSL(ir_, size) { } explicit CompilerHLSL(const ParsedIR &ir_) : CompilerGLSL(ir_) { } explicit CompilerHLSL(ParsedIR &&ir_) : CompilerGLSL(std::move(ir_)) { } const Options &get_hlsl_options() const { return hlsl_options; } void set_hlsl_options(const Options &opts) { hlsl_options = opts; } // Optionally specify a custom root constant layout. // // Push constants ranges will be split up according to the // layout specified. void set_root_constant_layouts(std::vector layout); // Compiles and remaps vertex attributes at specific locations to a fixed semantic. // The default is TEXCOORD# where # denotes location. // Matrices are unrolled to vectors with notation ${SEMANTIC}_#, where # denotes row. // $SEMANTIC is either TEXCOORD# or a semantic name specified here. void add_vertex_attribute_remap(const HLSLVertexAttributeRemap &vertex_attributes); std::string compile() override; // This is a special HLSL workaround for the NumWorkGroups builtin. // This does not exist in HLSL, so the calling application must create a dummy cbuffer in // which the application will store this builtin. // The cbuffer layout will be: // cbuffer SPIRV_Cross_NumWorkgroups : register(b#, space#) { uint3 SPIRV_Cross_NumWorkgroups_count; }; // This must be called before compile(). // The function returns 0 if NumWorkGroups builtin is not statically used in the shader from the current entry point. // If non-zero, this returns the variable ID of a cbuffer which corresponds to // the cbuffer declared above. By default, no binding or descriptor set decoration is set, // so the calling application should declare explicit bindings on this ID before calling compile(). VariableID remap_num_workgroups_builtin(); // Controls how resource bindings are declared in the output HLSL. void set_resource_binding_flags(HLSLBindingFlags flags); // resource is a resource binding to indicate the HLSL CBV, SRV, UAV or sampler binding // to use for a particular SPIR-V description set // and binding. If resource bindings are provided, // is_hlsl_resource_binding_used() will return true after calling ::compile() if // the set/binding combination was used by the HLSL code. void add_hlsl_resource_binding(const HLSLResourceBinding &resource); bool is_hlsl_resource_binding_used(spv::ExecutionModel model, uint32_t set, uint32_t binding) const; // Controls which storage buffer bindings will be forced to be declared as UAVs. void set_hlsl_force_storage_buffer_as_uav(uint32_t desc_set, uint32_t binding); private: std::string type_to_glsl(const SPIRType &type, uint32_t id = 0) override; std::string image_type_hlsl(const SPIRType &type, uint32_t id); std::string image_type_hlsl_modern(const SPIRType &type, uint32_t id); std::string image_type_hlsl_legacy(const SPIRType &type, uint32_t id); void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override; void emit_hlsl_entry_point(); void emit_header() override; void emit_resources(); void declare_undefined_values() override; void emit_interface_block_globally(const SPIRVariable &type); void emit_interface_block_in_struct(const SPIRVariable &type, std::unordered_set &active_locations); void emit_builtin_inputs_in_struct(); void emit_builtin_outputs_in_struct(); void emit_texture_op(const Instruction &i, bool sparse) override; void emit_instruction(const Instruction &instruction) override; void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count) override; void emit_buffer_block(const SPIRVariable &type) override; void emit_push_constant_block(const SPIRVariable &var) override; void emit_uniform(const SPIRVariable &var) override; void emit_modern_uniform(const SPIRVariable &var); void emit_legacy_uniform(const SPIRVariable &var); void emit_specialization_constants_and_structs(); void emit_composite_constants(); void emit_fixup() override; std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage) override; std::string layout_for_member(const SPIRType &type, uint32_t index) override; std::string to_interpolation_qualifiers(const Bitset &flags) override; std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type) override; bool emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0) override; std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) override; std::string to_sampler_expression(uint32_t id); std::string to_resource_binding(const SPIRVariable &var); std::string to_resource_binding_sampler(const SPIRVariable &var); std::string to_resource_register(HLSLBindingFlagBits flag, char space, uint32_t binding, uint32_t set); std::string to_initializer_expression(const SPIRVariable &var) override; void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) override; void emit_access_chain(const Instruction &instruction); void emit_load(const Instruction &instruction); void read_access_chain(std::string *expr, const std::string &lhs, const SPIRAccessChain &chain); void read_access_chain_struct(const std::string &lhs, const SPIRAccessChain &chain); void read_access_chain_array(const std::string &lhs, const SPIRAccessChain &chain); void write_access_chain(const SPIRAccessChain &chain, uint32_t value, const SmallVector &composite_chain); void write_access_chain_struct(const SPIRAccessChain &chain, uint32_t value, const SmallVector &composite_chain); void write_access_chain_array(const SPIRAccessChain &chain, uint32_t value, const SmallVector &composite_chain); std::string write_access_chain_value(uint32_t value, const SmallVector &composite_chain, bool enclose); void emit_store(const Instruction &instruction); void emit_atomic(const uint32_t *ops, uint32_t length, spv::Op op); void emit_subgroup_op(const Instruction &i) override; void emit_block_hints(const SPIRBlock &block) override; void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const std::string &qualifier, uint32_t base_offset = 0) override; const char *to_storage_qualifiers_glsl(const SPIRVariable &var) override; void replace_illegal_names() override; bool is_hlsl_force_storage_buffer_as_uav(ID id) const; Options hlsl_options; // TODO: Refactor this to be more similar to MSL, maybe have some common system in place? bool requires_op_fmod = false; bool requires_fp16_packing = false; bool requires_uint2_packing = false; bool requires_explicit_fp16_packing = false; bool requires_unorm8_packing = false; bool requires_snorm8_packing = false; bool requires_unorm16_packing = false; bool requires_snorm16_packing = false; bool requires_bitfield_insert = false; bool requires_bitfield_extract = false; bool requires_inverse_2x2 = false; bool requires_inverse_3x3 = false; bool requires_inverse_4x4 = false; bool requires_scalar_reflect = false; bool requires_scalar_refract = false; bool requires_scalar_faceforward = false; struct TextureSizeVariants { // MSVC 2013 workaround. TextureSizeVariants() { srv = 0; for (auto &unorm : uav) for (auto &u : unorm) u = 0; } uint64_t srv; uint64_t uav[3][4]; } required_texture_size_variants; void require_texture_query_variant(uint32_t var_id); void emit_texture_size_variants(uint64_t variant_mask, const char *vecsize_qualifier, bool uav, const char *type_qualifier); enum TextureQueryVariantDim { Query1D = 0, Query1DArray, Query2D, Query2DArray, Query3D, QueryBuffer, QueryCube, QueryCubeArray, Query2DMS, Query2DMSArray, QueryDimCount }; enum TextureQueryVariantType { QueryTypeFloat = 0, QueryTypeInt = 16, QueryTypeUInt = 32, QueryTypeCount = 3 }; enum BitcastType { TypeNormal, TypePackUint2x32, TypeUnpackUint64 }; BitcastType get_bitcast_type(uint32_t result_type, uint32_t op0); void emit_builtin_variables(); bool require_output = false; bool require_input = false; SmallVector remap_vertex_attributes; uint32_t type_to_consumed_locations(const SPIRType &type) const; void emit_io_block(const SPIRVariable &var); std::string to_semantic(uint32_t location, spv::ExecutionModel em, spv::StorageClass sc); uint32_t num_workgroups_builtin = 0; HLSLBindingFlags resource_binding_flags = 0; // Custom root constant layout, which should be emitted // when translating push constant ranges. std::vector root_constants_layout; void validate_shader_model(); std::string get_unique_identifier(); uint32_t unique_identifier_count = 0; std::unordered_map, InternalHasher> resource_bindings; void remap_hlsl_resource_binding(HLSLBindingFlagBits type, uint32_t &desc_set, uint32_t &binding); std::unordered_set force_uav_buffer_bindings; // Returns true for BuiltInSampleMask because gl_SampleMask[] is an array in SPIR-V, but SV_Coverage is a scalar in HLSL. bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const override; }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_msl.cpp000066400000000000000000020343471400026215700171310ustar00rootroot00000000000000/* * Copyright 2016-2021 The Brenwill Workshop Ltd. * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_msl.hpp" #include "GLSL.std.450.h" #include #include #include using namespace spv; using namespace SPIRV_CROSS_NAMESPACE; using namespace std; static const uint32_t k_unknown_location = ~0u; static const uint32_t k_unknown_component = ~0u; static const char *force_inline = "static inline __attribute__((always_inline))"; CompilerMSL::CompilerMSL(std::vector spirv_) : CompilerGLSL(move(spirv_)) { } CompilerMSL::CompilerMSL(const uint32_t *ir_, size_t word_count) : CompilerGLSL(ir_, word_count) { } CompilerMSL::CompilerMSL(const ParsedIR &ir_) : CompilerGLSL(ir_) { } CompilerMSL::CompilerMSL(ParsedIR &&ir_) : CompilerGLSL(std::move(ir_)) { } void CompilerMSL::add_msl_shader_input(const MSLShaderInput &si) { inputs_by_location[si.location] = si; if (si.builtin != BuiltInMax && !inputs_by_builtin.count(si.builtin)) inputs_by_builtin[si.builtin] = si; } void CompilerMSL::add_msl_resource_binding(const MSLResourceBinding &binding) { StageSetBinding tuple = { binding.stage, binding.desc_set, binding.binding }; resource_bindings[tuple] = { binding, false }; } void CompilerMSL::add_dynamic_buffer(uint32_t desc_set, uint32_t binding, uint32_t index) { SetBindingPair pair = { desc_set, binding }; buffers_requiring_dynamic_offset[pair] = { index, 0 }; } void CompilerMSL::add_inline_uniform_block(uint32_t desc_set, uint32_t binding) { SetBindingPair pair = { desc_set, binding }; inline_uniform_blocks.insert(pair); } void CompilerMSL::add_discrete_descriptor_set(uint32_t desc_set) { if (desc_set < kMaxArgumentBuffers) argument_buffer_discrete_mask |= 1u << desc_set; } void CompilerMSL::set_argument_buffer_device_address_space(uint32_t desc_set, bool device_storage) { if (desc_set < kMaxArgumentBuffers) { if (device_storage) argument_buffer_device_storage_mask |= 1u << desc_set; else argument_buffer_device_storage_mask &= ~(1u << desc_set); } } bool CompilerMSL::is_msl_shader_input_used(uint32_t location) { return inputs_in_use.count(location) != 0; } bool CompilerMSL::is_msl_resource_binding_used(ExecutionModel model, uint32_t desc_set, uint32_t binding) const { StageSetBinding tuple = { model, desc_set, binding }; auto itr = resource_bindings.find(tuple); return itr != end(resource_bindings) && itr->second.second; } // Returns the size of the array of resources used by the variable with the specified id. // The returned value is retrieved from the resource binding added using add_msl_resource_binding(). uint32_t CompilerMSL::get_resource_array_size(uint32_t id) const { StageSetBinding tuple = { get_entry_point().model, get_decoration(id, DecorationDescriptorSet), get_decoration(id, DecorationBinding) }; auto itr = resource_bindings.find(tuple); return itr != end(resource_bindings) ? itr->second.first.count : 0; } uint32_t CompilerMSL::get_automatic_msl_resource_binding(uint32_t id) const { return get_extended_decoration(id, SPIRVCrossDecorationResourceIndexPrimary); } uint32_t CompilerMSL::get_automatic_msl_resource_binding_secondary(uint32_t id) const { return get_extended_decoration(id, SPIRVCrossDecorationResourceIndexSecondary); } uint32_t CompilerMSL::get_automatic_msl_resource_binding_tertiary(uint32_t id) const { return get_extended_decoration(id, SPIRVCrossDecorationResourceIndexTertiary); } uint32_t CompilerMSL::get_automatic_msl_resource_binding_quaternary(uint32_t id) const { return get_extended_decoration(id, SPIRVCrossDecorationResourceIndexQuaternary); } void CompilerMSL::set_fragment_output_components(uint32_t location, uint32_t components) { fragment_output_components[location] = components; } bool CompilerMSL::builtin_translates_to_nonarray(spv::BuiltIn builtin) const { return (builtin == BuiltInSampleMask); } void CompilerMSL::build_implicit_builtins() { bool need_sample_pos = active_input_builtins.get(BuiltInSamplePosition); bool need_vertex_params = capture_output_to_buffer && get_execution_model() == ExecutionModelVertex && !msl_options.vertex_for_tessellation; bool need_tesc_params = get_execution_model() == ExecutionModelTessellationControl; bool need_subgroup_mask = active_input_builtins.get(BuiltInSubgroupEqMask) || active_input_builtins.get(BuiltInSubgroupGeMask) || active_input_builtins.get(BuiltInSubgroupGtMask) || active_input_builtins.get(BuiltInSubgroupLeMask) || active_input_builtins.get(BuiltInSubgroupLtMask); bool need_subgroup_ge_mask = !msl_options.is_ios() && (active_input_builtins.get(BuiltInSubgroupGeMask) || active_input_builtins.get(BuiltInSubgroupGtMask)); bool need_multiview = get_execution_model() == ExecutionModelVertex && !msl_options.view_index_from_device_index && msl_options.multiview_layered_rendering && (msl_options.multiview || active_input_builtins.get(BuiltInViewIndex)); bool need_dispatch_base = msl_options.dispatch_base && get_execution_model() == ExecutionModelGLCompute && (active_input_builtins.get(BuiltInWorkgroupId) || active_input_builtins.get(BuiltInGlobalInvocationId)); bool need_grid_params = get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation; bool need_vertex_base_params = need_grid_params && (active_input_builtins.get(BuiltInVertexId) || active_input_builtins.get(BuiltInVertexIndex) || active_input_builtins.get(BuiltInBaseVertex) || active_input_builtins.get(BuiltInInstanceId) || active_input_builtins.get(BuiltInInstanceIndex) || active_input_builtins.get(BuiltInBaseInstance)); bool need_sample_mask = msl_options.additional_fixed_sample_mask != 0xffffffff; bool need_local_invocation_index = msl_options.emulate_subgroups && active_input_builtins.get(BuiltInSubgroupId); bool need_workgroup_size = msl_options.emulate_subgroups && active_input_builtins.get(BuiltInNumSubgroups); if (need_subpass_input || need_sample_pos || need_subgroup_mask || need_vertex_params || need_tesc_params || need_multiview || need_dispatch_base || need_vertex_base_params || need_grid_params || needs_sample_id || needs_subgroup_invocation_id || needs_subgroup_size || need_sample_mask || need_local_invocation_index || need_workgroup_size) { bool has_frag_coord = false; bool has_sample_id = false; bool has_vertex_idx = false; bool has_base_vertex = false; bool has_instance_idx = false; bool has_base_instance = false; bool has_invocation_id = false; bool has_primitive_id = false; bool has_subgroup_invocation_id = false; bool has_subgroup_size = false; bool has_view_idx = false; bool has_layer = false; bool has_local_invocation_index = false; bool has_workgroup_size = false; uint32_t workgroup_id_type = 0; ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { if (var.storage != StorageClassInput && var.storage != StorageClassOutput) return; if (!interface_variable_exists_in_entry_point(var.self)) return; if (!has_decoration(var.self, DecorationBuiltIn)) return; BuiltIn builtin = ir.meta[var.self].decoration.builtin_type; if (var.storage == StorageClassOutput) { if (need_sample_mask && builtin == BuiltInSampleMask) { builtin_sample_mask_id = var.self; mark_implicit_builtin(StorageClassOutput, BuiltInSampleMask, var.self); does_shader_write_sample_mask = true; } } if (var.storage != StorageClassInput) return; // Use Metal's native frame-buffer fetch API for subpass inputs. if (need_subpass_input && (!msl_options.use_framebuffer_fetch_subpasses)) { switch (builtin) { case BuiltInFragCoord: mark_implicit_builtin(StorageClassInput, BuiltInFragCoord, var.self); builtin_frag_coord_id = var.self; has_frag_coord = true; break; case BuiltInLayer: if (!msl_options.arrayed_subpass_input || msl_options.multiview) break; mark_implicit_builtin(StorageClassInput, BuiltInLayer, var.self); builtin_layer_id = var.self; has_layer = true; break; case BuiltInViewIndex: if (!msl_options.multiview) break; mark_implicit_builtin(StorageClassInput, BuiltInViewIndex, var.self); builtin_view_idx_id = var.self; has_view_idx = true; break; default: break; } } if ((need_sample_pos || needs_sample_id) && builtin == BuiltInSampleId) { builtin_sample_id_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInSampleId, var.self); has_sample_id = true; } if (need_vertex_params) { switch (builtin) { case BuiltInVertexIndex: builtin_vertex_idx_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInVertexIndex, var.self); has_vertex_idx = true; break; case BuiltInBaseVertex: builtin_base_vertex_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInBaseVertex, var.self); has_base_vertex = true; break; case BuiltInInstanceIndex: builtin_instance_idx_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInInstanceIndex, var.self); has_instance_idx = true; break; case BuiltInBaseInstance: builtin_base_instance_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInBaseInstance, var.self); has_base_instance = true; break; default: break; } } if (need_tesc_params) { switch (builtin) { case BuiltInInvocationId: builtin_invocation_id_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInInvocationId, var.self); has_invocation_id = true; break; case BuiltInPrimitiveId: builtin_primitive_id_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInPrimitiveId, var.self); has_primitive_id = true; break; default: break; } } if ((need_subgroup_mask || needs_subgroup_invocation_id) && builtin == BuiltInSubgroupLocalInvocationId) { builtin_subgroup_invocation_id_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInSubgroupLocalInvocationId, var.self); has_subgroup_invocation_id = true; } if ((need_subgroup_ge_mask || needs_subgroup_size) && builtin == BuiltInSubgroupSize) { builtin_subgroup_size_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInSubgroupSize, var.self); has_subgroup_size = true; } if (need_multiview) { switch (builtin) { case BuiltInInstanceIndex: // The view index here is derived from the instance index. builtin_instance_idx_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInInstanceIndex, var.self); has_instance_idx = true; break; case BuiltInBaseInstance: // If a non-zero base instance is used, we need to adjust for it when calculating the view index. builtin_base_instance_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInBaseInstance, var.self); has_base_instance = true; break; case BuiltInViewIndex: builtin_view_idx_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInViewIndex, var.self); has_view_idx = true; break; default: break; } } if (need_local_invocation_index && builtin == BuiltInLocalInvocationIndex) { builtin_local_invocation_index_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInLocalInvocationIndex, var.self); has_local_invocation_index = true; } if (need_workgroup_size && builtin == BuiltInLocalInvocationId) { builtin_workgroup_size_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInWorkgroupSize, var.self); has_workgroup_size = true; } // The base workgroup needs to have the same type and vector size // as the workgroup or invocation ID, so keep track of the type that // was used. if (need_dispatch_base && workgroup_id_type == 0 && (builtin == BuiltInWorkgroupId || builtin == BuiltInGlobalInvocationId)) workgroup_id_type = var.basetype; }); // Use Metal's native frame-buffer fetch API for subpass inputs. if ((!has_frag_coord || (msl_options.multiview && !has_view_idx) || (msl_options.arrayed_subpass_input && !msl_options.multiview && !has_layer)) && (!msl_options.use_framebuffer_fetch_subpasses) && need_subpass_input) { if (!has_frag_coord) { uint32_t offset = ir.increase_bound_by(3); uint32_t type_id = offset; uint32_t type_ptr_id = offset + 1; uint32_t var_id = offset + 2; // Create gl_FragCoord. SPIRType vec4_type; vec4_type.basetype = SPIRType::Float; vec4_type.width = 32; vec4_type.vecsize = 4; set(type_id, vec4_type); SPIRType vec4_type_ptr; vec4_type_ptr = vec4_type; vec4_type_ptr.pointer = true; vec4_type_ptr.parent_type = type_id; vec4_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, vec4_type_ptr); ptr_type.self = type_id; set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInFragCoord); builtin_frag_coord_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInFragCoord, var_id); } if (!has_layer && msl_options.arrayed_subpass_input && !msl_options.multiview) { uint32_t offset = ir.increase_bound_by(2); uint32_t type_ptr_id = offset; uint32_t var_id = offset + 1; // Create gl_Layer. SPIRType uint_type_ptr; uint_type_ptr = get_uint_type(); uint_type_ptr.pointer = true; uint_type_ptr.parent_type = get_uint_type_id(); uint_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, uint_type_ptr); ptr_type.self = get_uint_type_id(); set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInLayer); builtin_layer_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInLayer, var_id); } if (!has_view_idx && msl_options.multiview) { uint32_t offset = ir.increase_bound_by(2); uint32_t type_ptr_id = offset; uint32_t var_id = offset + 1; // Create gl_ViewIndex. SPIRType uint_type_ptr; uint_type_ptr = get_uint_type(); uint_type_ptr.pointer = true; uint_type_ptr.parent_type = get_uint_type_id(); uint_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, uint_type_ptr); ptr_type.self = get_uint_type_id(); set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInViewIndex); builtin_view_idx_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInViewIndex, var_id); } } if (!has_sample_id && (need_sample_pos || needs_sample_id)) { uint32_t offset = ir.increase_bound_by(2); uint32_t type_ptr_id = offset; uint32_t var_id = offset + 1; // Create gl_SampleID. SPIRType uint_type_ptr; uint_type_ptr = get_uint_type(); uint_type_ptr.pointer = true; uint_type_ptr.parent_type = get_uint_type_id(); uint_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, uint_type_ptr); ptr_type.self = get_uint_type_id(); set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInSampleId); builtin_sample_id_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInSampleId, var_id); } if ((need_vertex_params && (!has_vertex_idx || !has_base_vertex || !has_instance_idx || !has_base_instance)) || (need_multiview && (!has_instance_idx || !has_base_instance || !has_view_idx))) { uint32_t type_ptr_id = ir.increase_bound_by(1); SPIRType uint_type_ptr; uint_type_ptr = get_uint_type(); uint_type_ptr.pointer = true; uint_type_ptr.parent_type = get_uint_type_id(); uint_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, uint_type_ptr); ptr_type.self = get_uint_type_id(); if (need_vertex_params && !has_vertex_idx) { uint32_t var_id = ir.increase_bound_by(1); // Create gl_VertexIndex. set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInVertexIndex); builtin_vertex_idx_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInVertexIndex, var_id); } if (need_vertex_params && !has_base_vertex) { uint32_t var_id = ir.increase_bound_by(1); // Create gl_BaseVertex. set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInBaseVertex); builtin_base_vertex_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInBaseVertex, var_id); } if (!has_instance_idx) // Needed by both multiview and tessellation { uint32_t var_id = ir.increase_bound_by(1); // Create gl_InstanceIndex. set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInInstanceIndex); builtin_instance_idx_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInInstanceIndex, var_id); } if (!has_base_instance) // Needed by both multiview and tessellation { uint32_t var_id = ir.increase_bound_by(1); // Create gl_BaseInstance. set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInBaseInstance); builtin_base_instance_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInBaseInstance, var_id); } if (need_multiview) { // Multiview shaders are not allowed to write to gl_Layer, ostensibly because // it is implicitly written from gl_ViewIndex, but we have to do that explicitly. // Note that we can't just abuse gl_ViewIndex for this purpose: it's an input, but // gl_Layer is an output in vertex-pipeline shaders. uint32_t type_ptr_out_id = ir.increase_bound_by(2); SPIRType uint_type_ptr_out; uint_type_ptr_out = get_uint_type(); uint_type_ptr_out.pointer = true; uint_type_ptr_out.parent_type = get_uint_type_id(); uint_type_ptr_out.storage = StorageClassOutput; auto &ptr_out_type = set(type_ptr_out_id, uint_type_ptr_out); ptr_out_type.self = get_uint_type_id(); uint32_t var_id = type_ptr_out_id + 1; set(var_id, type_ptr_out_id, StorageClassOutput); set_decoration(var_id, DecorationBuiltIn, BuiltInLayer); builtin_layer_id = var_id; mark_implicit_builtin(StorageClassOutput, BuiltInLayer, var_id); } if (need_multiview && !has_view_idx) { uint32_t var_id = ir.increase_bound_by(1); // Create gl_ViewIndex. set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInViewIndex); builtin_view_idx_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInViewIndex, var_id); } } if ((need_tesc_params && (msl_options.multi_patch_workgroup || !has_invocation_id || !has_primitive_id)) || need_grid_params) { uint32_t type_ptr_id = ir.increase_bound_by(1); SPIRType uint_type_ptr; uint_type_ptr = get_uint_type(); uint_type_ptr.pointer = true; uint_type_ptr.parent_type = get_uint_type_id(); uint_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, uint_type_ptr); ptr_type.self = get_uint_type_id(); if (msl_options.multi_patch_workgroup || need_grid_params) { uint32_t var_id = ir.increase_bound_by(1); // Create gl_GlobalInvocationID. set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInGlobalInvocationId); builtin_invocation_id_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInGlobalInvocationId, var_id); } else if (need_tesc_params && !has_invocation_id) { uint32_t var_id = ir.increase_bound_by(1); // Create gl_InvocationID. set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInInvocationId); builtin_invocation_id_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInInvocationId, var_id); } if (need_tesc_params && !has_primitive_id) { uint32_t var_id = ir.increase_bound_by(1); // Create gl_PrimitiveID. set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInPrimitiveId); builtin_primitive_id_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInPrimitiveId, var_id); } if (need_grid_params) { uint32_t var_id = ir.increase_bound_by(1); set(var_id, build_extended_vector_type(get_uint_type_id(), 3), StorageClassInput); set_extended_decoration(var_id, SPIRVCrossDecorationBuiltInStageInputSize); get_entry_point().interface_variables.push_back(var_id); set_name(var_id, "spvStageInputSize"); builtin_stage_input_size_id = var_id; } } if (!has_subgroup_invocation_id && (need_subgroup_mask || needs_subgroup_invocation_id)) { uint32_t offset = ir.increase_bound_by(2); uint32_t type_ptr_id = offset; uint32_t var_id = offset + 1; // Create gl_SubgroupInvocationID. SPIRType uint_type_ptr; uint_type_ptr = get_uint_type(); uint_type_ptr.pointer = true; uint_type_ptr.parent_type = get_uint_type_id(); uint_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, uint_type_ptr); ptr_type.self = get_uint_type_id(); set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInSubgroupLocalInvocationId); builtin_subgroup_invocation_id_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInSubgroupLocalInvocationId, var_id); } if (!has_subgroup_size && (need_subgroup_ge_mask || needs_subgroup_size)) { uint32_t offset = ir.increase_bound_by(2); uint32_t type_ptr_id = offset; uint32_t var_id = offset + 1; // Create gl_SubgroupSize. SPIRType uint_type_ptr; uint_type_ptr = get_uint_type(); uint_type_ptr.pointer = true; uint_type_ptr.parent_type = get_uint_type_id(); uint_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, uint_type_ptr); ptr_type.self = get_uint_type_id(); set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInSubgroupSize); builtin_subgroup_size_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInSubgroupSize, var_id); } if (need_dispatch_base || need_vertex_base_params) { if (workgroup_id_type == 0) workgroup_id_type = build_extended_vector_type(get_uint_type_id(), 3); uint32_t var_id; if (msl_options.supports_msl_version(1, 2)) { // If we have MSL 1.2, we can (ab)use the [[grid_origin]] builtin // to convey this information and save a buffer slot. uint32_t offset = ir.increase_bound_by(1); var_id = offset; set(var_id, workgroup_id_type, StorageClassInput); set_extended_decoration(var_id, SPIRVCrossDecorationBuiltInDispatchBase); get_entry_point().interface_variables.push_back(var_id); } else { // Otherwise, we need to fall back to a good ol' fashioned buffer. uint32_t offset = ir.increase_bound_by(2); var_id = offset; uint32_t type_id = offset + 1; SPIRType var_type = get(workgroup_id_type); var_type.storage = StorageClassUniform; set(type_id, var_type); set(var_id, type_id, StorageClassUniform); // This should never match anything. set_decoration(var_id, DecorationDescriptorSet, ~(5u)); set_decoration(var_id, DecorationBinding, msl_options.indirect_params_buffer_index); set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary, msl_options.indirect_params_buffer_index); } set_name(var_id, "spvDispatchBase"); builtin_dispatch_base_id = var_id; } if (need_sample_mask && !does_shader_write_sample_mask) { uint32_t offset = ir.increase_bound_by(2); uint32_t var_id = offset + 1; // Create gl_SampleMask. SPIRType uint_type_ptr_out; uint_type_ptr_out = get_uint_type(); uint_type_ptr_out.pointer = true; uint_type_ptr_out.parent_type = get_uint_type_id(); uint_type_ptr_out.storage = StorageClassOutput; auto &ptr_out_type = set(offset, uint_type_ptr_out); ptr_out_type.self = get_uint_type_id(); set(var_id, offset, StorageClassOutput); set_decoration(var_id, DecorationBuiltIn, BuiltInSampleMask); builtin_sample_mask_id = var_id; mark_implicit_builtin(StorageClassOutput, BuiltInSampleMask, var_id); } if (need_local_invocation_index && !has_local_invocation_index) { uint32_t offset = ir.increase_bound_by(2); uint32_t type_ptr_id = offset; uint32_t var_id = offset + 1; // Create gl_LocalInvocationIndex. SPIRType uint_type_ptr; uint_type_ptr = get_uint_type(); uint_type_ptr.pointer = true; uint_type_ptr.parent_type = get_uint_type_id(); uint_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, uint_type_ptr); ptr_type.self = get_uint_type_id(); set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInLocalInvocationIndex); builtin_local_invocation_index_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInLocalInvocationIndex, var_id); } if (need_workgroup_size && !has_workgroup_size) { uint32_t offset = ir.increase_bound_by(2); uint32_t type_ptr_id = offset; uint32_t var_id = offset + 1; // Create gl_WorkgroupSize. uint32_t type_id = build_extended_vector_type(get_uint_type_id(), 3); SPIRType uint_type_ptr = get(type_id); uint_type_ptr.pointer = true; uint_type_ptr.parent_type = type_id; uint_type_ptr.storage = StorageClassInput; auto &ptr_type = set(type_ptr_id, uint_type_ptr); ptr_type.self = type_id; set(var_id, type_ptr_id, StorageClassInput); set_decoration(var_id, DecorationBuiltIn, BuiltInWorkgroupSize); builtin_workgroup_size_id = var_id; mark_implicit_builtin(StorageClassInput, BuiltInWorkgroupSize, var_id); } } if (needs_swizzle_buffer_def) { uint32_t var_id = build_constant_uint_array_pointer(); set_name(var_id, "spvSwizzleConstants"); // This should never match anything. set_decoration(var_id, DecorationDescriptorSet, kSwizzleBufferBinding); set_decoration(var_id, DecorationBinding, msl_options.swizzle_buffer_index); set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary, msl_options.swizzle_buffer_index); swizzle_buffer_id = var_id; } if (!buffers_requiring_array_length.empty()) { uint32_t var_id = build_constant_uint_array_pointer(); set_name(var_id, "spvBufferSizeConstants"); // This should never match anything. set_decoration(var_id, DecorationDescriptorSet, kBufferSizeBufferBinding); set_decoration(var_id, DecorationBinding, msl_options.buffer_size_buffer_index); set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary, msl_options.buffer_size_buffer_index); buffer_size_buffer_id = var_id; } if (needs_view_mask_buffer()) { uint32_t var_id = build_constant_uint_array_pointer(); set_name(var_id, "spvViewMask"); // This should never match anything. set_decoration(var_id, DecorationDescriptorSet, ~(4u)); set_decoration(var_id, DecorationBinding, msl_options.view_mask_buffer_index); set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary, msl_options.view_mask_buffer_index); view_mask_buffer_id = var_id; } if (!buffers_requiring_dynamic_offset.empty()) { uint32_t var_id = build_constant_uint_array_pointer(); set_name(var_id, "spvDynamicOffsets"); // This should never match anything. set_decoration(var_id, DecorationDescriptorSet, ~(5u)); set_decoration(var_id, DecorationBinding, msl_options.dynamic_offsets_buffer_index); set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary, msl_options.dynamic_offsets_buffer_index); dynamic_offsets_buffer_id = var_id; } } // Checks if the specified builtin variable (e.g. gl_InstanceIndex) is marked as active. // If not, it marks it as active and forces a recompilation. // This might be used when the optimization of inactive builtins was too optimistic (e.g. when "spvOut" is emitted). void CompilerMSL::ensure_builtin(spv::StorageClass storage, spv::BuiltIn builtin) { Bitset *active_builtins = nullptr; switch (storage) { case StorageClassInput: active_builtins = &active_input_builtins; break; case StorageClassOutput: active_builtins = &active_output_builtins; break; default: break; } // At this point, the specified builtin variable must have already been declared in the entry point. // If not, mark as active and force recompile. if (active_builtins != nullptr && !active_builtins->get(builtin)) { active_builtins->set(builtin); force_recompile(); } } void CompilerMSL::mark_implicit_builtin(StorageClass storage, BuiltIn builtin, uint32_t id) { Bitset *active_builtins = nullptr; switch (storage) { case StorageClassInput: active_builtins = &active_input_builtins; break; case StorageClassOutput: active_builtins = &active_output_builtins; break; default: break; } assert(active_builtins != nullptr); active_builtins->set(builtin); auto &var = get_entry_point().interface_variables; if (find(begin(var), end(var), VariableID(id)) == end(var)) var.push_back(id); } uint32_t CompilerMSL::build_constant_uint_array_pointer() { uint32_t offset = ir.increase_bound_by(3); uint32_t type_ptr_id = offset; uint32_t type_ptr_ptr_id = offset + 1; uint32_t var_id = offset + 2; // Create a buffer to hold extra data, including the swizzle constants. SPIRType uint_type_pointer = get_uint_type(); uint_type_pointer.pointer = true; uint_type_pointer.pointer_depth = 1; uint_type_pointer.parent_type = get_uint_type_id(); uint_type_pointer.storage = StorageClassUniform; set(type_ptr_id, uint_type_pointer); set_decoration(type_ptr_id, DecorationArrayStride, 4); SPIRType uint_type_pointer2 = uint_type_pointer; uint_type_pointer2.pointer_depth++; uint_type_pointer2.parent_type = type_ptr_id; set(type_ptr_ptr_id, uint_type_pointer2); set(var_id, type_ptr_ptr_id, StorageClassUniformConstant); return var_id; } static string create_sampler_address(const char *prefix, MSLSamplerAddress addr) { switch (addr) { case MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE: return join(prefix, "address::clamp_to_edge"); case MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO: return join(prefix, "address::clamp_to_zero"); case MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER: return join(prefix, "address::clamp_to_border"); case MSL_SAMPLER_ADDRESS_REPEAT: return join(prefix, "address::repeat"); case MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT: return join(prefix, "address::mirrored_repeat"); default: SPIRV_CROSS_THROW("Invalid sampler addressing mode."); } } SPIRType &CompilerMSL::get_stage_in_struct_type() { auto &si_var = get(stage_in_var_id); return get_variable_data_type(si_var); } SPIRType &CompilerMSL::get_stage_out_struct_type() { auto &so_var = get(stage_out_var_id); return get_variable_data_type(so_var); } SPIRType &CompilerMSL::get_patch_stage_in_struct_type() { auto &si_var = get(patch_stage_in_var_id); return get_variable_data_type(si_var); } SPIRType &CompilerMSL::get_patch_stage_out_struct_type() { auto &so_var = get(patch_stage_out_var_id); return get_variable_data_type(so_var); } std::string CompilerMSL::get_tess_factor_struct_name() { if (get_entry_point().flags.get(ExecutionModeTriangles)) return "MTLTriangleTessellationFactorsHalf"; return "MTLQuadTessellationFactorsHalf"; } SPIRType &CompilerMSL::get_uint_type() { return get(get_uint_type_id()); } uint32_t CompilerMSL::get_uint_type_id() { if (uint_type_id != 0) return uint_type_id; uint_type_id = ir.increase_bound_by(1); SPIRType type; type.basetype = SPIRType::UInt; type.width = 32; set(uint_type_id, type); return uint_type_id; } void CompilerMSL::emit_entry_point_declarations() { // FIXME: Get test coverage here ... // Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries declare_complex_constant_arrays(); // Emit constexpr samplers here. for (auto &samp : constexpr_samplers_by_id) { auto &var = get(samp.first); auto &type = get(var.basetype); if (type.basetype == SPIRType::Sampler) add_resource_name(samp.first); SmallVector args; auto &s = samp.second; if (s.coord != MSL_SAMPLER_COORD_NORMALIZED) args.push_back("coord::pixel"); if (s.min_filter == s.mag_filter) { if (s.min_filter != MSL_SAMPLER_FILTER_NEAREST) args.push_back("filter::linear"); } else { if (s.min_filter != MSL_SAMPLER_FILTER_NEAREST) args.push_back("min_filter::linear"); if (s.mag_filter != MSL_SAMPLER_FILTER_NEAREST) args.push_back("mag_filter::linear"); } switch (s.mip_filter) { case MSL_SAMPLER_MIP_FILTER_NONE: // Default break; case MSL_SAMPLER_MIP_FILTER_NEAREST: args.push_back("mip_filter::nearest"); break; case MSL_SAMPLER_MIP_FILTER_LINEAR: args.push_back("mip_filter::linear"); break; default: SPIRV_CROSS_THROW("Invalid mip filter."); } if (s.s_address == s.t_address && s.s_address == s.r_address) { if (s.s_address != MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE) args.push_back(create_sampler_address("", s.s_address)); } else { if (s.s_address != MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE) args.push_back(create_sampler_address("s_", s.s_address)); if (s.t_address != MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE) args.push_back(create_sampler_address("t_", s.t_address)); if (s.r_address != MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE) args.push_back(create_sampler_address("r_", s.r_address)); } if (s.compare_enable) { switch (s.compare_func) { case MSL_SAMPLER_COMPARE_FUNC_ALWAYS: args.push_back("compare_func::always"); break; case MSL_SAMPLER_COMPARE_FUNC_NEVER: args.push_back("compare_func::never"); break; case MSL_SAMPLER_COMPARE_FUNC_EQUAL: args.push_back("compare_func::equal"); break; case MSL_SAMPLER_COMPARE_FUNC_NOT_EQUAL: args.push_back("compare_func::not_equal"); break; case MSL_SAMPLER_COMPARE_FUNC_LESS: args.push_back("compare_func::less"); break; case MSL_SAMPLER_COMPARE_FUNC_LESS_EQUAL: args.push_back("compare_func::less_equal"); break; case MSL_SAMPLER_COMPARE_FUNC_GREATER: args.push_back("compare_func::greater"); break; case MSL_SAMPLER_COMPARE_FUNC_GREATER_EQUAL: args.push_back("compare_func::greater_equal"); break; default: SPIRV_CROSS_THROW("Invalid sampler compare function."); } } if (s.s_address == MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER || s.t_address == MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER || s.r_address == MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER) { switch (s.border_color) { case MSL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK: args.push_back("border_color::opaque_black"); break; case MSL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE: args.push_back("border_color::opaque_white"); break; case MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK: args.push_back("border_color::transparent_black"); break; default: SPIRV_CROSS_THROW("Invalid sampler border color."); } } if (s.anisotropy_enable) args.push_back(join("max_anisotropy(", s.max_anisotropy, ")")); if (s.lod_clamp_enable) { args.push_back(join("lod_clamp(", convert_to_string(s.lod_clamp_min, current_locale_radix_character), ", ", convert_to_string(s.lod_clamp_max, current_locale_radix_character), ")")); } // If we would emit no arguments, then omit the parentheses entirely. Otherwise, // we'll wind up with a "most vexing parse" situation. if (args.empty()) statement("constexpr sampler ", type.basetype == SPIRType::SampledImage ? to_sampler_expression(samp.first) : to_name(samp.first), ";"); else statement("constexpr sampler ", type.basetype == SPIRType::SampledImage ? to_sampler_expression(samp.first) : to_name(samp.first), "(", merge(args), ");"); } // Emit dynamic buffers here. for (auto &dynamic_buffer : buffers_requiring_dynamic_offset) { if (!dynamic_buffer.second.second) { // Could happen if no buffer was used at requested binding point. continue; } const auto &var = get(dynamic_buffer.second.second); uint32_t var_id = var.self; const auto &type = get_variable_data_type(var); string name = to_name(var.self); uint32_t desc_set = get_decoration(var.self, DecorationDescriptorSet); uint32_t arg_id = argument_buffer_ids[desc_set]; uint32_t base_index = dynamic_buffer.second.first; if (!type.array.empty()) { // This is complicated, because we need to support arrays of arrays. // And it's even worse if the outermost dimension is a runtime array, because now // all this complicated goop has to go into the shader itself. (FIXME) if (!type.array[type.array.size() - 1]) SPIRV_CROSS_THROW("Runtime arrays with dynamic offsets are not supported yet."); else { is_using_builtin_array = true; statement(get_argument_address_space(var), " ", type_to_glsl(type), "* ", to_restrict(var_id), name, type_to_array_glsl(type), " ="); uint32_t dim = uint32_t(type.array.size()); uint32_t j = 0; for (SmallVector indices(type.array.size()); indices[type.array.size() - 1] < to_array_size_literal(type); j++) { while (dim > 0) { begin_scope(); --dim; } string arrays; for (uint32_t i = uint32_t(type.array.size()); i; --i) arrays += join("[", indices[i - 1], "]"); statement("(", get_argument_address_space(var), " ", type_to_glsl(type), "* ", to_restrict(var_id, false), ")((", get_argument_address_space(var), " char* ", to_restrict(var_id, false), ")", to_name(arg_id), ".", ensure_valid_name(name, "m"), arrays, " + ", to_name(dynamic_offsets_buffer_id), "[", base_index + j, "]),"); while (++indices[dim] >= to_array_size_literal(type, dim) && dim < type.array.size() - 1) { end_scope(","); indices[dim++] = 0; } } end_scope_decl(); statement_no_indent(""); is_using_builtin_array = false; } } else { statement(get_argument_address_space(var), " auto& ", to_restrict(var_id), name, " = *(", get_argument_address_space(var), " ", type_to_glsl(type), "* ", to_restrict(var_id, false), ")((", get_argument_address_space(var), " char* ", to_restrict(var_id, false), ")", to_name(arg_id), ".", ensure_valid_name(name, "m"), " + ", to_name(dynamic_offsets_buffer_id), "[", base_index, "]);"); } } // Emit buffer arrays here. for (uint32_t array_id : buffer_arrays) { const auto &var = get(array_id); const auto &type = get_variable_data_type(var); const auto &buffer_type = get_variable_element_type(var); string name = to_name(array_id); statement(get_argument_address_space(var), " ", type_to_glsl(buffer_type), "* ", to_restrict(array_id), name, "[] ="); begin_scope(); for (uint32_t i = 0; i < to_array_size_literal(type); ++i) statement(name, "_", i, ","); end_scope_decl(); statement_no_indent(""); } // For some reason, without this, we end up emitting the arrays twice. buffer_arrays.clear(); // Emit disabled fragment outputs. std::sort(disabled_frag_outputs.begin(), disabled_frag_outputs.end()); for (uint32_t var_id : disabled_frag_outputs) { auto &var = get(var_id); add_local_variable_name(var_id); statement(variable_decl(var), ";"); var.deferred_declaration = false; } } string CompilerMSL::compile() { replace_illegal_entry_point_names(); ir.fixup_reserved_names(); // Do not deal with GLES-isms like precision, older extensions and such. options.vulkan_semantics = true; options.es = false; options.version = 450; backend.null_pointer_literal = "nullptr"; backend.float_literal_suffix = false; backend.uint32_t_literal_suffix = true; backend.int16_t_literal_suffix = ""; backend.uint16_t_literal_suffix = ""; backend.basic_int_type = "int"; backend.basic_uint_type = "uint"; backend.basic_int8_type = "char"; backend.basic_uint8_type = "uchar"; backend.basic_int16_type = "short"; backend.basic_uint16_type = "ushort"; backend.discard_literal = "discard_fragment()"; backend.demote_literal = "discard_fragment()"; backend.boolean_mix_function = "select"; backend.swizzle_is_function = false; backend.shared_is_implied = false; backend.use_initializer_list = true; backend.use_typed_initializer_list = true; backend.native_row_major_matrix = false; backend.unsized_array_supported = false; backend.can_declare_arrays_inline = false; backend.allow_truncated_access_chain = true; backend.comparison_image_samples_scalar = true; backend.native_pointers = true; backend.nonuniform_qualifier = ""; backend.support_small_type_sampling_result = true; backend.supports_empty_struct = true; // Allow Metal to use the array template unless we force it off. backend.can_return_array = !msl_options.force_native_arrays; backend.array_is_value_type = !msl_options.force_native_arrays; // Arrays which are part of buffer objects are never considered to be native arrays. backend.buffer_offset_array_is_value_type = false; capture_output_to_buffer = msl_options.capture_output_to_buffer; is_rasterization_disabled = msl_options.disable_rasterization || capture_output_to_buffer; // Initialize array here rather than constructor, MSVC 2013 workaround. for (auto &id : next_metal_resource_ids) id = 0; fixup_type_alias(); replace_illegal_names(); sync_entry_point_aliases_and_names(); build_function_control_flow_graphs_and_analyze(); update_active_builtins(); analyze_image_and_sampler_usage(); analyze_sampled_image_usage(); analyze_interlocked_resource_usage(); preprocess_op_codes(); build_implicit_builtins(); fixup_image_load_store_access(); set_enabled_interface_variables(get_active_interface_variables()); if (msl_options.force_active_argument_buffer_resources) activate_argument_buffer_resources(); if (swizzle_buffer_id) active_interface_variables.insert(swizzle_buffer_id); if (buffer_size_buffer_id) active_interface_variables.insert(buffer_size_buffer_id); if (view_mask_buffer_id) active_interface_variables.insert(view_mask_buffer_id); if (dynamic_offsets_buffer_id) active_interface_variables.insert(dynamic_offsets_buffer_id); if (builtin_layer_id) active_interface_variables.insert(builtin_layer_id); if (builtin_dispatch_base_id && !msl_options.supports_msl_version(1, 2)) active_interface_variables.insert(builtin_dispatch_base_id); if (builtin_sample_mask_id) active_interface_variables.insert(builtin_sample_mask_id); // Create structs to hold input, output and uniform variables. // Do output first to ensure out. is declared at top of entry function. qual_pos_var_name = ""; stage_out_var_id = add_interface_block(StorageClassOutput); patch_stage_out_var_id = add_interface_block(StorageClassOutput, true); stage_in_var_id = add_interface_block(StorageClassInput); if (get_execution_model() == ExecutionModelTessellationEvaluation) patch_stage_in_var_id = add_interface_block(StorageClassInput, true); if (get_execution_model() == ExecutionModelTessellationControl) stage_out_ptr_var_id = add_interface_block_pointer(stage_out_var_id, StorageClassOutput); if (is_tessellation_shader()) stage_in_ptr_var_id = add_interface_block_pointer(stage_in_var_id, StorageClassInput); // Metal vertex functions that define no output must disable rasterization and return void. if (!stage_out_var_id) is_rasterization_disabled = true; // Convert the use of global variables to recursively-passed function parameters localize_global_variables(); extract_global_variables_from_functions(); // Mark any non-stage-in structs to be tightly packed. mark_packable_structs(); reorder_type_alias(); // Add fixup hooks required by shader inputs and outputs. This needs to happen before // the loop, so the hooks aren't added multiple times. fix_up_shader_inputs_outputs(); // If we are using argument buffers, we create argument buffer structures for them here. // These buffers will be used in the entry point, not the individual resources. if (msl_options.argument_buffers) { if (!msl_options.supports_msl_version(2, 0)) SPIRV_CROSS_THROW("Argument buffers can only be used with MSL 2.0 and up."); analyze_argument_buffers(); } uint32_t pass_count = 0; do { if (pass_count >= 3) SPIRV_CROSS_THROW("Over 3 compilation loops detected. Must be a bug!"); reset(); // Start bindings at zero. next_metal_resource_index_buffer = 0; next_metal_resource_index_texture = 0; next_metal_resource_index_sampler = 0; for (auto &id : next_metal_resource_ids) id = 0; // Move constructor for this type is broken on GCC 4.9 ... buffer.reset(); emit_header(); emit_custom_templates(); emit_specialization_constants_and_structs(); emit_resources(); emit_custom_functions(); emit_function(get(ir.default_entry_point), Bitset()); pass_count++; } while (is_forcing_recompilation()); return buffer.str(); } // Register the need to output any custom functions. void CompilerMSL::preprocess_op_codes() { OpCodePreprocessor preproc(*this); traverse_all_reachable_opcodes(get(ir.default_entry_point), preproc); suppress_missing_prototypes = preproc.suppress_missing_prototypes; if (preproc.uses_atomics) { add_header_line("#include "); add_pragma_line("#pragma clang diagnostic ignored \"-Wunused-variable\""); } // Before MSL 2.1 (2.2 for textures), Metal vertex functions that write to // resources must disable rasterization and return void. if (preproc.uses_resource_write) is_rasterization_disabled = true; // Tessellation control shaders are run as compute functions in Metal, and so // must capture their output to a buffer. if (get_execution_model() == ExecutionModelTessellationControl || (get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation)) { is_rasterization_disabled = true; capture_output_to_buffer = true; } if (preproc.needs_subgroup_invocation_id) needs_subgroup_invocation_id = true; if (preproc.needs_subgroup_size) needs_subgroup_size = true; // build_implicit_builtins() hasn't run yet, and in fact, this needs to execute // before then so that gl_SampleID will get added; so we also need to check if // that function would add gl_FragCoord. if (preproc.needs_sample_id || msl_options.force_sample_rate_shading || (is_sample_rate() && (active_input_builtins.get(BuiltInFragCoord) || (need_subpass_input && !msl_options.use_framebuffer_fetch_subpasses)))) needs_sample_id = true; } // Move the Private and Workgroup global variables to the entry function. // Non-constant variables cannot have global scope in Metal. void CompilerMSL::localize_global_variables() { auto &entry_func = get(ir.default_entry_point); auto iter = global_variables.begin(); while (iter != global_variables.end()) { uint32_t v_id = *iter; auto &var = get(v_id); if (var.storage == StorageClassPrivate || var.storage == StorageClassWorkgroup) { if (!variable_is_lut(var)) entry_func.add_local_variable(v_id); iter = global_variables.erase(iter); } else iter++; } } // For any global variable accessed directly by a function, // extract that variable and add it as an argument to that function. void CompilerMSL::extract_global_variables_from_functions() { // Uniforms unordered_set global_var_ids; ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { if (var.storage == StorageClassInput || var.storage == StorageClassOutput || var.storage == StorageClassUniform || var.storage == StorageClassUniformConstant || var.storage == StorageClassPushConstant || var.storage == StorageClassStorageBuffer) { global_var_ids.insert(var.self); } }); // Local vars that are declared in the main function and accessed directly by a function auto &entry_func = get(ir.default_entry_point); for (auto &var : entry_func.local_variables) if (get(var).storage != StorageClassFunction) global_var_ids.insert(var); std::set added_arg_ids; unordered_set processed_func_ids; extract_global_variables_from_function(ir.default_entry_point, added_arg_ids, global_var_ids, processed_func_ids); } // MSL does not support the use of global variables for shader input content. // For any global variable accessed directly by the specified function, extract that variable, // add it as an argument to that function, and the arg to the added_arg_ids collection. void CompilerMSL::extract_global_variables_from_function(uint32_t func_id, std::set &added_arg_ids, unordered_set &global_var_ids, unordered_set &processed_func_ids) { // Avoid processing a function more than once if (processed_func_ids.find(func_id) != processed_func_ids.end()) { // Return function global variables added_arg_ids = function_global_vars[func_id]; return; } processed_func_ids.insert(func_id); auto &func = get(func_id); // Recursively establish global args added to functions on which we depend. for (auto block : func.blocks) { auto &b = get(block); for (auto &i : b.ops) { auto ops = stream(i); auto op = static_cast(i.op); switch (op) { case OpLoad: case OpInBoundsAccessChain: case OpAccessChain: case OpPtrAccessChain: case OpArrayLength: { uint32_t base_id = ops[2]; if (global_var_ids.find(base_id) != global_var_ids.end()) added_arg_ids.insert(base_id); // Use Metal's native frame-buffer fetch API for subpass inputs. auto &type = get(ops[0]); if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData && (!msl_options.use_framebuffer_fetch_subpasses)) { // Implicitly reads gl_FragCoord. assert(builtin_frag_coord_id != 0); added_arg_ids.insert(builtin_frag_coord_id); if (msl_options.multiview) { // Implicitly reads gl_ViewIndex. assert(builtin_view_idx_id != 0); added_arg_ids.insert(builtin_view_idx_id); } else if (msl_options.arrayed_subpass_input) { // Implicitly reads gl_Layer. assert(builtin_layer_id != 0); added_arg_ids.insert(builtin_layer_id); } } break; } case OpFunctionCall: { // First see if any of the function call args are globals for (uint32_t arg_idx = 3; arg_idx < i.length; arg_idx++) { uint32_t arg_id = ops[arg_idx]; if (global_var_ids.find(arg_id) != global_var_ids.end()) added_arg_ids.insert(arg_id); } // Then recurse into the function itself to extract globals used internally in the function uint32_t inner_func_id = ops[2]; std::set inner_func_args; extract_global_variables_from_function(inner_func_id, inner_func_args, global_var_ids, processed_func_ids); added_arg_ids.insert(inner_func_args.begin(), inner_func_args.end()); break; } case OpStore: { uint32_t base_id = ops[0]; if (global_var_ids.find(base_id) != global_var_ids.end()) added_arg_ids.insert(base_id); uint32_t rvalue_id = ops[1]; if (global_var_ids.find(rvalue_id) != global_var_ids.end()) added_arg_ids.insert(rvalue_id); break; } case OpSelect: { uint32_t base_id = ops[3]; if (global_var_ids.find(base_id) != global_var_ids.end()) added_arg_ids.insert(base_id); base_id = ops[4]; if (global_var_ids.find(base_id) != global_var_ids.end()) added_arg_ids.insert(base_id); break; } // Emulate texture2D atomic operations case OpImageTexelPointer: { // When using the pointer, we need to know which variable it is actually loaded from. uint32_t base_id = ops[2]; auto *var = maybe_get_backing_variable(base_id); if (var && atomic_image_vars.count(var->self)) { if (global_var_ids.find(base_id) != global_var_ids.end()) added_arg_ids.insert(base_id); } break; } case OpExtInst: { uint32_t extension_set = ops[2]; if (get(extension_set).ext == SPIRExtension::GLSL) { auto op_450 = static_cast(ops[3]); switch (op_450) { case GLSLstd450InterpolateAtCentroid: case GLSLstd450InterpolateAtSample: case GLSLstd450InterpolateAtOffset: { // For these, we really need the stage-in block. It is theoretically possible to pass the // interpolant object, but a) doing so would require us to create an entirely new variable // with Interpolant type, and b) if we have a struct or array, handling all the members and // elements could get unwieldy fast. added_arg_ids.insert(stage_in_var_id); break; } default: break; } } break; } case OpGroupNonUniformInverseBallot: { added_arg_ids.insert(builtin_subgroup_invocation_id_id); break; } case OpGroupNonUniformBallotFindLSB: case OpGroupNonUniformBallotFindMSB: { added_arg_ids.insert(builtin_subgroup_size_id); break; } case OpGroupNonUniformBallotBitCount: { auto operation = static_cast(ops[3]); switch (operation) { case GroupOperationReduce: added_arg_ids.insert(builtin_subgroup_size_id); break; case GroupOperationInclusiveScan: case GroupOperationExclusiveScan: added_arg_ids.insert(builtin_subgroup_invocation_id_id); break; default: break; } break; } default: break; } // TODO: Add all other operations which can affect memory. // We should consider a more unified system here to reduce boiler-plate. // This kind of analysis is done in several places ... } } function_global_vars[func_id] = added_arg_ids; // Add the global variables as arguments to the function if (func_id != ir.default_entry_point) { bool added_in = false; bool added_out = false; for (uint32_t arg_id : added_arg_ids) { auto &var = get(arg_id); uint32_t type_id = var.basetype; auto *p_type = &get(type_id); BuiltIn bi_type = BuiltIn(get_decoration(arg_id, DecorationBuiltIn)); if (((is_tessellation_shader() && var.storage == StorageClassInput) || (get_execution_model() == ExecutionModelTessellationControl && var.storage == StorageClassOutput)) && !(has_decoration(arg_id, DecorationPatch) || is_patch_block(*p_type)) && (!is_builtin_variable(var) || bi_type == BuiltInPosition || bi_type == BuiltInPointSize || bi_type == BuiltInClipDistance || bi_type == BuiltInCullDistance || p_type->basetype == SPIRType::Struct)) { // Tessellation control shaders see inputs and per-vertex outputs as arrays. // Similarly, tessellation evaluation shaders see per-vertex inputs as arrays. // We collected them into a structure; we must pass the array of this // structure to the function. std::string name; if (var.storage == StorageClassInput) { if (added_in) continue; name = "gl_in"; arg_id = stage_in_ptr_var_id; added_in = true; } else if (var.storage == StorageClassOutput) { if (added_out) continue; name = "gl_out"; arg_id = stage_out_ptr_var_id; added_out = true; } type_id = get(arg_id).basetype; uint32_t next_id = ir.increase_bound_by(1); func.add_parameter(type_id, next_id, true); set(next_id, type_id, StorageClassFunction, 0, arg_id); set_name(next_id, name); } else if (is_builtin_variable(var) && p_type->basetype == SPIRType::Struct) { // Get the pointee type type_id = get_pointee_type_id(type_id); p_type = &get(type_id); uint32_t mbr_idx = 0; for (auto &mbr_type_id : p_type->member_types) { BuiltIn builtin = BuiltInMax; bool is_builtin = is_member_builtin(*p_type, mbr_idx, &builtin); if (is_builtin && has_active_builtin(builtin, var.storage)) { // Add a arg variable with the same type and decorations as the member uint32_t next_ids = ir.increase_bound_by(2); uint32_t ptr_type_id = next_ids + 0; uint32_t var_id = next_ids + 1; // Make sure we have an actual pointer type, // so that we will get the appropriate address space when declaring these builtins. auto &ptr = set(ptr_type_id, get(mbr_type_id)); ptr.self = mbr_type_id; ptr.storage = var.storage; ptr.pointer = true; ptr.parent_type = mbr_type_id; func.add_parameter(mbr_type_id, var_id, true); set(var_id, ptr_type_id, StorageClassFunction); ir.meta[var_id].decoration = ir.meta[type_id].members[mbr_idx]; } mbr_idx++; } } else { uint32_t next_id = ir.increase_bound_by(1); func.add_parameter(type_id, next_id, true); set(next_id, type_id, StorageClassFunction, 0, arg_id); // Ensure the existing variable has a valid name and the new variable has all the same meta info set_name(arg_id, ensure_valid_name(to_name(arg_id), "v")); ir.meta[next_id] = ir.meta[arg_id]; } } } } // For all variables that are some form of non-input-output interface block, mark that all the structs // that are recursively contained within the type referenced by that variable should be packed tightly. void CompilerMSL::mark_packable_structs() { ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { if (var.storage != StorageClassFunction && !is_hidden_variable(var)) { auto &type = this->get(var.basetype); if (type.pointer && (type.storage == StorageClassUniform || type.storage == StorageClassUniformConstant || type.storage == StorageClassPushConstant || type.storage == StorageClassStorageBuffer) && (has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock))) mark_as_packable(type); } }); } // If the specified type is a struct, it and any nested structs // are marked as packable with the SPIRVCrossDecorationBufferBlockRepacked decoration, void CompilerMSL::mark_as_packable(SPIRType &type) { // If this is not the base type (eg. it's a pointer or array), tunnel down if (type.parent_type) { mark_as_packable(get(type.parent_type)); return; } if (type.basetype == SPIRType::Struct) { set_extended_decoration(type.self, SPIRVCrossDecorationBufferBlockRepacked); // Recurse uint32_t mbr_cnt = uint32_t(type.member_types.size()); for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++) { uint32_t mbr_type_id = type.member_types[mbr_idx]; auto &mbr_type = get(mbr_type_id); mark_as_packable(mbr_type); if (mbr_type.type_alias) { auto &mbr_type_alias = get(mbr_type.type_alias); mark_as_packable(mbr_type_alias); } } } } // If a shader input exists at the location, it is marked as being used by this shader void CompilerMSL::mark_location_as_used_by_shader(uint32_t location, const SPIRType &type, StorageClass storage) { if (storage != StorageClassInput) return; if (is_array(type)) { uint32_t dim = 1; for (uint32_t i = 0; i < type.array.size(); i++) dim *= to_array_size_literal(type, i); for (uint32_t i = 0; i < dim; i++) { if (is_matrix(type)) { for (uint32_t j = 0; j < type.columns; j++) inputs_in_use.insert(location++); } else inputs_in_use.insert(location++); } } else if (is_matrix(type)) { for (uint32_t i = 0; i < type.columns; i++) inputs_in_use.insert(location + i); } else inputs_in_use.insert(location); } uint32_t CompilerMSL::get_target_components_for_fragment_location(uint32_t location) const { auto itr = fragment_output_components.find(location); if (itr == end(fragment_output_components)) return 4; else return itr->second; } uint32_t CompilerMSL::build_extended_vector_type(uint32_t type_id, uint32_t components, SPIRType::BaseType basetype) { uint32_t new_type_id = ir.increase_bound_by(1); auto &old_type = get(type_id); auto *type = &set(new_type_id, old_type); type->vecsize = components; if (basetype != SPIRType::Unknown) type->basetype = basetype; type->self = new_type_id; type->parent_type = type_id; type->array.clear(); type->array_size_literal.clear(); type->pointer = false; if (is_array(old_type)) { uint32_t array_type_id = ir.increase_bound_by(1); type = &set(array_type_id, *type); type->parent_type = new_type_id; type->array = old_type.array; type->array_size_literal = old_type.array_size_literal; new_type_id = array_type_id; } if (old_type.pointer) { uint32_t ptr_type_id = ir.increase_bound_by(1); type = &set(ptr_type_id, *type); type->self = new_type_id; type->parent_type = new_type_id; type->storage = old_type.storage; type->pointer = true; new_type_id = ptr_type_id; } return new_type_id; } uint32_t CompilerMSL::build_msl_interpolant_type(uint32_t type_id, bool is_noperspective) { uint32_t new_type_id = ir.increase_bound_by(1); SPIRType &type = set(new_type_id, get(type_id)); type.basetype = SPIRType::Interpolant; type.parent_type = type_id; // In Metal, the pull-model interpolant type encodes perspective-vs-no-perspective in the type itself. // Add this decoration so we know which argument to pass to the template. if (is_noperspective) set_decoration(new_type_id, DecorationNoPerspective); return new_type_id; } void CompilerMSL::add_plain_variable_to_interface_block(StorageClass storage, const string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta) { bool is_builtin = is_builtin_variable(var); BuiltIn builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn)); bool is_flat = has_decoration(var.self, DecorationFlat); bool is_noperspective = has_decoration(var.self, DecorationNoPerspective); bool is_centroid = has_decoration(var.self, DecorationCentroid); bool is_sample = has_decoration(var.self, DecorationSample); // Add a reference to the variable type to the interface struct. uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size()); uint32_t type_id = ensure_correct_builtin_type(var.basetype, builtin); var.basetype = type_id; type_id = get_pointee_type_id(var.basetype); if (meta.strip_array && is_array(get(type_id))) type_id = get(type_id).parent_type; auto &type = get(type_id); uint32_t target_components = 0; uint32_t type_components = type.vecsize; bool padded_output = false; bool padded_input = false; uint32_t start_component = 0; auto &entry_func = get(ir.default_entry_point); // Deal with Component decorations. InterfaceBlockMeta::LocationMeta *location_meta = nullptr; if (has_decoration(var.self, DecorationLocation)) { auto location_meta_itr = meta.location_meta.find(get_decoration(var.self, DecorationLocation)); if (location_meta_itr != end(meta.location_meta)) location_meta = &location_meta_itr->second; } bool pad_fragment_output = has_decoration(var.self, DecorationLocation) && msl_options.pad_fragment_output_components && get_entry_point().model == ExecutionModelFragment && storage == StorageClassOutput; // Check if we need to pad fragment output to match a certain number of components. if (location_meta) { start_component = get_decoration(var.self, DecorationComponent); uint32_t num_components = location_meta->num_components; if (pad_fragment_output) { uint32_t locn = get_decoration(var.self, DecorationLocation); num_components = std::max(num_components, get_target_components_for_fragment_location(locn)); } if (location_meta->ib_index != ~0u) { // We have already declared the variable. Just emit an early-declared variable and fixup as needed. entry_func.add_local_variable(var.self); vars_needing_early_declaration.push_back(var.self); if (var.storage == StorageClassInput) { uint32_t ib_index = location_meta->ib_index; entry_func.fixup_hooks_in.push_back([=, &var]() { statement(to_name(var.self), " = ", ib_var_ref, ".", to_member_name(ib_type, ib_index), vector_swizzle(type_components, start_component), ";"); }); } else { uint32_t ib_index = location_meta->ib_index; entry_func.fixup_hooks_out.push_back([=, &var]() { statement(ib_var_ref, ".", to_member_name(ib_type, ib_index), vector_swizzle(type_components, start_component), " = ", to_name(var.self), ";"); }); } return; } else { location_meta->ib_index = uint32_t(ib_type.member_types.size()); type_id = build_extended_vector_type(type_id, num_components); if (var.storage == StorageClassInput) padded_input = true; else padded_output = true; } } else if (pad_fragment_output) { uint32_t locn = get_decoration(var.self, DecorationLocation); target_components = get_target_components_for_fragment_location(locn); if (type_components < target_components) { // Make a new type here. type_id = build_extended_vector_type(type_id, target_components); padded_output = true; } } if (storage == StorageClassInput && pull_model_inputs.count(var.self)) ib_type.member_types.push_back(build_msl_interpolant_type(type_id, is_noperspective)); else ib_type.member_types.push_back(type_id); // Give the member a name string mbr_name = ensure_valid_name(to_expression(var.self), "m"); set_member_name(ib_type.self, ib_mbr_idx, mbr_name); // Update the original variable reference to include the structure reference string qual_var_name = ib_var_ref + "." + mbr_name; // If using pull-model interpolation, need to add a call to the correct interpolation method. if (storage == StorageClassInput && pull_model_inputs.count(var.self)) { if (is_centroid) qual_var_name += ".interpolate_at_centroid()"; else if (is_sample) qual_var_name += join(".interpolate_at_sample(", to_expression(builtin_sample_id_id), ")"); else qual_var_name += ".interpolate_at_center()"; } if (padded_output || padded_input) { entry_func.add_local_variable(var.self); vars_needing_early_declaration.push_back(var.self); if (padded_output) { entry_func.fixup_hooks_out.push_back([=, &var]() { statement(qual_var_name, vector_swizzle(type_components, start_component), " = ", to_name(var.self), ";"); }); } else { entry_func.fixup_hooks_in.push_back([=, &var]() { statement(to_name(var.self), " = ", qual_var_name, vector_swizzle(type_components, start_component), ";"); }); } } else if (!meta.strip_array) ir.meta[var.self].decoration.qualified_alias = qual_var_name; if (var.storage == StorageClassOutput && var.initializer != ID(0)) { if (padded_output || padded_input) { entry_func.fixup_hooks_in.push_back( [=, &var]() { statement(to_name(var.self), " = ", to_expression(var.initializer), ";"); }); } else { if (meta.strip_array) { entry_func.fixup_hooks_in.push_back([=, &var]() { uint32_t index = get_extended_decoration(var.self, SPIRVCrossDecorationInterfaceMemberIndex); statement(to_expression(stage_out_ptr_var_id), "[", builtin_to_glsl(BuiltInInvocationId, StorageClassInput), "].", to_member_name(ib_type, index), " = ", to_expression(var.initializer), "[", builtin_to_glsl(BuiltInInvocationId, StorageClassInput), "];"); }); } else { entry_func.fixup_hooks_in.push_back([=, &var]() { statement(qual_var_name, " = ", to_expression(var.initializer), ";"); }); } } } // Copy the variable location from the original variable to the member if (get_decoration_bitset(var.self).get(DecorationLocation)) { uint32_t locn = get_decoration(var.self, DecorationLocation); if (storage == StorageClassInput) { type_id = ensure_correct_input_type(var.basetype, locn, location_meta ? location_meta->num_components : 0); if (!location_meta) var.basetype = type_id; type_id = get_pointee_type_id(type_id); if (meta.strip_array && is_array(get(type_id))) type_id = get(type_id).parent_type; if (pull_model_inputs.count(var.self)) ib_type.member_types[ib_mbr_idx] = build_msl_interpolant_type(type_id, is_noperspective); else ib_type.member_types[ib_mbr_idx] = type_id; } set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, get(type_id), storage); } else if (is_builtin && is_tessellation_shader() && inputs_by_builtin.count(builtin)) { uint32_t locn = inputs_by_builtin[builtin].location; set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, type, storage); } if (!location_meta) { if (get_decoration_bitset(var.self).get(DecorationComponent)) { uint32_t component = get_decoration(var.self, DecorationComponent); set_member_decoration(ib_type.self, ib_mbr_idx, DecorationComponent, component); } } if (get_decoration_bitset(var.self).get(DecorationIndex)) { uint32_t index = get_decoration(var.self, DecorationIndex); set_member_decoration(ib_type.self, ib_mbr_idx, DecorationIndex, index); } // Mark the member as builtin if needed if (is_builtin) { set_member_decoration(ib_type.self, ib_mbr_idx, DecorationBuiltIn, builtin); if (builtin == BuiltInPosition && storage == StorageClassOutput) qual_pos_var_name = qual_var_name; } // Copy interpolation decorations if needed if (storage != StorageClassInput || !pull_model_inputs.count(var.self)) { if (is_flat) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationFlat); if (is_noperspective) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationNoPerspective); if (is_centroid) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationCentroid); if (is_sample) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationSample); } // If we have location meta, there is no unique OrigID. We won't need it, since we flatten/unflatten // the variable to stack anyways here. if (!location_meta) set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceOrigID, var.self); } void CompilerMSL::add_composite_variable_to_interface_block(StorageClass storage, const string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta) { auto &entry_func = get(ir.default_entry_point); auto &var_type = meta.strip_array ? get_variable_element_type(var) : get_variable_data_type(var); uint32_t elem_cnt = 0; if (is_matrix(var_type)) { if (is_array(var_type)) SPIRV_CROSS_THROW("MSL cannot emit arrays-of-matrices in input and output variables."); elem_cnt = var_type.columns; } else if (is_array(var_type)) { if (var_type.array.size() != 1) SPIRV_CROSS_THROW("MSL cannot emit arrays-of-arrays in input and output variables."); elem_cnt = to_array_size_literal(var_type); } bool is_builtin = is_builtin_variable(var); BuiltIn builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn)); bool is_flat = has_decoration(var.self, DecorationFlat); bool is_noperspective = has_decoration(var.self, DecorationNoPerspective); bool is_centroid = has_decoration(var.self, DecorationCentroid); bool is_sample = has_decoration(var.self, DecorationSample); auto *usable_type = &var_type; if (usable_type->pointer) usable_type = &get(usable_type->parent_type); while (is_array(*usable_type) || is_matrix(*usable_type)) usable_type = &get(usable_type->parent_type); // If a builtin, force it to have the proper name. if (is_builtin) set_name(var.self, builtin_to_glsl(builtin, StorageClassFunction)); bool flatten_from_ib_var = false; string flatten_from_ib_mbr_name; if (storage == StorageClassOutput && is_builtin && builtin == BuiltInClipDistance) { // Also declare [[clip_distance]] attribute here. uint32_t clip_array_mbr_idx = uint32_t(ib_type.member_types.size()); ib_type.member_types.push_back(get_variable_data_type_id(var)); set_member_decoration(ib_type.self, clip_array_mbr_idx, DecorationBuiltIn, BuiltInClipDistance); flatten_from_ib_mbr_name = builtin_to_glsl(BuiltInClipDistance, StorageClassOutput); set_member_name(ib_type.self, clip_array_mbr_idx, flatten_from_ib_mbr_name); // When we flatten, we flatten directly from the "out" struct, // not from a function variable. flatten_from_ib_var = true; if (!msl_options.enable_clip_distance_user_varying) return; } else if (!meta.strip_array) { // Only flatten/unflatten IO composites for non-tessellation cases where arrays are not stripped. entry_func.add_local_variable(var.self); // We need to declare the variable early and at entry-point scope. vars_needing_early_declaration.push_back(var.self); } for (uint32_t i = 0; i < elem_cnt; i++) { // Add a reference to the variable type to the interface struct. uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size()); uint32_t target_components = 0; bool padded_output = false; uint32_t type_id = usable_type->self; // Check if we need to pad fragment output to match a certain number of components. if (get_decoration_bitset(var.self).get(DecorationLocation) && msl_options.pad_fragment_output_components && get_entry_point().model == ExecutionModelFragment && storage == StorageClassOutput) { uint32_t locn = get_decoration(var.self, DecorationLocation) + i; target_components = get_target_components_for_fragment_location(locn); if (usable_type->vecsize < target_components) { // Make a new type here. type_id = build_extended_vector_type(usable_type->self, target_components); padded_output = true; } } if (storage == StorageClassInput && pull_model_inputs.count(var.self)) ib_type.member_types.push_back(build_msl_interpolant_type(get_pointee_type_id(type_id), is_noperspective)); else ib_type.member_types.push_back(get_pointee_type_id(type_id)); // Give the member a name string mbr_name = ensure_valid_name(join(to_expression(var.self), "_", i), "m"); set_member_name(ib_type.self, ib_mbr_idx, mbr_name); // There is no qualified alias since we need to flatten the internal array on return. if (get_decoration_bitset(var.self).get(DecorationLocation)) { uint32_t locn = get_decoration(var.self, DecorationLocation) + i; if (storage == StorageClassInput) { var.basetype = ensure_correct_input_type(var.basetype, locn); uint32_t mbr_type_id = ensure_correct_input_type(usable_type->self, locn); if (storage == StorageClassInput && pull_model_inputs.count(var.self)) ib_type.member_types[ib_mbr_idx] = build_msl_interpolant_type(mbr_type_id, is_noperspective); else ib_type.member_types[ib_mbr_idx] = mbr_type_id; } set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, *usable_type, storage); } else if (is_builtin && is_tessellation_shader() && inputs_by_builtin.count(builtin)) { uint32_t locn = inputs_by_builtin[builtin].location + i; set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, *usable_type, storage); } else if (is_builtin && builtin == BuiltInClipDistance) { // Declare the ClipDistance as [[user(clipN)]]. set_member_decoration(ib_type.self, ib_mbr_idx, DecorationBuiltIn, BuiltInClipDistance); set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, i); } if (get_decoration_bitset(var.self).get(DecorationIndex)) { uint32_t index = get_decoration(var.self, DecorationIndex); set_member_decoration(ib_type.self, ib_mbr_idx, DecorationIndex, index); } if (storage != StorageClassInput || !pull_model_inputs.count(var.self)) { // Copy interpolation decorations if needed if (is_flat) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationFlat); if (is_noperspective) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationNoPerspective); if (is_centroid) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationCentroid); if (is_sample) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationSample); } set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceOrigID, var.self); // Only flatten/unflatten IO composites for non-tessellation cases where arrays are not stripped. if (!meta.strip_array) { switch (storage) { case StorageClassInput: entry_func.fixup_hooks_in.push_back([=, &var]() { if (pull_model_inputs.count(var.self)) { string lerp_call; if (is_centroid) lerp_call = ".interpolate_at_centroid()"; else if (is_sample) lerp_call = join(".interpolate_at_sample(", to_expression(builtin_sample_id_id), ")"); else lerp_call = ".interpolate_at_center()"; statement(to_name(var.self), "[", i, "] = ", ib_var_ref, ".", mbr_name, lerp_call, ";"); } else { statement(to_name(var.self), "[", i, "] = ", ib_var_ref, ".", mbr_name, ";"); } }); break; case StorageClassOutput: entry_func.fixup_hooks_out.push_back([=, &var]() { if (padded_output) { auto &padded_type = this->get(type_id); statement( ib_var_ref, ".", mbr_name, " = ", remap_swizzle(padded_type, usable_type->vecsize, join(to_name(var.self), "[", i, "]")), ";"); } else if (flatten_from_ib_var) statement(ib_var_ref, ".", mbr_name, " = ", ib_var_ref, ".", flatten_from_ib_mbr_name, "[", i, "];"); else statement(ib_var_ref, ".", mbr_name, " = ", to_name(var.self), "[", i, "];"); }); break; default: break; } } } } uint32_t CompilerMSL::get_accumulated_member_location(const SPIRVariable &var, uint32_t mbr_idx, bool strip_array) { auto &type = strip_array ? get_variable_element_type(var) : get_variable_data_type(var); uint32_t location = get_decoration(var.self, DecorationLocation); for (uint32_t i = 0; i < mbr_idx; i++) { auto &mbr_type = get(type.member_types[i]); // Start counting from any place we have a new location decoration. if (has_member_decoration(type.self, mbr_idx, DecorationLocation)) location = get_member_decoration(type.self, mbr_idx, DecorationLocation); uint32_t location_count = 1; if (mbr_type.columns > 1) location_count = mbr_type.columns; if (!mbr_type.array.empty()) for (uint32_t j = 0; j < uint32_t(mbr_type.array.size()); j++) location_count *= to_array_size_literal(mbr_type, j); location += location_count; } return location; } void CompilerMSL::add_composite_member_variable_to_interface_block(StorageClass storage, const string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, uint32_t mbr_idx, InterfaceBlockMeta &meta) { auto &entry_func = get(ir.default_entry_point); auto &var_type = meta.strip_array ? get_variable_element_type(var) : get_variable_data_type(var); BuiltIn builtin = BuiltInMax; bool is_builtin = is_member_builtin(var_type, mbr_idx, &builtin); bool is_flat = has_member_decoration(var_type.self, mbr_idx, DecorationFlat) || has_decoration(var.self, DecorationFlat); bool is_noperspective = has_member_decoration(var_type.self, mbr_idx, DecorationNoPerspective) || has_decoration(var.self, DecorationNoPerspective); bool is_centroid = has_member_decoration(var_type.self, mbr_idx, DecorationCentroid) || has_decoration(var.self, DecorationCentroid); bool is_sample = has_member_decoration(var_type.self, mbr_idx, DecorationSample) || has_decoration(var.self, DecorationSample); uint32_t mbr_type_id = var_type.member_types[mbr_idx]; auto &mbr_type = get(mbr_type_id); uint32_t elem_cnt = 0; if (is_matrix(mbr_type)) { if (is_array(mbr_type)) SPIRV_CROSS_THROW("MSL cannot emit arrays-of-matrices in input and output variables."); elem_cnt = mbr_type.columns; } else if (is_array(mbr_type)) { if (mbr_type.array.size() != 1) SPIRV_CROSS_THROW("MSL cannot emit arrays-of-arrays in input and output variables."); elem_cnt = to_array_size_literal(mbr_type); } auto *usable_type = &mbr_type; if (usable_type->pointer) usable_type = &get(usable_type->parent_type); while (is_array(*usable_type) || is_matrix(*usable_type)) usable_type = &get(usable_type->parent_type); bool flatten_from_ib_var = false; string flatten_from_ib_mbr_name; if (storage == StorageClassOutput && is_builtin && builtin == BuiltInClipDistance) { // Also declare [[clip_distance]] attribute here. uint32_t clip_array_mbr_idx = uint32_t(ib_type.member_types.size()); ib_type.member_types.push_back(mbr_type_id); set_member_decoration(ib_type.self, clip_array_mbr_idx, DecorationBuiltIn, BuiltInClipDistance); flatten_from_ib_mbr_name = builtin_to_glsl(BuiltInClipDistance, StorageClassOutput); set_member_name(ib_type.self, clip_array_mbr_idx, flatten_from_ib_mbr_name); // When we flatten, we flatten directly from the "out" struct, // not from a function variable. flatten_from_ib_var = true; if (!msl_options.enable_clip_distance_user_varying) return; } for (uint32_t i = 0; i < elem_cnt; i++) { // Add a reference to the variable type to the interface struct. uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size()); if (storage == StorageClassInput && pull_model_inputs.count(var.self)) ib_type.member_types.push_back(build_msl_interpolant_type(usable_type->self, is_noperspective)); else ib_type.member_types.push_back(usable_type->self); // Give the member a name string mbr_name = ensure_valid_name(join(to_qualified_member_name(var_type, mbr_idx), "_", i), "m"); set_member_name(ib_type.self, ib_mbr_idx, mbr_name); if (has_member_decoration(var_type.self, mbr_idx, DecorationLocation)) { uint32_t locn = get_member_decoration(var_type.self, mbr_idx, DecorationLocation) + i; set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, *usable_type, storage); } else if (has_decoration(var.self, DecorationLocation)) { uint32_t locn = get_accumulated_member_location(var, mbr_idx, meta.strip_array) + i; set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, *usable_type, storage); } else if (is_builtin && is_tessellation_shader() && inputs_by_builtin.count(builtin)) { uint32_t locn = inputs_by_builtin[builtin].location + i; set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, *usable_type, storage); } else if (is_builtin && builtin == BuiltInClipDistance) { // Declare the ClipDistance as [[user(clipN)]]. set_member_decoration(ib_type.self, ib_mbr_idx, DecorationBuiltIn, BuiltInClipDistance); set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, i); } if (has_member_decoration(var_type.self, mbr_idx, DecorationComponent)) SPIRV_CROSS_THROW("DecorationComponent on matrices and arrays make little sense."); if (storage != StorageClassInput || !pull_model_inputs.count(var.self)) { // Copy interpolation decorations if needed if (is_flat) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationFlat); if (is_noperspective) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationNoPerspective); if (is_centroid) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationCentroid); if (is_sample) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationSample); } set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceOrigID, var.self); set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceMemberIndex, mbr_idx); // Unflatten or flatten from [[stage_in]] or [[stage_out]] as appropriate. if (!meta.strip_array) { switch (storage) { case StorageClassInput: entry_func.fixup_hooks_in.push_back([=, &var, &var_type]() { if (pull_model_inputs.count(var.self)) { string lerp_call; if (is_centroid) lerp_call = ".interpolate_at_centroid()"; else if (is_sample) lerp_call = join(".interpolate_at_sample(", to_expression(builtin_sample_id_id), ")"); else lerp_call = ".interpolate_at_center()"; statement(to_name(var.self), ".", to_member_name(var_type, mbr_idx), "[", i, "] = ", ib_var_ref, ".", mbr_name, lerp_call, ";"); } else { statement(to_name(var.self), ".", to_member_name(var_type, mbr_idx), "[", i, "] = ", ib_var_ref, ".", mbr_name, ";"); } }); break; case StorageClassOutput: entry_func.fixup_hooks_out.push_back([=, &var, &var_type]() { if (flatten_from_ib_var) { statement(ib_var_ref, ".", mbr_name, " = ", ib_var_ref, ".", flatten_from_ib_mbr_name, "[", i, "];"); } else { statement(ib_var_ref, ".", mbr_name, " = ", to_name(var.self), ".", to_member_name(var_type, mbr_idx), "[", i, "];"); } }); break; default: break; } } } } void CompilerMSL::add_plain_member_variable_to_interface_block(StorageClass storage, const string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, uint32_t mbr_idx, InterfaceBlockMeta &meta) { auto &var_type = meta.strip_array ? get_variable_element_type(var) : get_variable_data_type(var); auto &entry_func = get(ir.default_entry_point); BuiltIn builtin = BuiltInMax; bool is_builtin = is_member_builtin(var_type, mbr_idx, &builtin); bool is_flat = has_member_decoration(var_type.self, mbr_idx, DecorationFlat) || has_decoration(var.self, DecorationFlat); bool is_noperspective = has_member_decoration(var_type.self, mbr_idx, DecorationNoPerspective) || has_decoration(var.self, DecorationNoPerspective); bool is_centroid = has_member_decoration(var_type.self, mbr_idx, DecorationCentroid) || has_decoration(var.self, DecorationCentroid); bool is_sample = has_member_decoration(var_type.self, mbr_idx, DecorationSample) || has_decoration(var.self, DecorationSample); // Add a reference to the member to the interface struct. uint32_t mbr_type_id = var_type.member_types[mbr_idx]; uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size()); mbr_type_id = ensure_correct_builtin_type(mbr_type_id, builtin); var_type.member_types[mbr_idx] = mbr_type_id; if (storage == StorageClassInput && pull_model_inputs.count(var.self)) ib_type.member_types.push_back(build_msl_interpolant_type(mbr_type_id, is_noperspective)); else ib_type.member_types.push_back(mbr_type_id); // Give the member a name string mbr_name = ensure_valid_name(to_qualified_member_name(var_type, mbr_idx), "m"); set_member_name(ib_type.self, ib_mbr_idx, mbr_name); // Update the original variable reference to include the structure reference string qual_var_name = ib_var_ref + "." + mbr_name; // If using pull-model interpolation, need to add a call to the correct interpolation method. if (storage == StorageClassInput && pull_model_inputs.count(var.self)) { if (is_centroid) qual_var_name += ".interpolate_at_centroid()"; else if (is_sample) qual_var_name += join(".interpolate_at_sample(", to_expression(builtin_sample_id_id), ")"); else qual_var_name += ".interpolate_at_center()"; } bool flatten_stage_out = false; if (is_builtin && !meta.strip_array) { // For the builtin gl_PerVertex, we cannot treat it as a block anyways, // so redirect to qualified name. set_member_qualified_name(var_type.self, mbr_idx, qual_var_name); } else if (!meta.strip_array) { // Unflatten or flatten from [[stage_in]] or [[stage_out]] as appropriate. switch (storage) { case StorageClassInput: entry_func.fixup_hooks_in.push_back([=, &var, &var_type]() { statement(to_name(var.self), ".", to_member_name(var_type, mbr_idx), " = ", qual_var_name, ";"); }); break; case StorageClassOutput: flatten_stage_out = true; entry_func.fixup_hooks_out.push_back([=, &var, &var_type]() { statement(qual_var_name, " = ", to_name(var.self), ".", to_member_name(var_type, mbr_idx), ";"); }); break; default: break; } } // Copy the variable location from the original variable to the member if (has_member_decoration(var_type.self, mbr_idx, DecorationLocation)) { uint32_t locn = get_member_decoration(var_type.self, mbr_idx, DecorationLocation); if (storage == StorageClassInput) { mbr_type_id = ensure_correct_input_type(mbr_type_id, locn); var_type.member_types[mbr_idx] = mbr_type_id; if (storage == StorageClassInput && pull_model_inputs.count(var.self)) ib_type.member_types[ib_mbr_idx] = build_msl_interpolant_type(mbr_type_id, is_noperspective); else ib_type.member_types[ib_mbr_idx] = mbr_type_id; } set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, get(mbr_type_id), storage); } else if (has_decoration(var.self, DecorationLocation)) { // The block itself might have a location and in this case, all members of the block // receive incrementing locations. uint32_t locn = get_accumulated_member_location(var, mbr_idx, meta.strip_array); if (storage == StorageClassInput) { mbr_type_id = ensure_correct_input_type(mbr_type_id, locn); var_type.member_types[mbr_idx] = mbr_type_id; if (storage == StorageClassInput && pull_model_inputs.count(var.self)) ib_type.member_types[ib_mbr_idx] = build_msl_interpolant_type(mbr_type_id, is_noperspective); else ib_type.member_types[ib_mbr_idx] = mbr_type_id; } set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, get(mbr_type_id), storage); } else if (is_builtin && is_tessellation_shader() && inputs_by_builtin.count(builtin)) { uint32_t locn = 0; auto builtin_itr = inputs_by_builtin.find(builtin); if (builtin_itr != end(inputs_by_builtin)) locn = builtin_itr->second.location; set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, get(mbr_type_id), storage); } // Copy the component location, if present. if (has_member_decoration(var_type.self, mbr_idx, DecorationComponent)) { uint32_t comp = get_member_decoration(var_type.self, mbr_idx, DecorationComponent); set_member_decoration(ib_type.self, ib_mbr_idx, DecorationComponent, comp); } // Mark the member as builtin if needed if (is_builtin) { set_member_decoration(ib_type.self, ib_mbr_idx, DecorationBuiltIn, builtin); if (builtin == BuiltInPosition && storage == StorageClassOutput) qual_pos_var_name = qual_var_name; } const SPIRConstant *c = nullptr; if (!flatten_stage_out && var.storage == StorageClassOutput && var.initializer != ID(0) && (c = maybe_get(var.initializer))) { if (meta.strip_array) { entry_func.fixup_hooks_in.push_back([=, &var]() { auto &type = this->get(var.basetype); uint32_t index = get_extended_decoration(var.self, SPIRVCrossDecorationInterfaceMemberIndex); index += mbr_idx; AccessChainMeta chain_meta; auto constant_chain = access_chain_internal(var.initializer, &builtin_invocation_id_id, 1, 0, &chain_meta); statement(to_expression(stage_out_ptr_var_id), "[", builtin_to_glsl(BuiltInInvocationId, StorageClassInput), "].", to_member_name(ib_type, index), " = ", constant_chain, ".", to_member_name(type, mbr_idx), ";"); }); } else { entry_func.fixup_hooks_in.push_back([=]() { statement(qual_var_name, " = ", constant_expression( this->get(c->subconstants[mbr_idx])), ";"); }); } } if (storage != StorageClassInput || !pull_model_inputs.count(var.self)) { // Copy interpolation decorations if needed if (is_flat) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationFlat); if (is_noperspective) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationNoPerspective); if (is_centroid) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationCentroid); if (is_sample) set_member_decoration(ib_type.self, ib_mbr_idx, DecorationSample); } set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceOrigID, var.self); set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceMemberIndex, mbr_idx); } // In Metal, the tessellation levels are stored as tightly packed half-precision floating point values. // But, stage-in attribute offsets and strides must be multiples of four, so we can't pass the levels // individually. Therefore, we must pass them as vectors. Triangles get a single float4, with the outer // levels in 'xyz' and the inner level in 'w'. Quads get a float4 containing the outer levels and a // float2 containing the inner levels. void CompilerMSL::add_tess_level_input_to_interface_block(const std::string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var) { auto &entry_func = get(ir.default_entry_point); auto &var_type = get_variable_element_type(var); BuiltIn builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn)); // Force the variable to have the proper name. set_name(var.self, builtin_to_glsl(builtin, StorageClassFunction)); if (get_entry_point().flags.get(ExecutionModeTriangles)) { // Triangles are tricky, because we want only one member in the struct. // We need to declare the variable early and at entry-point scope. entry_func.add_local_variable(var.self); vars_needing_early_declaration.push_back(var.self); string mbr_name = "gl_TessLevel"; // If we already added the other one, we can skip this step. if (!added_builtin_tess_level) { // Add a reference to the variable type to the interface struct. uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size()); uint32_t type_id = build_extended_vector_type(var_type.self, 4); ib_type.member_types.push_back(type_id); // Give the member a name set_member_name(ib_type.self, ib_mbr_idx, mbr_name); // There is no qualified alias since we need to flatten the internal array on return. if (get_decoration_bitset(var.self).get(DecorationLocation)) { uint32_t locn = get_decoration(var.self, DecorationLocation); set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, var_type, StorageClassInput); } else if (inputs_by_builtin.count(builtin)) { uint32_t locn = inputs_by_builtin[builtin].location; set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, var_type, StorageClassInput); } added_builtin_tess_level = true; } switch (builtin) { case BuiltInTessLevelOuter: entry_func.fixup_hooks_in.push_back([=, &var]() { statement(to_name(var.self), "[0] = ", ib_var_ref, ".", mbr_name, ".x;"); statement(to_name(var.self), "[1] = ", ib_var_ref, ".", mbr_name, ".y;"); statement(to_name(var.self), "[2] = ", ib_var_ref, ".", mbr_name, ".z;"); }); break; case BuiltInTessLevelInner: entry_func.fixup_hooks_in.push_back( [=, &var]() { statement(to_name(var.self), "[0] = ", ib_var_ref, ".", mbr_name, ".w;"); }); break; default: assert(false); break; } } else { // Add a reference to the variable type to the interface struct. uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size()); uint32_t type_id = build_extended_vector_type(var_type.self, builtin == BuiltInTessLevelOuter ? 4 : 2); // Change the type of the variable, too. uint32_t ptr_type_id = ir.increase_bound_by(1); auto &new_var_type = set(ptr_type_id, get(type_id)); new_var_type.pointer = true; new_var_type.storage = StorageClassInput; new_var_type.parent_type = type_id; var.basetype = ptr_type_id; ib_type.member_types.push_back(type_id); // Give the member a name string mbr_name = to_expression(var.self); set_member_name(ib_type.self, ib_mbr_idx, mbr_name); // Since vectors can be indexed like arrays, there is no need to unpack this. We can // just refer to the vector directly. So give it a qualified alias. string qual_var_name = ib_var_ref + "." + mbr_name; ir.meta[var.self].decoration.qualified_alias = qual_var_name; if (get_decoration_bitset(var.self).get(DecorationLocation)) { uint32_t locn = get_decoration(var.self, DecorationLocation); set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, new_var_type, StorageClassInput); } else if (inputs_by_builtin.count(builtin)) { uint32_t locn = inputs_by_builtin[builtin].location; set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn); mark_location_as_used_by_shader(locn, new_var_type, StorageClassInput); } } } void CompilerMSL::add_variable_to_interface_block(StorageClass storage, const string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta) { auto &entry_func = get(ir.default_entry_point); // Tessellation control I/O variables and tessellation evaluation per-point inputs are // usually declared as arrays. In these cases, we want to add the element type to the // interface block, since in Metal it's the interface block itself which is arrayed. auto &var_type = meta.strip_array ? get_variable_element_type(var) : get_variable_data_type(var); bool is_builtin = is_builtin_variable(var); auto builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn)); if (var_type.basetype == SPIRType::Struct) { if (!is_builtin_type(var_type) && (!capture_output_to_buffer || storage == StorageClassInput) && !meta.strip_array) { // For I/O blocks or structs, we will need to pass the block itself around // to functions if they are used globally in leaf functions. // Rather than passing down member by member, // we unflatten I/O blocks while running the shader, // and pass the actual struct type down to leaf functions. // We then unflatten inputs, and flatten outputs in the "fixup" stages. entry_func.add_local_variable(var.self); vars_needing_early_declaration.push_back(var.self); } if (capture_output_to_buffer && storage != StorageClassInput && !has_decoration(var_type.self, DecorationBlock)) { // In Metal tessellation shaders, the interface block itself is arrayed. This makes things // very complicated, since stage-in structures in MSL don't support nested structures. // Luckily, for stage-out when capturing output, we can avoid this and just add // composite members directly, because the stage-out structure is stored to a buffer, // not returned. add_plain_variable_to_interface_block(storage, ib_var_ref, ib_type, var, meta); } else { // Flatten the struct members into the interface struct for (uint32_t mbr_idx = 0; mbr_idx < uint32_t(var_type.member_types.size()); mbr_idx++) { builtin = BuiltInMax; is_builtin = is_member_builtin(var_type, mbr_idx, &builtin); auto &mbr_type = get(var_type.member_types[mbr_idx]); if (!is_builtin || has_active_builtin(builtin, storage)) { bool is_composite_type = is_matrix(mbr_type) || is_array(mbr_type); bool attribute_load_store = storage == StorageClassInput && get_execution_model() != ExecutionModelFragment; bool storage_is_stage_io = (storage == StorageClassInput && !(get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup)) || storage == StorageClassOutput; // ClipDistance always needs to be declared as user attributes. if (builtin == BuiltInClipDistance) is_builtin = false; if ((!is_builtin || attribute_load_store) && storage_is_stage_io && is_composite_type) { add_composite_member_variable_to_interface_block(storage, ib_var_ref, ib_type, var, mbr_idx, meta); } else { add_plain_member_variable_to_interface_block(storage, ib_var_ref, ib_type, var, mbr_idx, meta); } } } } } else if (get_execution_model() == ExecutionModelTessellationEvaluation && storage == StorageClassInput && !meta.strip_array && is_builtin && (builtin == BuiltInTessLevelOuter || builtin == BuiltInTessLevelInner)) { add_tess_level_input_to_interface_block(ib_var_ref, ib_type, var); } else if (var_type.basetype == SPIRType::Boolean || var_type.basetype == SPIRType::Char || type_is_integral(var_type) || type_is_floating_point(var_type)) { if (!is_builtin || has_active_builtin(builtin, storage)) { bool is_composite_type = is_matrix(var_type) || is_array(var_type); bool storage_is_stage_io = (storage == StorageClassInput && !(get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup)) || (storage == StorageClassOutput && !capture_output_to_buffer); bool attribute_load_store = storage == StorageClassInput && get_execution_model() != ExecutionModelFragment; // ClipDistance always needs to be declared as user attributes. if (builtin == BuiltInClipDistance) is_builtin = false; // MSL does not allow matrices or arrays in input or output variables, so need to handle it specially. if ((!is_builtin || attribute_load_store) && storage_is_stage_io && is_composite_type) { add_composite_variable_to_interface_block(storage, ib_var_ref, ib_type, var, meta); } else { add_plain_variable_to_interface_block(storage, ib_var_ref, ib_type, var, meta); } } } } // Fix up the mapping of variables to interface member indices, which is used to compile access chains // for per-vertex variables in a tessellation control shader. void CompilerMSL::fix_up_interface_member_indices(StorageClass storage, uint32_t ib_type_id) { // Only needed for tessellation shaders and pull-model interpolants. // Need to redirect interface indices back to variables themselves. // For structs, each member of the struct need a separate instance. if (get_execution_model() != ExecutionModelTessellationControl && !(get_execution_model() == ExecutionModelTessellationEvaluation && storage == StorageClassInput) && !(get_execution_model() == ExecutionModelFragment && storage == StorageClassInput && !pull_model_inputs.empty())) return; auto mbr_cnt = uint32_t(ir.meta[ib_type_id].members.size()); for (uint32_t i = 0; i < mbr_cnt; i++) { uint32_t var_id = get_extended_member_decoration(ib_type_id, i, SPIRVCrossDecorationInterfaceOrigID); if (!var_id) continue; auto &var = get(var_id); auto &type = get_variable_element_type(var); if (storage == StorageClassInput && type.basetype == SPIRType::Struct) { uint32_t mbr_idx = get_extended_member_decoration(ib_type_id, i, SPIRVCrossDecorationInterfaceMemberIndex); // Only set the lowest InterfaceMemberIndex for each variable member. // IB struct members will be emitted in-order w.r.t. interface member index. if (!has_extended_member_decoration(var_id, mbr_idx, SPIRVCrossDecorationInterfaceMemberIndex)) set_extended_member_decoration(var_id, mbr_idx, SPIRVCrossDecorationInterfaceMemberIndex, i); } else { // Only set the lowest InterfaceMemberIndex for each variable. // IB struct members will be emitted in-order w.r.t. interface member index. if (!has_extended_decoration(var_id, SPIRVCrossDecorationInterfaceMemberIndex)) set_extended_decoration(var_id, SPIRVCrossDecorationInterfaceMemberIndex, i); } } } // Add an interface structure for the type of storage, which is either StorageClassInput or StorageClassOutput. // Returns the ID of the newly added variable, or zero if no variable was added. uint32_t CompilerMSL::add_interface_block(StorageClass storage, bool patch) { // Accumulate the variables that should appear in the interface struct. SmallVector vars; bool incl_builtins = storage == StorageClassOutput || is_tessellation_shader(); bool has_seen_barycentric = false; InterfaceBlockMeta meta; // Varying interfaces between stages which use "user()" attribute can be dealt with // without explicit packing and unpacking of components. For any variables which link against the runtime // in some way (vertex attributes, fragment output, etc), we'll need to deal with it somehow. bool pack_components = (storage == StorageClassInput && get_execution_model() == ExecutionModelVertex) || (storage == StorageClassOutput && get_execution_model() == ExecutionModelFragment) || (storage == StorageClassOutput && get_execution_model() == ExecutionModelVertex && capture_output_to_buffer); ir.for_each_typed_id([&](uint32_t var_id, SPIRVariable &var) { if (var.storage != storage) return; auto &type = this->get(var.basetype); bool is_builtin = is_builtin_variable(var); auto bi_type = BuiltIn(get_decoration(var_id, DecorationBuiltIn)); uint32_t location = get_decoration(var_id, DecorationLocation); // These builtins are part of the stage in/out structs. bool is_interface_block_builtin = (bi_type == BuiltInPosition || bi_type == BuiltInPointSize || bi_type == BuiltInClipDistance || bi_type == BuiltInCullDistance || bi_type == BuiltInLayer || bi_type == BuiltInViewportIndex || bi_type == BuiltInBaryCoordNV || bi_type == BuiltInBaryCoordNoPerspNV || bi_type == BuiltInFragDepth || bi_type == BuiltInFragStencilRefEXT || bi_type == BuiltInSampleMask) || (get_execution_model() == ExecutionModelTessellationEvaluation && (bi_type == BuiltInTessLevelOuter || bi_type == BuiltInTessLevelInner)); bool is_active = interface_variable_exists_in_entry_point(var.self); if (is_builtin && is_active) { // Only emit the builtin if it's active in this entry point. Interface variable list might lie. is_active = has_active_builtin(bi_type, storage); } bool filter_patch_decoration = (has_decoration(var_id, DecorationPatch) || is_patch_block(type)) == patch; bool hidden = is_hidden_variable(var, incl_builtins); // ClipDistance is never hidden, we need to emulate it when used as an input. if (bi_type == BuiltInClipDistance) hidden = false; // It's not enough to simply avoid marking fragment outputs if the pipeline won't // accept them. We can't put them in the struct at all, or otherwise the compiler // complains that the outputs weren't explicitly marked. if (get_execution_model() == ExecutionModelFragment && storage == StorageClassOutput && !patch && ((is_builtin && ((bi_type == BuiltInFragDepth && !msl_options.enable_frag_depth_builtin) || (bi_type == BuiltInFragStencilRefEXT && !msl_options.enable_frag_stencil_ref_builtin))) || (!is_builtin && !(msl_options.enable_frag_output_mask & (1 << location))))) { hidden = true; disabled_frag_outputs.push_back(var_id); // If a builtin, force it to have the proper name. if (is_builtin) set_name(var_id, builtin_to_glsl(bi_type, StorageClassFunction)); } // Barycentric inputs must be emitted in stage-in, because they can have interpolation arguments. if (is_active && (bi_type == BuiltInBaryCoordNV || bi_type == BuiltInBaryCoordNoPerspNV)) { if (has_seen_barycentric) SPIRV_CROSS_THROW("Cannot declare both BaryCoordNV and BaryCoordNoPerspNV in same shader in MSL."); has_seen_barycentric = true; hidden = false; } if (is_active && !hidden && type.pointer && filter_patch_decoration && (!is_builtin || is_interface_block_builtin)) { vars.push_back(&var); if (!is_builtin) { // Need to deal specially with DecorationComponent. // Multiple variables can alias the same Location, and try to make sure each location is declared only once. // We will swizzle data in and out to make this work. // We only need to consider plain variables here, not composites. // This is only relevant for vertex inputs and fragment outputs. // Technically tessellation as well, but it is too complicated to support. uint32_t component = get_decoration(var_id, DecorationComponent); if (component != 0) { if (is_tessellation_shader()) SPIRV_CROSS_THROW("Component decoration is not supported in tessellation shaders."); else if (pack_components) { auto &location_meta = meta.location_meta[location]; location_meta.num_components = std::max(location_meta.num_components, component + type.vecsize); } } } } }); // If no variables qualify, leave. // For patch input in a tessellation evaluation shader, the per-vertex stage inputs // are included in a special patch control point array. if (vars.empty() && !(storage == StorageClassInput && patch && stage_in_var_id)) return 0; // Add a new typed variable for this interface structure. // The initializer expression is allocated here, but populated when the function // declaraion is emitted, because it is cleared after each compilation pass. uint32_t next_id = ir.increase_bound_by(3); uint32_t ib_type_id = next_id++; auto &ib_type = set(ib_type_id); ib_type.basetype = SPIRType::Struct; ib_type.storage = storage; set_decoration(ib_type_id, DecorationBlock); uint32_t ib_var_id = next_id++; auto &var = set(ib_var_id, ib_type_id, storage, 0); var.initializer = next_id++; string ib_var_ref; auto &entry_func = get(ir.default_entry_point); switch (storage) { case StorageClassInput: ib_var_ref = patch ? patch_stage_in_var_name : stage_in_var_name; if (get_execution_model() == ExecutionModelTessellationControl) { // Add a hook to populate the shared workgroup memory containing the gl_in array. entry_func.fixup_hooks_in.push_back([=]() { // Can't use PatchVertices, PrimitiveId, or InvocationId yet; the hooks for those may not have run yet. if (msl_options.multi_patch_workgroup) { // n.b. builtin_invocation_id_id here is the dispatch global invocation ID, // not the TC invocation ID. statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "* gl_in = &", input_buffer_var_name, "[min(", to_expression(builtin_invocation_id_id), ".x / ", get_entry_point().output_vertices, ", spvIndirectParams[1] - 1) * spvIndirectParams[0]];"); } else { // It's safe to use InvocationId here because it's directly mapped to a // Metal builtin, and therefore doesn't need a hook. statement("if (", to_expression(builtin_invocation_id_id), " < spvIndirectParams[0])"); statement(" ", input_wg_var_name, "[", to_expression(builtin_invocation_id_id), "] = ", ib_var_ref, ";"); statement("threadgroup_barrier(mem_flags::mem_threadgroup);"); statement("if (", to_expression(builtin_invocation_id_id), " >= ", get_entry_point().output_vertices, ")"); statement(" return;"); } }); } break; case StorageClassOutput: { ib_var_ref = patch ? patch_stage_out_var_name : stage_out_var_name; // Add the output interface struct as a local variable to the entry function. // If the entry point should return the output struct, set the entry function // to return the output interface struct, otherwise to return nothing. // Indicate the output var requires early initialization. bool ep_should_return_output = !get_is_rasterization_disabled(); uint32_t rtn_id = ep_should_return_output ? ib_var_id : 0; if (!capture_output_to_buffer) { entry_func.add_local_variable(ib_var_id); for (auto &blk_id : entry_func.blocks) { auto &blk = get(blk_id); if (blk.terminator == SPIRBlock::Return) blk.return_value = rtn_id; } vars_needing_early_declaration.push_back(ib_var_id); } else { switch (get_execution_model()) { case ExecutionModelVertex: case ExecutionModelTessellationEvaluation: // Instead of declaring a struct variable to hold the output and then // copying that to the output buffer, we'll declare the output variable // as a reference to the final output element in the buffer. Then we can // avoid the extra copy. entry_func.fixup_hooks_in.push_back([=]() { if (stage_out_var_id) { // The first member of the indirect buffer is always the number of vertices // to draw. // We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice if (get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation) { statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref, " = ", output_buffer_var_name, "[", to_expression(builtin_invocation_id_id), ".y * ", to_expression(builtin_stage_input_size_id), ".x + ", to_expression(builtin_invocation_id_id), ".x];"); } else if (msl_options.enable_base_index_zero) { statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref, " = ", output_buffer_var_name, "[", to_expression(builtin_instance_idx_id), " * spvIndirectParams[0] + ", to_expression(builtin_vertex_idx_id), "];"); } else { statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref, " = ", output_buffer_var_name, "[(", to_expression(builtin_instance_idx_id), " - ", to_expression(builtin_base_instance_id), ") * spvIndirectParams[0] + ", to_expression(builtin_vertex_idx_id), " - ", to_expression(builtin_base_vertex_id), "];"); } } }); break; case ExecutionModelTessellationControl: if (msl_options.multi_patch_workgroup) { // We cannot use PrimitiveId here, because the hook may not have run yet. if (patch) { entry_func.fixup_hooks_in.push_back([=]() { statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref, " = ", patch_output_buffer_var_name, "[", to_expression(builtin_invocation_id_id), ".x / ", get_entry_point().output_vertices, "];"); }); } else { entry_func.fixup_hooks_in.push_back([=]() { statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "* gl_out = &", output_buffer_var_name, "[", to_expression(builtin_invocation_id_id), ".x - ", to_expression(builtin_invocation_id_id), ".x % ", get_entry_point().output_vertices, "];"); }); } } else { if (patch) { entry_func.fixup_hooks_in.push_back([=]() { statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref, " = ", patch_output_buffer_var_name, "[", to_expression(builtin_primitive_id_id), "];"); }); } else { entry_func.fixup_hooks_in.push_back([=]() { statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "* gl_out = &", output_buffer_var_name, "[", to_expression(builtin_primitive_id_id), " * ", get_entry_point().output_vertices, "];"); }); } } break; default: break; } } break; } default: break; } set_name(ib_type_id, to_name(ir.default_entry_point) + "_" + ib_var_ref); set_name(ib_var_id, ib_var_ref); for (auto *p_var : vars) { bool strip_array = (get_execution_model() == ExecutionModelTessellationControl || (get_execution_model() == ExecutionModelTessellationEvaluation && storage == StorageClassInput)) && !patch; meta.strip_array = strip_array; add_variable_to_interface_block(storage, ib_var_ref, ib_type, *p_var, meta); } if (get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup && storage == StorageClassInput) { // For tessellation control inputs, add all outputs from the vertex shader to ensure // the struct containing them is the correct size and layout. for (auto &input : inputs_by_location) { if (is_msl_shader_input_used(input.first)) continue; // Create a fake variable to put at the location. uint32_t offset = ir.increase_bound_by(4); uint32_t type_id = offset; uint32_t array_type_id = offset + 1; uint32_t ptr_type_id = offset + 2; uint32_t var_id = offset + 3; SPIRType type; switch (input.second.format) { case MSL_SHADER_INPUT_FORMAT_UINT16: case MSL_SHADER_INPUT_FORMAT_ANY16: type.basetype = SPIRType::UShort; type.width = 16; break; case MSL_SHADER_INPUT_FORMAT_ANY32: default: type.basetype = SPIRType::UInt; type.width = 32; break; } type.vecsize = input.second.vecsize; set(type_id, type); type.array.push_back(0); type.array_size_literal.push_back(true); type.parent_type = type_id; set(array_type_id, type); type.pointer = true; type.parent_type = array_type_id; type.storage = storage; auto &ptr_type = set(ptr_type_id, type); ptr_type.self = array_type_id; auto &fake_var = set(var_id, ptr_type_id, storage); set_decoration(var_id, DecorationLocation, input.first); meta.strip_array = true; add_variable_to_interface_block(storage, ib_var_ref, ib_type, fake_var, meta); } } // Sort the members of the structure by their locations. MemberSorter member_sorter(ib_type, ir.meta[ib_type_id], MemberSorter::Location); member_sorter.sort(); // The member indices were saved to the original variables, but after the members // were sorted, those indices are now likely incorrect. Fix those up now. if (!patch) fix_up_interface_member_indices(storage, ib_type_id); // For patch inputs, add one more member, holding the array of control point data. if (get_execution_model() == ExecutionModelTessellationEvaluation && storage == StorageClassInput && patch && stage_in_var_id) { uint32_t pcp_type_id = ir.increase_bound_by(1); auto &pcp_type = set(pcp_type_id, ib_type); pcp_type.basetype = SPIRType::ControlPointArray; pcp_type.parent_type = pcp_type.type_alias = get_stage_in_struct_type().self; pcp_type.storage = storage; ir.meta[pcp_type_id] = ir.meta[ib_type.self]; uint32_t mbr_idx = uint32_t(ib_type.member_types.size()); ib_type.member_types.push_back(pcp_type_id); set_member_name(ib_type.self, mbr_idx, "gl_in"); } return ib_var_id; } uint32_t CompilerMSL::add_interface_block_pointer(uint32_t ib_var_id, StorageClass storage) { if (!ib_var_id) return 0; uint32_t ib_ptr_var_id; uint32_t next_id = ir.increase_bound_by(3); auto &ib_type = expression_type(ib_var_id); if (get_execution_model() == ExecutionModelTessellationControl) { // Tessellation control per-vertex I/O is presented as an array, so we must // do the same with our struct here. uint32_t ib_ptr_type_id = next_id++; auto &ib_ptr_type = set(ib_ptr_type_id, ib_type); ib_ptr_type.parent_type = ib_ptr_type.type_alias = ib_type.self; ib_ptr_type.pointer = true; ib_ptr_type.storage = storage == StorageClassInput ? (msl_options.multi_patch_workgroup ? StorageClassStorageBuffer : StorageClassWorkgroup) : StorageClassStorageBuffer; ir.meta[ib_ptr_type_id] = ir.meta[ib_type.self]; // To ensure that get_variable_data_type() doesn't strip off the pointer, // which we need, use another pointer. uint32_t ib_ptr_ptr_type_id = next_id++; auto &ib_ptr_ptr_type = set(ib_ptr_ptr_type_id, ib_ptr_type); ib_ptr_ptr_type.parent_type = ib_ptr_type_id; ib_ptr_ptr_type.type_alias = ib_type.self; ib_ptr_ptr_type.storage = StorageClassFunction; ir.meta[ib_ptr_ptr_type_id] = ir.meta[ib_type.self]; ib_ptr_var_id = next_id; set(ib_ptr_var_id, ib_ptr_ptr_type_id, StorageClassFunction, 0); set_name(ib_ptr_var_id, storage == StorageClassInput ? "gl_in" : "gl_out"); } else { // Tessellation evaluation per-vertex inputs are also presented as arrays. // But, in Metal, this array uses a very special type, 'patch_control_point', // which is a container that can be used to access the control point data. // To represent this, a special 'ControlPointArray' type has been added to the // SPIRV-Cross type system. It should only be generated by and seen in the MSL // backend (i.e. this one). uint32_t pcp_type_id = next_id++; auto &pcp_type = set(pcp_type_id, ib_type); pcp_type.basetype = SPIRType::ControlPointArray; pcp_type.parent_type = pcp_type.type_alias = ib_type.self; pcp_type.storage = storage; ir.meta[pcp_type_id] = ir.meta[ib_type.self]; ib_ptr_var_id = next_id; set(ib_ptr_var_id, pcp_type_id, storage, 0); set_name(ib_ptr_var_id, "gl_in"); ir.meta[ib_ptr_var_id].decoration.qualified_alias = join(patch_stage_in_var_name, ".gl_in"); } return ib_ptr_var_id; } // Ensure that the type is compatible with the builtin. // If it is, simply return the given type ID. // Otherwise, create a new type, and return it's ID. uint32_t CompilerMSL::ensure_correct_builtin_type(uint32_t type_id, BuiltIn builtin) { auto &type = get(type_id); if ((builtin == BuiltInSampleMask && is_array(type)) || ((builtin == BuiltInLayer || builtin == BuiltInViewportIndex || builtin == BuiltInFragStencilRefEXT) && type.basetype != SPIRType::UInt)) { uint32_t next_id = ir.increase_bound_by(type.pointer ? 2 : 1); uint32_t base_type_id = next_id++; auto &base_type = set(base_type_id); base_type.basetype = SPIRType::UInt; base_type.width = 32; if (!type.pointer) return base_type_id; uint32_t ptr_type_id = next_id++; auto &ptr_type = set(ptr_type_id); ptr_type = base_type; ptr_type.pointer = true; ptr_type.storage = type.storage; ptr_type.parent_type = base_type_id; return ptr_type_id; } return type_id; } // Ensure that the type is compatible with the shader input. // If it is, simply return the given type ID. // Otherwise, create a new type, and return its ID. uint32_t CompilerMSL::ensure_correct_input_type(uint32_t type_id, uint32_t location, uint32_t num_components) { auto &type = get(type_id); auto p_va = inputs_by_location.find(location); if (p_va == end(inputs_by_location)) { if (num_components > type.vecsize) return build_extended_vector_type(type_id, num_components); else return type_id; } if (num_components == 0) num_components = p_va->second.vecsize; switch (p_va->second.format) { case MSL_SHADER_INPUT_FORMAT_UINT8: { switch (type.basetype) { case SPIRType::UByte: case SPIRType::UShort: case SPIRType::UInt: if (num_components > type.vecsize) return build_extended_vector_type(type_id, num_components); else return type_id; case SPIRType::Short: return build_extended_vector_type(type_id, num_components > type.vecsize ? num_components : type.vecsize, SPIRType::UShort); case SPIRType::Int: return build_extended_vector_type(type_id, num_components > type.vecsize ? num_components : type.vecsize, SPIRType::UInt); default: SPIRV_CROSS_THROW("Vertex attribute type mismatch between host and shader"); } } case MSL_SHADER_INPUT_FORMAT_UINT16: { switch (type.basetype) { case SPIRType::UShort: case SPIRType::UInt: if (num_components > type.vecsize) return build_extended_vector_type(type_id, num_components); else return type_id; case SPIRType::Int: return build_extended_vector_type(type_id, num_components > type.vecsize ? num_components : type.vecsize, SPIRType::UInt); default: SPIRV_CROSS_THROW("Vertex attribute type mismatch between host and shader"); } } default: if (num_components > type.vecsize) type_id = build_extended_vector_type(type_id, num_components); break; } return type_id; } void CompilerMSL::mark_struct_members_packed(const SPIRType &type) { set_extended_decoration(type.self, SPIRVCrossDecorationPhysicalTypePacked); // Problem case! Struct needs to be placed at an awkward alignment. // Mark every member of the child struct as packed. uint32_t mbr_cnt = uint32_t(type.member_types.size()); for (uint32_t i = 0; i < mbr_cnt; i++) { auto &mbr_type = get(type.member_types[i]); if (mbr_type.basetype == SPIRType::Struct) { // Recursively mark structs as packed. auto *struct_type = &mbr_type; while (!struct_type->array.empty()) struct_type = &get(struct_type->parent_type); mark_struct_members_packed(*struct_type); } else if (!is_scalar(mbr_type)) set_extended_member_decoration(type.self, i, SPIRVCrossDecorationPhysicalTypePacked); } } void CompilerMSL::mark_scalar_layout_structs(const SPIRType &type) { uint32_t mbr_cnt = uint32_t(type.member_types.size()); for (uint32_t i = 0; i < mbr_cnt; i++) { auto &mbr_type = get(type.member_types[i]); if (mbr_type.basetype == SPIRType::Struct) { auto *struct_type = &mbr_type; while (!struct_type->array.empty()) struct_type = &get(struct_type->parent_type); if (has_extended_decoration(struct_type->self, SPIRVCrossDecorationPhysicalTypePacked)) continue; uint32_t msl_alignment = get_declared_struct_member_alignment_msl(type, i); uint32_t msl_size = get_declared_struct_member_size_msl(type, i); uint32_t spirv_offset = type_struct_member_offset(type, i); uint32_t spirv_offset_next; if (i + 1 < mbr_cnt) spirv_offset_next = type_struct_member_offset(type, i + 1); else spirv_offset_next = spirv_offset + msl_size; // Both are complicated cases. In scalar layout, a struct of float3 might just consume 12 bytes, // and the next member will be placed at offset 12. bool struct_is_misaligned = (spirv_offset % msl_alignment) != 0; bool struct_is_too_large = spirv_offset + msl_size > spirv_offset_next; uint32_t array_stride = 0; bool struct_needs_explicit_padding = false; // Verify that if a struct is used as an array that ArrayStride matches the effective size of the struct. if (!mbr_type.array.empty()) { array_stride = type_struct_member_array_stride(type, i); uint32_t dimensions = uint32_t(mbr_type.array.size() - 1); for (uint32_t dim = 0; dim < dimensions; dim++) { uint32_t array_size = to_array_size_literal(mbr_type, dim); array_stride /= max(array_size, 1u); } // Set expected struct size based on ArrayStride. struct_needs_explicit_padding = true; // If struct size is larger than array stride, we might be able to fit, if we tightly pack. if (get_declared_struct_size_msl(*struct_type) > array_stride) struct_is_too_large = true; } if (struct_is_misaligned || struct_is_too_large) mark_struct_members_packed(*struct_type); mark_scalar_layout_structs(*struct_type); if (struct_needs_explicit_padding) { msl_size = get_declared_struct_size_msl(*struct_type, true, true); if (array_stride < msl_size) { SPIRV_CROSS_THROW("Cannot express an array stride smaller than size of struct type."); } else { if (has_extended_decoration(struct_type->self, SPIRVCrossDecorationPaddingTarget)) { if (array_stride != get_extended_decoration(struct_type->self, SPIRVCrossDecorationPaddingTarget)) SPIRV_CROSS_THROW( "A struct is used with different array strides. Cannot express this in MSL."); } else set_extended_decoration(struct_type->self, SPIRVCrossDecorationPaddingTarget, array_stride); } } } } } // Sort the members of the struct type by offset, and pack and then pad members where needed // to align MSL members with SPIR-V offsets. The struct members are iterated twice. Packing // occurs first, followed by padding, because packing a member reduces both its size and its // natural alignment, possibly requiring a padding member to be added ahead of it. void CompilerMSL::align_struct(SPIRType &ib_type, unordered_set &aligned_structs) { // We align structs recursively, so stop any redundant work. ID &ib_type_id = ib_type.self; if (aligned_structs.count(ib_type_id)) return; aligned_structs.insert(ib_type_id); // Sort the members of the interface structure by their offset. // They should already be sorted per SPIR-V spec anyway. MemberSorter member_sorter(ib_type, ir.meta[ib_type_id], MemberSorter::Offset); member_sorter.sort(); auto mbr_cnt = uint32_t(ib_type.member_types.size()); for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++) { // Pack any dependent struct types before we pack a parent struct. auto &mbr_type = get(ib_type.member_types[mbr_idx]); if (mbr_type.basetype == SPIRType::Struct) align_struct(mbr_type, aligned_structs); } // Test the alignment of each member, and if a member should be closer to the previous // member than the default spacing expects, it is likely that the previous member is in // a packed format. If so, and the previous member is packable, pack it. // For example ... this applies to any 3-element vector that is followed by a scalar. uint32_t msl_offset = 0; for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++) { // This checks the member in isolation, if the member needs some kind of type remapping to conform to SPIR-V // offsets, array strides and matrix strides. ensure_member_packing_rules_msl(ib_type, mbr_idx); // Align current offset to the current member's default alignment. If the member was packed, it will observe // the updated alignment here. uint32_t msl_align_mask = get_declared_struct_member_alignment_msl(ib_type, mbr_idx) - 1; uint32_t aligned_msl_offset = (msl_offset + msl_align_mask) & ~msl_align_mask; // Fetch the member offset as declared in the SPIRV. uint32_t spirv_mbr_offset = get_member_decoration(ib_type_id, mbr_idx, DecorationOffset); if (spirv_mbr_offset > aligned_msl_offset) { // Since MSL and SPIR-V have slightly different struct member alignment and // size rules, we'll pad to standard C-packing rules with a char[] array. If the member is farther // away than C-packing, expects, add an inert padding member before the the member. uint32_t padding_bytes = spirv_mbr_offset - aligned_msl_offset; set_extended_member_decoration(ib_type_id, mbr_idx, SPIRVCrossDecorationPaddingTarget, padding_bytes); // Re-align as a sanity check that aligning post-padding matches up. msl_offset += padding_bytes; aligned_msl_offset = (msl_offset + msl_align_mask) & ~msl_align_mask; } else if (spirv_mbr_offset < aligned_msl_offset) { // This should not happen, but deal with unexpected scenarios. // It *might* happen if a sub-struct has a larger alignment requirement in MSL than SPIR-V. SPIRV_CROSS_THROW("Cannot represent buffer block correctly in MSL."); } assert(aligned_msl_offset == spirv_mbr_offset); // Increment the current offset to be positioned immediately after the current member. // Don't do this for the last member since it can be unsized, and it is not relevant for padding purposes here. if (mbr_idx + 1 < mbr_cnt) msl_offset = aligned_msl_offset + get_declared_struct_member_size_msl(ib_type, mbr_idx); } } bool CompilerMSL::validate_member_packing_rules_msl(const SPIRType &type, uint32_t index) const { auto &mbr_type = get(type.member_types[index]); uint32_t spirv_offset = get_member_decoration(type.self, index, DecorationOffset); if (index + 1 < type.member_types.size()) { // First, we will check offsets. If SPIR-V offset + MSL size > SPIR-V offset of next member, // we *must* perform some kind of remapping, no way getting around it. // We can always pad after this member if necessary, so that case is fine. uint32_t spirv_offset_next = get_member_decoration(type.self, index + 1, DecorationOffset); assert(spirv_offset_next >= spirv_offset); uint32_t maximum_size = spirv_offset_next - spirv_offset; uint32_t msl_mbr_size = get_declared_struct_member_size_msl(type, index); if (msl_mbr_size > maximum_size) return false; } if (!mbr_type.array.empty()) { // If we have an array type, array stride must match exactly with SPIR-V. // An exception to this requirement is if we have one array element. // This comes from DX scalar layout workaround. // If app tries to be cheeky and access the member out of bounds, this will not work, but this is the best we can do. // In OpAccessChain with logical memory models, access chains must be in-bounds in SPIR-V specification. bool relax_array_stride = mbr_type.array.back() == 1 && mbr_type.array_size_literal.back(); if (!relax_array_stride) { uint32_t spirv_array_stride = type_struct_member_array_stride(type, index); uint32_t msl_array_stride = get_declared_struct_member_array_stride_msl(type, index); if (spirv_array_stride != msl_array_stride) return false; } } if (is_matrix(mbr_type)) { // Need to check MatrixStride as well. uint32_t spirv_matrix_stride = type_struct_member_matrix_stride(type, index); uint32_t msl_matrix_stride = get_declared_struct_member_matrix_stride_msl(type, index); if (spirv_matrix_stride != msl_matrix_stride) return false; } // Now, we check alignment. uint32_t msl_alignment = get_declared_struct_member_alignment_msl(type, index); if ((spirv_offset % msl_alignment) != 0) return false; // We're in the clear. return true; } // Here we need to verify that the member type we declare conforms to Offset, ArrayStride or MatrixStride restrictions. // If there is a mismatch, we need to emit remapped types, either normal types, or "packed_X" types. // In odd cases we need to emit packed and remapped types, for e.g. weird matrices or arrays with weird array strides. void CompilerMSL::ensure_member_packing_rules_msl(SPIRType &ib_type, uint32_t index) { if (validate_member_packing_rules_msl(ib_type, index)) return; // We failed validation. // This case will be nightmare-ish to deal with. This could possibly happen if struct alignment does not quite // match up with what we want. Scalar block layout comes to mind here where we might have to work around the rule // that struct alignment == max alignment of all members and struct size depends on this alignment. auto &mbr_type = get(ib_type.member_types[index]); if (mbr_type.basetype == SPIRType::Struct) SPIRV_CROSS_THROW("Cannot perform any repacking for structs when it is used as a member of another struct."); // Perform remapping here. // There is nothing to be gained by using packed scalars, so don't attempt it. if (!is_scalar(ib_type)) set_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked); // Try validating again, now with packed. if (validate_member_packing_rules_msl(ib_type, index)) return; // We're in deep trouble, and we need to create a new PhysicalType which matches up with what we expect. // A lot of work goes here ... // We will need remapping on Load and Store to translate the types between Logical and Physical. // First, we check if we have small vector std140 array. // We detect this if we have an array of vectors, and array stride is greater than number of elements. if (!mbr_type.array.empty() && !is_matrix(mbr_type)) { uint32_t array_stride = type_struct_member_array_stride(ib_type, index); // Hack off array-of-arrays until we find the array stride per element we must have to make it work. uint32_t dimensions = uint32_t(mbr_type.array.size() - 1); for (uint32_t dim = 0; dim < dimensions; dim++) array_stride /= max(to_array_size_literal(mbr_type, dim), 1u); uint32_t elems_per_stride = array_stride / (mbr_type.width / 8); if (elems_per_stride == 3) SPIRV_CROSS_THROW("Cannot use ArrayStride of 3 elements in remapping scenarios."); else if (elems_per_stride > 4) SPIRV_CROSS_THROW("Cannot represent vectors with more than 4 elements in MSL."); auto physical_type = mbr_type; physical_type.vecsize = elems_per_stride; physical_type.parent_type = 0; uint32_t type_id = ir.increase_bound_by(1); set(type_id, physical_type); set_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID, type_id); set_decoration(type_id, DecorationArrayStride, array_stride); // Remove packed_ for vectors of size 1, 2 and 4. if (has_extended_decoration(ib_type.self, SPIRVCrossDecorationPhysicalTypePacked)) SPIRV_CROSS_THROW("Unable to remove packed decoration as entire struct must be fully packed. Do not mix " "scalar and std140 layout rules."); else unset_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked); } else if (is_matrix(mbr_type)) { // MatrixStride might be std140-esque. uint32_t matrix_stride = type_struct_member_matrix_stride(ib_type, index); uint32_t elems_per_stride = matrix_stride / (mbr_type.width / 8); if (elems_per_stride == 3) SPIRV_CROSS_THROW("Cannot use ArrayStride of 3 elements in remapping scenarios."); else if (elems_per_stride > 4) SPIRV_CROSS_THROW("Cannot represent vectors with more than 4 elements in MSL."); bool row_major = has_member_decoration(ib_type.self, index, DecorationRowMajor); auto physical_type = mbr_type; physical_type.parent_type = 0; if (row_major) physical_type.columns = elems_per_stride; else physical_type.vecsize = elems_per_stride; uint32_t type_id = ir.increase_bound_by(1); set(type_id, physical_type); set_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID, type_id); // Remove packed_ for vectors of size 1, 2 and 4. if (has_extended_decoration(ib_type.self, SPIRVCrossDecorationPhysicalTypePacked)) SPIRV_CROSS_THROW("Unable to remove packed decoration as entire struct must be fully packed. Do not mix " "scalar and std140 layout rules."); else unset_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked); } else SPIRV_CROSS_THROW("Found a buffer packing case which we cannot represent in MSL."); // Try validating again, now with physical type remapping. if (validate_member_packing_rules_msl(ib_type, index)) return; // We might have a particular odd scalar layout case where the last element of an array // does not take up as much space as the ArrayStride or MatrixStride. This can happen with DX cbuffers. // The "proper" workaround for this is extremely painful and essentially impossible in the edge case of float3[], // so we hack around it by declaring the offending array or matrix with one less array size/col/row, // and rely on padding to get the correct value. We will technically access arrays out of bounds into the padding region, // but it should spill over gracefully without too much trouble. We rely on behavior like this for unsized arrays anyways. // E.g. we might observe a physical layout of: // { float2 a[2]; float b; } in cbuffer layout where ArrayStride of a is 16, but offset of b is 24, packed right after a[1] ... uint32_t type_id = get_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID); auto &type = get(type_id); // Modify the physical type in-place. This is safe since each physical type workaround is a copy. if (is_array(type)) { if (type.array.back() > 1) { if (!type.array_size_literal.back()) SPIRV_CROSS_THROW("Cannot apply scalar layout workaround with spec constant array size."); type.array.back() -= 1; } else { // We have an array of size 1, so we cannot decrement that. Our only option now is to // force a packed layout instead, and drop the physical type remap since ArrayStride is meaningless now. unset_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID); set_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked); } } else if (is_matrix(type)) { bool row_major = has_member_decoration(ib_type.self, index, DecorationRowMajor); if (!row_major) { // Slice off one column. If we only have 2 columns, this might turn the matrix into a vector with one array element instead. if (type.columns > 2) { type.columns--; } else if (type.columns == 2) { type.columns = 1; assert(type.array.empty()); type.array.push_back(1); type.array_size_literal.push_back(true); } } else { // Slice off one row. If we only have 2 rows, this might turn the matrix into a vector with one array element instead. if (type.vecsize > 2) { type.vecsize--; } else if (type.vecsize == 2) { type.vecsize = type.columns; type.columns = 1; assert(type.array.empty()); type.array.push_back(1); type.array_size_literal.push_back(true); } } } // This better validate now, or we must fail gracefully. if (!validate_member_packing_rules_msl(ib_type, index)) SPIRV_CROSS_THROW("Found a buffer packing case which we cannot represent in MSL."); } void CompilerMSL::emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression) { auto &type = expression_type(rhs_expression); bool lhs_remapped_type = has_extended_decoration(lhs_expression, SPIRVCrossDecorationPhysicalTypeID); bool lhs_packed_type = has_extended_decoration(lhs_expression, SPIRVCrossDecorationPhysicalTypePacked); auto *lhs_e = maybe_get(lhs_expression); auto *rhs_e = maybe_get(rhs_expression); bool transpose = lhs_e && lhs_e->need_transpose; // No physical type remapping, and no packed type, so can just emit a store directly. if (!lhs_remapped_type && !lhs_packed_type) { // We might not be dealing with remapped physical types or packed types, // but we might be doing a clean store to a row-major matrix. // In this case, we just flip transpose states, and emit the store, a transpose must be in the RHS expression, if any. if (is_matrix(type) && lhs_e && lhs_e->need_transpose) { if (!rhs_e) SPIRV_CROSS_THROW("Need to transpose right-side expression of a store to row-major matrix, but it is " "not a SPIRExpression."); lhs_e->need_transpose = false; if (rhs_e && rhs_e->need_transpose) { // Direct copy, but might need to unpack RHS. // Skip the transpose, as we will transpose when writing to LHS and transpose(transpose(T)) == T. rhs_e->need_transpose = false; statement(to_expression(lhs_expression), " = ", to_unpacked_row_major_matrix_expression(rhs_expression), ";"); rhs_e->need_transpose = true; } else statement(to_expression(lhs_expression), " = transpose(", to_unpacked_expression(rhs_expression), ");"); lhs_e->need_transpose = true; register_write(lhs_expression); } else if (lhs_e && lhs_e->need_transpose) { lhs_e->need_transpose = false; // Storing a column to a row-major matrix. Unroll the write. for (uint32_t c = 0; c < type.vecsize; c++) { auto lhs_expr = to_dereferenced_expression(lhs_expression); auto column_index = lhs_expr.find_last_of('['); if (column_index != string::npos) { statement(lhs_expr.insert(column_index, join('[', c, ']')), " = ", to_extract_component_expression(rhs_expression, c), ";"); } } lhs_e->need_transpose = true; register_write(lhs_expression); } else CompilerGLSL::emit_store_statement(lhs_expression, rhs_expression); } else if (!lhs_remapped_type && !is_matrix(type) && !transpose) { // Even if the target type is packed, we can directly store to it. We cannot store to packed matrices directly, // since they are declared as array of vectors instead, and we need the fallback path below. CompilerGLSL::emit_store_statement(lhs_expression, rhs_expression); } else { // Special handling when storing to a remapped physical type. // This is mostly to deal with std140 padded matrices or vectors. TypeID physical_type_id = lhs_remapped_type ? ID(get_extended_decoration(lhs_expression, SPIRVCrossDecorationPhysicalTypeID)) : type.self; auto &physical_type = get(physical_type_id); if (is_matrix(type)) { const char *packed_pfx = lhs_packed_type ? "packed_" : ""; // Packed matrices are stored as arrays of packed vectors, so we need // to assign the vectors one at a time. // For row-major matrices, we need to transpose the *right-hand* side, // not the left-hand side. // Lots of cases to cover here ... bool rhs_transpose = rhs_e && rhs_e->need_transpose; SPIRType write_type = type; string cast_expr; // We're dealing with transpose manually. if (rhs_transpose) rhs_e->need_transpose = false; if (transpose) { // We're dealing with transpose manually. lhs_e->need_transpose = false; write_type.vecsize = type.columns; write_type.columns = 1; if (physical_type.columns != type.columns) cast_expr = join("(device ", packed_pfx, type_to_glsl(write_type), "&)"); if (rhs_transpose) { // If RHS is also transposed, we can just copy row by row. for (uint32_t i = 0; i < type.vecsize; i++) { statement(cast_expr, to_enclosed_expression(lhs_expression), "[", i, "]", " = ", to_unpacked_row_major_matrix_expression(rhs_expression), "[", i, "];"); } } else { auto vector_type = expression_type(rhs_expression); vector_type.vecsize = vector_type.columns; vector_type.columns = 1; // Transpose on the fly. Emitting a lot of full transpose() ops and extracting lanes seems very bad, // so pick out individual components instead. for (uint32_t i = 0; i < type.vecsize; i++) { string rhs_row = type_to_glsl_constructor(vector_type) + "("; for (uint32_t j = 0; j < vector_type.vecsize; j++) { rhs_row += join(to_enclosed_unpacked_expression(rhs_expression), "[", j, "][", i, "]"); if (j + 1 < vector_type.vecsize) rhs_row += ", "; } rhs_row += ")"; statement(cast_expr, to_enclosed_expression(lhs_expression), "[", i, "]", " = ", rhs_row, ";"); } } // We're dealing with transpose manually. lhs_e->need_transpose = true; } else { write_type.columns = 1; if (physical_type.vecsize != type.vecsize) cast_expr = join("(device ", packed_pfx, type_to_glsl(write_type), "&)"); if (rhs_transpose) { auto vector_type = expression_type(rhs_expression); vector_type.columns = 1; // Transpose on the fly. Emitting a lot of full transpose() ops and extracting lanes seems very bad, // so pick out individual components instead. for (uint32_t i = 0; i < type.columns; i++) { string rhs_row = type_to_glsl_constructor(vector_type) + "("; for (uint32_t j = 0; j < vector_type.vecsize; j++) { // Need to explicitly unpack expression since we've mucked with transpose state. auto unpacked_expr = to_unpacked_row_major_matrix_expression(rhs_expression); rhs_row += join(unpacked_expr, "[", j, "][", i, "]"); if (j + 1 < vector_type.vecsize) rhs_row += ", "; } rhs_row += ")"; statement(cast_expr, to_enclosed_expression(lhs_expression), "[", i, "]", " = ", rhs_row, ";"); } } else { // Copy column-by-column. for (uint32_t i = 0; i < type.columns; i++) { statement(cast_expr, to_enclosed_expression(lhs_expression), "[", i, "]", " = ", to_enclosed_unpacked_expression(rhs_expression), "[", i, "];"); } } } // We're dealing with transpose manually. if (rhs_transpose) rhs_e->need_transpose = true; } else if (transpose) { lhs_e->need_transpose = false; SPIRType write_type = type; write_type.vecsize = 1; write_type.columns = 1; // Storing a column to a row-major matrix. Unroll the write. for (uint32_t c = 0; c < type.vecsize; c++) { auto lhs_expr = to_enclosed_expression(lhs_expression); auto column_index = lhs_expr.find_last_of('['); if (column_index != string::npos) { statement("((device ", type_to_glsl(write_type), "*)&", lhs_expr.insert(column_index, join('[', c, ']', ")")), " = ", to_extract_component_expression(rhs_expression, c), ";"); } } lhs_e->need_transpose = true; } else if ((is_matrix(physical_type) || is_array(physical_type)) && physical_type.vecsize > type.vecsize) { assert(type.vecsize >= 1 && type.vecsize <= 3); // If we have packed types, we cannot use swizzled stores. // We could technically unroll the store for each element if needed. // When remapping to a std140 physical type, we always get float4, // and the packed decoration should always be removed. assert(!lhs_packed_type); string lhs = to_dereferenced_expression(lhs_expression); string rhs = to_pointer_expression(rhs_expression); // Unpack the expression so we can store to it with a float or float2. // It's still an l-value, so it's fine. Most other unpacking of expressions turn them into r-values instead. lhs = join("(device ", type_to_glsl(type), "&)", enclose_expression(lhs)); if (!optimize_read_modify_write(expression_type(rhs_expression), lhs, rhs)) statement(lhs, " = ", rhs, ";"); } else if (!is_matrix(type)) { string lhs = to_dereferenced_expression(lhs_expression); string rhs = to_pointer_expression(rhs_expression); if (!optimize_read_modify_write(expression_type(rhs_expression), lhs, rhs)) statement(lhs, " = ", rhs, ";"); } register_write(lhs_expression); } } static bool expression_ends_with(const string &expr_str, const std::string &ending) { if (expr_str.length() >= ending.length()) return (expr_str.compare(expr_str.length() - ending.length(), ending.length(), ending) == 0); else return false; } // Converts the format of the current expression from packed to unpacked, // by wrapping the expression in a constructor of the appropriate type. // Also, handle special physical ID remapping scenarios, similar to emit_store_statement(). string CompilerMSL::unpack_expression_type(string expr_str, const SPIRType &type, uint32_t physical_type_id, bool packed, bool row_major) { // Trivial case, nothing to do. if (physical_type_id == 0 && !packed) return expr_str; const SPIRType *physical_type = nullptr; if (physical_type_id) physical_type = &get(physical_type_id); static const char *swizzle_lut[] = { ".x", ".xy", ".xyz", }; if (physical_type && is_vector(*physical_type) && is_array(*physical_type) && physical_type->vecsize > type.vecsize && !expression_ends_with(expr_str, swizzle_lut[type.vecsize - 1])) { // std140 array cases for vectors. assert(type.vecsize >= 1 && type.vecsize <= 3); return enclose_expression(expr_str) + swizzle_lut[type.vecsize - 1]; } else if (physical_type && is_matrix(*physical_type) && is_vector(type) && physical_type->vecsize > type.vecsize) { // Extract column from padded matrix. assert(type.vecsize >= 1 && type.vecsize <= 3); return enclose_expression(expr_str) + swizzle_lut[type.vecsize - 1]; } else if (is_matrix(type)) { // Packed matrices are stored as arrays of packed vectors. Unfortunately, // we can't just pass the array straight to the matrix constructor. We have to // pass each vector individually, so that they can be unpacked to normal vectors. if (!physical_type) physical_type = &type; uint32_t vecsize = type.vecsize; uint32_t columns = type.columns; if (row_major) swap(vecsize, columns); uint32_t physical_vecsize = row_major ? physical_type->columns : physical_type->vecsize; const char *base_type = type.width == 16 ? "half" : "float"; string unpack_expr = join(base_type, columns, "x", vecsize, "("); const char *load_swiz = ""; if (physical_vecsize != vecsize) load_swiz = swizzle_lut[vecsize - 1]; for (uint32_t i = 0; i < columns; i++) { if (i > 0) unpack_expr += ", "; if (packed) unpack_expr += join(base_type, physical_vecsize, "(", expr_str, "[", i, "]", ")", load_swiz); else unpack_expr += join(expr_str, "[", i, "]", load_swiz); } unpack_expr += ")"; return unpack_expr; } else { return join(type_to_glsl(type), "(", expr_str, ")"); } } // Emits the file header info void CompilerMSL::emit_header() { // This particular line can be overridden during compilation, so make it a flag and not a pragma line. if (suppress_missing_prototypes) statement("#pragma clang diagnostic ignored \"-Wmissing-prototypes\""); // Disable warning about missing braces for array template to make arrays a value type if (spv_function_implementations.count(SPVFuncImplUnsafeArray) != 0) statement("#pragma clang diagnostic ignored \"-Wmissing-braces\""); for (auto &pragma : pragma_lines) statement(pragma); if (!pragma_lines.empty() || suppress_missing_prototypes) statement(""); statement("#include "); statement("#include "); for (auto &header : header_lines) statement(header); statement(""); statement("using namespace metal;"); statement(""); for (auto &td : typedef_lines) statement(td); if (!typedef_lines.empty()) statement(""); } void CompilerMSL::add_pragma_line(const string &line) { auto rslt = pragma_lines.insert(line); if (rslt.second) force_recompile(); } void CompilerMSL::add_typedef_line(const string &line) { auto rslt = typedef_lines.insert(line); if (rslt.second) force_recompile(); } // Template struct like spvUnsafeArray<> need to be declared *before* any resources are declared void CompilerMSL::emit_custom_templates() { for (const auto &spv_func : spv_function_implementations) { switch (spv_func) { case SPVFuncImplUnsafeArray: statement("template"); statement("struct spvUnsafeArray"); begin_scope(); statement("T elements[Num ? Num : 1];"); statement(""); statement("thread T& operator [] (size_t pos) thread"); begin_scope(); statement("return elements[pos];"); end_scope(); statement("constexpr const thread T& operator [] (size_t pos) const thread"); begin_scope(); statement("return elements[pos];"); end_scope(); statement(""); statement("device T& operator [] (size_t pos) device"); begin_scope(); statement("return elements[pos];"); end_scope(); statement("constexpr const device T& operator [] (size_t pos) const device"); begin_scope(); statement("return elements[pos];"); end_scope(); statement(""); statement("constexpr const constant T& operator [] (size_t pos) const constant"); begin_scope(); statement("return elements[pos];"); end_scope(); statement(""); statement("threadgroup T& operator [] (size_t pos) threadgroup"); begin_scope(); statement("return elements[pos];"); end_scope(); statement("constexpr const threadgroup T& operator [] (size_t pos) const threadgroup"); begin_scope(); statement("return elements[pos];"); end_scope(); end_scope_decl(); statement(""); break; default: break; } } } // Emits any needed custom function bodies. // Metal helper functions must be static force-inline, i.e. static inline __attribute__((always_inline)) // otherwise they will cause problems when linked together in a single Metallib. void CompilerMSL::emit_custom_functions() { for (uint32_t i = kArrayCopyMultidimMax; i >= 2; i--) if (spv_function_implementations.count(static_cast(SPVFuncImplArrayCopyMultidimBase + i))) spv_function_implementations.insert(static_cast(SPVFuncImplArrayCopyMultidimBase + i - 1)); if (spv_function_implementations.count(SPVFuncImplDynamicImageSampler)) { // Unfortunately, this one needs a lot of the other functions to compile OK. if (!msl_options.supports_msl_version(2)) SPIRV_CROSS_THROW( "spvDynamicImageSampler requires default-constructible texture objects, which require MSL 2.0."); spv_function_implementations.insert(SPVFuncImplForwardArgs); spv_function_implementations.insert(SPVFuncImplTextureSwizzle); if (msl_options.swizzle_texture_samples) spv_function_implementations.insert(SPVFuncImplGatherSwizzle); for (uint32_t i = SPVFuncImplChromaReconstructNearest2Plane; i <= SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane; i++) spv_function_implementations.insert(static_cast(i)); spv_function_implementations.insert(SPVFuncImplExpandITUFullRange); spv_function_implementations.insert(SPVFuncImplExpandITUNarrowRange); spv_function_implementations.insert(SPVFuncImplConvertYCbCrBT709); spv_function_implementations.insert(SPVFuncImplConvertYCbCrBT601); spv_function_implementations.insert(SPVFuncImplConvertYCbCrBT2020); } for (uint32_t i = SPVFuncImplChromaReconstructNearest2Plane; i <= SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane; i++) if (spv_function_implementations.count(static_cast(i))) spv_function_implementations.insert(SPVFuncImplForwardArgs); if (spv_function_implementations.count(SPVFuncImplTextureSwizzle) || spv_function_implementations.count(SPVFuncImplGatherSwizzle) || spv_function_implementations.count(SPVFuncImplGatherCompareSwizzle)) { spv_function_implementations.insert(SPVFuncImplForwardArgs); spv_function_implementations.insert(SPVFuncImplGetSwizzle); } for (const auto &spv_func : spv_function_implementations) { switch (spv_func) { case SPVFuncImplMod: statement("// Implementation of the GLSL mod() function, which is slightly different than Metal fmod()"); statement("template"); statement("inline Tx mod(Tx x, Ty y)"); begin_scope(); statement("return x - y * floor(x / y);"); end_scope(); statement(""); break; case SPVFuncImplRadians: statement("// Implementation of the GLSL radians() function"); statement("template"); statement("inline T radians(T d)"); begin_scope(); statement("return d * T(0.01745329251);"); end_scope(); statement(""); break; case SPVFuncImplDegrees: statement("// Implementation of the GLSL degrees() function"); statement("template"); statement("inline T degrees(T r)"); begin_scope(); statement("return r * T(57.2957795131);"); end_scope(); statement(""); break; case SPVFuncImplFindILsb: statement("// Implementation of the GLSL findLSB() function"); statement("template"); statement("inline T spvFindLSB(T x)"); begin_scope(); statement("return select(ctz(x), T(-1), x == T(0));"); end_scope(); statement(""); break; case SPVFuncImplFindUMsb: statement("// Implementation of the unsigned GLSL findMSB() function"); statement("template"); statement("inline T spvFindUMSB(T x)"); begin_scope(); statement("return select(clz(T(0)) - (clz(x) + T(1)), T(-1), x == T(0));"); end_scope(); statement(""); break; case SPVFuncImplFindSMsb: statement("// Implementation of the signed GLSL findMSB() function"); statement("template"); statement("inline T spvFindSMSB(T x)"); begin_scope(); statement("T v = select(x, T(-1) - x, x < T(0));"); statement("return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0));"); end_scope(); statement(""); break; case SPVFuncImplSSign: statement("// Implementation of the GLSL sign() function for integer types"); statement("template::value>::type>"); statement("inline T sign(T x)"); begin_scope(); statement("return select(select(select(x, T(0), x == T(0)), T(1), x > T(0)), T(-1), x < T(0));"); end_scope(); statement(""); break; case SPVFuncImplArrayCopy: case SPVFuncImplArrayOfArrayCopy2Dim: case SPVFuncImplArrayOfArrayCopy3Dim: case SPVFuncImplArrayOfArrayCopy4Dim: case SPVFuncImplArrayOfArrayCopy5Dim: case SPVFuncImplArrayOfArrayCopy6Dim: { // Unfortunately we cannot template on the address space, so combinatorial explosion it is. static const char *function_name_tags[] = { "FromConstantToStack", "FromConstantToThreadGroup", "FromStackToStack", "FromStackToThreadGroup", "FromThreadGroupToStack", "FromThreadGroupToThreadGroup", "FromDeviceToDevice", "FromConstantToDevice", "FromStackToDevice", "FromThreadGroupToDevice", "FromDeviceToStack", "FromDeviceToThreadGroup", }; static const char *src_address_space[] = { "constant", "constant", "thread const", "thread const", "threadgroup const", "threadgroup const", "device const", "constant", "thread const", "threadgroup const", "device const", "device const", }; static const char *dst_address_space[] = { "thread", "threadgroup", "thread", "threadgroup", "thread", "threadgroup", "device", "device", "device", "device", "thread", "threadgroup", }; for (uint32_t variant = 0; variant < 12; variant++) { uint32_t dimensions = spv_func - SPVFuncImplArrayCopyMultidimBase; string tmp = "template 0) { string tex_width_str = convert_to_string(msl_options.texel_buffer_texture_width); statement("// Returns 2D texture coords corresponding to 1D texel buffer coords"); statement(force_inline); statement("uint2 spvTexelBufferCoord(uint tc)"); begin_scope(); statement(join("return uint2(tc % ", tex_width_str, ", tc / ", tex_width_str, ");")); end_scope(); statement(""); } else { statement("// Returns 2D texture coords corresponding to 1D texel buffer coords"); statement( "#define spvTexelBufferCoord(tc, tex) uint2((tc) % (tex).get_width(), (tc) / (tex).get_width())"); statement(""); } break; } // Emulate texture2D atomic operations case SPVFuncImplImage2DAtomicCoords: { if (msl_options.supports_msl_version(1, 2)) { statement("// The required alignment of a linear texture of R32Uint format."); statement("constant uint spvLinearTextureAlignmentOverride [[function_constant(", msl_options.r32ui_alignment_constant_id, ")]];"); statement("constant uint spvLinearTextureAlignment = ", "is_function_constant_defined(spvLinearTextureAlignmentOverride) ? ", "spvLinearTextureAlignmentOverride : ", msl_options.r32ui_linear_texture_alignment, ";"); } else { statement("// The required alignment of a linear texture of R32Uint format."); statement("constant uint spvLinearTextureAlignment = ", msl_options.r32ui_linear_texture_alignment, ";"); } statement("// Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics"); statement("#define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + ", " spvLinearTextureAlignment / 4 - 1) & ~(", " spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x)"); statement(""); break; } // "fadd" intrinsic support case SPVFuncImplFAdd: statement("template"); statement("T spvFAdd(T l, T r)"); begin_scope(); statement("return fma(T(1), l, r);"); end_scope(); statement(""); break; // "fmul' intrinsic support case SPVFuncImplFMul: statement("template"); statement("T spvFMul(T l, T r)"); begin_scope(); statement("return fma(l, r, T(0));"); end_scope(); statement(""); statement("template"); statement("vec spvFMulVectorMatrix(vec v, matrix m)"); begin_scope(); statement("vec res = vec(0);"); statement("for (uint i = Rows; i > 0; --i)"); begin_scope(); statement("vec tmp(0);"); statement("for (uint j = 0; j < Cols; ++j)"); begin_scope(); statement("tmp[j] = m[j][i - 1];"); end_scope(); statement("res = fma(tmp, vec(v[i - 1]), res);"); end_scope(); statement("return res;"); end_scope(); statement(""); statement("template"); statement("vec spvFMulMatrixVector(matrix m, vec v)"); begin_scope(); statement("vec res = vec(0);"); statement("for (uint i = Cols; i > 0; --i)"); begin_scope(); statement("res = fma(m[i - 1], vec(v[i - 1]), res);"); end_scope(); statement("return res;"); end_scope(); statement(""); statement("template"); statement( "matrix spvFMulMatrixMatrix(matrix l, matrix r)"); begin_scope(); statement("matrix res;"); statement("for (uint i = 0; i < RCols; i++)"); begin_scope(); statement("vec tmp(0);"); statement("for (uint j = 0; j < LCols; j++)"); begin_scope(); statement("tmp = fma(vec(r[i][j]), l[j], tmp);"); end_scope(); statement("res[i] = tmp;"); end_scope(); statement("return res;"); end_scope(); statement(""); break; // Emulate texturecube_array with texture2d_array for iOS where this type is not available case SPVFuncImplCubemapTo2DArrayFace: statement(force_inline); statement("float3 spvCubemapTo2DArrayFace(float3 P)"); begin_scope(); statement("float3 Coords = abs(P.xyz);"); statement("float CubeFace = 0;"); statement("float ProjectionAxis = 0;"); statement("float u = 0;"); statement("float v = 0;"); statement("if (Coords.x >= Coords.y && Coords.x >= Coords.z)"); begin_scope(); statement("CubeFace = P.x >= 0 ? 0 : 1;"); statement("ProjectionAxis = Coords.x;"); statement("u = P.x >= 0 ? -P.z : P.z;"); statement("v = -P.y;"); end_scope(); statement("else if (Coords.y >= Coords.x && Coords.y >= Coords.z)"); begin_scope(); statement("CubeFace = P.y >= 0 ? 2 : 3;"); statement("ProjectionAxis = Coords.y;"); statement("u = P.x;"); statement("v = P.y >= 0 ? P.z : -P.z;"); end_scope(); statement("else"); begin_scope(); statement("CubeFace = P.z >= 0 ? 4 : 5;"); statement("ProjectionAxis = Coords.z;"); statement("u = P.z >= 0 ? P.x : -P.x;"); statement("v = -P.y;"); end_scope(); statement("u = 0.5 * (u/ProjectionAxis + 1);"); statement("v = 0.5 * (v/ProjectionAxis + 1);"); statement("return float3(u, v, CubeFace);"); end_scope(); statement(""); break; case SPVFuncImplInverse4x4: statement("// Returns the determinant of a 2x2 matrix."); statement(force_inline); statement("float spvDet2x2(float a1, float a2, float b1, float b2)"); begin_scope(); statement("return a1 * b2 - b1 * a2;"); end_scope(); statement(""); statement("// Returns the determinant of a 3x3 matrix."); statement(force_inline); statement("float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, " "float c2, float c3)"); begin_scope(); statement("return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, " "b2, b3);"); end_scope(); statement(""); statement("// Returns the inverse of a matrix, by using the algorithm of calculating the classical"); statement("// adjoint and dividing by the determinant. The contents of the matrix are changed."); statement(force_inline); statement("float4x4 spvInverse4x4(float4x4 m)"); begin_scope(); statement("float4x4 adj; // The adjoint matrix (inverse after dividing by determinant)"); statement_no_indent(""); statement("// Create the transpose of the cofactors, as the classical adjoint of the matrix."); statement("adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], " "m[3][3]);"); statement("adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], " "m[3][3]);"); statement("adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], " "m[3][3]);"); statement("adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], " "m[2][3]);"); statement_no_indent(""); statement("adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], " "m[3][3]);"); statement("adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], " "m[3][3]);"); statement("adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], " "m[3][3]);"); statement("adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], " "m[2][3]);"); statement_no_indent(""); statement("adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], " "m[3][3]);"); statement("adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], " "m[3][3]);"); statement("adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], " "m[3][3]);"); statement("adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], " "m[2][3]);"); statement_no_indent(""); statement("adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], " "m[3][2]);"); statement("adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], " "m[3][2]);"); statement("adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], " "m[3][2]);"); statement("adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], " "m[2][2]);"); statement_no_indent(""); statement("// Calculate the determinant as a combination of the cofactors of the first row."); statement("float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] " "* m[3][0]);"); statement_no_indent(""); statement("// Divide the classical adjoint matrix by the determinant."); statement("// If determinant is zero, matrix is not invertable, so leave it unchanged."); statement("return (det != 0.0f) ? (adj * (1.0f / det)) : m;"); end_scope(); statement(""); break; case SPVFuncImplInverse3x3: if (spv_function_implementations.count(SPVFuncImplInverse4x4) == 0) { statement("// Returns the determinant of a 2x2 matrix."); statement(force_inline); statement("float spvDet2x2(float a1, float a2, float b1, float b2)"); begin_scope(); statement("return a1 * b2 - b1 * a2;"); end_scope(); statement(""); } statement("// Returns the inverse of a matrix, by using the algorithm of calculating the classical"); statement("// adjoint and dividing by the determinant. The contents of the matrix are changed."); statement(force_inline); statement("float3x3 spvInverse3x3(float3x3 m)"); begin_scope(); statement("float3x3 adj; // The adjoint matrix (inverse after dividing by determinant)"); statement_no_indent(""); statement("// Create the transpose of the cofactors, as the classical adjoint of the matrix."); statement("adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]);"); statement("adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]);"); statement("adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]);"); statement_no_indent(""); statement("adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]);"); statement("adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]);"); statement("adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]);"); statement_no_indent(""); statement("adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]);"); statement("adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]);"); statement("adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]);"); statement_no_indent(""); statement("// Calculate the determinant as a combination of the cofactors of the first row."); statement("float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]);"); statement_no_indent(""); statement("// Divide the classical adjoint matrix by the determinant."); statement("// If determinant is zero, matrix is not invertable, so leave it unchanged."); statement("return (det != 0.0f) ? (adj * (1.0f / det)) : m;"); end_scope(); statement(""); break; case SPVFuncImplInverse2x2: statement("// Returns the inverse of a matrix, by using the algorithm of calculating the classical"); statement("// adjoint and dividing by the determinant. The contents of the matrix are changed."); statement(force_inline); statement("float2x2 spvInverse2x2(float2x2 m)"); begin_scope(); statement("float2x2 adj; // The adjoint matrix (inverse after dividing by determinant)"); statement_no_indent(""); statement("// Create the transpose of the cofactors, as the classical adjoint of the matrix."); statement("adj[0][0] = m[1][1];"); statement("adj[0][1] = -m[0][1];"); statement_no_indent(""); statement("adj[1][0] = -m[1][0];"); statement("adj[1][1] = m[0][0];"); statement_no_indent(""); statement("// Calculate the determinant as a combination of the cofactors of the first row."); statement("float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]);"); statement_no_indent(""); statement("// Divide the classical adjoint matrix by the determinant."); statement("// If determinant is zero, matrix is not invertable, so leave it unchanged."); statement("return (det != 0.0f) ? (adj * (1.0f / det)) : m;"); end_scope(); statement(""); break; case SPVFuncImplForwardArgs: statement("template struct spvRemoveReference { typedef T type; };"); statement("template struct spvRemoveReference { typedef T type; };"); statement("template struct spvRemoveReference { typedef T type; };"); statement("template inline constexpr thread T&& spvForward(thread typename " "spvRemoveReference::type& x)"); begin_scope(); statement("return static_cast(x);"); end_scope(); statement("template inline constexpr thread T&& spvForward(thread typename " "spvRemoveReference::type&& x)"); begin_scope(); statement("return static_cast(x);"); end_scope(); statement(""); break; case SPVFuncImplGetSwizzle: statement("enum class spvSwizzle : uint"); begin_scope(); statement("none = 0,"); statement("zero,"); statement("one,"); statement("red,"); statement("green,"); statement("blue,"); statement("alpha"); end_scope_decl(); statement(""); statement("template"); statement("inline T spvGetSwizzle(vec x, T c, spvSwizzle s)"); begin_scope(); statement("switch (s)"); begin_scope(); statement("case spvSwizzle::none:"); statement(" return c;"); statement("case spvSwizzle::zero:"); statement(" return 0;"); statement("case spvSwizzle::one:"); statement(" return 1;"); statement("case spvSwizzle::red:"); statement(" return x.r;"); statement("case spvSwizzle::green:"); statement(" return x.g;"); statement("case spvSwizzle::blue:"); statement(" return x.b;"); statement("case spvSwizzle::alpha:"); statement(" return x.a;"); end_scope(); end_scope(); statement(""); break; case SPVFuncImplTextureSwizzle: statement("// Wrapper function that swizzles texture samples and fetches."); statement("template"); statement("inline vec spvTextureSwizzle(vec x, uint s)"); begin_scope(); statement("if (!s)"); statement(" return x;"); statement("return vec(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), " "spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) " "& 0xFF)), " "spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF)));"); end_scope(); statement(""); statement("template"); statement("inline T spvTextureSwizzle(T x, uint s)"); begin_scope(); statement("return spvTextureSwizzle(vec(x, 0, 0, 1), s).x;"); end_scope(); statement(""); break; case SPVFuncImplGatherSwizzle: statement("// Wrapper function that swizzles texture gathers."); statement("template class Tex, " "typename... Ts>"); statement("inline vec spvGatherSwizzle(const thread Tex& t, sampler s, " "uint sw, component c, Ts... params) METAL_CONST_ARG(c)"); begin_scope(); statement("if (sw)"); begin_scope(); statement("switch (spvSwizzle((sw >> (uint(c) * 8)) & 0xFF))"); begin_scope(); statement("case spvSwizzle::none:"); statement(" break;"); statement("case spvSwizzle::zero:"); statement(" return vec(0, 0, 0, 0);"); statement("case spvSwizzle::one:"); statement(" return vec(1, 1, 1, 1);"); statement("case spvSwizzle::red:"); statement(" return t.gather(s, spvForward(params)..., component::x);"); statement("case spvSwizzle::green:"); statement(" return t.gather(s, spvForward(params)..., component::y);"); statement("case spvSwizzle::blue:"); statement(" return t.gather(s, spvForward(params)..., component::z);"); statement("case spvSwizzle::alpha:"); statement(" return t.gather(s, spvForward(params)..., component::w);"); end_scope(); end_scope(); // texture::gather insists on its component parameter being a constant // expression, so we need this silly workaround just to compile the shader. statement("switch (c)"); begin_scope(); statement("case component::x:"); statement(" return t.gather(s, spvForward(params)..., component::x);"); statement("case component::y:"); statement(" return t.gather(s, spvForward(params)..., component::y);"); statement("case component::z:"); statement(" return t.gather(s, spvForward(params)..., component::z);"); statement("case component::w:"); statement(" return t.gather(s, spvForward(params)..., component::w);"); end_scope(); end_scope(); statement(""); break; case SPVFuncImplGatherCompareSwizzle: statement("// Wrapper function that swizzles depth texture gathers."); statement("template class Tex, " "typename... Ts>"); statement("inline vec spvGatherCompareSwizzle(const thread Tex& t, sampler " "s, uint sw, Ts... params) "); begin_scope(); statement("if (sw)"); begin_scope(); statement("switch (spvSwizzle(sw & 0xFF))"); begin_scope(); statement("case spvSwizzle::none:"); statement("case spvSwizzle::red:"); statement(" break;"); statement("case spvSwizzle::zero:"); statement("case spvSwizzle::green:"); statement("case spvSwizzle::blue:"); statement("case spvSwizzle::alpha:"); statement(" return vec(0, 0, 0, 0);"); statement("case spvSwizzle::one:"); statement(" return vec(1, 1, 1, 1);"); end_scope(); end_scope(); statement("return t.gather_compare(s, spvForward(params)...);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupBroadcast: // Metal doesn't allow broadcasting boolean values directly, but we can work around that by broadcasting // them as integers. statement("template"); statement("inline T spvSubgroupBroadcast(T value, ushort lane)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return quad_broadcast(value, lane);"); else statement("return simd_broadcast(value, lane);"); end_scope(); statement(""); statement("template<>"); statement("inline bool spvSubgroupBroadcast(bool value, ushort lane)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return !!quad_broadcast((ushort)value, lane);"); else statement("return !!simd_broadcast((ushort)value, lane);"); end_scope(); statement(""); statement("template"); statement("inline vec spvSubgroupBroadcast(vec value, ushort lane)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return (vec)quad_broadcast((vec)value, lane);"); else statement("return (vec)simd_broadcast((vec)value, lane);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupBroadcastFirst: statement("template"); statement("inline T spvSubgroupBroadcastFirst(T value)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return quad_broadcast_first(value);"); else statement("return simd_broadcast_first(value);"); end_scope(); statement(""); statement("template<>"); statement("inline bool spvSubgroupBroadcastFirst(bool value)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return !!quad_broadcast_first((ushort)value);"); else statement("return !!simd_broadcast_first((ushort)value);"); end_scope(); statement(""); statement("template"); statement("inline vec spvSubgroupBroadcastFirst(vec value)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return (vec)quad_broadcast_first((vec)value);"); else statement("return (vec)simd_broadcast_first((vec)value);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupBallot: statement("inline uint4 spvSubgroupBallot(bool value)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) { statement("return uint4((quad_vote::vote_t)quad_ballot(value), 0, 0, 0);"); } else if (msl_options.is_ios()) { // The current simd_vote on iOS uses a 32-bit integer-like object. statement("return uint4((simd_vote::vote_t)simd_ballot(value), 0, 0, 0);"); } else { statement("simd_vote vote = simd_ballot(value);"); statement("// simd_ballot() returns a 64-bit integer-like object, but"); statement("// SPIR-V callers expect a uint4. We must convert."); statement("// FIXME: This won't include higher bits if Apple ever supports"); statement("// 128 lanes in an SIMD-group."); statement( "return uint4((uint)((simd_vote::vote_t)vote & 0xFFFFFFFF), (uint)(((simd_vote::vote_t)vote >> " "32) & 0xFFFFFFFF), 0, 0);"); } end_scope(); statement(""); break; case SPVFuncImplSubgroupBallotBitExtract: statement("inline bool spvSubgroupBallotBitExtract(uint4 ballot, uint bit)"); begin_scope(); statement("return !!extract_bits(ballot[bit / 32], bit % 32, 1);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupBallotFindLSB: statement("inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize)"); begin_scope(); if (msl_options.is_ios()) { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupSize), uint3(0));"); } else { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), " "extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0));"); } statement("ballot &= mask;"); statement("return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + " "ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupBallotFindMSB: statement("inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize)"); begin_scope(); if (msl_options.is_ios()) { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupSize), uint3(0));"); } else { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), " "extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0));"); } statement("ballot &= mask;"); statement("return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - " "(clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), " "ballot.z == 0), ballot.w == 0);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupBallotBitCount: statement("inline uint spvPopCount4(uint4 ballot)"); begin_scope(); statement("return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w);"); end_scope(); statement(""); statement("inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize)"); begin_scope(); if (msl_options.is_ios()) { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupSize), uint3(0));"); } else { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), " "extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0));"); } statement("return spvPopCount4(ballot & mask);"); end_scope(); statement(""); statement("inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID)"); begin_scope(); if (msl_options.is_ios()) { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID + 1), uint3(0));"); } else { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), " "extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), " "uint2(0));"); } statement("return spvPopCount4(ballot & mask);"); end_scope(); statement(""); statement("inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID)"); begin_scope(); if (msl_options.is_ios()) { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, gl_SubgroupInvocationID), uint2(0));"); } else { statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), " "extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0));"); } statement("return spvPopCount4(ballot & mask);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupAllEqual: // Metal doesn't provide a function to evaluate this directly. But, we can // implement this by comparing every thread's value to one thread's value // (in this case, the value of the first active thread). Then, by the transitive // property of equality, if all comparisons return true, then they are all equal. statement("template"); statement("inline bool spvSubgroupAllEqual(T value)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return quad_all(all(value == quad_broadcast_first(value)));"); else statement("return simd_all(all(value == simd_broadcast_first(value)));"); end_scope(); statement(""); statement("template<>"); statement("inline bool spvSubgroupAllEqual(bool value)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return quad_all(value) || !quad_any(value);"); else statement("return simd_all(value) || !simd_any(value);"); end_scope(); statement(""); statement("template"); statement("inline bool spvSubgroupAllEqual(vec value)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return quad_all(all(value == (vec)quad_broadcast_first((vec)value)));"); else statement("return simd_all(all(value == (vec)simd_broadcast_first((vec)value)));"); end_scope(); statement(""); break; case SPVFuncImplSubgroupShuffle: statement("template"); statement("inline T spvSubgroupShuffle(T value, ushort lane)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return quad_shuffle(value, lane);"); else statement("return simd_shuffle(value, lane);"); end_scope(); statement(""); statement("template<>"); statement("inline bool spvSubgroupShuffle(bool value, ushort lane)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return !!quad_shuffle((ushort)value, lane);"); else statement("return !!simd_shuffle((ushort)value, lane);"); end_scope(); statement(""); statement("template"); statement("inline vec spvSubgroupShuffle(vec value, ushort lane)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return (vec)quad_shuffle((vec)value, lane);"); else statement("return (vec)simd_shuffle((vec)value, lane);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupShuffleXor: statement("template"); statement("inline T spvSubgroupShuffleXor(T value, ushort mask)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return quad_shuffle_xor(value, mask);"); else statement("return simd_shuffle_xor(value, mask);"); end_scope(); statement(""); statement("template<>"); statement("inline bool spvSubgroupShuffleXor(bool value, ushort mask)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return !!quad_shuffle_xor((ushort)value, mask);"); else statement("return !!simd_shuffle_xor((ushort)value, mask);"); end_scope(); statement(""); statement("template"); statement("inline vec spvSubgroupShuffleXor(vec value, ushort mask)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return (vec)quad_shuffle_xor((vec)value, mask);"); else statement("return (vec)simd_shuffle_xor((vec)value, mask);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupShuffleUp: statement("template"); statement("inline T spvSubgroupShuffleUp(T value, ushort delta)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return quad_shuffle_up(value, delta);"); else statement("return simd_shuffle_up(value, delta);"); end_scope(); statement(""); statement("template<>"); statement("inline bool spvSubgroupShuffleUp(bool value, ushort delta)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return !!quad_shuffle_up((ushort)value, delta);"); else statement("return !!simd_shuffle_up((ushort)value, delta);"); end_scope(); statement(""); statement("template"); statement("inline vec spvSubgroupShuffleUp(vec value, ushort delta)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return (vec)quad_shuffle_up((vec)value, delta);"); else statement("return (vec)simd_shuffle_up((vec)value, delta);"); end_scope(); statement(""); break; case SPVFuncImplSubgroupShuffleDown: statement("template"); statement("inline T spvSubgroupShuffleDown(T value, ushort delta)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return quad_shuffle_down(value, delta);"); else statement("return simd_shuffle_down(value, delta);"); end_scope(); statement(""); statement("template<>"); statement("inline bool spvSubgroupShuffleDown(bool value, ushort delta)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return !!quad_shuffle_down((ushort)value, delta);"); else statement("return !!simd_shuffle_down((ushort)value, delta);"); end_scope(); statement(""); statement("template"); statement("inline vec spvSubgroupShuffleDown(vec value, ushort delta)"); begin_scope(); if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) statement("return (vec)quad_shuffle_down((vec)value, delta);"); else statement("return (vec)simd_shuffle_down((vec)value, delta);"); end_scope(); statement(""); break; case SPVFuncImplQuadBroadcast: statement("template"); statement("inline T spvQuadBroadcast(T value, uint lane)"); begin_scope(); statement("return quad_broadcast(value, lane);"); end_scope(); statement(""); statement("template<>"); statement("inline bool spvQuadBroadcast(bool value, uint lane)"); begin_scope(); statement("return !!quad_broadcast((ushort)value, lane);"); end_scope(); statement(""); statement("template"); statement("inline vec spvQuadBroadcast(vec value, uint lane)"); begin_scope(); statement("return (vec)quad_broadcast((vec)value, lane);"); end_scope(); statement(""); break; case SPVFuncImplQuadSwap: // We can implement this easily based on the following table giving // the target lane ID from the direction and current lane ID: // Direction // | 0 | 1 | 2 | // ---+---+---+---+ // L 0 | 1 2 3 // a 1 | 0 3 2 // n 2 | 3 0 1 // e 3 | 2 1 0 // Notice that target = source ^ (direction + 1). statement("template"); statement("inline T spvQuadSwap(T value, uint dir)"); begin_scope(); statement("return quad_shuffle_xor(value, dir + 1);"); end_scope(); statement(""); statement("template<>"); statement("inline bool spvQuadSwap(bool value, uint dir)"); begin_scope(); statement("return !!quad_shuffle_xor((ushort)value, dir + 1);"); end_scope(); statement(""); statement("template"); statement("inline vec spvQuadSwap(vec value, uint dir)"); begin_scope(); statement("return (vec)quad_shuffle_xor((vec)value, dir + 1);"); end_scope(); statement(""); break; case SPVFuncImplReflectScalar: // Metal does not support scalar versions of these functions. statement("template"); statement("inline T spvReflect(T i, T n)"); begin_scope(); statement("return i - T(2) * i * n * n;"); end_scope(); statement(""); break; case SPVFuncImplRefractScalar: // Metal does not support scalar versions of these functions. statement("template"); statement("inline T spvRefract(T i, T n, T eta)"); begin_scope(); statement("T NoI = n * i;"); statement("T NoI2 = NoI * NoI;"); statement("T k = T(1) - eta * eta * (T(1) - NoI2);"); statement("if (k < T(0))"); begin_scope(); statement("return T(0);"); end_scope(); statement("else"); begin_scope(); statement("return eta * i - (eta * NoI + sqrt(k)) * n;"); end_scope(); end_scope(); statement(""); break; case SPVFuncImplFaceForwardScalar: // Metal does not support scalar versions of these functions. statement("template"); statement("inline T spvFaceForward(T n, T i, T nref)"); begin_scope(); statement("return i * nref < T(0) ? n : -n;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructNearest2Plane: statement("template"); statement("inline vec spvChromaReconstructNearest(texture2d plane0, texture2d plane1, sampler " "samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("ycbcr.br = plane1.sample(samp, coord, spvForward(options)...).rg;"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructNearest3Plane: statement("template"); statement("inline vec spvChromaReconstructNearest(texture2d plane0, texture2d plane1, " "texture2d plane2, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("ycbcr.b = plane1.sample(samp, coord, spvForward(options)...).r;"); statement("ycbcr.r = plane2.sample(samp, coord, spvForward(options)...).r;"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear422CositedEven2Plane: statement("template"); statement("inline vec spvChromaReconstructLinear422CositedEven(texture2d plane0, texture2d " "plane1, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("if (fract(coord.x * plane1.get_width()) != 0.0)"); begin_scope(); statement("ycbcr.br = vec(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), 0.5).rg);"); end_scope(); statement("else"); begin_scope(); statement("ycbcr.br = plane1.sample(samp, coord, spvForward(options)...).rg;"); end_scope(); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear422CositedEven3Plane: statement("template"); statement("inline vec spvChromaReconstructLinear422CositedEven(texture2d plane0, texture2d " "plane1, texture2d plane2, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("if (fract(coord.x * plane1.get_width()) != 0.0)"); begin_scope(); statement("ycbcr.b = T(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), 0.5).r);"); statement("ycbcr.r = T(mix(plane2.sample(samp, coord, spvForward(options)...), " "plane2.sample(samp, coord, spvForward(options)..., int2(1, 0)), 0.5).r);"); end_scope(); statement("else"); begin_scope(); statement("ycbcr.b = plane1.sample(samp, coord, spvForward(options)...).r;"); statement("ycbcr.r = plane2.sample(samp, coord, spvForward(options)...).r;"); end_scope(); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear422Midpoint2Plane: statement("template"); statement("inline vec spvChromaReconstructLinear422Midpoint(texture2d plane0, texture2d " "plane1, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("int2 offs = int2(fract(coord.x * plane1.get_width()) != 0.0 ? 1 : -1, 0);"); statement("ycbcr.br = vec(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., offs), 0.25).rg);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear422Midpoint3Plane: statement("template"); statement("inline vec spvChromaReconstructLinear422Midpoint(texture2d plane0, texture2d " "plane1, texture2d plane2, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("int2 offs = int2(fract(coord.x * plane1.get_width()) != 0.0 ? 1 : -1, 0);"); statement("ycbcr.b = T(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., offs), 0.25).r);"); statement("ycbcr.r = T(mix(plane2.sample(samp, coord, spvForward(options)...), " "plane2.sample(samp, coord, spvForward(options)..., offs), 0.25).r);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven2Plane: statement("template"); statement("inline vec spvChromaReconstructLinear420XCositedEvenYCositedEven(texture2d plane0, " "texture2d plane1, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("float2 ab = fract(round(coord * float2(plane0.get_width(), plane0.get_height())) * 0.5);"); statement("ycbcr.br = vec(mix(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane1.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).rg);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven3Plane: statement("template"); statement("inline vec spvChromaReconstructLinear420XCositedEvenYCositedEven(texture2d plane0, " "texture2d plane1, texture2d plane2, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("float2 ab = fract(round(coord * float2(plane0.get_width(), plane0.get_height())) * 0.5);"); statement("ycbcr.b = T(mix(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane1.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).r);"); statement("ycbcr.r = T(mix(mix(plane2.sample(samp, coord, spvForward(options)...), " "plane2.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane2.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane2.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).r);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven2Plane: statement("template"); statement("inline vec spvChromaReconstructLinear420XMidpointYCositedEven(texture2d plane0, " "texture2d plane1, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0.5, " "0)) * 0.5);"); statement("ycbcr.br = vec(mix(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane1.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).rg);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven3Plane: statement("template"); statement("inline vec spvChromaReconstructLinear420XMidpointYCositedEven(texture2d plane0, " "texture2d plane1, texture2d plane2, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0.5, " "0)) * 0.5);"); statement("ycbcr.b = T(mix(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane1.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).r);"); statement("ycbcr.r = T(mix(mix(plane2.sample(samp, coord, spvForward(options)...), " "plane2.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane2.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane2.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).r);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint2Plane: statement("template"); statement("inline vec spvChromaReconstructLinear420XCositedEvenYMidpoint(texture2d plane0, " "texture2d plane1, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0, " "0.5)) * 0.5);"); statement("ycbcr.br = vec(mix(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane1.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).rg);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint3Plane: statement("template"); statement("inline vec spvChromaReconstructLinear420XCositedEvenYMidpoint(texture2d plane0, " "texture2d plane1, texture2d plane2, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0, " "0.5)) * 0.5);"); statement("ycbcr.b = T(mix(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane1.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).r);"); statement("ycbcr.r = T(mix(mix(plane2.sample(samp, coord, spvForward(options)...), " "plane2.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane2.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane2.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).r);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint2Plane: statement("template"); statement("inline vec spvChromaReconstructLinear420XMidpointYMidpoint(texture2d plane0, " "texture2d plane1, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0.5, " "0.5)) * 0.5);"); statement("ycbcr.br = vec(mix(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane1.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).rg);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane: statement("template"); statement("inline vec spvChromaReconstructLinear420XMidpointYMidpoint(texture2d plane0, " "texture2d plane1, texture2d plane2, sampler samp, float2 coord, LodOptions... options)"); begin_scope(); statement("vec ycbcr = vec(0, 0, 0, 1);"); statement("ycbcr.g = plane0.sample(samp, coord, spvForward(options)...).r;"); statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0.5, " "0.5)) * 0.5);"); statement("ycbcr.b = T(mix(mix(plane1.sample(samp, coord, spvForward(options)...), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane1.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane1.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).r);"); statement("ycbcr.r = T(mix(mix(plane2.sample(samp, coord, spvForward(options)...), " "plane2.sample(samp, coord, spvForward(options)..., int2(1, 0)), ab.x), " "mix(plane2.sample(samp, coord, spvForward(options)..., int2(0, 1)), " "plane2.sample(samp, coord, spvForward(options)..., int2(1, 1)), ab.x), ab.y).r);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplExpandITUFullRange: statement("template"); statement("inline vec spvExpandITUFullRange(vec ycbcr, int n)"); begin_scope(); statement("ycbcr.br -= exp2(T(n-1))/(exp2(T(n))-1);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplExpandITUNarrowRange: statement("template"); statement("inline vec spvExpandITUNarrowRange(vec ycbcr, int n)"); begin_scope(); statement("ycbcr.g = (ycbcr.g * (exp2(T(n)) - 1) - ldexp(T(16), n - 8))/ldexp(T(219), n - 8);"); statement("ycbcr.br = (ycbcr.br * (exp2(T(n)) - 1) - ldexp(T(128), n - 8))/ldexp(T(224), n - 8);"); statement("return ycbcr;"); end_scope(); statement(""); break; case SPVFuncImplConvertYCbCrBT709: statement("// cf. Khronos Data Format Specification, section 15.1.1"); statement("constant float3x3 spvBT709Factors = {{1, 1, 1}, {0, -0.13397432/0.7152, 1.8556}, {1.5748, " "-0.33480248/0.7152, 0}};"); statement(""); statement("template"); statement("inline vec spvConvertYCbCrBT709(vec ycbcr)"); begin_scope(); statement("vec rgba;"); statement("rgba.rgb = vec(spvBT709Factors * ycbcr.gbr);"); statement("rgba.a = ycbcr.a;"); statement("return rgba;"); end_scope(); statement(""); break; case SPVFuncImplConvertYCbCrBT601: statement("// cf. Khronos Data Format Specification, section 15.1.2"); statement("constant float3x3 spvBT601Factors = {{1, 1, 1}, {0, -0.202008/0.587, 1.772}, {1.402, " "-0.419198/0.587, 0}};"); statement(""); statement("template"); statement("inline vec spvConvertYCbCrBT601(vec ycbcr)"); begin_scope(); statement("vec rgba;"); statement("rgba.rgb = vec(spvBT601Factors * ycbcr.gbr);"); statement("rgba.a = ycbcr.a;"); statement("return rgba;"); end_scope(); statement(""); break; case SPVFuncImplConvertYCbCrBT2020: statement("// cf. Khronos Data Format Specification, section 15.1.3"); statement("constant float3x3 spvBT2020Factors = {{1, 1, 1}, {0, -0.11156702/0.6780, 1.8814}, {1.4746, " "-0.38737742/0.6780, 0}};"); statement(""); statement("template"); statement("inline vec spvConvertYCbCrBT2020(vec ycbcr)"); begin_scope(); statement("vec rgba;"); statement("rgba.rgb = vec(spvBT2020Factors * ycbcr.gbr);"); statement("rgba.a = ycbcr.a;"); statement("return rgba;"); end_scope(); statement(""); break; case SPVFuncImplDynamicImageSampler: statement("enum class spvFormatResolution"); begin_scope(); statement("_444 = 0,"); statement("_422,"); statement("_420"); end_scope_decl(); statement(""); statement("enum class spvChromaFilter"); begin_scope(); statement("nearest = 0,"); statement("linear"); end_scope_decl(); statement(""); statement("enum class spvXChromaLocation"); begin_scope(); statement("cosited_even = 0,"); statement("midpoint"); end_scope_decl(); statement(""); statement("enum class spvYChromaLocation"); begin_scope(); statement("cosited_even = 0,"); statement("midpoint"); end_scope_decl(); statement(""); statement("enum class spvYCbCrModelConversion"); begin_scope(); statement("rgb_identity = 0,"); statement("ycbcr_identity,"); statement("ycbcr_bt_709,"); statement("ycbcr_bt_601,"); statement("ycbcr_bt_2020"); end_scope_decl(); statement(""); statement("enum class spvYCbCrRange"); begin_scope(); statement("itu_full = 0,"); statement("itu_narrow"); end_scope_decl(); statement(""); statement("struct spvComponentBits"); begin_scope(); statement("constexpr explicit spvComponentBits(int v) thread : value(v) {}"); statement("uchar value : 6;"); end_scope_decl(); statement("// A class corresponding to metal::sampler which holds sampler"); statement("// Y'CbCr conversion info."); statement("struct spvYCbCrSampler"); begin_scope(); statement("constexpr spvYCbCrSampler() thread : val(build()) {}"); statement("template"); statement("constexpr spvYCbCrSampler(Ts... t) thread : val(build(t...)) {}"); statement("constexpr spvYCbCrSampler(const thread spvYCbCrSampler& s) thread = default;"); statement(""); statement("spvFormatResolution get_resolution() const thread"); begin_scope(); statement("return spvFormatResolution((val & resolution_mask) >> resolution_base);"); end_scope(); statement("spvChromaFilter get_chroma_filter() const thread"); begin_scope(); statement("return spvChromaFilter((val & chroma_filter_mask) >> chroma_filter_base);"); end_scope(); statement("spvXChromaLocation get_x_chroma_offset() const thread"); begin_scope(); statement("return spvXChromaLocation((val & x_chroma_off_mask) >> x_chroma_off_base);"); end_scope(); statement("spvYChromaLocation get_y_chroma_offset() const thread"); begin_scope(); statement("return spvYChromaLocation((val & y_chroma_off_mask) >> y_chroma_off_base);"); end_scope(); statement("spvYCbCrModelConversion get_ycbcr_model() const thread"); begin_scope(); statement("return spvYCbCrModelConversion((val & ycbcr_model_mask) >> ycbcr_model_base);"); end_scope(); statement("spvYCbCrRange get_ycbcr_range() const thread"); begin_scope(); statement("return spvYCbCrRange((val & ycbcr_range_mask) >> ycbcr_range_base);"); end_scope(); statement("int get_bpc() const thread { return (val & bpc_mask) >> bpc_base; }"); statement(""); statement("private:"); statement("ushort val;"); statement(""); statement("constexpr static constant ushort resolution_bits = 2;"); statement("constexpr static constant ushort chroma_filter_bits = 2;"); statement("constexpr static constant ushort x_chroma_off_bit = 1;"); statement("constexpr static constant ushort y_chroma_off_bit = 1;"); statement("constexpr static constant ushort ycbcr_model_bits = 3;"); statement("constexpr static constant ushort ycbcr_range_bit = 1;"); statement("constexpr static constant ushort bpc_bits = 6;"); statement(""); statement("constexpr static constant ushort resolution_base = 0;"); statement("constexpr static constant ushort chroma_filter_base = 2;"); statement("constexpr static constant ushort x_chroma_off_base = 4;"); statement("constexpr static constant ushort y_chroma_off_base = 5;"); statement("constexpr static constant ushort ycbcr_model_base = 6;"); statement("constexpr static constant ushort ycbcr_range_base = 9;"); statement("constexpr static constant ushort bpc_base = 10;"); statement(""); statement( "constexpr static constant ushort resolution_mask = ((1 << resolution_bits) - 1) << resolution_base;"); statement("constexpr static constant ushort chroma_filter_mask = ((1 << chroma_filter_bits) - 1) << " "chroma_filter_base;"); statement("constexpr static constant ushort x_chroma_off_mask = ((1 << x_chroma_off_bit) - 1) << " "x_chroma_off_base;"); statement("constexpr static constant ushort y_chroma_off_mask = ((1 << y_chroma_off_bit) - 1) << " "y_chroma_off_base;"); statement("constexpr static constant ushort ycbcr_model_mask = ((1 << ycbcr_model_bits) - 1) << " "ycbcr_model_base;"); statement("constexpr static constant ushort ycbcr_range_mask = ((1 << ycbcr_range_bit) - 1) << " "ycbcr_range_base;"); statement("constexpr static constant ushort bpc_mask = ((1 << bpc_bits) - 1) << bpc_base;"); statement(""); statement("static constexpr ushort build()"); begin_scope(); statement("return 0;"); end_scope(); statement(""); statement("template"); statement("static constexpr ushort build(spvFormatResolution res, Ts... t)"); begin_scope(); statement("return (ushort(res) << resolution_base) | (build(t...) & ~resolution_mask);"); end_scope(); statement(""); statement("template"); statement("static constexpr ushort build(spvChromaFilter filt, Ts... t)"); begin_scope(); statement("return (ushort(filt) << chroma_filter_base) | (build(t...) & ~chroma_filter_mask);"); end_scope(); statement(""); statement("template"); statement("static constexpr ushort build(spvXChromaLocation loc, Ts... t)"); begin_scope(); statement("return (ushort(loc) << x_chroma_off_base) | (build(t...) & ~x_chroma_off_mask);"); end_scope(); statement(""); statement("template"); statement("static constexpr ushort build(spvYChromaLocation loc, Ts... t)"); begin_scope(); statement("return (ushort(loc) << y_chroma_off_base) | (build(t...) & ~y_chroma_off_mask);"); end_scope(); statement(""); statement("template"); statement("static constexpr ushort build(spvYCbCrModelConversion model, Ts... t)"); begin_scope(); statement("return (ushort(model) << ycbcr_model_base) | (build(t...) & ~ycbcr_model_mask);"); end_scope(); statement(""); statement("template"); statement("static constexpr ushort build(spvYCbCrRange range, Ts... t)"); begin_scope(); statement("return (ushort(range) << ycbcr_range_base) | (build(t...) & ~ycbcr_range_mask);"); end_scope(); statement(""); statement("template"); statement("static constexpr ushort build(spvComponentBits bpc, Ts... t)"); begin_scope(); statement("return (ushort(bpc.value) << bpc_base) | (build(t...) & ~bpc_mask);"); end_scope(); end_scope_decl(); statement(""); statement("// A class which can hold up to three textures and a sampler, including"); statement("// Y'CbCr conversion info, used to pass combined image-samplers"); statement("// dynamically to functions."); statement("template"); statement("struct spvDynamicImageSampler"); begin_scope(); statement("texture2d plane0;"); statement("texture2d plane1;"); statement("texture2d plane2;"); statement("sampler samp;"); statement("spvYCbCrSampler ycbcr_samp;"); statement("uint swizzle = 0;"); statement(""); if (msl_options.swizzle_texture_samples) { statement("constexpr spvDynamicImageSampler(texture2d tex, sampler samp, uint sw) thread :"); statement(" plane0(tex), samp(samp), swizzle(sw) {}"); } else { statement("constexpr spvDynamicImageSampler(texture2d tex, sampler samp) thread :"); statement(" plane0(tex), samp(samp) {}"); } statement("constexpr spvDynamicImageSampler(texture2d tex, sampler samp, spvYCbCrSampler ycbcr_samp, " "uint sw) thread :"); statement(" plane0(tex), samp(samp), ycbcr_samp(ycbcr_samp), swizzle(sw) {}"); statement("constexpr spvDynamicImageSampler(texture2d plane0, texture2d plane1,"); statement(" sampler samp, spvYCbCrSampler ycbcr_samp, uint sw) thread :"); statement(" plane0(plane0), plane1(plane1), samp(samp), ycbcr_samp(ycbcr_samp), swizzle(sw) {}"); statement( "constexpr spvDynamicImageSampler(texture2d plane0, texture2d plane1, texture2d plane2,"); statement(" sampler samp, spvYCbCrSampler ycbcr_samp, uint sw) thread :"); statement(" plane0(plane0), plane1(plane1), plane2(plane2), samp(samp), ycbcr_samp(ycbcr_samp), " "swizzle(sw) {}"); statement(""); // XXX This is really hard to follow... I've left comments to make it a bit easier. statement("template"); statement("vec do_sample(float2 coord, LodOptions... options) const thread"); begin_scope(); statement("if (!is_null_texture(plane1))"); begin_scope(); statement("if (ycbcr_samp.get_resolution() == spvFormatResolution::_444 ||"); statement(" ycbcr_samp.get_chroma_filter() == spvChromaFilter::nearest)"); begin_scope(); statement("if (!is_null_texture(plane2))"); statement(" return spvChromaReconstructNearest(plane0, plane1, plane2, samp, coord,"); statement(" spvForward(options)...);"); statement( "return spvChromaReconstructNearest(plane0, plane1, samp, coord, spvForward(options)...);"); end_scope(); // if (resolution == 422 || chroma_filter == nearest) statement("switch (ycbcr_samp.get_resolution())"); begin_scope(); statement("case spvFormatResolution::_444: break;"); statement("case spvFormatResolution::_422:"); begin_scope(); statement("switch (ycbcr_samp.get_x_chroma_offset())"); begin_scope(); statement("case spvXChromaLocation::cosited_even:"); statement(" if (!is_null_texture(plane2))"); statement(" return spvChromaReconstructLinear422CositedEven("); statement(" plane0, plane1, plane2, samp,"); statement(" coord, spvForward(options)...);"); statement(" return spvChromaReconstructLinear422CositedEven("); statement(" plane0, plane1, samp, coord,"); statement(" spvForward(options)...);"); statement("case spvXChromaLocation::midpoint:"); statement(" if (!is_null_texture(plane2))"); statement(" return spvChromaReconstructLinear422Midpoint("); statement(" plane0, plane1, plane2, samp,"); statement(" coord, spvForward(options)...);"); statement(" return spvChromaReconstructLinear422Midpoint("); statement(" plane0, plane1, samp, coord,"); statement(" spvForward(options)...);"); end_scope(); // switch (x_chroma_offset) end_scope(); // case 422: statement("case spvFormatResolution::_420:"); begin_scope(); statement("switch (ycbcr_samp.get_x_chroma_offset())"); begin_scope(); statement("case spvXChromaLocation::cosited_even:"); begin_scope(); statement("switch (ycbcr_samp.get_y_chroma_offset())"); begin_scope(); statement("case spvYChromaLocation::cosited_even:"); statement(" if (!is_null_texture(plane2))"); statement(" return spvChromaReconstructLinear420XCositedEvenYCositedEven("); statement(" plane0, plane1, plane2, samp,"); statement(" coord, spvForward(options)...);"); statement(" return spvChromaReconstructLinear420XCositedEvenYCositedEven("); statement(" plane0, plane1, samp, coord,"); statement(" spvForward(options)...);"); statement("case spvYChromaLocation::midpoint:"); statement(" if (!is_null_texture(plane2))"); statement(" return spvChromaReconstructLinear420XCositedEvenYMidpoint("); statement(" plane0, plane1, plane2, samp,"); statement(" coord, spvForward(options)...);"); statement(" return spvChromaReconstructLinear420XCositedEvenYMidpoint("); statement(" plane0, plane1, samp, coord,"); statement(" spvForward(options)...);"); end_scope(); // switch (y_chroma_offset) end_scope(); // case x::cosited_even: statement("case spvXChromaLocation::midpoint:"); begin_scope(); statement("switch (ycbcr_samp.get_y_chroma_offset())"); begin_scope(); statement("case spvYChromaLocation::cosited_even:"); statement(" if (!is_null_texture(plane2))"); statement(" return spvChromaReconstructLinear420XMidpointYCositedEven("); statement(" plane0, plane1, plane2, samp,"); statement(" coord, spvForward(options)...);"); statement(" return spvChromaReconstructLinear420XMidpointYCositedEven("); statement(" plane0, plane1, samp, coord,"); statement(" spvForward(options)...);"); statement("case spvYChromaLocation::midpoint:"); statement(" if (!is_null_texture(plane2))"); statement(" return spvChromaReconstructLinear420XMidpointYMidpoint("); statement(" plane0, plane1, plane2, samp,"); statement(" coord, spvForward(options)...);"); statement(" return spvChromaReconstructLinear420XMidpointYMidpoint("); statement(" plane0, plane1, samp, coord,"); statement(" spvForward(options)...);"); end_scope(); // switch (y_chroma_offset) end_scope(); // case x::midpoint end_scope(); // switch (x_chroma_offset) end_scope(); // case 420: end_scope(); // switch (resolution) end_scope(); // if (multiplanar) statement("return plane0.sample(samp, coord, spvForward(options)...);"); end_scope(); // do_sample() statement("template "); statement("vec sample(float2 coord, LodOptions... options) const thread"); begin_scope(); statement( "vec s = spvTextureSwizzle(do_sample(coord, spvForward(options)...), swizzle);"); statement("if (ycbcr_samp.get_ycbcr_model() == spvYCbCrModelConversion::rgb_identity)"); statement(" return s;"); statement(""); statement("switch (ycbcr_samp.get_ycbcr_range())"); begin_scope(); statement("case spvYCbCrRange::itu_full:"); statement(" s = spvExpandITUFullRange(s, ycbcr_samp.get_bpc());"); statement(" break;"); statement("case spvYCbCrRange::itu_narrow:"); statement(" s = spvExpandITUNarrowRange(s, ycbcr_samp.get_bpc());"); statement(" break;"); end_scope(); statement(""); statement("switch (ycbcr_samp.get_ycbcr_model())"); begin_scope(); statement("case spvYCbCrModelConversion::rgb_identity:"); // Silence Clang warning statement("case spvYCbCrModelConversion::ycbcr_identity:"); statement(" return s;"); statement("case spvYCbCrModelConversion::ycbcr_bt_709:"); statement(" return spvConvertYCbCrBT709(s);"); statement("case spvYCbCrModelConversion::ycbcr_bt_601:"); statement(" return spvConvertYCbCrBT601(s);"); statement("case spvYCbCrModelConversion::ycbcr_bt_2020:"); statement(" return spvConvertYCbCrBT2020(s);"); end_scope(); end_scope(); statement(""); // Sampler Y'CbCr conversion forbids offsets. statement("vec sample(float2 coord, int2 offset) const thread"); begin_scope(); if (msl_options.swizzle_texture_samples) statement("return spvTextureSwizzle(plane0.sample(samp, coord, offset), swizzle);"); else statement("return plane0.sample(samp, coord, offset);"); end_scope(); statement("template"); statement("vec sample(float2 coord, lod_options options, int2 offset) const thread"); begin_scope(); if (msl_options.swizzle_texture_samples) statement("return spvTextureSwizzle(plane0.sample(samp, coord, options, offset), swizzle);"); else statement("return plane0.sample(samp, coord, options, offset);"); end_scope(); statement("#if __HAVE_MIN_LOD_CLAMP__"); statement("vec sample(float2 coord, bias b, min_lod_clamp min_lod, int2 offset) const thread"); begin_scope(); statement("return plane0.sample(samp, coord, b, min_lod, offset);"); end_scope(); statement( "vec sample(float2 coord, gradient2d grad, min_lod_clamp min_lod, int2 offset) const thread"); begin_scope(); statement("return plane0.sample(samp, coord, grad, min_lod, offset);"); end_scope(); statement("#endif"); statement(""); // Y'CbCr conversion forbids all operations but sampling. statement("vec read(uint2 coord, uint lod = 0) const thread"); begin_scope(); statement("return plane0.read(coord, lod);"); end_scope(); statement(""); statement("vec gather(float2 coord, int2 offset = int2(0), component c = component::x) const thread"); begin_scope(); if (msl_options.swizzle_texture_samples) statement("return spvGatherSwizzle(plane0, samp, swizzle, c, coord, offset);"); else statement("return plane0.gather(samp, coord, offset, c);"); end_scope(); end_scope_decl(); statement(""); default: break; } } } // Undefined global memory is not allowed in MSL. // Declare constant and init to zeros. Use {}, as global constructors can break Metal. void CompilerMSL::declare_undefined_values() { bool emitted = false; ir.for_each_typed_id([&](uint32_t, SPIRUndef &undef) { auto &type = this->get(undef.basetype); // OpUndef can be void for some reason ... if (type.basetype == SPIRType::Void) return; statement("constant ", variable_decl(type, to_name(undef.self), undef.self), " = {};"); emitted = true; }); if (emitted) statement(""); } void CompilerMSL::declare_constant_arrays() { bool fully_inlined = ir.ids_for_type[TypeFunction].size() == 1; // MSL cannot declare arrays inline (except when declaring a variable), so we must move them out to // global constants directly, so we are able to use constants as variable expressions. bool emitted = false; ir.for_each_typed_id([&](uint32_t, SPIRConstant &c) { if (c.specialization) return; auto &type = this->get(c.constant_type); // Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. // FIXME: However, hoisting constants to main() means we need to pass down constant arrays to leaf functions if they are used there. // If there are multiple functions in the module, drop this case to avoid breaking use cases which do not need to // link into Metal libraries. This is hacky. if (!type.array.empty() && (!fully_inlined || is_scalar(type) || is_vector(type))) { auto name = to_name(c.self); statement("constant ", variable_decl(type, name), " = ", constant_expression(c), ";"); emitted = true; } }); if (emitted) statement(""); } // Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries void CompilerMSL::declare_complex_constant_arrays() { // If we do not have a fully inlined module, we did not opt in to // declaring constant arrays of complex types. See CompilerMSL::declare_constant_arrays(). bool fully_inlined = ir.ids_for_type[TypeFunction].size() == 1; if (!fully_inlined) return; // MSL cannot declare arrays inline (except when declaring a variable), so we must move them out to // global constants directly, so we are able to use constants as variable expressions. bool emitted = false; ir.for_each_typed_id([&](uint32_t, SPIRConstant &c) { if (c.specialization) return; auto &type = this->get(c.constant_type); if (!type.array.empty() && !(is_scalar(type) || is_vector(type))) { auto name = to_name(c.self); statement("", variable_decl(type, name), " = ", constant_expression(c), ";"); emitted = true; } }); if (emitted) statement(""); } void CompilerMSL::emit_resources() { declare_constant_arrays(); declare_undefined_values(); // Emit the special [[stage_in]] and [[stage_out]] interface blocks which we created. emit_interface_block(stage_out_var_id); emit_interface_block(patch_stage_out_var_id); emit_interface_block(stage_in_var_id); emit_interface_block(patch_stage_in_var_id); } // Emit declarations for the specialization Metal function constants void CompilerMSL::emit_specialization_constants_and_structs() { SpecializationConstant wg_x, wg_y, wg_z; ID workgroup_size_id = get_work_group_size_specialization_constants(wg_x, wg_y, wg_z); bool emitted = false; unordered_set declared_structs; unordered_set aligned_structs; // First, we need to deal with scalar block layout. // It is possible that a struct may have to be placed at an alignment which does not match the innate alignment of the struct itself. // In that case, if such a case exists for a struct, we must force that all elements of the struct become packed_ types. // This makes the struct alignment as small as physically possible. // When we actually align the struct later, we can insert padding as necessary to make the packed members behave like normally aligned types. ir.for_each_typed_id([&](uint32_t type_id, const SPIRType &type) { if (type.basetype == SPIRType::Struct && has_extended_decoration(type_id, SPIRVCrossDecorationBufferBlockRepacked)) mark_scalar_layout_structs(type); }); bool builtin_block_type_is_required = false; // Very special case. If gl_PerVertex is initialized as an array (tessellation) // we have to potentially emit the gl_PerVertex struct type so that we can emit a constant LUT. ir.for_each_typed_id([&](uint32_t, SPIRConstant &c) { auto &type = this->get(c.constant_type); if (is_array(type) && has_decoration(type.self, DecorationBlock) && is_builtin_type(type)) builtin_block_type_is_required = true; }); // Very particular use of the soft loop lock. // align_struct may need to create custom types on the fly, but we don't care about // these types for purpose of iterating over them in ir.ids_for_type and friends. auto loop_lock = ir.create_loop_soft_lock(); for (auto &id_ : ir.ids_for_constant_or_type) { auto &id = ir.ids[id_]; if (id.get_type() == TypeConstant) { auto &c = id.get(); if (c.self == workgroup_size_id) { // TODO: This can be expressed as a [[threads_per_threadgroup]] input semantic, but we need to know // the work group size at compile time in SPIR-V, and [[threads_per_threadgroup]] would need to be passed around as a global. // The work group size may be a specialization constant. statement("constant uint3 ", builtin_to_glsl(BuiltInWorkgroupSize, StorageClassWorkgroup), " [[maybe_unused]] = ", constant_expression(get(workgroup_size_id)), ";"); emitted = true; } else if (c.specialization) { auto &type = get(c.constant_type); string sc_type_name = type_to_glsl(type); string sc_name = to_name(c.self); string sc_tmp_name = sc_name + "_tmp"; // Function constants are only supported in MSL 1.2 and later. // If we don't support it just declare the "default" directly. // This "default" value can be overridden to the true specialization constant by the API user. // Specialization constants which are used as array length expressions cannot be function constants in MSL, // so just fall back to macros. if (msl_options.supports_msl_version(1, 2) && has_decoration(c.self, DecorationSpecId) && !c.is_used_as_array_length) { uint32_t constant_id = get_decoration(c.self, DecorationSpecId); // Only scalar, non-composite values can be function constants. statement("constant ", sc_type_name, " ", sc_tmp_name, " [[function_constant(", constant_id, ")]];"); statement("constant ", sc_type_name, " ", sc_name, " = is_function_constant_defined(", sc_tmp_name, ") ? ", sc_tmp_name, " : ", constant_expression(c), ";"); } else if (has_decoration(c.self, DecorationSpecId)) { // Fallback to macro overrides. c.specialization_constant_macro_name = constant_value_macro_name(get_decoration(c.self, DecorationSpecId)); statement("#ifndef ", c.specialization_constant_macro_name); statement("#define ", c.specialization_constant_macro_name, " ", constant_expression(c)); statement("#endif"); statement("constant ", sc_type_name, " ", sc_name, " = ", c.specialization_constant_macro_name, ";"); } else { // Composite specialization constants must be built from other specialization constants. statement("constant ", sc_type_name, " ", sc_name, " = ", constant_expression(c), ";"); } emitted = true; } } else if (id.get_type() == TypeConstantOp) { auto &c = id.get(); auto &type = get(c.basetype); auto name = to_name(c.self); statement("constant ", variable_decl(type, name), " = ", constant_op_expression(c), ";"); emitted = true; } else if (id.get_type() == TypeType) { // Output non-builtin interface structs. These include local function structs // and structs nested within uniform and read-write buffers. auto &type = id.get(); TypeID type_id = type.self; bool is_struct = (type.basetype == SPIRType::Struct) && type.array.empty() && !type.pointer; bool is_block = has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock); bool is_builtin_block = is_block && is_builtin_type(type); bool is_declarable_struct = is_struct && (!is_builtin_block || builtin_block_type_is_required); // We'll declare this later. if (stage_out_var_id && get_stage_out_struct_type().self == type_id) is_declarable_struct = false; if (patch_stage_out_var_id && get_patch_stage_out_struct_type().self == type_id) is_declarable_struct = false; if (stage_in_var_id && get_stage_in_struct_type().self == type_id) is_declarable_struct = false; if (patch_stage_in_var_id && get_patch_stage_in_struct_type().self == type_id) is_declarable_struct = false; // Align and emit declarable structs...but avoid declaring each more than once. if (is_declarable_struct && declared_structs.count(type_id) == 0) { if (emitted) statement(""); emitted = false; declared_structs.insert(type_id); if (has_extended_decoration(type_id, SPIRVCrossDecorationBufferBlockRepacked)) align_struct(type, aligned_structs); // Make sure we declare the underlying struct type, and not the "decorated" type with pointers, etc. emit_struct(get(type_id)); } } } if (emitted) statement(""); } void CompilerMSL::emit_binary_unord_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op) { bool forward = should_forward(op0) && should_forward(op1); emit_op(result_type, result_id, join("(isunordered(", to_enclosed_unpacked_expression(op0), ", ", to_enclosed_unpacked_expression(op1), ") || ", to_enclosed_unpacked_expression(op0), " ", op, " ", to_enclosed_unpacked_expression(op1), ")"), forward); inherit_expression_dependencies(result_id, op0); inherit_expression_dependencies(result_id, op1); } bool CompilerMSL::emit_tessellation_io_load(uint32_t result_type_id, uint32_t id, uint32_t ptr) { auto &ptr_type = expression_type(ptr); auto &result_type = get(result_type_id); if (ptr_type.storage != StorageClassInput && ptr_type.storage != StorageClassOutput) return false; if (ptr_type.storage == StorageClassOutput && get_execution_model() == ExecutionModelTessellationEvaluation) return false; bool multi_patch_tess_ctl = get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup && ptr_type.storage == StorageClassInput; bool flat_matrix = is_matrix(result_type) && ptr_type.storage == StorageClassInput && !multi_patch_tess_ctl; bool flat_struct = result_type.basetype == SPIRType::Struct && ptr_type.storage == StorageClassInput; bool flat_data_type = flat_matrix || is_array(result_type) || flat_struct; if (!flat_data_type) return false; if (has_decoration(ptr, DecorationPatch)) return false; // Now, we must unflatten a composite type and take care of interleaving array access with gl_in/gl_out. // Lots of painful code duplication since we *really* should not unroll these kinds of loads in entry point fixup // unless we're forced to do this when the code is emitting inoptimal OpLoads. string expr; uint32_t interface_index = get_extended_decoration(ptr, SPIRVCrossDecorationInterfaceMemberIndex); auto *var = maybe_get_backing_variable(ptr); bool ptr_is_io_variable = ir.ids[ptr].get_type() == TypeVariable; auto &expr_type = get_pointee_type(ptr_type.self); const auto &iface_type = expression_type(stage_in_ptr_var_id); if (result_type.array.size() > 2) { SPIRV_CROSS_THROW("Cannot load tessellation IO variables with more than 2 dimensions."); } else if (result_type.array.size() == 2) { if (!ptr_is_io_variable) SPIRV_CROSS_THROW("Loading an array-of-array must be loaded directly from an IO variable."); if (interface_index == uint32_t(-1)) SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue."); if (result_type.basetype == SPIRType::Struct || flat_matrix) SPIRV_CROSS_THROW("Cannot load array-of-array of composite type in tessellation IO."); expr += type_to_glsl(result_type) + "({ "; uint32_t num_control_points = to_array_size_literal(result_type, 1); uint32_t base_interface_index = interface_index; auto &sub_type = get(result_type.parent_type); for (uint32_t i = 0; i < num_control_points; i++) { expr += type_to_glsl(sub_type) + "({ "; interface_index = base_interface_index; uint32_t array_size = to_array_size_literal(result_type, 0); if (multi_patch_tess_ctl) { for (uint32_t j = 0; j < array_size; j++) { const uint32_t indices[3] = { i, interface_index, j }; AccessChainMeta meta; expr += access_chain_internal(stage_in_ptr_var_id, indices, 3, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta); // If the expression has more vector components than the result type, insert // a swizzle. This shouldn't happen normally on valid SPIR-V, but it might // happen if we replace the type of an input variable. if (!is_matrix(sub_type) && sub_type.basetype != SPIRType::Struct && expr_type.vecsize > sub_type.vecsize) expr += vector_swizzle(sub_type.vecsize, 0); if (j + 1 < array_size) expr += ", "; } } else { for (uint32_t j = 0; j < array_size; j++, interface_index++) { const uint32_t indices[2] = { i, interface_index }; AccessChainMeta meta; expr += access_chain_internal(stage_in_ptr_var_id, indices, 2, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta); if (!is_matrix(sub_type) && sub_type.basetype != SPIRType::Struct && expr_type.vecsize > sub_type.vecsize) expr += vector_swizzle(sub_type.vecsize, 0); if (j + 1 < array_size) expr += ", "; } } expr += " })"; if (i + 1 < num_control_points) expr += ", "; } expr += " })"; } else if (flat_struct) { bool is_array_of_struct = is_array(result_type); if (is_array_of_struct && !ptr_is_io_variable) SPIRV_CROSS_THROW("Loading array of struct from IO variable must come directly from IO variable."); uint32_t num_control_points = 1; if (is_array_of_struct) { num_control_points = to_array_size_literal(result_type, 0); expr += type_to_glsl(result_type) + "({ "; } auto &struct_type = is_array_of_struct ? get(result_type.parent_type) : result_type; assert(struct_type.array.empty()); for (uint32_t i = 0; i < num_control_points; i++) { expr += type_to_glsl(struct_type) + "{ "; for (uint32_t j = 0; j < uint32_t(struct_type.member_types.size()); j++) { // The base interface index is stored per variable for structs. if (var) { interface_index = get_extended_member_decoration(var->self, j, SPIRVCrossDecorationInterfaceMemberIndex); } if (interface_index == uint32_t(-1)) SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue."); const auto &mbr_type = get(struct_type.member_types[j]); const auto &expr_mbr_type = get(expr_type.member_types[j]); if (is_matrix(mbr_type) && ptr_type.storage == StorageClassInput && !multi_patch_tess_ctl) { expr += type_to_glsl(mbr_type) + "("; for (uint32_t k = 0; k < mbr_type.columns; k++, interface_index++) { if (is_array_of_struct) { const uint32_t indices[2] = { i, interface_index }; AccessChainMeta meta; expr += access_chain_internal( stage_in_ptr_var_id, indices, 2, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta); } else expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index); if (expr_mbr_type.vecsize > mbr_type.vecsize) expr += vector_swizzle(mbr_type.vecsize, 0); if (k + 1 < mbr_type.columns) expr += ", "; } expr += ")"; } else if (is_array(mbr_type)) { expr += type_to_glsl(mbr_type) + "({ "; uint32_t array_size = to_array_size_literal(mbr_type, 0); if (multi_patch_tess_ctl) { for (uint32_t k = 0; k < array_size; k++) { if (is_array_of_struct) { const uint32_t indices[3] = { i, interface_index, k }; AccessChainMeta meta; expr += access_chain_internal( stage_in_ptr_var_id, indices, 3, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta); } else expr += join(to_expression(ptr), ".", to_member_name(iface_type, interface_index), "[", k, "]"); if (expr_mbr_type.vecsize > mbr_type.vecsize) expr += vector_swizzle(mbr_type.vecsize, 0); if (k + 1 < array_size) expr += ", "; } } else { for (uint32_t k = 0; k < array_size; k++, interface_index++) { if (is_array_of_struct) { const uint32_t indices[2] = { i, interface_index }; AccessChainMeta meta; expr += access_chain_internal( stage_in_ptr_var_id, indices, 2, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta); } else expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index); if (expr_mbr_type.vecsize > mbr_type.vecsize) expr += vector_swizzle(mbr_type.vecsize, 0); if (k + 1 < array_size) expr += ", "; } } expr += " })"; } else { if (is_array_of_struct) { const uint32_t indices[2] = { i, interface_index }; AccessChainMeta meta; expr += access_chain_internal(stage_in_ptr_var_id, indices, 2, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta); } else expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index); if (expr_mbr_type.vecsize > mbr_type.vecsize) expr += vector_swizzle(mbr_type.vecsize, 0); } if (j + 1 < struct_type.member_types.size()) expr += ", "; } expr += " }"; if (i + 1 < num_control_points) expr += ", "; } if (is_array_of_struct) expr += " })"; } else if (flat_matrix) { bool is_array_of_matrix = is_array(result_type); if (is_array_of_matrix && !ptr_is_io_variable) SPIRV_CROSS_THROW("Loading array of matrix from IO variable must come directly from IO variable."); if (interface_index == uint32_t(-1)) SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue."); if (is_array_of_matrix) { // Loading a matrix from each control point. uint32_t base_interface_index = interface_index; uint32_t num_control_points = to_array_size_literal(result_type, 0); expr += type_to_glsl(result_type) + "({ "; auto &matrix_type = get_variable_element_type(get(ptr)); for (uint32_t i = 0; i < num_control_points; i++) { interface_index = base_interface_index; expr += type_to_glsl(matrix_type) + "("; for (uint32_t j = 0; j < result_type.columns; j++, interface_index++) { const uint32_t indices[2] = { i, interface_index }; AccessChainMeta meta; expr += access_chain_internal(stage_in_ptr_var_id, indices, 2, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta); if (expr_type.vecsize > result_type.vecsize) expr += vector_swizzle(result_type.vecsize, 0); if (j + 1 < result_type.columns) expr += ", "; } expr += ")"; if (i + 1 < num_control_points) expr += ", "; } expr += " })"; } else { expr += type_to_glsl(result_type) + "("; for (uint32_t i = 0; i < result_type.columns; i++, interface_index++) { expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index); if (expr_type.vecsize > result_type.vecsize) expr += vector_swizzle(result_type.vecsize, 0); if (i + 1 < result_type.columns) expr += ", "; } expr += ")"; } } else if (ptr_is_io_variable) { assert(is_array(result_type)); assert(result_type.array.size() == 1); if (interface_index == uint32_t(-1)) SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue."); // We're loading an array directly from a global variable. // This means we're loading one member from each control point. expr += type_to_glsl(result_type) + "({ "; uint32_t num_control_points = to_array_size_literal(result_type, 0); for (uint32_t i = 0; i < num_control_points; i++) { const uint32_t indices[2] = { i, interface_index }; AccessChainMeta meta; expr += access_chain_internal(stage_in_ptr_var_id, indices, 2, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta); if (expr_type.vecsize > result_type.vecsize) expr += vector_swizzle(result_type.vecsize, 0); if (i + 1 < num_control_points) expr += ", "; } expr += " })"; } else { // We're loading an array from a concrete control point. assert(is_array(result_type)); assert(result_type.array.size() == 1); if (interface_index == uint32_t(-1)) SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue."); expr += type_to_glsl(result_type) + "({ "; uint32_t array_size = to_array_size_literal(result_type, 0); for (uint32_t i = 0; i < array_size; i++, interface_index++) { expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index); if (expr_type.vecsize > result_type.vecsize) expr += vector_swizzle(result_type.vecsize, 0); if (i + 1 < array_size) expr += ", "; } expr += " })"; } emit_op(result_type_id, id, expr, false); register_read(id, ptr, false); return true; } bool CompilerMSL::emit_tessellation_access_chain(const uint32_t *ops, uint32_t length) { // If this is a per-vertex output, remap it to the I/O array buffer. // Any object which did not go through IO flattening shenanigans will go there instead. // We will unflatten on-demand instead as needed, but not all possible cases can be supported, especially with arrays. auto *var = maybe_get_backing_variable(ops[2]); bool patch = false; bool flat_data = false; bool ptr_is_chain = false; bool multi_patch = get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup; if (var) { patch = has_decoration(ops[2], DecorationPatch) || is_patch_block(get_variable_data_type(*var)); // Should match strip_array in add_interface_block. flat_data = var->storage == StorageClassInput || (var->storage == StorageClassOutput && get_execution_model() == ExecutionModelTessellationControl); // We might have a chained access chain, where // we first take the access chain to the control point, and then we chain into a member or something similar. // In this case, we need to skip gl_in/gl_out remapping. ptr_is_chain = var->self != ID(ops[2]); } BuiltIn bi_type = BuiltIn(get_decoration(ops[2], DecorationBuiltIn)); if (var && flat_data && !patch && (!is_builtin_variable(*var) || bi_type == BuiltInPosition || bi_type == BuiltInPointSize || bi_type == BuiltInClipDistance || bi_type == BuiltInCullDistance || get_variable_data_type(*var).basetype == SPIRType::Struct)) { AccessChainMeta meta; SmallVector indices; uint32_t next_id = ir.increase_bound_by(1); indices.reserve(length - 3 + 1); uint32_t first_non_array_index = ptr_is_chain ? 3 : 4; VariableID stage_var_id = var->storage == StorageClassInput ? stage_in_ptr_var_id : stage_out_ptr_var_id; VariableID ptr = ptr_is_chain ? VariableID(ops[2]) : stage_var_id; if (!ptr_is_chain) { // Index into gl_in/gl_out with first array index. indices.push_back(ops[3]); } auto &result_ptr_type = get(ops[0]); uint32_t const_mbr_id = next_id++; uint32_t index = get_extended_decoration(var->self, SPIRVCrossDecorationInterfaceMemberIndex); if (var->storage == StorageClassInput || has_decoration(get_variable_element_type(*var).self, DecorationBlock)) { uint32_t i = first_non_array_index; auto *type = &get_variable_element_type(*var); if (index == uint32_t(-1) && length >= (first_non_array_index + 1)) { // Maybe this is a struct type in the input class, in which case // we put it as a decoration on the corresponding member. index = get_extended_member_decoration(var->self, get_constant(ops[first_non_array_index]).scalar(), SPIRVCrossDecorationInterfaceMemberIndex); assert(index != uint32_t(-1)); i++; type = &get(type->member_types[get_constant(ops[first_non_array_index]).scalar()]); } // In this case, we're poking into flattened structures and arrays, so now we have to // combine the following indices. If we encounter a non-constant index, // we're hosed. for (; i < length; ++i) { if ((multi_patch || (!is_array(*type) && !is_matrix(*type))) && type->basetype != SPIRType::Struct) break; auto *c = maybe_get(ops[i]); if (!c || c->specialization) SPIRV_CROSS_THROW("Trying to dynamically index into an array interface variable in tessellation. " "This is currently unsupported."); // We're in flattened space, so just increment the member index into IO block. // We can only do this once in the current implementation, so either: // Struct, Matrix or 1-dimensional array for a control point. index += c->scalar(); if (type->parent_type) type = &get(type->parent_type); else if (type->basetype == SPIRType::Struct) type = &get(type->member_types[c->scalar()]); } if ((!multi_patch && (is_matrix(result_ptr_type) || is_array(result_ptr_type))) || result_ptr_type.basetype == SPIRType::Struct) { // We're not going to emit the actual member name, we let any further OpLoad take care of that. // Tag the access chain with the member index we're referencing. set_extended_decoration(ops[1], SPIRVCrossDecorationInterfaceMemberIndex, index); } else { // Access the appropriate member of gl_in/gl_out. set(const_mbr_id, get_uint_type_id(), index, false); indices.push_back(const_mbr_id); // Append any straggling access chain indices. if (i < length) indices.insert(indices.end(), ops + i, ops + length); } } else { assert(index != uint32_t(-1)); set(const_mbr_id, get_uint_type_id(), index, false); indices.push_back(const_mbr_id); indices.insert(indices.end(), ops + 4, ops + length); } // We use the pointer to the base of the input/output array here, // so this is always a pointer chain. string e; if (!ptr_is_chain) { // This is the start of an access chain, use ptr_chain to index into control point array. e = access_chain(ptr, indices.data(), uint32_t(indices.size()), result_ptr_type, &meta, true); } else { // If we're accessing a struct, we need to use member indices which are based on the IO block, // not actual struct type, so we have to use a split access chain here where // first path resolves the control point index, i.e. gl_in[index], and second half deals with // looking up flattened member name. // However, it is possible that we partially accessed a struct, // by taking pointer to member inside the control-point array. // For this case, we fall back to a natural access chain since we have already dealt with remapping struct members. // One way to check this here is if we have 2 implied read expressions. // First one is the gl_in/gl_out struct itself, then an index into that array. // If we have traversed further, we use a normal access chain formulation. auto *ptr_expr = maybe_get(ptr); if (ptr_expr && ptr_expr->implied_read_expressions.size() == 2) { e = join(to_expression(ptr), access_chain_internal(stage_var_id, indices.data(), uint32_t(indices.size()), ACCESS_CHAIN_CHAIN_ONLY_BIT, &meta)); } else { e = access_chain_internal(ptr, indices.data(), uint32_t(indices.size()), 0, &meta); } } // Get the actual type of the object that was accessed. If it's a vector type and we changed it, // then we'll need to add a swizzle. // For this, we can't necessarily rely on the type of the base expression, because it might be // another access chain, and it will therefore already have the "correct" type. auto *expr_type = &get_variable_data_type(*var); if (has_extended_decoration(ops[2], SPIRVCrossDecorationTessIOOriginalInputTypeID)) expr_type = &get(get_extended_decoration(ops[2], SPIRVCrossDecorationTessIOOriginalInputTypeID)); for (uint32_t i = 3; i < length; i++) { if (!is_array(*expr_type) && expr_type->basetype == SPIRType::Struct) expr_type = &get(expr_type->member_types[get(ops[i]).scalar()]); else expr_type = &get(expr_type->parent_type); } if (!is_array(*expr_type) && !is_matrix(*expr_type) && expr_type->basetype != SPIRType::Struct && expr_type->vecsize > result_ptr_type.vecsize) e += vector_swizzle(result_ptr_type.vecsize, 0); auto &expr = set(ops[1], move(e), ops[0], should_forward(ops[2])); expr.loaded_from = var->self; expr.need_transpose = meta.need_transpose; expr.access_chain = true; // Mark the result as being packed if necessary. if (meta.storage_is_packed) set_extended_decoration(ops[1], SPIRVCrossDecorationPhysicalTypePacked); if (meta.storage_physical_type != 0) set_extended_decoration(ops[1], SPIRVCrossDecorationPhysicalTypeID, meta.storage_physical_type); if (meta.storage_is_invariant) set_decoration(ops[1], DecorationInvariant); // Save the type we found in case the result is used in another access chain. set_extended_decoration(ops[1], SPIRVCrossDecorationTessIOOriginalInputTypeID, expr_type->self); // If we have some expression dependencies in our access chain, this access chain is technically a forwarded // temporary which could be subject to invalidation. // Need to assume we're forwarded while calling inherit_expression_depdendencies. forwarded_temporaries.insert(ops[1]); // The access chain itself is never forced to a temporary, but its dependencies might. suppressed_usage_tracking.insert(ops[1]); for (uint32_t i = 2; i < length; i++) { inherit_expression_dependencies(ops[1], ops[i]); add_implied_read_expression(expr, ops[i]); } // If we have no dependencies after all, i.e., all indices in the access chain are immutable temporaries, // we're not forwarded after all. if (expr.expression_dependencies.empty()) forwarded_temporaries.erase(ops[1]); return true; } // If this is the inner tessellation level, and we're tessellating triangles, // drop the last index. It isn't an array in this case, so we can't have an // array reference here. We need to make this ID a variable instead of an // expression so we don't try to dereference it as a variable pointer. // Don't do this if the index is a constant 1, though. We need to drop stores // to that one. auto *m = ir.find_meta(var ? var->self : ID(0)); if (get_execution_model() == ExecutionModelTessellationControl && var && m && m->decoration.builtin_type == BuiltInTessLevelInner && get_entry_point().flags.get(ExecutionModeTriangles)) { auto *c = maybe_get(ops[3]); if (c && c->scalar() == 1) return false; auto &dest_var = set(ops[1], *var); dest_var.basetype = ops[0]; ir.meta[ops[1]] = ir.meta[ops[2]]; inherit_expression_dependencies(ops[1], ops[2]); return true; } return false; } bool CompilerMSL::is_out_of_bounds_tessellation_level(uint32_t id_lhs) { if (!get_entry_point().flags.get(ExecutionModeTriangles)) return false; // In SPIR-V, TessLevelInner always has two elements and TessLevelOuter always has // four. This is true even if we are tessellating triangles. This allows clients // to use a single tessellation control shader with multiple tessellation evaluation // shaders. // In Metal, however, only the first element of TessLevelInner and the first three // of TessLevelOuter are accessible. This stems from how in Metal, the tessellation // levels must be stored to a dedicated buffer in a particular format that depends // on the patch type. Therefore, in Triangles mode, any access to the second // inner level or the fourth outer level must be dropped. const auto *e = maybe_get(id_lhs); if (!e || !e->access_chain) return false; BuiltIn builtin = BuiltIn(get_decoration(e->loaded_from, DecorationBuiltIn)); if (builtin != BuiltInTessLevelInner && builtin != BuiltInTessLevelOuter) return false; auto *c = maybe_get(e->implied_read_expressions[1]); if (!c) return false; return (builtin == BuiltInTessLevelInner && c->scalar() == 1) || (builtin == BuiltInTessLevelOuter && c->scalar() == 3); } void CompilerMSL::prepare_access_chain_for_scalar_access(std::string &expr, const SPIRType &type, spv::StorageClass storage, bool &is_packed) { // If there is any risk of writes happening with the access chain in question, // and there is a risk of concurrent write access to other components, // we must cast the access chain to a plain pointer to ensure we only access the exact scalars we expect. // The MSL compiler refuses to allow component-level access for any non-packed vector types. if (!is_packed && (storage == StorageClassStorageBuffer || storage == StorageClassWorkgroup)) { const char *addr_space = storage == StorageClassWorkgroup ? "threadgroup" : "device"; expr = join("((", addr_space, " ", type_to_glsl(type), "*)&", enclose_expression(expr), ")"); // Further indexing should happen with packed rules (array index, not swizzle). is_packed = true; } } // Sets the interface member index for an access chain to a pull-model interpolant. void CompilerMSL::fix_up_interpolant_access_chain(const uint32_t *ops, uint32_t length) { auto *var = maybe_get_backing_variable(ops[2]); if (!var || !pull_model_inputs.count(var->self)) return; // Get the base index. uint32_t interface_index; auto &var_type = get_variable_data_type(*var); auto &result_type = get(ops[0]); auto *type = &var_type; if (has_extended_decoration(ops[2], SPIRVCrossDecorationInterfaceMemberIndex)) { interface_index = get_extended_decoration(ops[2], SPIRVCrossDecorationInterfaceMemberIndex); } else { // Assume an access chain into a struct variable. assert(var_type.basetype == SPIRType::Struct); auto &c = get(ops[3 + var_type.array.size()]); interface_index = get_extended_member_decoration(var->self, c.scalar(), SPIRVCrossDecorationInterfaceMemberIndex); } // Accumulate indices. We'll have to skip over the one for the struct, if present, because we already accounted // for that getting the base index. for (uint32_t i = 3; i < length; ++i) { if (is_vector(*type) && is_scalar(result_type)) { // We don't want to combine the next index. Actually, we need to save it // so we know to apply a swizzle to the result of the interpolation. set_extended_decoration(ops[1], SPIRVCrossDecorationInterpolantComponentExpr, ops[i]); break; } auto *c = maybe_get(ops[i]); if (!c || c->specialization) SPIRV_CROSS_THROW("Trying to dynamically index into an array interface variable using pull-model " "interpolation. This is currently unsupported."); if (type->parent_type) type = &get(type->parent_type); else if (type->basetype == SPIRType::Struct) type = &get(type->member_types[c->scalar()]); if (!has_extended_decoration(ops[2], SPIRVCrossDecorationInterfaceMemberIndex) && i - 3 == var_type.array.size()) continue; interface_index += c->scalar(); } // Save this to the access chain itself so we can recover it later when calling an interpolation function. set_extended_decoration(ops[1], SPIRVCrossDecorationInterfaceMemberIndex, interface_index); } // Override for MSL-specific syntax instructions void CompilerMSL::emit_instruction(const Instruction &instruction) { #define MSL_BOP(op) emit_binary_op(ops[0], ops[1], ops[2], ops[3], #op) #define MSL_BOP_CAST(op, type) \ emit_binary_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, opcode_is_sign_invariant(opcode)) #define MSL_UOP(op) emit_unary_op(ops[0], ops[1], ops[2], #op) #define MSL_QFOP(op) emit_quaternary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], ops[5], #op) #define MSL_TFOP(op) emit_trinary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], #op) #define MSL_BFOP(op) emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], #op) #define MSL_BFOP_CAST(op, type) \ emit_binary_func_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, opcode_is_sign_invariant(opcode)) #define MSL_UFOP(op) emit_unary_func_op(ops[0], ops[1], ops[2], #op) #define MSL_UNORD_BOP(op) emit_binary_unord_op(ops[0], ops[1], ops[2], ops[3], #op) auto ops = stream(instruction); auto opcode = static_cast(instruction.op); // If we need to do implicit bitcasts, make sure we do it with the correct type. uint32_t integer_width = get_integer_width_for_instruction(instruction); auto int_type = to_signed_basetype(integer_width); auto uint_type = to_unsigned_basetype(integer_width); switch (opcode) { case OpLoad: { uint32_t id = ops[1]; uint32_t ptr = ops[2]; if (is_tessellation_shader()) { if (!emit_tessellation_io_load(ops[0], id, ptr)) CompilerGLSL::emit_instruction(instruction); } else { // Sample mask input for Metal is not an array if (BuiltIn(get_decoration(ptr, DecorationBuiltIn)) == BuiltInSampleMask) set_decoration(id, DecorationBuiltIn, BuiltInSampleMask); CompilerGLSL::emit_instruction(instruction); } break; } // Comparisons case OpIEqual: MSL_BOP_CAST(==, int_type); break; case OpLogicalEqual: case OpFOrdEqual: MSL_BOP(==); break; case OpINotEqual: MSL_BOP_CAST(!=, int_type); break; case OpLogicalNotEqual: case OpFOrdNotEqual: MSL_BOP(!=); break; case OpUGreaterThan: MSL_BOP_CAST(>, uint_type); break; case OpSGreaterThan: MSL_BOP_CAST(>, int_type); break; case OpFOrdGreaterThan: MSL_BOP(>); break; case OpUGreaterThanEqual: MSL_BOP_CAST(>=, uint_type); break; case OpSGreaterThanEqual: MSL_BOP_CAST(>=, int_type); break; case OpFOrdGreaterThanEqual: MSL_BOP(>=); break; case OpULessThan: MSL_BOP_CAST(<, uint_type); break; case OpSLessThan: MSL_BOP_CAST(<, int_type); break; case OpFOrdLessThan: MSL_BOP(<); break; case OpULessThanEqual: MSL_BOP_CAST(<=, uint_type); break; case OpSLessThanEqual: MSL_BOP_CAST(<=, int_type); break; case OpFOrdLessThanEqual: MSL_BOP(<=); break; case OpFUnordEqual: MSL_UNORD_BOP(==); break; case OpFUnordNotEqual: MSL_UNORD_BOP(!=); break; case OpFUnordGreaterThan: MSL_UNORD_BOP(>); break; case OpFUnordGreaterThanEqual: MSL_UNORD_BOP(>=); break; case OpFUnordLessThan: MSL_UNORD_BOP(<); break; case OpFUnordLessThanEqual: MSL_UNORD_BOP(<=); break; // Derivatives case OpDPdx: case OpDPdxFine: case OpDPdxCoarse: MSL_UFOP(dfdx); register_control_dependent_expression(ops[1]); break; case OpDPdy: case OpDPdyFine: case OpDPdyCoarse: MSL_UFOP(dfdy); register_control_dependent_expression(ops[1]); break; case OpFwidth: case OpFwidthCoarse: case OpFwidthFine: MSL_UFOP(fwidth); register_control_dependent_expression(ops[1]); break; // Bitfield case OpBitFieldInsert: { emit_bitfield_insert_op(ops[0], ops[1], ops[2], ops[3], ops[4], ops[5], "insert_bits", SPIRType::UInt); break; } case OpBitFieldSExtract: { emit_trinary_func_op_bitextract(ops[0], ops[1], ops[2], ops[3], ops[4], "extract_bits", int_type, int_type, SPIRType::UInt, SPIRType::UInt); break; } case OpBitFieldUExtract: { emit_trinary_func_op_bitextract(ops[0], ops[1], ops[2], ops[3], ops[4], "extract_bits", uint_type, uint_type, SPIRType::UInt, SPIRType::UInt); break; } case OpBitReverse: // BitReverse does not have issues with sign since result type must match input type. MSL_UFOP(reverse_bits); break; case OpBitCount: { auto basetype = expression_type(ops[2]).basetype; emit_unary_func_op_cast(ops[0], ops[1], ops[2], "popcount", basetype, basetype); break; } case OpFRem: MSL_BFOP(fmod); break; case OpFMul: if (msl_options.invariant_float_math) MSL_BFOP(spvFMul); else MSL_BOP(*); break; case OpFAdd: if (msl_options.invariant_float_math) MSL_BFOP(spvFAdd); else MSL_BOP(+); break; // Atomics case OpAtomicExchange: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t ptr = ops[2]; uint32_t mem_sem = ops[4]; uint32_t val = ops[5]; emit_atomic_func_op(result_type, id, "atomic_exchange_explicit", mem_sem, mem_sem, false, ptr, val); break; } case OpAtomicCompareExchange: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t ptr = ops[2]; uint32_t mem_sem_pass = ops[4]; uint32_t mem_sem_fail = ops[5]; uint32_t val = ops[6]; uint32_t comp = ops[7]; emit_atomic_func_op(result_type, id, "atomic_compare_exchange_weak_explicit", mem_sem_pass, mem_sem_fail, true, ptr, comp, true, false, val); break; } case OpAtomicCompareExchangeWeak: SPIRV_CROSS_THROW("OpAtomicCompareExchangeWeak is only supported in kernel profile."); case OpAtomicLoad: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t ptr = ops[2]; uint32_t mem_sem = ops[4]; emit_atomic_func_op(result_type, id, "atomic_load_explicit", mem_sem, mem_sem, false, ptr, 0); break; } case OpAtomicStore: { uint32_t result_type = expression_type(ops[0]).self; uint32_t id = ops[0]; uint32_t ptr = ops[0]; uint32_t mem_sem = ops[2]; uint32_t val = ops[3]; emit_atomic_func_op(result_type, id, "atomic_store_explicit", mem_sem, mem_sem, false, ptr, val); break; } #define MSL_AFMO_IMPL(op, valsrc, valconst) \ do \ { \ uint32_t result_type = ops[0]; \ uint32_t id = ops[1]; \ uint32_t ptr = ops[2]; \ uint32_t mem_sem = ops[4]; \ uint32_t val = valsrc; \ emit_atomic_func_op(result_type, id, "atomic_fetch_" #op "_explicit", mem_sem, mem_sem, false, ptr, val, \ false, valconst); \ } while (false) #define MSL_AFMO(op) MSL_AFMO_IMPL(op, ops[5], false) #define MSL_AFMIO(op) MSL_AFMO_IMPL(op, 1, true) case OpAtomicIIncrement: MSL_AFMIO(add); break; case OpAtomicIDecrement: MSL_AFMIO(sub); break; case OpAtomicIAdd: MSL_AFMO(add); break; case OpAtomicISub: MSL_AFMO(sub); break; case OpAtomicSMin: case OpAtomicUMin: MSL_AFMO(min); break; case OpAtomicSMax: case OpAtomicUMax: MSL_AFMO(max); break; case OpAtomicAnd: MSL_AFMO(and); break; case OpAtomicOr: MSL_AFMO(or); break; case OpAtomicXor: MSL_AFMO(xor); break; // Images // Reads == Fetches in Metal case OpImageRead: { // Mark that this shader reads from this image uint32_t img_id = ops[2]; auto &type = expression_type(img_id); if (type.image.dim != DimSubpassData) { auto *p_var = maybe_get_backing_variable(img_id); if (p_var && has_decoration(p_var->self, DecorationNonReadable)) { unset_decoration(p_var->self, DecorationNonReadable); force_recompile(); } } emit_texture_op(instruction, false); break; } // Emulate texture2D atomic operations case OpImageTexelPointer: { // When using the pointer, we need to know which variable it is actually loaded from. auto *var = maybe_get_backing_variable(ops[2]); if (var && atomic_image_vars.count(var->self)) { uint32_t result_type = ops[0]; uint32_t id = ops[1]; std::string coord = to_expression(ops[3]); auto &type = expression_type(ops[2]); if (type.image.dim == Dim2D) { coord = join("spvImage2DAtomicCoord(", coord, ", ", to_expression(ops[2]), ")"); } auto &e = set(id, join(to_expression(ops[2]), "_atomic[", coord, "]"), result_type, true); e.loaded_from = var ? var->self : ID(0); inherit_expression_dependencies(id, ops[3]); } else { uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto &e = set(id, join(to_expression(ops[2]), ", ", to_expression(ops[3])), result_type, true); // When using the pointer, we need to know which variable it is actually loaded from. e.loaded_from = var ? var->self : ID(0); inherit_expression_dependencies(id, ops[3]); } break; } case OpImageWrite: { uint32_t img_id = ops[0]; uint32_t coord_id = ops[1]; uint32_t texel_id = ops[2]; const uint32_t *opt = &ops[3]; uint32_t length = instruction.length - 3; // Bypass pointers because we need the real image struct auto &type = expression_type(img_id); auto &img_type = get(type.self); // Ensure this image has been marked as being written to and force a // recommpile so that the image type output will include write access auto *p_var = maybe_get_backing_variable(img_id); if (p_var && has_decoration(p_var->self, DecorationNonWritable)) { unset_decoration(p_var->self, DecorationNonWritable); force_recompile(); } bool forward = false; uint32_t bias = 0; uint32_t lod = 0; uint32_t flags = 0; if (length) { flags = *opt++; length--; } auto test = [&](uint32_t &v, uint32_t flag) { if (length && (flags & flag)) { v = *opt++; length--; } }; test(bias, ImageOperandsBiasMask); test(lod, ImageOperandsLodMask); auto &texel_type = expression_type(texel_id); auto store_type = texel_type; store_type.vecsize = 4; TextureFunctionArguments args = {}; args.base.img = img_id; args.base.imgtype = &img_type; args.base.is_fetch = true; args.coord = coord_id; args.lod = lod; statement(join(to_expression(img_id), ".write(", remap_swizzle(store_type, texel_type.vecsize, to_expression(texel_id)), ", ", CompilerMSL::to_function_args(args, &forward), ");")); if (p_var && variable_storage_is_aliased(*p_var)) flush_all_aliased_variables(); break; } case OpImageQuerySize: case OpImageQuerySizeLod: { uint32_t rslt_type_id = ops[0]; auto &rslt_type = get(rslt_type_id); uint32_t id = ops[1]; uint32_t img_id = ops[2]; string img_exp = to_expression(img_id); auto &img_type = expression_type(img_id); Dim img_dim = img_type.image.dim; bool img_is_array = img_type.image.arrayed; if (img_type.basetype != SPIRType::Image) SPIRV_CROSS_THROW("Invalid type for OpImageQuerySize."); string lod; if (opcode == OpImageQuerySizeLod) { // LOD index defaults to zero, so don't bother outputing level zero index string decl_lod = to_expression(ops[3]); if (decl_lod != "0") lod = decl_lod; } string expr = type_to_glsl(rslt_type) + "("; expr += img_exp + ".get_width(" + lod + ")"; if (img_dim == Dim2D || img_dim == DimCube || img_dim == Dim3D) expr += ", " + img_exp + ".get_height(" + lod + ")"; if (img_dim == Dim3D) expr += ", " + img_exp + ".get_depth(" + lod + ")"; if (img_is_array) { expr += ", " + img_exp + ".get_array_size()"; if (img_dim == DimCube && msl_options.emulate_cube_array) expr += " / 6"; } expr += ")"; emit_op(rslt_type_id, id, expr, should_forward(img_id)); break; } case OpImageQueryLod: { if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("ImageQueryLod is only supported on MSL 2.2 and up."); uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t image_id = ops[2]; uint32_t coord_id = ops[3]; emit_uninitialized_temporary_expression(result_type, id); auto sampler_expr = to_sampler_expression(image_id); auto *combined = maybe_get(image_id); auto image_expr = combined ? to_expression(combined->image) : to_expression(image_id); // TODO: It is unclear if calculcate_clamped_lod also conditionally rounds // the reported LOD based on the sampler. NEAREST miplevel should // round the LOD, but LINEAR miplevel should not round. // Let's hope this does not become an issue ... statement(to_expression(id), ".x = ", image_expr, ".calculate_clamped_lod(", sampler_expr, ", ", to_expression(coord_id), ");"); statement(to_expression(id), ".y = ", image_expr, ".calculate_unclamped_lod(", sampler_expr, ", ", to_expression(coord_id), ");"); register_control_dependent_expression(id); break; } #define MSL_ImgQry(qrytype) \ do \ { \ uint32_t rslt_type_id = ops[0]; \ auto &rslt_type = get(rslt_type_id); \ uint32_t id = ops[1]; \ uint32_t img_id = ops[2]; \ string img_exp = to_expression(img_id); \ string expr = type_to_glsl(rslt_type) + "(" + img_exp + ".get_num_" #qrytype "())"; \ emit_op(rslt_type_id, id, expr, should_forward(img_id)); \ } while (false) case OpImageQueryLevels: MSL_ImgQry(mip_levels); break; case OpImageQuerySamples: MSL_ImgQry(samples); break; case OpImage: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto *combined = maybe_get(ops[2]); if (combined) { auto &e = emit_op(result_type, id, to_expression(combined->image), true, true); auto *var = maybe_get_backing_variable(combined->image); if (var) e.loaded_from = var->self; } else { auto *var = maybe_get_backing_variable(ops[2]); SPIRExpression *e; if (var && has_extended_decoration(var->self, SPIRVCrossDecorationDynamicImageSampler)) e = &emit_op(result_type, id, join(to_expression(ops[2]), ".plane0"), true, true); else e = &emit_op(result_type, id, to_expression(ops[2]), true, true); if (var) e->loaded_from = var->self; } break; } // Casting case OpQuantizeToF16: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t arg = ops[2]; string exp; auto &type = get(result_type); switch (type.vecsize) { case 1: exp = join("float(half(", to_expression(arg), "))"); break; case 2: exp = join("float2(half2(", to_expression(arg), "))"); break; case 3: exp = join("float3(half3(", to_expression(arg), "))"); break; case 4: exp = join("float4(half4(", to_expression(arg), "))"); break; default: SPIRV_CROSS_THROW("Illegal argument to OpQuantizeToF16."); } emit_op(result_type, id, exp, should_forward(arg)); break; } case OpInBoundsAccessChain: case OpAccessChain: case OpPtrAccessChain: if (is_tessellation_shader()) { if (!emit_tessellation_access_chain(ops, instruction.length)) CompilerGLSL::emit_instruction(instruction); } else CompilerGLSL::emit_instruction(instruction); fix_up_interpolant_access_chain(ops, instruction.length); break; case OpStore: if (is_out_of_bounds_tessellation_level(ops[0])) break; if (maybe_emit_array_assignment(ops[0], ops[1])) break; CompilerGLSL::emit_instruction(instruction); break; // Compute barriers case OpMemoryBarrier: emit_barrier(0, ops[0], ops[1]); break; case OpControlBarrier: // In GLSL a memory barrier is often followed by a control barrier. // But in MSL, memory barriers are also control barriers, so don't // emit a simple control barrier if a memory barrier has just been emitted. if (previous_instruction_opcode != OpMemoryBarrier) emit_barrier(ops[0], ops[1], ops[2]); break; case OpOuterProduct: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t a = ops[2]; uint32_t b = ops[3]; auto &type = get(result_type); string expr = type_to_glsl_constructor(type); expr += "("; for (uint32_t col = 0; col < type.columns; col++) { expr += to_enclosed_expression(a); expr += " * "; expr += to_extract_component_expression(b, col); if (col + 1 < type.columns) expr += ", "; } expr += ")"; emit_op(result_type, id, expr, should_forward(a) && should_forward(b)); inherit_expression_dependencies(id, a); inherit_expression_dependencies(id, b); break; } case OpVectorTimesMatrix: case OpMatrixTimesVector: { if (!msl_options.invariant_float_math) { CompilerGLSL::emit_instruction(instruction); break; } // If the matrix needs transpose, just flip the multiply order. auto *e = maybe_get(ops[opcode == OpMatrixTimesVector ? 2 : 3]); if (e && e->need_transpose) { e->need_transpose = false; string expr; if (opcode == OpMatrixTimesVector) { expr = join("spvFMulVectorMatrix(", to_enclosed_unpacked_expression(ops[3]), ", ", to_unpacked_row_major_matrix_expression(ops[2]), ")"); } else { expr = join("spvFMulMatrixVector(", to_unpacked_row_major_matrix_expression(ops[3]), ", ", to_enclosed_unpacked_expression(ops[2]), ")"); } bool forward = should_forward(ops[2]) && should_forward(ops[3]); emit_op(ops[0], ops[1], expr, forward); e->need_transpose = true; inherit_expression_dependencies(ops[1], ops[2]); inherit_expression_dependencies(ops[1], ops[3]); } else { if (opcode == OpMatrixTimesVector) MSL_BFOP(spvFMulMatrixVector); else MSL_BFOP(spvFMulVectorMatrix); } break; } case OpMatrixTimesMatrix: { if (!msl_options.invariant_float_math) { CompilerGLSL::emit_instruction(instruction); break; } auto *a = maybe_get(ops[2]); auto *b = maybe_get(ops[3]); // If both matrices need transpose, we can multiply in flipped order and tag the expression as transposed. // a^T * b^T = (b * a)^T. if (a && b && a->need_transpose && b->need_transpose) { a->need_transpose = false; b->need_transpose = false; auto expr = join("spvFMulMatrixMatrix(", enclose_expression(to_unpacked_row_major_matrix_expression(ops[3])), ", ", enclose_expression(to_unpacked_row_major_matrix_expression(ops[2])), ")"); bool forward = should_forward(ops[2]) && should_forward(ops[3]); auto &e = emit_op(ops[0], ops[1], expr, forward); e.need_transpose = true; a->need_transpose = true; b->need_transpose = true; inherit_expression_dependencies(ops[1], ops[2]); inherit_expression_dependencies(ops[1], ops[3]); } else MSL_BFOP(spvFMulMatrixMatrix); break; } case OpIAddCarry: case OpISubBorrow: { uint32_t result_type = ops[0]; uint32_t result_id = ops[1]; uint32_t op0 = ops[2]; uint32_t op1 = ops[3]; auto &type = get(result_type); emit_uninitialized_temporary_expression(result_type, result_id); auto &res_type = get(type.member_types[1]); if (opcode == OpIAddCarry) { statement(to_expression(result_id), ".", to_member_name(type, 0), " = ", to_enclosed_expression(op0), " + ", to_enclosed_expression(op1), ";"); statement(to_expression(result_id), ".", to_member_name(type, 1), " = select(", type_to_glsl(res_type), "(1), ", type_to_glsl(res_type), "(0), ", to_expression(result_id), ".", to_member_name(type, 0), " >= max(", to_expression(op0), ", ", to_expression(op1), "));"); } else { statement(to_expression(result_id), ".", to_member_name(type, 0), " = ", to_enclosed_expression(op0), " - ", to_enclosed_expression(op1), ";"); statement(to_expression(result_id), ".", to_member_name(type, 1), " = select(", type_to_glsl(res_type), "(1), ", type_to_glsl(res_type), "(0), ", to_enclosed_expression(op0), " >= ", to_enclosed_expression(op1), ");"); } break; } case OpUMulExtended: case OpSMulExtended: { uint32_t result_type = ops[0]; uint32_t result_id = ops[1]; uint32_t op0 = ops[2]; uint32_t op1 = ops[3]; auto &type = get(result_type); emit_uninitialized_temporary_expression(result_type, result_id); statement(to_expression(result_id), ".", to_member_name(type, 0), " = ", to_enclosed_expression(op0), " * ", to_enclosed_expression(op1), ";"); statement(to_expression(result_id), ".", to_member_name(type, 1), " = mulhi(", to_expression(op0), ", ", to_expression(op1), ");"); break; } case OpArrayLength: { auto &type = expression_type(ops[2]); uint32_t offset = type_struct_member_offset(type, ops[3]); uint32_t stride = type_struct_member_array_stride(type, ops[3]); auto expr = join("(", to_buffer_size_expression(ops[2]), " - ", offset, ") / ", stride); emit_op(ops[0], ops[1], expr, true); break; } // SPV_INTEL_shader_integer_functions2 case OpUCountLeadingZerosINTEL: MSL_UFOP(clz); break; case OpUCountTrailingZerosINTEL: MSL_UFOP(ctz); break; case OpAbsISubINTEL: case OpAbsUSubINTEL: MSL_BFOP(absdiff); break; case OpIAddSatINTEL: case OpUAddSatINTEL: MSL_BFOP(addsat); break; case OpIAverageINTEL: case OpUAverageINTEL: MSL_BFOP(hadd); break; case OpIAverageRoundedINTEL: case OpUAverageRoundedINTEL: MSL_BFOP(rhadd); break; case OpISubSatINTEL: case OpUSubSatINTEL: MSL_BFOP(subsat); break; case OpIMul32x16INTEL: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t a = ops[2], b = ops[3]; bool forward = should_forward(a) && should_forward(b); emit_op(result_type, id, join("int(short(", to_expression(a), ")) * int(short(", to_expression(b), "))"), forward); inherit_expression_dependencies(id, a); inherit_expression_dependencies(id, b); break; } case OpUMul32x16INTEL: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; uint32_t a = ops[2], b = ops[3]; bool forward = should_forward(a) && should_forward(b); emit_op(result_type, id, join("uint(ushort(", to_expression(a), ")) * uint(ushort(", to_expression(b), "))"), forward); inherit_expression_dependencies(id, a); inherit_expression_dependencies(id, b); break; } // SPV_EXT_demote_to_helper_invocation case OpDemoteToHelperInvocationEXT: if (!msl_options.supports_msl_version(2, 3)) SPIRV_CROSS_THROW("discard_fragment() does not formally have demote semantics until MSL 2.3."); CompilerGLSL::emit_instruction(instruction); break; case OpIsHelperInvocationEXT: if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 3)) SPIRV_CROSS_THROW("simd_is_helper_thread() requires MSL 2.3 on iOS."); else if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("simd_is_helper_thread() requires MSL 2.1 on macOS."); emit_op(ops[0], ops[1], "simd_is_helper_thread()", false); break; case OpBeginInvocationInterlockEXT: case OpEndInvocationInterlockEXT: if (!msl_options.supports_msl_version(2, 0)) SPIRV_CROSS_THROW("Raster order groups require MSL 2.0."); break; // Nothing to do in the body default: CompilerGLSL::emit_instruction(instruction); break; } previous_instruction_opcode = opcode; } void CompilerMSL::emit_texture_op(const Instruction &i, bool sparse) { if (sparse) SPIRV_CROSS_THROW("Sparse feedback not yet supported in MSL."); if (msl_options.use_framebuffer_fetch_subpasses) { auto *ops = stream(i); uint32_t result_type_id = ops[0]; uint32_t id = ops[1]; uint32_t img = ops[2]; auto &type = expression_type(img); auto &imgtype = get(type.self); // Use Metal's native frame-buffer fetch API for subpass inputs. if (imgtype.image.dim == DimSubpassData) { // Subpass inputs cannot be invalidated, // so just forward the expression directly. string expr = to_expression(img); emit_op(result_type_id, id, expr, true); return; } } // Fallback to default implementation CompilerGLSL::emit_texture_op(i, sparse); } void CompilerMSL::emit_barrier(uint32_t id_exe_scope, uint32_t id_mem_scope, uint32_t id_mem_sem) { if (get_execution_model() != ExecutionModelGLCompute && get_execution_model() != ExecutionModelTessellationControl) return; uint32_t exe_scope = id_exe_scope ? evaluate_constant_u32(id_exe_scope) : uint32_t(ScopeInvocation); uint32_t mem_scope = id_mem_scope ? evaluate_constant_u32(id_mem_scope) : uint32_t(ScopeInvocation); // Use the wider of the two scopes (smaller value) exe_scope = min(exe_scope, mem_scope); if (msl_options.emulate_subgroups && exe_scope >= ScopeSubgroup && !id_mem_sem) // In this case, we assume a "subgroup" size of 1. The barrier, then, is a noop. return; string bar_stmt; if ((msl_options.is_ios() && msl_options.supports_msl_version(1, 2)) || msl_options.supports_msl_version(2)) bar_stmt = exe_scope < ScopeSubgroup ? "threadgroup_barrier" : "simdgroup_barrier"; else bar_stmt = "threadgroup_barrier"; bar_stmt += "("; uint32_t mem_sem = id_mem_sem ? evaluate_constant_u32(id_mem_sem) : uint32_t(MemorySemanticsMaskNone); // Use the | operator to combine flags if we can. if (msl_options.supports_msl_version(1, 2)) { string mem_flags = ""; // For tesc shaders, this also affects objects in the Output storage class. // Since in Metal, these are placed in a device buffer, we have to sync device memory here. if (get_execution_model() == ExecutionModelTessellationControl || (mem_sem & (MemorySemanticsUniformMemoryMask | MemorySemanticsCrossWorkgroupMemoryMask))) mem_flags += "mem_flags::mem_device"; // Fix tessellation patch function processing if (get_execution_model() == ExecutionModelTessellationControl || (mem_sem & (MemorySemanticsSubgroupMemoryMask | MemorySemanticsWorkgroupMemoryMask))) { if (!mem_flags.empty()) mem_flags += " | "; mem_flags += "mem_flags::mem_threadgroup"; } if (mem_sem & MemorySemanticsImageMemoryMask) { if (!mem_flags.empty()) mem_flags += " | "; mem_flags += "mem_flags::mem_texture"; } if (mem_flags.empty()) mem_flags = "mem_flags::mem_none"; bar_stmt += mem_flags; } else { if ((mem_sem & (MemorySemanticsUniformMemoryMask | MemorySemanticsCrossWorkgroupMemoryMask)) && (mem_sem & (MemorySemanticsSubgroupMemoryMask | MemorySemanticsWorkgroupMemoryMask))) bar_stmt += "mem_flags::mem_device_and_threadgroup"; else if (mem_sem & (MemorySemanticsUniformMemoryMask | MemorySemanticsCrossWorkgroupMemoryMask)) bar_stmt += "mem_flags::mem_device"; else if (mem_sem & (MemorySemanticsSubgroupMemoryMask | MemorySemanticsWorkgroupMemoryMask)) bar_stmt += "mem_flags::mem_threadgroup"; else if (mem_sem & MemorySemanticsImageMemoryMask) bar_stmt += "mem_flags::mem_texture"; else bar_stmt += "mem_flags::mem_none"; } bar_stmt += ");"; statement(bar_stmt); assert(current_emitting_block); flush_control_dependent_expressions(current_emitting_block->self); flush_all_active_variables(); } void CompilerMSL::emit_array_copy(const string &lhs, uint32_t rhs_id, StorageClass lhs_storage, StorageClass rhs_storage) { // Allow Metal to use the array template to make arrays a value type. // This, however, cannot be used for threadgroup address specifiers, so consider the custom array copy as fallback. bool lhs_thread = (lhs_storage == StorageClassOutput || lhs_storage == StorageClassFunction || lhs_storage == StorageClassGeneric || lhs_storage == StorageClassPrivate); bool rhs_thread = (rhs_storage == StorageClassInput || rhs_storage == StorageClassFunction || rhs_storage == StorageClassGeneric || rhs_storage == StorageClassPrivate); // If threadgroup storage qualifiers are *not* used: // Avoid spvCopy* wrapper functions; Otherwise, spvUnsafeArray<> template cannot be used with that storage qualifier. if (lhs_thread && rhs_thread && !using_builtin_array()) { statement(lhs, " = ", to_expression(rhs_id), ";"); } else { // Assignment from an array initializer is fine. auto &type = expression_type(rhs_id); auto *var = maybe_get_backing_variable(rhs_id); // Unfortunately, we cannot template on address space in MSL, // so explicit address space redirection it is ... bool is_constant = false; if (ir.ids[rhs_id].get_type() == TypeConstant) { is_constant = true; } else if (var && var->remapped_variable && var->statically_assigned && ir.ids[var->static_expression].get_type() == TypeConstant) { is_constant = true; } else if (rhs_storage == StorageClassUniform) { is_constant = true; } // For the case where we have OpLoad triggering an array copy, // we cannot easily detect this case ahead of time since it's // context dependent. We might have to force a recompile here // if this is the only use of array copies in our shader. if (type.array.size() > 1) { if (type.array.size() > kArrayCopyMultidimMax) SPIRV_CROSS_THROW("Cannot support this many dimensions for arrays of arrays."); auto func = static_cast(SPVFuncImplArrayCopyMultidimBase + type.array.size()); add_spv_func_and_recompile(func); } else add_spv_func_and_recompile(SPVFuncImplArrayCopy); const char *tag = nullptr; if (lhs_thread && is_constant) tag = "FromConstantToStack"; else if (lhs_storage == StorageClassWorkgroup && is_constant) tag = "FromConstantToThreadGroup"; else if (lhs_thread && rhs_thread) tag = "FromStackToStack"; else if (lhs_storage == StorageClassWorkgroup && rhs_thread) tag = "FromStackToThreadGroup"; else if (lhs_thread && rhs_storage == StorageClassWorkgroup) tag = "FromThreadGroupToStack"; else if (lhs_storage == StorageClassWorkgroup && rhs_storage == StorageClassWorkgroup) tag = "FromThreadGroupToThreadGroup"; else if (lhs_storage == StorageClassStorageBuffer && rhs_storage == StorageClassStorageBuffer) tag = "FromDeviceToDevice"; else if (lhs_storage == StorageClassStorageBuffer && is_constant) tag = "FromConstantToDevice"; else if (lhs_storage == StorageClassStorageBuffer && rhs_storage == StorageClassWorkgroup) tag = "FromThreadGroupToDevice"; else if (lhs_storage == StorageClassStorageBuffer && rhs_thread) tag = "FromStackToDevice"; else if (lhs_storage == StorageClassWorkgroup && rhs_storage == StorageClassStorageBuffer) tag = "FromDeviceToThreadGroup"; else if (lhs_thread && rhs_storage == StorageClassStorageBuffer) tag = "FromDeviceToStack"; else SPIRV_CROSS_THROW("Unknown storage class used for copying arrays."); // Pass internal array of spvUnsafeArray<> into wrapper functions if (lhs_thread && !msl_options.force_native_arrays) statement("spvArrayCopy", tag, type.array.size(), "(", lhs, ".elements, ", to_expression(rhs_id), ");"); else if (rhs_thread && !msl_options.force_native_arrays) statement("spvArrayCopy", tag, type.array.size(), "(", lhs, ", ", to_expression(rhs_id), ".elements);"); else statement("spvArrayCopy", tag, type.array.size(), "(", lhs, ", ", to_expression(rhs_id), ");"); } } // Since MSL does not allow arrays to be copied via simple variable assignment, // if the LHS and RHS represent an assignment of an entire array, it must be // implemented by calling an array copy function. // Returns whether the struct assignment was emitted. bool CompilerMSL::maybe_emit_array_assignment(uint32_t id_lhs, uint32_t id_rhs) { // We only care about assignments of an entire array auto &type = expression_type(id_rhs); if (type.array.size() == 0) return false; auto *var = maybe_get(id_lhs); // Is this a remapped, static constant? Don't do anything. if (var && var->remapped_variable && var->statically_assigned) return true; if (ir.ids[id_rhs].get_type() == TypeConstant && var && var->deferred_declaration) { // Special case, if we end up declaring a variable when assigning the constant array, // we can avoid the copy by directly assigning the constant expression. // This is likely necessary to be able to use a variable as a true look-up table, as it is unlikely // the compiler will be able to optimize the spvArrayCopy() into a constant LUT. // After a variable has been declared, we can no longer assign constant arrays in MSL unfortunately. statement(to_expression(id_lhs), " = ", constant_expression(get(id_rhs)), ";"); return true; } // Ensure the LHS variable has been declared auto *p_v_lhs = maybe_get_backing_variable(id_lhs); if (p_v_lhs) flush_variable_declaration(p_v_lhs->self); emit_array_copy(to_expression(id_lhs), id_rhs, get_expression_effective_storage_class(id_lhs), get_expression_effective_storage_class(id_rhs)); register_write(id_lhs); return true; } // Emits one of the atomic functions. In MSL, the atomic functions operate on pointers void CompilerMSL::emit_atomic_func_op(uint32_t result_type, uint32_t result_id, const char *op, uint32_t mem_order_1, uint32_t mem_order_2, bool has_mem_order_2, uint32_t obj, uint32_t op1, bool op1_is_pointer, bool op1_is_literal, uint32_t op2) { string exp = string(op) + "("; auto &type = get_pointee_type(expression_type(obj)); exp += "("; auto *var = maybe_get_backing_variable(obj); if (!var) SPIRV_CROSS_THROW("No backing variable for atomic operation."); // Emulate texture2D atomic operations const auto &res_type = get(var->basetype); if (res_type.storage == StorageClassUniformConstant && res_type.basetype == SPIRType::Image) { exp += "device"; } else { exp += get_argument_address_space(*var); } exp += " atomic_"; exp += type_to_glsl(type); exp += "*)"; exp += "&"; exp += to_enclosed_expression(obj); bool is_atomic_compare_exchange_strong = op1_is_pointer && op1; if (is_atomic_compare_exchange_strong) { assert(strcmp(op, "atomic_compare_exchange_weak_explicit") == 0); assert(op2); assert(has_mem_order_2); exp += ", &"; exp += to_name(result_id); exp += ", "; exp += to_expression(op2); exp += ", "; exp += get_memory_order(mem_order_1); exp += ", "; exp += get_memory_order(mem_order_2); exp += ")"; // MSL only supports the weak atomic compare exchange, so emit a CAS loop here. // The MSL function returns false if the atomic write fails OR the comparison test fails, // so we must validate that it wasn't the comparison test that failed before continuing // the CAS loop, otherwise it will loop infinitely, with the comparison test always failing. // The function updates the comparitor value from the memory value, so the additional // comparison test evaluates the memory value against the expected value. emit_uninitialized_temporary_expression(result_type, result_id); statement("do"); begin_scope(); statement(to_name(result_id), " = ", to_expression(op1), ";"); end_scope_decl(join("while (!", exp, " && ", to_name(result_id), " == ", to_enclosed_expression(op1), ")")); } else { assert(strcmp(op, "atomic_compare_exchange_weak_explicit") != 0); if (op1) { if (op1_is_literal) exp += join(", ", op1); else exp += ", " + to_expression(op1); } if (op2) exp += ", " + to_expression(op2); exp += string(", ") + get_memory_order(mem_order_1); if (has_mem_order_2) exp += string(", ") + get_memory_order(mem_order_2); exp += ")"; if (strcmp(op, "atomic_store_explicit") != 0) emit_op(result_type, result_id, exp, false); else statement(exp, ";"); } flush_all_atomic_capable_variables(); } // Metal only supports relaxed memory order for now const char *CompilerMSL::get_memory_order(uint32_t) { return "memory_order_relaxed"; } // Override for MSL-specific extension syntax instructions void CompilerMSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t count) { auto op = static_cast(eop); // If we need to do implicit bitcasts, make sure we do it with the correct type. uint32_t integer_width = get_integer_width_for_glsl_instruction(op, args, count); auto int_type = to_signed_basetype(integer_width); auto uint_type = to_unsigned_basetype(integer_width); switch (op) { case GLSLstd450Atan2: emit_binary_func_op(result_type, id, args[0], args[1], "atan2"); break; case GLSLstd450InverseSqrt: emit_unary_func_op(result_type, id, args[0], "rsqrt"); break; case GLSLstd450RoundEven: emit_unary_func_op(result_type, id, args[0], "rint"); break; case GLSLstd450FindILsb: { // In this template version of findLSB, we return T. auto basetype = expression_type(args[0]).basetype; emit_unary_func_op_cast(result_type, id, args[0], "spvFindLSB", basetype, basetype); break; } case GLSLstd450FindSMsb: emit_unary_func_op_cast(result_type, id, args[0], "spvFindSMSB", int_type, int_type); break; case GLSLstd450FindUMsb: emit_unary_func_op_cast(result_type, id, args[0], "spvFindUMSB", uint_type, uint_type); break; case GLSLstd450PackSnorm4x8: emit_unary_func_op(result_type, id, args[0], "pack_float_to_snorm4x8"); break; case GLSLstd450PackUnorm4x8: emit_unary_func_op(result_type, id, args[0], "pack_float_to_unorm4x8"); break; case GLSLstd450PackSnorm2x16: emit_unary_func_op(result_type, id, args[0], "pack_float_to_snorm2x16"); break; case GLSLstd450PackUnorm2x16: emit_unary_func_op(result_type, id, args[0], "pack_float_to_unorm2x16"); break; case GLSLstd450PackHalf2x16: { auto expr = join("as_type(half2(", to_expression(args[0]), "))"); emit_op(result_type, id, expr, should_forward(args[0])); inherit_expression_dependencies(id, args[0]); break; } case GLSLstd450UnpackSnorm4x8: emit_unary_func_op(result_type, id, args[0], "unpack_snorm4x8_to_float"); break; case GLSLstd450UnpackUnorm4x8: emit_unary_func_op(result_type, id, args[0], "unpack_unorm4x8_to_float"); break; case GLSLstd450UnpackSnorm2x16: emit_unary_func_op(result_type, id, args[0], "unpack_snorm2x16_to_float"); break; case GLSLstd450UnpackUnorm2x16: emit_unary_func_op(result_type, id, args[0], "unpack_unorm2x16_to_float"); break; case GLSLstd450UnpackHalf2x16: { auto expr = join("float2(as_type(", to_expression(args[0]), "))"); emit_op(result_type, id, expr, should_forward(args[0])); inherit_expression_dependencies(id, args[0]); break; } case GLSLstd450PackDouble2x32: emit_unary_func_op(result_type, id, args[0], "unsupported_GLSLstd450PackDouble2x32"); // Currently unsupported break; case GLSLstd450UnpackDouble2x32: emit_unary_func_op(result_type, id, args[0], "unsupported_GLSLstd450UnpackDouble2x32"); // Currently unsupported break; case GLSLstd450MatrixInverse: { auto &mat_type = get(result_type); switch (mat_type.columns) { case 2: emit_unary_func_op(result_type, id, args[0], "spvInverse2x2"); break; case 3: emit_unary_func_op(result_type, id, args[0], "spvInverse3x3"); break; case 4: emit_unary_func_op(result_type, id, args[0], "spvInverse4x4"); break; default: break; } break; } case GLSLstd450FMin: // If the result type isn't float, don't bother calling the specific // precise::/fast:: version. Metal doesn't have those for half and // double types. if (get(result_type).basetype != SPIRType::Float) emit_binary_func_op(result_type, id, args[0], args[1], "min"); else emit_binary_func_op(result_type, id, args[0], args[1], "fast::min"); break; case GLSLstd450FMax: if (get(result_type).basetype != SPIRType::Float) emit_binary_func_op(result_type, id, args[0], args[1], "max"); else emit_binary_func_op(result_type, id, args[0], args[1], "fast::max"); break; case GLSLstd450FClamp: // TODO: If args[1] is 0 and args[2] is 1, emit a saturate() call. if (get(result_type).basetype != SPIRType::Float) emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "clamp"); else emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "fast::clamp"); break; case GLSLstd450NMin: if (get(result_type).basetype != SPIRType::Float) emit_binary_func_op(result_type, id, args[0], args[1], "min"); else emit_binary_func_op(result_type, id, args[0], args[1], "precise::min"); break; case GLSLstd450NMax: if (get(result_type).basetype != SPIRType::Float) emit_binary_func_op(result_type, id, args[0], args[1], "max"); else emit_binary_func_op(result_type, id, args[0], args[1], "precise::max"); break; case GLSLstd450NClamp: // TODO: If args[1] is 0 and args[2] is 1, emit a saturate() call. if (get(result_type).basetype != SPIRType::Float) emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "clamp"); else emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "precise::clamp"); break; case GLSLstd450InterpolateAtCentroid: { // We can't just emit the expression normally, because the qualified name contains a call to the default // interpolate method, or refers to a local variable. We saved the interface index we need; use it to construct // the base for the method call. uint32_t interface_index = get_extended_decoration(args[0], SPIRVCrossDecorationInterfaceMemberIndex); string component; if (has_extended_decoration(args[0], SPIRVCrossDecorationInterpolantComponentExpr)) { uint32_t index_expr = get_extended_decoration(args[0], SPIRVCrossDecorationInterpolantComponentExpr); auto *c = maybe_get(index_expr); if (!c || c->specialization) component = join("[", to_expression(index_expr), "]"); else component = join(".", index_to_swizzle(c->scalar())); } emit_op(result_type, id, join(to_name(stage_in_var_id), ".", to_member_name(get_stage_in_struct_type(), interface_index), ".interpolate_at_centroid()", component), should_forward(args[0])); break; } case GLSLstd450InterpolateAtSample: { uint32_t interface_index = get_extended_decoration(args[0], SPIRVCrossDecorationInterfaceMemberIndex); string component; if (has_extended_decoration(args[0], SPIRVCrossDecorationInterpolantComponentExpr)) { uint32_t index_expr = get_extended_decoration(args[0], SPIRVCrossDecorationInterpolantComponentExpr); auto *c = maybe_get(index_expr); if (!c || c->specialization) component = join("[", to_expression(index_expr), "]"); else component = join(".", index_to_swizzle(c->scalar())); } emit_op(result_type, id, join(to_name(stage_in_var_id), ".", to_member_name(get_stage_in_struct_type(), interface_index), ".interpolate_at_sample(", to_expression(args[1]), ")", component), should_forward(args[0]) && should_forward(args[1])); break; } case GLSLstd450InterpolateAtOffset: { uint32_t interface_index = get_extended_decoration(args[0], SPIRVCrossDecorationInterfaceMemberIndex); string component; if (has_extended_decoration(args[0], SPIRVCrossDecorationInterpolantComponentExpr)) { uint32_t index_expr = get_extended_decoration(args[0], SPIRVCrossDecorationInterpolantComponentExpr); auto *c = maybe_get(index_expr); if (!c || c->specialization) component = join("[", to_expression(index_expr), "]"); else component = join(".", index_to_swizzle(c->scalar())); } // Like Direct3D, Metal puts the (0, 0) at the upper-left corner, not the center as SPIR-V and GLSL do. // Offset the offset by (1/2 - 1/16), or 0.4375, to compensate for this. // It has to be (1/2 - 1/16) and not 1/2, or several CTS tests subtly break on Intel. emit_op(result_type, id, join(to_name(stage_in_var_id), ".", to_member_name(get_stage_in_struct_type(), interface_index), ".interpolate_at_offset(", to_expression(args[1]), " + 0.4375)", component), should_forward(args[0]) && should_forward(args[1])); break; } case GLSLstd450Distance: // MSL does not support scalar versions here. if (expression_type(args[0]).vecsize == 1) { // Equivalent to length(a - b) -> abs(a - b). emit_op(result_type, id, join("abs(", to_enclosed_unpacked_expression(args[0]), " - ", to_enclosed_unpacked_expression(args[1]), ")"), should_forward(args[0]) && should_forward(args[1])); inherit_expression_dependencies(id, args[0]); inherit_expression_dependencies(id, args[1]); } else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; case GLSLstd450Length: // MSL does not support scalar versions here. if (expression_type(args[0]).vecsize == 1) { // Equivalent to abs(). emit_unary_func_op(result_type, id, args[0], "abs"); } else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; case GLSLstd450Normalize: // MSL does not support scalar versions here. if (expression_type(args[0]).vecsize == 1) { // Returns -1 or 1 for valid input, sign() does the job. emit_unary_func_op(result_type, id, args[0], "sign"); } else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; case GLSLstd450Reflect: if (get(result_type).vecsize == 1) emit_binary_func_op(result_type, id, args[0], args[1], "spvReflect"); else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; case GLSLstd450Refract: if (get(result_type).vecsize == 1) emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "spvRefract"); else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; case GLSLstd450FaceForward: if (get(result_type).vecsize == 1) emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "spvFaceForward"); else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; case GLSLstd450Modf: case GLSLstd450Frexp: { // Special case. If the variable is a scalar access chain, we cannot use it directly. We have to emit a temporary. auto *ptr = maybe_get(args[1]); if (ptr && ptr->access_chain && is_scalar(expression_type(args[1]))) { register_call_out_argument(args[1]); forced_temporaries.insert(id); // Need to create temporaries and copy over to access chain after. // We cannot directly take the reference of a vector swizzle in MSL, even if it's scalar ... uint32_t &tmp_id = extra_sub_expressions[id]; if (!tmp_id) tmp_id = ir.increase_bound_by(1); uint32_t tmp_type_id = get_pointee_type_id(ptr->expression_type); emit_uninitialized_temporary_expression(tmp_type_id, tmp_id); emit_binary_func_op(result_type, id, args[0], tmp_id, eop == GLSLstd450Modf ? "modf" : "frexp"); statement(to_expression(args[1]), " = ", to_expression(tmp_id), ";"); } else CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; } default: CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); break; } } void CompilerMSL::emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t count) { enum AMDShaderTrinaryMinMax { FMin3AMD = 1, UMin3AMD = 2, SMin3AMD = 3, FMax3AMD = 4, UMax3AMD = 5, SMax3AMD = 6, FMid3AMD = 7, UMid3AMD = 8, SMid3AMD = 9 }; if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Trinary min/max functions require MSL 2.1."); auto op = static_cast(eop); switch (op) { case FMid3AMD: case UMid3AMD: case SMid3AMD: emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "median3"); break; default: CompilerGLSL::emit_spv_amd_shader_trinary_minmax_op(result_type, id, eop, args, count); break; } } // Emit a structure declaration for the specified interface variable. void CompilerMSL::emit_interface_block(uint32_t ib_var_id) { if (ib_var_id) { auto &ib_var = get(ib_var_id); auto &ib_type = get_variable_data_type(ib_var); assert(ib_type.basetype == SPIRType::Struct && !ib_type.member_types.empty()); emit_struct(ib_type); } } // Emits the declaration signature of the specified function. // If this is the entry point function, Metal-specific return value and function arguments are added. void CompilerMSL::emit_function_prototype(SPIRFunction &func, const Bitset &) { if (func.self != ir.default_entry_point) add_function_overload(func); local_variable_names = resource_names; string decl; processing_entry_point = func.self == ir.default_entry_point; // Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib. if (!processing_entry_point) statement(force_inline); auto &type = get(func.return_type); if (!type.array.empty() && msl_options.force_native_arrays) { // We cannot return native arrays in MSL, so "return" through an out variable. decl += "void"; } else { decl += func_type_decl(type); } decl += " "; decl += to_name(func.self); decl += "("; if (!type.array.empty() && msl_options.force_native_arrays) { // Fake arrays returns by writing to an out array instead. decl += "thread "; decl += type_to_glsl(type); decl += " (&spvReturnValue)"; decl += type_to_array_glsl(type); if (!func.arguments.empty()) decl += ", "; } if (processing_entry_point) { if (msl_options.argument_buffers) decl += entry_point_args_argument_buffer(!func.arguments.empty()); else decl += entry_point_args_classic(!func.arguments.empty()); // If entry point function has variables that require early declaration, // ensure they each have an empty initializer, creating one if needed. // This is done at this late stage because the initialization expression // is cleared after each compilation pass. for (auto var_id : vars_needing_early_declaration) { auto &ed_var = get(var_id); ID &initializer = ed_var.initializer; if (!initializer) initializer = ir.increase_bound_by(1); // Do not override proper initializers. if (ir.ids[initializer].get_type() == TypeNone || ir.ids[initializer].get_type() == TypeExpression) set(ed_var.initializer, "{}", ed_var.basetype, true); } } for (auto &arg : func.arguments) { uint32_t name_id = arg.id; auto *var = maybe_get(arg.id); if (var) { // If we need to modify the name of the variable, make sure we modify the original variable. // Our alias is just a shadow variable. if (arg.alias_global_variable && var->basevariable) name_id = var->basevariable; var->parameter = &arg; // Hold a pointer to the parameter so we can invalidate the readonly field if needed. } add_local_variable_name(name_id); decl += argument_decl(arg); bool is_dynamic_img_sampler = has_extended_decoration(arg.id, SPIRVCrossDecorationDynamicImageSampler); auto &arg_type = get(arg.type); if (arg_type.basetype == SPIRType::SampledImage && !is_dynamic_img_sampler) { // Manufacture automatic plane args for multiplanar texture uint32_t planes = 1; if (auto *constexpr_sampler = find_constexpr_sampler(name_id)) if (constexpr_sampler->ycbcr_conversion_enable) planes = constexpr_sampler->planes; for (uint32_t i = 1; i < planes; i++) decl += join(", ", argument_decl(arg), plane_name_suffix, i); // Manufacture automatic sampler arg for SampledImage texture if (arg_type.image.dim != DimBuffer) decl += join(", thread const ", sampler_type(arg_type, arg.id), " ", to_sampler_expression(arg.id)); } // Manufacture automatic swizzle arg. if (msl_options.swizzle_texture_samples && has_sampled_images && is_sampled_image_type(arg_type) && !is_dynamic_img_sampler) { bool arg_is_array = !arg_type.array.empty(); decl += join(", constant uint", arg_is_array ? "* " : "& ", to_swizzle_expression(arg.id)); } if (buffers_requiring_array_length.count(name_id)) { bool arg_is_array = !arg_type.array.empty(); decl += join(", constant uint", arg_is_array ? "* " : "& ", to_buffer_size_expression(name_id)); } if (&arg != &func.arguments.back()) decl += ", "; } decl += ")"; statement(decl); } static bool needs_chroma_reconstruction(const MSLConstexprSampler *constexpr_sampler) { // For now, only multiplanar images need explicit reconstruction. GBGR and BGRG images // use implicit reconstruction. return constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable && constexpr_sampler->planes > 1; } // Returns the texture sampling function string for the specified image and sampling characteristics. string CompilerMSL::to_function_name(const TextureFunctionNameArguments &args) { VariableID img = args.base.img; auto &imgtype = *args.base.imgtype; const MSLConstexprSampler *constexpr_sampler = nullptr; bool is_dynamic_img_sampler = false; if (auto *var = maybe_get_backing_variable(img)) { constexpr_sampler = find_constexpr_sampler(var->basevariable ? var->basevariable : VariableID(var->self)); is_dynamic_img_sampler = has_extended_decoration(var->self, SPIRVCrossDecorationDynamicImageSampler); } // Special-case gather. We have to alter the component being looked up // in the swizzle case. if (msl_options.swizzle_texture_samples && args.base.is_gather && !is_dynamic_img_sampler && (!constexpr_sampler || !constexpr_sampler->ycbcr_conversion_enable)) { add_spv_func_and_recompile(imgtype.image.depth ? SPVFuncImplGatherCompareSwizzle : SPVFuncImplGatherSwizzle); return imgtype.image.depth ? "spvGatherCompareSwizzle" : "spvGatherSwizzle"; } auto *combined = maybe_get(img); // Texture reference string fname; if (needs_chroma_reconstruction(constexpr_sampler) && !is_dynamic_img_sampler) { if (constexpr_sampler->planes != 2 && constexpr_sampler->planes != 3) SPIRV_CROSS_THROW("Unhandled number of color image planes!"); // 444 images aren't downsampled, so we don't need to do linear filtering. if (constexpr_sampler->resolution == MSL_FORMAT_RESOLUTION_444 || constexpr_sampler->chroma_filter == MSL_SAMPLER_FILTER_NEAREST) { if (constexpr_sampler->planes == 2) add_spv_func_and_recompile(SPVFuncImplChromaReconstructNearest2Plane); else add_spv_func_and_recompile(SPVFuncImplChromaReconstructNearest3Plane); fname = "spvChromaReconstructNearest"; } else // Linear with a downsampled format { fname = "spvChromaReconstructLinear"; switch (constexpr_sampler->resolution) { case MSL_FORMAT_RESOLUTION_444: assert(false); break; // not reached case MSL_FORMAT_RESOLUTION_422: switch (constexpr_sampler->x_chroma_offset) { case MSL_CHROMA_LOCATION_COSITED_EVEN: if (constexpr_sampler->planes == 2) add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear422CositedEven2Plane); else add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear422CositedEven3Plane); fname += "422CositedEven"; break; case MSL_CHROMA_LOCATION_MIDPOINT: if (constexpr_sampler->planes == 2) add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear422Midpoint2Plane); else add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear422Midpoint3Plane); fname += "422Midpoint"; break; default: SPIRV_CROSS_THROW("Invalid chroma location."); } break; case MSL_FORMAT_RESOLUTION_420: fname += "420"; switch (constexpr_sampler->x_chroma_offset) { case MSL_CHROMA_LOCATION_COSITED_EVEN: switch (constexpr_sampler->y_chroma_offset) { case MSL_CHROMA_LOCATION_COSITED_EVEN: if (constexpr_sampler->planes == 2) add_spv_func_and_recompile( SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven2Plane); else add_spv_func_and_recompile( SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven3Plane); fname += "XCositedEvenYCositedEven"; break; case MSL_CHROMA_LOCATION_MIDPOINT: if (constexpr_sampler->planes == 2) add_spv_func_and_recompile( SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint2Plane); else add_spv_func_and_recompile( SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint3Plane); fname += "XCositedEvenYMidpoint"; break; default: SPIRV_CROSS_THROW("Invalid Y chroma location."); } break; case MSL_CHROMA_LOCATION_MIDPOINT: switch (constexpr_sampler->y_chroma_offset) { case MSL_CHROMA_LOCATION_COSITED_EVEN: if (constexpr_sampler->planes == 2) add_spv_func_and_recompile( SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven2Plane); else add_spv_func_and_recompile( SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven3Plane); fname += "XMidpointYCositedEven"; break; case MSL_CHROMA_LOCATION_MIDPOINT: if (constexpr_sampler->planes == 2) add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint2Plane); else add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane); fname += "XMidpointYMidpoint"; break; default: SPIRV_CROSS_THROW("Invalid Y chroma location."); } break; default: SPIRV_CROSS_THROW("Invalid X chroma location."); } break; default: SPIRV_CROSS_THROW("Invalid format resolution."); } } } else { fname = to_expression(combined ? combined->image : img) + "."; // Texture function and sampler if (args.base.is_fetch) fname += "read"; else if (args.base.is_gather) fname += "gather"; else fname += "sample"; if (args.has_dref) fname += "_compare"; } return fname; } string CompilerMSL::convert_to_f32(const string &expr, uint32_t components) { SPIRType t; t.basetype = SPIRType::Float; t.vecsize = components; t.columns = 1; return join(type_to_glsl_constructor(t), "(", expr, ")"); } static inline bool sampling_type_needs_f32_conversion(const SPIRType &type) { // Double is not supported to begin with, but doesn't hurt to check for completion. return type.basetype == SPIRType::Half || type.basetype == SPIRType::Double; } // Returns the function args for a texture sampling function for the specified image and sampling characteristics. string CompilerMSL::to_function_args(const TextureFunctionArguments &args, bool *p_forward) { VariableID img = args.base.img; auto &imgtype = *args.base.imgtype; uint32_t lod = args.lod; uint32_t grad_x = args.grad_x; uint32_t grad_y = args.grad_y; uint32_t bias = args.bias; const MSLConstexprSampler *constexpr_sampler = nullptr; bool is_dynamic_img_sampler = false; if (auto *var = maybe_get_backing_variable(img)) { constexpr_sampler = find_constexpr_sampler(var->basevariable ? var->basevariable : VariableID(var->self)); is_dynamic_img_sampler = has_extended_decoration(var->self, SPIRVCrossDecorationDynamicImageSampler); } string farg_str; bool forward = true; if (!is_dynamic_img_sampler) { // Texture reference (for some cases) if (needs_chroma_reconstruction(constexpr_sampler)) { // Multiplanar images need two or three textures. farg_str += to_expression(img); for (uint32_t i = 1; i < constexpr_sampler->planes; i++) farg_str += join(", ", to_expression(img), plane_name_suffix, i); } else if ((!constexpr_sampler || !constexpr_sampler->ycbcr_conversion_enable) && msl_options.swizzle_texture_samples && args.base.is_gather) { auto *combined = maybe_get(img); farg_str += to_expression(combined ? combined->image : img); } // Sampler reference if (!args.base.is_fetch) { if (!farg_str.empty()) farg_str += ", "; farg_str += to_sampler_expression(img); } if ((!constexpr_sampler || !constexpr_sampler->ycbcr_conversion_enable) && msl_options.swizzle_texture_samples && args.base.is_gather) { // Add the swizzle constant from the swizzle buffer. farg_str += ", " + to_swizzle_expression(img); used_swizzle_buffer = true; } // Swizzled gather puts the component before the other args, to allow template // deduction to work. if (args.component && msl_options.swizzle_texture_samples) { forward = should_forward(args.component); farg_str += ", " + to_component_argument(args.component); } } // Texture coordinates forward = forward && should_forward(args.coord); auto coord_expr = to_enclosed_expression(args.coord); auto &coord_type = expression_type(args.coord); bool coord_is_fp = type_is_floating_point(coord_type); bool is_cube_fetch = false; string tex_coords = coord_expr; uint32_t alt_coord_component = 0; switch (imgtype.image.dim) { case Dim1D: if (coord_type.vecsize > 1) tex_coords = enclose_expression(tex_coords) + ".x"; if (args.base.is_fetch) tex_coords = "uint(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")"; else if (sampling_type_needs_f32_conversion(coord_type)) tex_coords = convert_to_f32(tex_coords, 1); if (msl_options.texture_1D_as_2D) { if (args.base.is_fetch) tex_coords = "uint2(" + tex_coords + ", 0)"; else tex_coords = "float2(" + tex_coords + ", 0.5)"; } alt_coord_component = 1; break; case DimBuffer: if (coord_type.vecsize > 1) tex_coords = enclose_expression(tex_coords) + ".x"; if (msl_options.texture_buffer_native) { tex_coords = "uint(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")"; } else { // Metal texel buffer textures are 2D, so convert 1D coord to 2D. // Support for Metal 2.1's new texture_buffer type. if (args.base.is_fetch) { if (msl_options.texel_buffer_texture_width > 0) { tex_coords = "spvTexelBufferCoord(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")"; } else { tex_coords = "spvTexelBufferCoord(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ", " + to_expression(img) + ")"; } } } alt_coord_component = 1; break; case DimSubpassData: // If we're using Metal's native frame-buffer fetch API for subpass inputs, // this path will not be hit. tex_coords = "uint2(gl_FragCoord.xy)"; alt_coord_component = 2; break; case Dim2D: if (coord_type.vecsize > 2) tex_coords = enclose_expression(tex_coords) + ".xy"; if (args.base.is_fetch) tex_coords = "uint2(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")"; else if (sampling_type_needs_f32_conversion(coord_type)) tex_coords = convert_to_f32(tex_coords, 2); alt_coord_component = 2; break; case Dim3D: if (coord_type.vecsize > 3) tex_coords = enclose_expression(tex_coords) + ".xyz"; if (args.base.is_fetch) tex_coords = "uint3(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")"; else if (sampling_type_needs_f32_conversion(coord_type)) tex_coords = convert_to_f32(tex_coords, 3); alt_coord_component = 3; break; case DimCube: if (args.base.is_fetch) { is_cube_fetch = true; tex_coords += ".xy"; tex_coords = "uint2(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")"; } else { if (coord_type.vecsize > 3) tex_coords = enclose_expression(tex_coords) + ".xyz"; } if (sampling_type_needs_f32_conversion(coord_type)) tex_coords = convert_to_f32(tex_coords, 3); alt_coord_component = 3; break; default: break; } if (args.base.is_fetch && (args.offset || args.coffset)) { uint32_t offset_expr = args.offset ? args.offset : args.coffset; // Fetch offsets must be applied directly to the coordinate. forward = forward && should_forward(offset_expr); auto &type = expression_type(offset_expr); if (imgtype.image.dim == Dim1D && msl_options.texture_1D_as_2D) { if (type.basetype != SPIRType::UInt) tex_coords += join(" + uint2(", bitcast_expression(SPIRType::UInt, offset_expr), ", 0)"); else tex_coords += join(" + uint2(", to_enclosed_expression(offset_expr), ", 0)"); } else { if (type.basetype != SPIRType::UInt) tex_coords += " + " + bitcast_expression(SPIRType::UInt, offset_expr); else tex_coords += " + " + to_enclosed_expression(offset_expr); } } // If projection, use alt coord as divisor if (args.base.is_proj) { if (sampling_type_needs_f32_conversion(coord_type)) tex_coords += " / " + convert_to_f32(to_extract_component_expression(args.coord, alt_coord_component), 1); else tex_coords += " / " + to_extract_component_expression(args.coord, alt_coord_component); } if (!farg_str.empty()) farg_str += ", "; if (imgtype.image.dim == DimCube && imgtype.image.arrayed && msl_options.emulate_cube_array) { farg_str += "spvCubemapTo2DArrayFace(" + tex_coords + ").xy"; if (is_cube_fetch) farg_str += ", uint(" + to_extract_component_expression(args.coord, 2) + ")"; else farg_str += ", uint(spvCubemapTo2DArrayFace(" + tex_coords + ").z) + (uint(" + round_fp_tex_coords(to_extract_component_expression(args.coord, alt_coord_component), coord_is_fp) + ") * 6u)"; add_spv_func_and_recompile(SPVFuncImplCubemapTo2DArrayFace); } else { farg_str += tex_coords; // If fetch from cube, add face explicitly if (is_cube_fetch) { // Special case for cube arrays, face and layer are packed in one dimension. if (imgtype.image.arrayed) farg_str += ", uint(" + to_extract_component_expression(args.coord, 2) + ") % 6u"; else farg_str += ", uint(" + round_fp_tex_coords(to_extract_component_expression(args.coord, 2), coord_is_fp) + ")"; } // If array, use alt coord if (imgtype.image.arrayed) { // Special case for cube arrays, face and layer are packed in one dimension. if (imgtype.image.dim == DimCube && args.base.is_fetch) { farg_str += ", uint(" + to_extract_component_expression(args.coord, 2) + ") / 6u"; } else { farg_str += ", uint(" + round_fp_tex_coords(to_extract_component_expression(args.coord, alt_coord_component), coord_is_fp) + ")"; if (imgtype.image.dim == DimSubpassData) { if (msl_options.multiview) farg_str += " + gl_ViewIndex"; else if (msl_options.arrayed_subpass_input) farg_str += " + gl_Layer"; } } } else if (imgtype.image.dim == DimSubpassData) { if (msl_options.multiview) farg_str += ", gl_ViewIndex"; else if (msl_options.arrayed_subpass_input) farg_str += ", gl_Layer"; } } // Depth compare reference value if (args.dref) { forward = forward && should_forward(args.dref); farg_str += ", "; auto &dref_type = expression_type(args.dref); string dref_expr; if (args.base.is_proj) dref_expr = join(to_enclosed_expression(args.dref), " / ", to_extract_component_expression(args.coord, alt_coord_component)); else dref_expr = to_expression(args.dref); if (sampling_type_needs_f32_conversion(dref_type)) dref_expr = convert_to_f32(dref_expr, 1); farg_str += dref_expr; if (msl_options.is_macos() && (grad_x || grad_y)) { // For sample compare, MSL does not support gradient2d for all targets (only iOS apparently according to docs). // However, the most common case here is to have a constant gradient of 0, as that is the only way to express // LOD == 0 in GLSL with sampler2DArrayShadow (cascaded shadow mapping). // We will detect a compile-time constant 0 value for gradient and promote that to level(0) on MSL. bool constant_zero_x = !grad_x || expression_is_constant_null(grad_x); bool constant_zero_y = !grad_y || expression_is_constant_null(grad_y); if (constant_zero_x && constant_zero_y) { lod = 0; grad_x = 0; grad_y = 0; farg_str += ", level(0)"; } else if (!msl_options.supports_msl_version(2, 3)) { SPIRV_CROSS_THROW("Using non-constant 0.0 gradient() qualifier for sample_compare. This is not " "supported on macOS prior to MSL 2.3."); } } if (msl_options.is_macos() && bias) { // Bias is not supported either on macOS with sample_compare. // Verify it is compile-time zero, and drop the argument. if (expression_is_constant_null(bias)) { bias = 0; } else if (!msl_options.supports_msl_version(2, 3)) { SPIRV_CROSS_THROW("Using non-constant 0.0 bias() qualifier for sample_compare. This is not supported " "on macOS prior to MSL 2.3."); } } } // LOD Options // Metal does not support LOD for 1D textures. if (bias && (imgtype.image.dim != Dim1D || msl_options.texture_1D_as_2D)) { forward = forward && should_forward(bias); farg_str += ", bias(" + to_expression(bias) + ")"; } // Metal does not support LOD for 1D textures. if (lod && (imgtype.image.dim != Dim1D || msl_options.texture_1D_as_2D)) { forward = forward && should_forward(lod); if (args.base.is_fetch) { farg_str += ", " + to_expression(lod); } else { farg_str += ", level(" + to_expression(lod) + ")"; } } else if (args.base.is_fetch && !lod && (imgtype.image.dim != Dim1D || msl_options.texture_1D_as_2D) && imgtype.image.dim != DimBuffer && !imgtype.image.ms && imgtype.image.sampled != 2) { // Lod argument is optional in OpImageFetch, but we require a LOD value, pick 0 as the default. // Check for sampled type as well, because is_fetch is also used for OpImageRead in MSL. farg_str += ", 0"; } // Metal does not support LOD for 1D textures. if ((grad_x || grad_y) && (imgtype.image.dim != Dim1D || msl_options.texture_1D_as_2D)) { forward = forward && should_forward(grad_x); forward = forward && should_forward(grad_y); string grad_opt; switch (imgtype.image.dim) { case Dim1D: case Dim2D: grad_opt = "2d"; break; case Dim3D: grad_opt = "3d"; break; case DimCube: if (imgtype.image.arrayed && msl_options.emulate_cube_array) grad_opt = "2d"; else grad_opt = "cube"; break; default: grad_opt = "unsupported_gradient_dimension"; break; } farg_str += ", gradient" + grad_opt + "(" + to_expression(grad_x) + ", " + to_expression(grad_y) + ")"; } if (args.min_lod) { if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("min_lod_clamp() is only supported in MSL 2.2+ and up."); forward = forward && should_forward(args.min_lod); farg_str += ", min_lod_clamp(" + to_expression(args.min_lod) + ")"; } // Add offsets string offset_expr; const SPIRType *offset_type = nullptr; if (args.coffset && !args.base.is_fetch) { forward = forward && should_forward(args.coffset); offset_expr = to_expression(args.coffset); offset_type = &expression_type(args.coffset); } else if (args.offset && !args.base.is_fetch) { forward = forward && should_forward(args.offset); offset_expr = to_expression(args.offset); offset_type = &expression_type(args.offset); } if (!offset_expr.empty()) { switch (imgtype.image.dim) { case Dim1D: if (!msl_options.texture_1D_as_2D) break; if (offset_type->vecsize > 1) offset_expr = enclose_expression(offset_expr) + ".x"; farg_str += join(", int2(", offset_expr, ", 0)"); break; case Dim2D: if (offset_type->vecsize > 2) offset_expr = enclose_expression(offset_expr) + ".xy"; farg_str += ", " + offset_expr; break; case Dim3D: if (offset_type->vecsize > 3) offset_expr = enclose_expression(offset_expr) + ".xyz"; farg_str += ", " + offset_expr; break; default: break; } } if (args.component) { // If 2D has gather component, ensure it also has an offset arg if (imgtype.image.dim == Dim2D && offset_expr.empty()) farg_str += ", int2(0)"; if (!msl_options.swizzle_texture_samples || is_dynamic_img_sampler) { forward = forward && should_forward(args.component); uint32_t image_var = 0; if (const auto *combined = maybe_get(img)) { if (const auto *img_var = maybe_get_backing_variable(combined->image)) image_var = img_var->self; } else if (const auto *var = maybe_get_backing_variable(img)) { image_var = var->self; } if (image_var == 0 || !image_is_comparison(expression_type(image_var), image_var)) farg_str += ", " + to_component_argument(args.component); } } if (args.sample) { forward = forward && should_forward(args.sample); farg_str += ", "; farg_str += to_expression(args.sample); } *p_forward = forward; return farg_str; } // If the texture coordinates are floating point, invokes MSL round() function to round them. string CompilerMSL::round_fp_tex_coords(string tex_coords, bool coord_is_fp) { return coord_is_fp ? ("round(" + tex_coords + ")") : tex_coords; } // Returns a string to use in an image sampling function argument. // The ID must be a scalar constant. string CompilerMSL::to_component_argument(uint32_t id) { uint32_t component_index = evaluate_constant_u32(id); switch (component_index) { case 0: return "component::x"; case 1: return "component::y"; case 2: return "component::z"; case 3: return "component::w"; default: SPIRV_CROSS_THROW("The value (" + to_string(component_index) + ") of OpConstant ID " + to_string(id) + " is not a valid Component index, which must be one of 0, 1, 2, or 3."); return "component::x"; } } // Establish sampled image as expression object and assign the sampler to it. void CompilerMSL::emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) { set(result_id, result_type, image_id, samp_id); } string CompilerMSL::to_texture_op(const Instruction &i, bool sparse, bool *forward, SmallVector &inherited_expressions) { auto *ops = stream(i); uint32_t result_type_id = ops[0]; uint32_t img = ops[2]; auto &result_type = get(result_type_id); auto op = static_cast(i.op); bool is_gather = (op == OpImageGather || op == OpImageDrefGather); // Bypass pointers because we need the real image struct auto &type = expression_type(img); auto &imgtype = get(type.self); const MSLConstexprSampler *constexpr_sampler = nullptr; bool is_dynamic_img_sampler = false; if (auto *var = maybe_get_backing_variable(img)) { constexpr_sampler = find_constexpr_sampler(var->basevariable ? var->basevariable : VariableID(var->self)); is_dynamic_img_sampler = has_extended_decoration(var->self, SPIRVCrossDecorationDynamicImageSampler); } string expr; if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable && !is_dynamic_img_sampler) { // If this needs sampler Y'CbCr conversion, we need to do some additional // processing. switch (constexpr_sampler->ycbcr_model) { case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: // Default break; case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709: add_spv_func_and_recompile(SPVFuncImplConvertYCbCrBT709); expr += "spvConvertYCbCrBT709("; break; case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601: add_spv_func_and_recompile(SPVFuncImplConvertYCbCrBT601); expr += "spvConvertYCbCrBT601("; break; case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020: add_spv_func_and_recompile(SPVFuncImplConvertYCbCrBT2020); expr += "spvConvertYCbCrBT2020("; break; default: SPIRV_CROSS_THROW("Invalid Y'CbCr model conversion."); } if (constexpr_sampler->ycbcr_model != MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY) { switch (constexpr_sampler->ycbcr_range) { case MSL_SAMPLER_YCBCR_RANGE_ITU_FULL: add_spv_func_and_recompile(SPVFuncImplExpandITUFullRange); expr += "spvExpandITUFullRange("; break; case MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW: add_spv_func_and_recompile(SPVFuncImplExpandITUNarrowRange); expr += "spvExpandITUNarrowRange("; break; default: SPIRV_CROSS_THROW("Invalid Y'CbCr range."); } } } else if (msl_options.swizzle_texture_samples && !is_gather && is_sampled_image_type(imgtype) && !is_dynamic_img_sampler) { add_spv_func_and_recompile(SPVFuncImplTextureSwizzle); expr += "spvTextureSwizzle("; } string inner_expr = CompilerGLSL::to_texture_op(i, sparse, forward, inherited_expressions); if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable && !is_dynamic_img_sampler) { if (!constexpr_sampler->swizzle_is_identity()) { static const char swizzle_names[] = "rgba"; if (!constexpr_sampler->swizzle_has_one_or_zero()) { // If we can, do it inline. expr += inner_expr + "."; for (uint32_t c = 0; c < 4; c++) { switch (constexpr_sampler->swizzle[c]) { case MSL_COMPONENT_SWIZZLE_IDENTITY: expr += swizzle_names[c]; break; case MSL_COMPONENT_SWIZZLE_R: case MSL_COMPONENT_SWIZZLE_G: case MSL_COMPONENT_SWIZZLE_B: case MSL_COMPONENT_SWIZZLE_A: expr += swizzle_names[constexpr_sampler->swizzle[c] - MSL_COMPONENT_SWIZZLE_R]; break; default: SPIRV_CROSS_THROW("Invalid component swizzle."); } } } else { // Otherwise, we need to emit a temporary and swizzle that. uint32_t temp_id = ir.increase_bound_by(1); emit_op(result_type_id, temp_id, inner_expr, false); for (auto &inherit : inherited_expressions) inherit_expression_dependencies(temp_id, inherit); inherited_expressions.clear(); inherited_expressions.push_back(temp_id); switch (op) { case OpImageSampleDrefImplicitLod: case OpImageSampleImplicitLod: case OpImageSampleProjImplicitLod: case OpImageSampleProjDrefImplicitLod: register_control_dependent_expression(temp_id); break; default: break; } expr += type_to_glsl(result_type) + "("; for (uint32_t c = 0; c < 4; c++) { switch (constexpr_sampler->swizzle[c]) { case MSL_COMPONENT_SWIZZLE_IDENTITY: expr += to_expression(temp_id) + "." + swizzle_names[c]; break; case MSL_COMPONENT_SWIZZLE_ZERO: expr += "0"; break; case MSL_COMPONENT_SWIZZLE_ONE: expr += "1"; break; case MSL_COMPONENT_SWIZZLE_R: case MSL_COMPONENT_SWIZZLE_G: case MSL_COMPONENT_SWIZZLE_B: case MSL_COMPONENT_SWIZZLE_A: expr += to_expression(temp_id) + "." + swizzle_names[constexpr_sampler->swizzle[c] - MSL_COMPONENT_SWIZZLE_R]; break; default: SPIRV_CROSS_THROW("Invalid component swizzle."); } if (c < 3) expr += ", "; } expr += ")"; } } else expr += inner_expr; if (constexpr_sampler->ycbcr_model != MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY) { expr += join(", ", constexpr_sampler->bpc, ")"); if (constexpr_sampler->ycbcr_model != MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY) expr += ")"; } } else { expr += inner_expr; if (msl_options.swizzle_texture_samples && !is_gather && is_sampled_image_type(imgtype) && !is_dynamic_img_sampler) { // Add the swizzle constant from the swizzle buffer. expr += ", " + to_swizzle_expression(img) + ")"; used_swizzle_buffer = true; } } return expr; } static string create_swizzle(MSLComponentSwizzle swizzle) { switch (swizzle) { case MSL_COMPONENT_SWIZZLE_IDENTITY: return "spvSwizzle::none"; case MSL_COMPONENT_SWIZZLE_ZERO: return "spvSwizzle::zero"; case MSL_COMPONENT_SWIZZLE_ONE: return "spvSwizzle::one"; case MSL_COMPONENT_SWIZZLE_R: return "spvSwizzle::red"; case MSL_COMPONENT_SWIZZLE_G: return "spvSwizzle::green"; case MSL_COMPONENT_SWIZZLE_B: return "spvSwizzle::blue"; case MSL_COMPONENT_SWIZZLE_A: return "spvSwizzle::alpha"; default: SPIRV_CROSS_THROW("Invalid component swizzle."); return ""; } } // Returns a string representation of the ID, usable as a function arg. // Manufacture automatic sampler arg for SampledImage texture. string CompilerMSL::to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) { string arg_str; auto &type = expression_type(id); bool is_dynamic_img_sampler = has_extended_decoration(arg.id, SPIRVCrossDecorationDynamicImageSampler); // If the argument *itself* is a "dynamic" combined-image sampler, then we can just pass that around. bool arg_is_dynamic_img_sampler = has_extended_decoration(id, SPIRVCrossDecorationDynamicImageSampler); if (is_dynamic_img_sampler && !arg_is_dynamic_img_sampler) arg_str = join("spvDynamicImageSampler<", type_to_glsl(get(type.image.type)), ">("); auto *c = maybe_get(id); if (msl_options.force_native_arrays && c && !get(c->constant_type).array.empty()) { // If we are passing a constant array directly to a function for some reason, // the callee will expect an argument in thread const address space // (since we can only bind to arrays with references in MSL). // To resolve this, we must emit a copy in this address space. // This kind of code gen should be rare enough that performance is not a real concern. // Inline the SPIR-V to avoid this kind of suboptimal codegen. // // We risk calling this inside a continue block (invalid code), // so just create a thread local copy in the current function. arg_str = join("_", id, "_array_copy"); auto &constants = current_function->constant_arrays_needed_on_stack; auto itr = find(begin(constants), end(constants), ID(id)); if (itr == end(constants)) { force_recompile(); constants.push_back(id); } } else arg_str += CompilerGLSL::to_func_call_arg(arg, id); // Need to check the base variable in case we need to apply a qualified alias. uint32_t var_id = 0; auto *var = maybe_get(id); if (var) var_id = var->basevariable; if (!arg_is_dynamic_img_sampler) { auto *constexpr_sampler = find_constexpr_sampler(var_id ? var_id : id); if (type.basetype == SPIRType::SampledImage) { // Manufacture automatic plane args for multiplanar texture uint32_t planes = 1; if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable) { planes = constexpr_sampler->planes; // If this parameter isn't aliasing a global, then we need to use // the special "dynamic image-sampler" class to pass it--and we need // to use it for *every* non-alias parameter, in case a combined // image-sampler with a Y'CbCr conversion is passed. Hopefully, this // pathological case is so rare that it should never be hit in practice. if (!arg.alias_global_variable) add_spv_func_and_recompile(SPVFuncImplDynamicImageSampler); } for (uint32_t i = 1; i < planes; i++) arg_str += join(", ", CompilerGLSL::to_func_call_arg(arg, id), plane_name_suffix, i); // Manufacture automatic sampler arg if the arg is a SampledImage texture. if (type.image.dim != DimBuffer) arg_str += ", " + to_sampler_expression(var_id ? var_id : id); // Add sampler Y'CbCr conversion info if we have it if (is_dynamic_img_sampler && constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable) { SmallVector samp_args; switch (constexpr_sampler->resolution) { case MSL_FORMAT_RESOLUTION_444: // Default break; case MSL_FORMAT_RESOLUTION_422: samp_args.push_back("spvFormatResolution::_422"); break; case MSL_FORMAT_RESOLUTION_420: samp_args.push_back("spvFormatResolution::_420"); break; default: SPIRV_CROSS_THROW("Invalid format resolution."); } if (constexpr_sampler->chroma_filter != MSL_SAMPLER_FILTER_NEAREST) samp_args.push_back("spvChromaFilter::linear"); if (constexpr_sampler->x_chroma_offset != MSL_CHROMA_LOCATION_COSITED_EVEN) samp_args.push_back("spvXChromaLocation::midpoint"); if (constexpr_sampler->y_chroma_offset != MSL_CHROMA_LOCATION_COSITED_EVEN) samp_args.push_back("spvYChromaLocation::midpoint"); switch (constexpr_sampler->ycbcr_model) { case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: // Default break; case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: samp_args.push_back("spvYCbCrModelConversion::ycbcr_identity"); break; case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709: samp_args.push_back("spvYCbCrModelConversion::ycbcr_bt_709"); break; case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601: samp_args.push_back("spvYCbCrModelConversion::ycbcr_bt_601"); break; case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020: samp_args.push_back("spvYCbCrModelConversion::ycbcr_bt_2020"); break; default: SPIRV_CROSS_THROW("Invalid Y'CbCr model conversion."); } if (constexpr_sampler->ycbcr_range != MSL_SAMPLER_YCBCR_RANGE_ITU_FULL) samp_args.push_back("spvYCbCrRange::itu_narrow"); samp_args.push_back(join("spvComponentBits(", constexpr_sampler->bpc, ")")); arg_str += join(", spvYCbCrSampler(", merge(samp_args), ")"); } } if (is_dynamic_img_sampler && constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable) arg_str += join(", (uint(", create_swizzle(constexpr_sampler->swizzle[3]), ") << 24) | (uint(", create_swizzle(constexpr_sampler->swizzle[2]), ") << 16) | (uint(", create_swizzle(constexpr_sampler->swizzle[1]), ") << 8) | uint(", create_swizzle(constexpr_sampler->swizzle[0]), ")"); else if (msl_options.swizzle_texture_samples && has_sampled_images && is_sampled_image_type(type)) arg_str += ", " + to_swizzle_expression(var_id ? var_id : id); if (buffers_requiring_array_length.count(var_id)) arg_str += ", " + to_buffer_size_expression(var_id ? var_id : id); if (is_dynamic_img_sampler) arg_str += ")"; } // Emulate texture2D atomic operations auto *backing_var = maybe_get_backing_variable(var_id); if (backing_var && atomic_image_vars.count(backing_var->self)) { arg_str += ", " + to_expression(var_id) + "_atomic"; } return arg_str; } // If the ID represents a sampled image that has been assigned a sampler already, // generate an expression for the sampler, otherwise generate a fake sampler name // by appending a suffix to the expression constructed from the ID. string CompilerMSL::to_sampler_expression(uint32_t id) { auto *combined = maybe_get(id); auto expr = to_expression(combined ? combined->image : VariableID(id)); auto index = expr.find_first_of('['); uint32_t samp_id = 0; if (combined) samp_id = combined->sampler; if (index == string::npos) return samp_id ? to_expression(samp_id) : expr + sampler_name_suffix; else { auto image_expr = expr.substr(0, index); auto array_expr = expr.substr(index); return samp_id ? to_expression(samp_id) : (image_expr + sampler_name_suffix + array_expr); } } string CompilerMSL::to_swizzle_expression(uint32_t id) { auto *combined = maybe_get(id); auto expr = to_expression(combined ? combined->image : VariableID(id)); auto index = expr.find_first_of('['); // If an image is part of an argument buffer translate this to a legal identifier. string::size_type period = 0; while ((period = expr.find_first_of('.', period)) != string::npos && period < index) expr[period] = '_'; if (index == string::npos) return expr + swizzle_name_suffix; else { auto image_expr = expr.substr(0, index); auto array_expr = expr.substr(index); return image_expr + swizzle_name_suffix + array_expr; } } string CompilerMSL::to_buffer_size_expression(uint32_t id) { auto expr = to_expression(id); auto index = expr.find_first_of('['); // This is quite crude, but we need to translate the reference name (*spvDescriptorSetN.name) to // the pointer expression spvDescriptorSetN.name to make a reasonable expression here. // This only happens if we have argument buffers and we are using OpArrayLength on a lone SSBO in that set. if (expr.size() >= 3 && expr[0] == '(' && expr[1] == '*') expr = address_of_expression(expr); // If a buffer is part of an argument buffer translate this to a legal identifier. for (auto &c : expr) if (c == '.') c = '_'; if (index == string::npos) return expr + buffer_size_name_suffix; else { auto buffer_expr = expr.substr(0, index); auto array_expr = expr.substr(index); return buffer_expr + buffer_size_name_suffix + array_expr; } } // Checks whether the type is a Block all of whose members have DecorationPatch. bool CompilerMSL::is_patch_block(const SPIRType &type) { if (!has_decoration(type.self, DecorationBlock)) return false; for (uint32_t i = 0; i < type.member_types.size(); i++) { if (!has_member_decoration(type.self, i, DecorationPatch)) return false; } return true; } // Checks whether the ID is a row_major matrix that requires conversion before use bool CompilerMSL::is_non_native_row_major_matrix(uint32_t id) { auto *e = maybe_get(id); if (e) return e->need_transpose; else return has_decoration(id, DecorationRowMajor); } // Checks whether the member is a row_major matrix that requires conversion before use bool CompilerMSL::member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index) { return has_member_decoration(type.self, index, DecorationRowMajor); } string CompilerMSL::convert_row_major_matrix(string exp_str, const SPIRType &exp_type, uint32_t physical_type_id, bool is_packed) { if (!is_matrix(exp_type)) { return CompilerGLSL::convert_row_major_matrix(move(exp_str), exp_type, physical_type_id, is_packed); } else { strip_enclosed_expression(exp_str); if (physical_type_id != 0 || is_packed) exp_str = unpack_expression_type(exp_str, exp_type, physical_type_id, is_packed, true); return join("transpose(", exp_str, ")"); } } // Called automatically at the end of the entry point function void CompilerMSL::emit_fixup() { if (is_vertex_like_shader() && stage_out_var_id && !qual_pos_var_name.empty() && !capture_output_to_buffer) { if (options.vertex.fixup_clipspace) statement(qual_pos_var_name, ".z = (", qual_pos_var_name, ".z + ", qual_pos_var_name, ".w) * 0.5; // Adjust clip-space for Metal"); if (options.vertex.flip_vert_y) statement(qual_pos_var_name, ".y = -(", qual_pos_var_name, ".y);", " // Invert Y-axis for Metal"); } } // Return a string defining a structure member, with padding and packing. string CompilerMSL::to_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const string &qualifier) { if (member_is_remapped_physical_type(type, index)) member_type_id = get_extended_member_decoration(type.self, index, SPIRVCrossDecorationPhysicalTypeID); auto &physical_type = get(member_type_id); // If this member is packed, mark it as so. string pack_pfx; // Allow Metal to use the array template to make arrays a value type uint32_t orig_id = 0; if (has_extended_member_decoration(type.self, index, SPIRVCrossDecorationInterfaceOrigID)) orig_id = get_extended_member_decoration(type.self, index, SPIRVCrossDecorationInterfaceOrigID); bool row_major = false; if (is_matrix(physical_type)) row_major = has_member_decoration(type.self, index, DecorationRowMajor); SPIRType row_major_physical_type; const SPIRType *declared_type = &physical_type; // If a struct is being declared with physical layout, // do not use array wrappers. // This avoids a lot of complicated cases with packed vectors and matrices, // and generally we cannot copy full arrays in and out of buffers into Function // address space. // Array of resources should also be declared as builtin arrays. if (has_member_decoration(type.self, index, DecorationOffset)) is_using_builtin_array = true; else if (has_extended_member_decoration(type.self, index, SPIRVCrossDecorationResourceIndexPrimary)) is_using_builtin_array = true; if (member_is_packed_physical_type(type, index)) { // If we're packing a matrix, output an appropriate typedef if (physical_type.basetype == SPIRType::Struct) { SPIRV_CROSS_THROW("Cannot emit a packed struct currently."); } else if (is_matrix(physical_type)) { uint32_t rows = physical_type.vecsize; uint32_t cols = physical_type.columns; pack_pfx = "packed_"; if (row_major) { // These are stored transposed. rows = physical_type.columns; cols = physical_type.vecsize; pack_pfx = "packed_rm_"; } string base_type = physical_type.width == 16 ? "half" : "float"; string td_line = "typedef "; td_line += "packed_" + base_type + to_string(rows); td_line += " " + pack_pfx; // Use the actual matrix size here. td_line += base_type + to_string(physical_type.columns) + "x" + to_string(physical_type.vecsize); td_line += "[" + to_string(cols) + "]"; td_line += ";"; add_typedef_line(td_line); } else if (!is_scalar(physical_type)) // scalar type is already packed. pack_pfx = "packed_"; } else if (row_major) { // Need to declare type with flipped vecsize/columns. row_major_physical_type = physical_type; swap(row_major_physical_type.vecsize, row_major_physical_type.columns); declared_type = &row_major_physical_type; } // Very specifically, image load-store in argument buffers are disallowed on MSL on iOS. if (msl_options.is_ios() && physical_type.basetype == SPIRType::Image && physical_type.image.sampled == 2) { if (!has_decoration(orig_id, DecorationNonWritable)) SPIRV_CROSS_THROW("Writable images are not allowed in argument buffers on iOS."); } // Array information is baked into these types. string array_type; if (physical_type.basetype != SPIRType::Image && physical_type.basetype != SPIRType::Sampler && physical_type.basetype != SPIRType::SampledImage) { BuiltIn builtin = BuiltInMax; // Special handling. In [[stage_out]] or [[stage_in]] blocks, // we need flat arrays, but if we're somehow declaring gl_PerVertex for constant array reasons, we want // template array types to be declared. bool is_ib_in_out = ((stage_out_var_id && get_stage_out_struct_type().self == type.self) || (stage_in_var_id && get_stage_in_struct_type().self == type.self)); if (is_ib_in_out && is_member_builtin(type, index, &builtin)) is_using_builtin_array = true; array_type = type_to_array_glsl(physical_type); } auto result = join(pack_pfx, type_to_glsl(*declared_type, orig_id), " ", qualifier, to_member_name(type, index), member_attribute_qualifier(type, index), array_type, ";"); is_using_builtin_array = false; return result; } // Emit a structure member, padding and packing to maintain the correct memeber alignments. void CompilerMSL::emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const string &qualifier, uint32_t) { // If this member requires padding to maintain its declared offset, emit a dummy padding member before it. if (has_extended_member_decoration(type.self, index, SPIRVCrossDecorationPaddingTarget)) { uint32_t pad_len = get_extended_member_decoration(type.self, index, SPIRVCrossDecorationPaddingTarget); statement("char _m", index, "_pad", "[", pad_len, "];"); } // Handle HLSL-style 0-based vertex/instance index. builtin_declaration = true; statement(to_struct_member(type, member_type_id, index, qualifier)); builtin_declaration = false; } void CompilerMSL::emit_struct_padding_target(const SPIRType &type) { uint32_t struct_size = get_declared_struct_size_msl(type, true, true); uint32_t target_size = get_extended_decoration(type.self, SPIRVCrossDecorationPaddingTarget); if (target_size < struct_size) SPIRV_CROSS_THROW("Cannot pad with negative bytes."); else if (target_size > struct_size) statement("char _m0_final_padding[", target_size - struct_size, "];"); } // Return a MSL qualifier for the specified function attribute member string CompilerMSL::member_attribute_qualifier(const SPIRType &type, uint32_t index) { auto &execution = get_entry_point(); uint32_t mbr_type_id = type.member_types[index]; auto &mbr_type = get(mbr_type_id); BuiltIn builtin = BuiltInMax; bool is_builtin = is_member_builtin(type, index, &builtin); if (has_extended_member_decoration(type.self, index, SPIRVCrossDecorationResourceIndexPrimary)) { string quals = join( " [[id(", get_extended_member_decoration(type.self, index, SPIRVCrossDecorationResourceIndexPrimary), ")"); if (interlocked_resources.count( get_extended_member_decoration(type.self, index, SPIRVCrossDecorationInterfaceOrigID))) quals += ", raster_order_group(0)"; quals += "]]"; return quals; } // Vertex function inputs if (execution.model == ExecutionModelVertex && type.storage == StorageClassInput) { if (is_builtin) { switch (builtin) { case BuiltInVertexId: case BuiltInVertexIndex: case BuiltInBaseVertex: case BuiltInInstanceId: case BuiltInInstanceIndex: case BuiltInBaseInstance: if (msl_options.vertex_for_tessellation) return ""; return string(" [[") + builtin_qualifier(builtin) + "]]"; case BuiltInDrawIndex: SPIRV_CROSS_THROW("DrawIndex is not supported in MSL."); default: return ""; } } uint32_t locn = get_ordered_member_location(type.self, index); if (locn != k_unknown_location) return string(" [[attribute(") + convert_to_string(locn) + ")]]"; } // Vertex and tessellation evaluation function outputs if (((execution.model == ExecutionModelVertex && !msl_options.vertex_for_tessellation) || execution.model == ExecutionModelTessellationEvaluation) && type.storage == StorageClassOutput) { if (is_builtin) { switch (builtin) { case BuiltInPointSize: // Only mark the PointSize builtin if really rendering points. // Some shaders may include a PointSize builtin even when used to render // non-point topologies, and Metal will reject this builtin when compiling // the shader into a render pipeline that uses a non-point topology. return msl_options.enable_point_size_builtin ? (string(" [[") + builtin_qualifier(builtin) + "]]") : ""; case BuiltInViewportIndex: if (!msl_options.supports_msl_version(2, 0)) SPIRV_CROSS_THROW("ViewportIndex requires Metal 2.0."); /* fallthrough */ case BuiltInPosition: case BuiltInLayer: return string(" [[") + builtin_qualifier(builtin) + "]]" + (mbr_type.array.empty() ? "" : " "); case BuiltInClipDistance: if (has_member_decoration(type.self, index, DecorationLocation)) return join(" [[user(clip", get_member_decoration(type.self, index, DecorationLocation), ")]]"); else return string(" [[") + builtin_qualifier(builtin) + "]]" + (mbr_type.array.empty() ? "" : " "); default: return ""; } } uint32_t comp; uint32_t locn = get_ordered_member_location(type.self, index, &comp); if (locn != k_unknown_location) { if (comp != k_unknown_component) return string(" [[user(locn") + convert_to_string(locn) + "_" + convert_to_string(comp) + ")]]"; else return string(" [[user(locn") + convert_to_string(locn) + ")]]"; } } // Tessellation control function inputs if (execution.model == ExecutionModelTessellationControl && type.storage == StorageClassInput) { if (is_builtin) { switch (builtin) { case BuiltInInvocationId: case BuiltInPrimitiveId: if (msl_options.multi_patch_workgroup) return ""; return string(" [[") + builtin_qualifier(builtin) + "]]" + (mbr_type.array.empty() ? "" : " "); case BuiltInSubgroupLocalInvocationId: // FIXME: Should work in any stage case BuiltInSubgroupSize: // FIXME: Should work in any stage if (msl_options.emulate_subgroups) return ""; return string(" [[") + builtin_qualifier(builtin) + "]]" + (mbr_type.array.empty() ? "" : " "); case BuiltInPatchVertices: return ""; // Others come from stage input. default: break; } } if (msl_options.multi_patch_workgroup) return ""; uint32_t locn = get_ordered_member_location(type.self, index); if (locn != k_unknown_location) return string(" [[attribute(") + convert_to_string(locn) + ")]]"; } // Tessellation control function outputs if (execution.model == ExecutionModelTessellationControl && type.storage == StorageClassOutput) { // For this type of shader, we always arrange for it to capture its // output to a buffer. For this reason, qualifiers are irrelevant here. return ""; } // Tessellation evaluation function inputs if (execution.model == ExecutionModelTessellationEvaluation && type.storage == StorageClassInput) { if (is_builtin) { switch (builtin) { case BuiltInPrimitiveId: case BuiltInTessCoord: return string(" [[") + builtin_qualifier(builtin) + "]]"; case BuiltInPatchVertices: return ""; // Others come from stage input. default: break; } } // The special control point array must not be marked with an attribute. if (get_type(type.member_types[index]).basetype == SPIRType::ControlPointArray) return ""; uint32_t locn = get_ordered_member_location(type.self, index); if (locn != k_unknown_location) return string(" [[attribute(") + convert_to_string(locn) + ")]]"; } // Tessellation evaluation function outputs were handled above. // Fragment function inputs if (execution.model == ExecutionModelFragment && type.storage == StorageClassInput) { string quals; if (is_builtin) { switch (builtin) { case BuiltInViewIndex: if (!msl_options.multiview || !msl_options.multiview_layered_rendering) break; /* fallthrough */ case BuiltInFrontFacing: case BuiltInPointCoord: case BuiltInFragCoord: case BuiltInSampleId: case BuiltInSampleMask: case BuiltInLayer: case BuiltInBaryCoordNV: case BuiltInBaryCoordNoPerspNV: quals = builtin_qualifier(builtin); break; case BuiltInClipDistance: return join(" [[user(clip", get_member_decoration(type.self, index, DecorationLocation), ")]]"); default: break; } } else { uint32_t comp; uint32_t locn = get_ordered_member_location(type.self, index, &comp); if (locn != k_unknown_location) { // For user-defined attributes, this is fine. From Vulkan spec: // A user-defined output variable is considered to match an input variable in the subsequent stage if // the two variables are declared with the same Location and Component decoration and match in type // and decoration, except that interpolation decorations are not required to match. For the purposes // of interface matching, variables declared without a Component decoration are considered to have a // Component decoration of zero. if (comp != k_unknown_component && comp != 0) quals = string("user(locn") + convert_to_string(locn) + "_" + convert_to_string(comp) + ")"; else quals = string("user(locn") + convert_to_string(locn) + ")"; } } if (builtin == BuiltInBaryCoordNV || builtin == BuiltInBaryCoordNoPerspNV) { if (has_member_decoration(type.self, index, DecorationFlat) || has_member_decoration(type.self, index, DecorationCentroid) || has_member_decoration(type.self, index, DecorationSample) || has_member_decoration(type.self, index, DecorationNoPerspective)) { // NoPerspective is baked into the builtin type. SPIRV_CROSS_THROW( "Flat, Centroid, Sample, NoPerspective decorations are not supported for BaryCoord inputs."); } } // Don't bother decorating integers with the 'flat' attribute; it's // the default (in fact, the only option). Also don't bother with the // FragCoord builtin; it's always noperspective on Metal. if (!type_is_integral(mbr_type) && (!is_builtin || builtin != BuiltInFragCoord)) { if (has_member_decoration(type.self, index, DecorationFlat)) { if (!quals.empty()) quals += ", "; quals += "flat"; } else if (has_member_decoration(type.self, index, DecorationCentroid)) { if (!quals.empty()) quals += ", "; if (has_member_decoration(type.self, index, DecorationNoPerspective)) quals += "centroid_no_perspective"; else quals += "centroid_perspective"; } else if (has_member_decoration(type.self, index, DecorationSample)) { if (!quals.empty()) quals += ", "; if (has_member_decoration(type.self, index, DecorationNoPerspective)) quals += "sample_no_perspective"; else quals += "sample_perspective"; } else if (has_member_decoration(type.self, index, DecorationNoPerspective)) { if (!quals.empty()) quals += ", "; quals += "center_no_perspective"; } } if (!quals.empty()) return " [[" + quals + "]]"; } // Fragment function outputs if (execution.model == ExecutionModelFragment && type.storage == StorageClassOutput) { if (is_builtin) { switch (builtin) { case BuiltInFragStencilRefEXT: // Similar to PointSize, only mark FragStencilRef if there's a stencil buffer. // Some shaders may include a FragStencilRef builtin even when used to render // without a stencil attachment, and Metal will reject this builtin // when compiling the shader into a render pipeline that does not set // stencilAttachmentPixelFormat. if (!msl_options.enable_frag_stencil_ref_builtin) return ""; if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Stencil export only supported in MSL 2.1 and up."); return string(" [[") + builtin_qualifier(builtin) + "]]"; case BuiltInFragDepth: // Ditto FragDepth. if (!msl_options.enable_frag_depth_builtin) return ""; /* fallthrough */ case BuiltInSampleMask: return string(" [[") + builtin_qualifier(builtin) + "]]"; default: return ""; } } uint32_t locn = get_ordered_member_location(type.self, index); // Metal will likely complain about missing color attachments, too. if (locn != k_unknown_location && !(msl_options.enable_frag_output_mask & (1 << locn))) return ""; if (locn != k_unknown_location && has_member_decoration(type.self, index, DecorationIndex)) return join(" [[color(", locn, "), index(", get_member_decoration(type.self, index, DecorationIndex), ")]]"); else if (locn != k_unknown_location) return join(" [[color(", locn, ")]]"); else if (has_member_decoration(type.self, index, DecorationIndex)) return join(" [[index(", get_member_decoration(type.self, index, DecorationIndex), ")]]"); else return ""; } // Compute function inputs if (execution.model == ExecutionModelGLCompute && type.storage == StorageClassInput) { if (is_builtin) { switch (builtin) { case BuiltInNumSubgroups: case BuiltInSubgroupId: case BuiltInSubgroupLocalInvocationId: // FIXME: Should work in any stage case BuiltInSubgroupSize: // FIXME: Should work in any stage if (msl_options.emulate_subgroups) break; /* fallthrough */ case BuiltInGlobalInvocationId: case BuiltInWorkgroupId: case BuiltInNumWorkgroups: case BuiltInLocalInvocationId: case BuiltInLocalInvocationIndex: return string(" [[") + builtin_qualifier(builtin) + "]]"; default: return ""; } } } return ""; } // Returns the location decoration of the member with the specified index in the specified type. // If the location of the member has been explicitly set, that location is used. If not, this // function assumes the members are ordered in their location order, and simply returns the // index as the location. uint32_t CompilerMSL::get_ordered_member_location(uint32_t type_id, uint32_t index, uint32_t *comp) { auto &m = ir.meta[type_id]; if (index < m.members.size()) { auto &dec = m.members[index]; if (comp) { if (dec.decoration_flags.get(DecorationComponent)) *comp = dec.component; else *comp = k_unknown_component; } if (dec.decoration_flags.get(DecorationLocation)) return dec.location; } return index; } // Returns the type declaration for a function, including the // entry type if the current function is the entry point function string CompilerMSL::func_type_decl(SPIRType &type) { // The regular function return type. If not processing the entry point function, that's all we need string return_type = type_to_glsl(type) + type_to_array_glsl(type); if (!processing_entry_point) return return_type; // If an outgoing interface block has been defined, and it should be returned, override the entry point return type bool ep_should_return_output = !get_is_rasterization_disabled(); if (stage_out_var_id && ep_should_return_output) return_type = type_to_glsl(get_stage_out_struct_type()) + type_to_array_glsl(type); // Prepend a entry type, based on the execution model string entry_type; auto &execution = get_entry_point(); switch (execution.model) { case ExecutionModelVertex: if (msl_options.vertex_for_tessellation && !msl_options.supports_msl_version(1, 2)) SPIRV_CROSS_THROW("Tessellation requires Metal 1.2."); entry_type = msl_options.vertex_for_tessellation ? "kernel" : "vertex"; break; case ExecutionModelTessellationEvaluation: if (!msl_options.supports_msl_version(1, 2)) SPIRV_CROSS_THROW("Tessellation requires Metal 1.2."); if (execution.flags.get(ExecutionModeIsolines)) SPIRV_CROSS_THROW("Metal does not support isoline tessellation."); if (msl_options.is_ios()) entry_type = join("[[ patch(", execution.flags.get(ExecutionModeTriangles) ? "triangle" : "quad", ") ]] vertex"); else entry_type = join("[[ patch(", execution.flags.get(ExecutionModeTriangles) ? "triangle" : "quad", ", ", execution.output_vertices, ") ]] vertex"); break; case ExecutionModelFragment: entry_type = execution.flags.get(ExecutionModeEarlyFragmentTests) || execution.flags.get(ExecutionModePostDepthCoverage) ? "[[ early_fragment_tests ]] fragment" : "fragment"; break; case ExecutionModelTessellationControl: if (!msl_options.supports_msl_version(1, 2)) SPIRV_CROSS_THROW("Tessellation requires Metal 1.2."); if (execution.flags.get(ExecutionModeIsolines)) SPIRV_CROSS_THROW("Metal does not support isoline tessellation."); /* fallthrough */ case ExecutionModelGLCompute: case ExecutionModelKernel: entry_type = "kernel"; break; default: entry_type = "unknown"; break; } return entry_type + " " + return_type; } // In MSL, address space qualifiers are required for all pointer or reference variables string CompilerMSL::get_argument_address_space(const SPIRVariable &argument) { const auto &type = get(argument.basetype); return get_type_address_space(type, argument.self, true); } string CompilerMSL::get_type_address_space(const SPIRType &type, uint32_t id, bool argument) { // This can be called for variable pointer contexts as well, so be very careful about which method we choose. Bitset flags; auto *var = maybe_get(id); if (var && type.basetype == SPIRType::Struct && (has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock))) flags = get_buffer_block_flags(id); else flags = get_decoration_bitset(id); const char *addr_space = nullptr; switch (type.storage) { case StorageClassWorkgroup: addr_space = "threadgroup"; break; case StorageClassStorageBuffer: { // For arguments from variable pointers, we use the write count deduction, so // we should not assume any constness here. Only for global SSBOs. bool readonly = false; if (!var || has_decoration(type.self, DecorationBlock)) readonly = flags.get(DecorationNonWritable); addr_space = readonly ? "const device" : "device"; break; } case StorageClassUniform: case StorageClassUniformConstant: case StorageClassPushConstant: if (type.basetype == SPIRType::Struct) { bool ssbo = has_decoration(type.self, DecorationBufferBlock); if (ssbo) addr_space = flags.get(DecorationNonWritable) ? "const device" : "device"; else addr_space = "constant"; } else if (!argument) { addr_space = "constant"; } else if (type_is_msl_framebuffer_fetch(type)) { // Subpass inputs are passed around by value. addr_space = ""; } break; case StorageClassFunction: case StorageClassGeneric: break; case StorageClassInput: if (get_execution_model() == ExecutionModelTessellationControl && var && var->basevariable == stage_in_ptr_var_id) addr_space = msl_options.multi_patch_workgroup ? "constant" : "threadgroup"; if (get_execution_model() == ExecutionModelFragment && var && var->basevariable == stage_in_var_id) addr_space = "thread"; break; case StorageClassOutput: if (capture_output_to_buffer) addr_space = "device"; break; default: break; } if (!addr_space) // No address space for plain values. addr_space = type.pointer || (argument && type.basetype == SPIRType::ControlPointArray) ? "thread" : ""; return join(flags.get(DecorationVolatile) || flags.get(DecorationCoherent) ? "volatile " : "", addr_space); } const char *CompilerMSL::to_restrict(uint32_t id, bool space) { // This can be called for variable pointer contexts as well, so be very careful about which method we choose. Bitset flags; if (ir.ids[id].get_type() == TypeVariable) { uint32_t type_id = expression_type_id(id); auto &type = expression_type(id); if (type.basetype == SPIRType::Struct && (has_decoration(type_id, DecorationBlock) || has_decoration(type_id, DecorationBufferBlock))) flags = get_buffer_block_flags(id); else flags = get_decoration_bitset(id); } else flags = get_decoration_bitset(id); return flags.get(DecorationRestrict) ? (space ? "restrict " : "restrict") : ""; } string CompilerMSL::entry_point_arg_stage_in() { string decl; if (get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup) return decl; // Stage-in structure uint32_t stage_in_id; if (get_execution_model() == ExecutionModelTessellationEvaluation) stage_in_id = patch_stage_in_var_id; else stage_in_id = stage_in_var_id; if (stage_in_id) { auto &var = get(stage_in_id); auto &type = get_variable_data_type(var); add_resource_name(var.self); decl = join(type_to_glsl(type), " ", to_name(var.self), " [[stage_in]]"); } return decl; } // Returns true if this input builtin should be a direct parameter on a shader function parameter list, // and false for builtins that should be passed or calculated some other way. bool CompilerMSL::is_direct_input_builtin(BuiltIn bi_type) { switch (bi_type) { // Vertex function in case BuiltInVertexId: case BuiltInVertexIndex: case BuiltInBaseVertex: case BuiltInInstanceId: case BuiltInInstanceIndex: case BuiltInBaseInstance: return get_execution_model() != ExecutionModelVertex || !msl_options.vertex_for_tessellation; // Tess. control function in case BuiltInPosition: case BuiltInPointSize: case BuiltInClipDistance: case BuiltInCullDistance: case BuiltInPatchVertices: return false; case BuiltInInvocationId: case BuiltInPrimitiveId: return get_execution_model() != ExecutionModelTessellationControl || !msl_options.multi_patch_workgroup; // Tess. evaluation function in case BuiltInTessLevelInner: case BuiltInTessLevelOuter: return false; // Fragment function in case BuiltInSamplePosition: case BuiltInHelperInvocation: case BuiltInBaryCoordNV: case BuiltInBaryCoordNoPerspNV: return false; case BuiltInViewIndex: return get_execution_model() == ExecutionModelFragment && msl_options.multiview && msl_options.multiview_layered_rendering; // Compute function in case BuiltInSubgroupId: case BuiltInNumSubgroups: return !msl_options.emulate_subgroups; // Any stage function in case BuiltInDeviceIndex: case BuiltInSubgroupEqMask: case BuiltInSubgroupGeMask: case BuiltInSubgroupGtMask: case BuiltInSubgroupLeMask: case BuiltInSubgroupLtMask: return false; case BuiltInSubgroupSize: if (msl_options.fixed_subgroup_size != 0) return false; /* fallthrough */ case BuiltInSubgroupLocalInvocationId: return !msl_options.emulate_subgroups; default: return true; } } // Returns true if this is a fragment shader that runs per sample, and false otherwise. bool CompilerMSL::is_sample_rate() const { auto &caps = get_declared_capabilities(); return get_execution_model() == ExecutionModelFragment && (msl_options.force_sample_rate_shading || std::find(caps.begin(), caps.end(), CapabilitySampleRateShading) != caps.end() || (msl_options.use_framebuffer_fetch_subpasses && need_subpass_input)); } void CompilerMSL::entry_point_args_builtin(string &ep_args) { // Builtin variables SmallVector, 8> active_builtins; ir.for_each_typed_id([&](uint32_t var_id, SPIRVariable &var) { if (var.storage != StorageClassInput) return; auto bi_type = BuiltIn(get_decoration(var_id, DecorationBuiltIn)); // Don't emit SamplePosition as a separate parameter. In the entry // point, we get that by calling get_sample_position() on the sample ID. if (is_builtin_variable(var) && get_variable_data_type(var).basetype != SPIRType::Struct && get_variable_data_type(var).basetype != SPIRType::ControlPointArray) { // If the builtin is not part of the active input builtin set, don't emit it. // Relevant for multiple entry-point modules which might declare unused builtins. if (!active_input_builtins.get(bi_type) || !interface_variable_exists_in_entry_point(var_id)) return; // Remember this variable. We may need to correct its type. active_builtins.push_back(make_pair(&var, bi_type)); if (is_direct_input_builtin(bi_type)) { if (!ep_args.empty()) ep_args += ", "; // Handle HLSL-style 0-based vertex/instance index. builtin_declaration = true; ep_args += builtin_type_decl(bi_type, var_id) + " " + to_expression(var_id); ep_args += " [[" + builtin_qualifier(bi_type); if (bi_type == BuiltInSampleMask && get_entry_point().flags.get(ExecutionModePostDepthCoverage)) { if (!msl_options.supports_msl_version(2)) SPIRV_CROSS_THROW("Post-depth coverage requires MSL 2.0."); if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 3)) SPIRV_CROSS_THROW("Post-depth coverage on Mac requires MSL 2.3."); ep_args += ", post_depth_coverage"; } ep_args += "]]"; builtin_declaration = false; } } if (has_extended_decoration(var_id, SPIRVCrossDecorationBuiltInDispatchBase)) { // This is a special implicit builtin, not corresponding to any SPIR-V builtin, // which holds the base that was passed to vkCmdDispatchBase() or vkCmdDrawIndexed(). If it's present, // assume we emitted it for a good reason. assert(msl_options.supports_msl_version(1, 2)); if (!ep_args.empty()) ep_args += ", "; ep_args += type_to_glsl(get_variable_data_type(var)) + " " + to_expression(var_id) + " [[grid_origin]]"; } if (has_extended_decoration(var_id, SPIRVCrossDecorationBuiltInStageInputSize)) { // This is another special implicit builtin, not corresponding to any SPIR-V builtin, // which holds the number of vertices and instances to draw. If it's present, // assume we emitted it for a good reason. assert(msl_options.supports_msl_version(1, 2)); if (!ep_args.empty()) ep_args += ", "; ep_args += type_to_glsl(get_variable_data_type(var)) + " " + to_expression(var_id) + " [[grid_size]]"; } }); // Correct the types of all encountered active builtins. We couldn't do this before // because ensure_correct_builtin_type() may increase the bound, which isn't allowed // while iterating over IDs. for (auto &var : active_builtins) var.first->basetype = ensure_correct_builtin_type(var.first->basetype, var.second); // Handle HLSL-style 0-based vertex/instance index. if (needs_base_vertex_arg == TriState::Yes) ep_args += built_in_func_arg(BuiltInBaseVertex, !ep_args.empty()); if (needs_base_instance_arg == TriState::Yes) ep_args += built_in_func_arg(BuiltInBaseInstance, !ep_args.empty()); if (capture_output_to_buffer) { // Add parameters to hold the indirect draw parameters and the shader output. This has to be handled // specially because it needs to be a pointer, not a reference. if (stage_out_var_id) { if (!ep_args.empty()) ep_args += ", "; ep_args += join("device ", type_to_glsl(get_stage_out_struct_type()), "* ", output_buffer_var_name, " [[buffer(", msl_options.shader_output_buffer_index, ")]]"); } if (get_execution_model() == ExecutionModelTessellationControl) { if (!ep_args.empty()) ep_args += ", "; ep_args += join("constant uint* spvIndirectParams [[buffer(", msl_options.indirect_params_buffer_index, ")]]"); } else if (stage_out_var_id && !(get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation)) { if (!ep_args.empty()) ep_args += ", "; ep_args += join("device uint* spvIndirectParams [[buffer(", msl_options.indirect_params_buffer_index, ")]]"); } if (get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation && (active_input_builtins.get(BuiltInVertexIndex) || active_input_builtins.get(BuiltInVertexId)) && msl_options.vertex_index_type != Options::IndexType::None) { // Add the index buffer so we can set gl_VertexIndex correctly. if (!ep_args.empty()) ep_args += ", "; switch (msl_options.vertex_index_type) { case Options::IndexType::None: break; case Options::IndexType::UInt16: ep_args += join("const device ushort* ", index_buffer_var_name, " [[buffer(", msl_options.shader_index_buffer_index, ")]]"); break; case Options::IndexType::UInt32: ep_args += join("const device uint* ", index_buffer_var_name, " [[buffer(", msl_options.shader_index_buffer_index, ")]]"); break; } } // Tessellation control shaders get three additional parameters: // a buffer to hold the per-patch data, a buffer to hold the per-patch // tessellation levels, and a block of workgroup memory to hold the // input control point data. if (get_execution_model() == ExecutionModelTessellationControl) { if (patch_stage_out_var_id) { if (!ep_args.empty()) ep_args += ", "; ep_args += join("device ", type_to_glsl(get_patch_stage_out_struct_type()), "* ", patch_output_buffer_var_name, " [[buffer(", convert_to_string(msl_options.shader_patch_output_buffer_index), ")]]"); } if (!ep_args.empty()) ep_args += ", "; ep_args += join("device ", get_tess_factor_struct_name(), "* ", tess_factor_buffer_var_name, " [[buffer(", convert_to_string(msl_options.shader_tess_factor_buffer_index), ")]]"); // Initializer for tess factors must be handled specially since it's never declared as a normal variable. uint32_t outer_factor_initializer_id = 0; uint32_t inner_factor_initializer_id = 0; ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { if (!has_decoration(var.self, DecorationBuiltIn) || var.storage != StorageClassOutput || !var.initializer) return; BuiltIn builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn)); if (builtin == BuiltInTessLevelInner) inner_factor_initializer_id = var.initializer; else if (builtin == BuiltInTessLevelOuter) outer_factor_initializer_id = var.initializer; }); const SPIRConstant *c = nullptr; if (outer_factor_initializer_id && (c = maybe_get(outer_factor_initializer_id))) { auto &entry_func = get(ir.default_entry_point); entry_func.fixup_hooks_in.push_back([=]() { uint32_t components = get_execution_mode_bitset().get(ExecutionModeTriangles) ? 3 : 4; for (uint32_t i = 0; i < components; i++) { statement(builtin_to_glsl(BuiltInTessLevelOuter, StorageClassOutput), "[", i, "] = ", "half(", to_expression(c->subconstants[i]), ");"); } }); } if (inner_factor_initializer_id && (c = maybe_get(inner_factor_initializer_id))) { auto &entry_func = get(ir.default_entry_point); if (get_execution_mode_bitset().get(ExecutionModeTriangles)) { entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_to_glsl(BuiltInTessLevelInner, StorageClassOutput), " = ", "half(", to_expression(c->subconstants[0]), ");"); }); } else { entry_func.fixup_hooks_in.push_back([=]() { for (uint32_t i = 0; i < 2; i++) { statement(builtin_to_glsl(BuiltInTessLevelInner, StorageClassOutput), "[", i, "] = ", "half(", to_expression(c->subconstants[i]), ");"); } }); } } if (stage_in_var_id) { if (!ep_args.empty()) ep_args += ", "; if (msl_options.multi_patch_workgroup) { ep_args += join("device ", type_to_glsl(get_stage_in_struct_type()), "* ", input_buffer_var_name, " [[buffer(", convert_to_string(msl_options.shader_input_buffer_index), ")]]"); } else { ep_args += join("threadgroup ", type_to_glsl(get_stage_in_struct_type()), "* ", input_wg_var_name, " [[threadgroup(", convert_to_string(msl_options.shader_input_wg_index), ")]]"); } } } } } string CompilerMSL::entry_point_args_argument_buffer(bool append_comma) { string ep_args = entry_point_arg_stage_in(); Bitset claimed_bindings; for (uint32_t i = 0; i < kMaxArgumentBuffers; i++) { uint32_t id = argument_buffer_ids[i]; if (id == 0) continue; add_resource_name(id); auto &var = get(id); auto &type = get_variable_data_type(var); if (!ep_args.empty()) ep_args += ", "; // Check if the argument buffer binding itself has been remapped. uint32_t buffer_binding; auto itr = resource_bindings.find({ get_entry_point().model, i, kArgumentBufferBinding }); if (itr != end(resource_bindings)) { buffer_binding = itr->second.first.msl_buffer; itr->second.second = true; } else { // As a fallback, directly map desc set <-> binding. // If that was taken, take the next buffer binding. if (claimed_bindings.get(i)) buffer_binding = next_metal_resource_index_buffer; else buffer_binding = i; } claimed_bindings.set(buffer_binding); ep_args += get_argument_address_space(var) + " " + type_to_glsl(type) + "& " + to_restrict(id) + to_name(id); ep_args += " [[buffer(" + convert_to_string(buffer_binding) + ")]]"; next_metal_resource_index_buffer = max(next_metal_resource_index_buffer, buffer_binding + 1); } entry_point_args_discrete_descriptors(ep_args); entry_point_args_builtin(ep_args); if (!ep_args.empty() && append_comma) ep_args += ", "; return ep_args; } const MSLConstexprSampler *CompilerMSL::find_constexpr_sampler(uint32_t id) const { // Try by ID. { auto itr = constexpr_samplers_by_id.find(id); if (itr != end(constexpr_samplers_by_id)) return &itr->second; } // Try by binding. { uint32_t desc_set = get_decoration(id, DecorationDescriptorSet); uint32_t binding = get_decoration(id, DecorationBinding); auto itr = constexpr_samplers_by_binding.find({ desc_set, binding }); if (itr != end(constexpr_samplers_by_binding)) return &itr->second; } return nullptr; } void CompilerMSL::entry_point_args_discrete_descriptors(string &ep_args) { // Output resources, sorted by resource index & type // We need to sort to work around a bug on macOS 10.13 with NVidia drivers where switching between shaders // with different order of buffers can result in issues with buffer assignments inside the driver. struct Resource { SPIRVariable *var; string name; SPIRType::BaseType basetype; uint32_t index; uint32_t plane; uint32_t secondary_index; }; SmallVector resources; ir.for_each_typed_id([&](uint32_t var_id, SPIRVariable &var) { if ((var.storage == StorageClassUniform || var.storage == StorageClassUniformConstant || var.storage == StorageClassPushConstant || var.storage == StorageClassStorageBuffer) && !is_hidden_variable(var)) { auto &type = get_variable_data_type(var); if (is_supported_argument_buffer_type(type) && var.storage != StorageClassPushConstant) { uint32_t desc_set = get_decoration(var_id, DecorationDescriptorSet); if (descriptor_set_is_argument_buffer(desc_set)) return; } const MSLConstexprSampler *constexpr_sampler = nullptr; if (type.basetype == SPIRType::SampledImage || type.basetype == SPIRType::Sampler) { constexpr_sampler = find_constexpr_sampler(var_id); if (constexpr_sampler) { // Mark this ID as a constexpr sampler for later in case it came from set/bindings. constexpr_samplers_by_id[var_id] = *constexpr_sampler; } } // Emulate texture2D atomic operations uint32_t secondary_index = 0; if (atomic_image_vars.count(var.self)) { secondary_index = get_metal_resource_index(var, SPIRType::AtomicCounter, 0); } if (type.basetype == SPIRType::SampledImage) { add_resource_name(var_id); uint32_t plane_count = 1; if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable) plane_count = constexpr_sampler->planes; for (uint32_t i = 0; i < plane_count; i++) resources.push_back({ &var, to_name(var_id), SPIRType::Image, get_metal_resource_index(var, SPIRType::Image, i), i, secondary_index }); if (type.image.dim != DimBuffer && !constexpr_sampler) { resources.push_back({ &var, to_sampler_expression(var_id), SPIRType::Sampler, get_metal_resource_index(var, SPIRType::Sampler), 0, 0 }); } } else if (!constexpr_sampler) { // constexpr samplers are not declared as resources. add_resource_name(var_id); resources.push_back({ &var, to_name(var_id), type.basetype, get_metal_resource_index(var, type.basetype), 0, secondary_index }); } } }); sort(resources.begin(), resources.end(), [](const Resource &lhs, const Resource &rhs) { return tie(lhs.basetype, lhs.index) < tie(rhs.basetype, rhs.index); }); for (auto &r : resources) { auto &var = *r.var; auto &type = get_variable_data_type(var); uint32_t var_id = var.self; switch (r.basetype) { case SPIRType::Struct: { auto &m = ir.meta[type.self]; if (m.members.size() == 0) break; if (!type.array.empty()) { if (type.array.size() > 1) SPIRV_CROSS_THROW("Arrays of arrays of buffers are not supported."); // Metal doesn't directly support this, so we must expand the // array. We'll declare a local array to hold these elements // later. uint32_t array_size = to_array_size_literal(type); if (array_size == 0) SPIRV_CROSS_THROW("Unsized arrays of buffers are not supported in MSL."); // Allow Metal to use the array template to make arrays a value type is_using_builtin_array = true; buffer_arrays.push_back(var_id); for (uint32_t i = 0; i < array_size; ++i) { if (!ep_args.empty()) ep_args += ", "; ep_args += get_argument_address_space(var) + " " + type_to_glsl(type) + "* " + to_restrict(var_id) + r.name + "_" + convert_to_string(i); ep_args += " [[buffer(" + convert_to_string(r.index + i) + ")"; if (interlocked_resources.count(var_id)) ep_args += ", raster_order_group(0)"; ep_args += "]]"; } is_using_builtin_array = false; } else { if (!ep_args.empty()) ep_args += ", "; ep_args += get_argument_address_space(var) + " " + type_to_glsl(type) + "& " + to_restrict(var_id) + r.name; ep_args += " [[buffer(" + convert_to_string(r.index) + ")"; if (interlocked_resources.count(var_id)) ep_args += ", raster_order_group(0)"; ep_args += "]]"; } break; } case SPIRType::Sampler: if (!ep_args.empty()) ep_args += ", "; ep_args += sampler_type(type, var_id) + " " + r.name; ep_args += " [[sampler(" + convert_to_string(r.index) + ")]]"; break; case SPIRType::Image: { if (!ep_args.empty()) ep_args += ", "; // Use Metal's native frame-buffer fetch API for subpass inputs. const auto &basetype = get(var.basetype); if (!type_is_msl_framebuffer_fetch(basetype)) { ep_args += image_type_glsl(type, var_id) + " " + r.name; if (r.plane > 0) ep_args += join(plane_name_suffix, r.plane); ep_args += " [[texture(" + convert_to_string(r.index) + ")"; if (interlocked_resources.count(var_id)) ep_args += ", raster_order_group(0)"; ep_args += "]]"; } else { if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 3)) SPIRV_CROSS_THROW("Framebuffer fetch on Mac is not supported before MSL 2.3."); ep_args += image_type_glsl(type, var_id) + " " + r.name; ep_args += " [[color(" + convert_to_string(r.index) + ")]]"; } // Emulate texture2D atomic operations if (atomic_image_vars.count(var.self)) { ep_args += ", device atomic_" + type_to_glsl(get(basetype.image.type), 0); ep_args += "* " + r.name + "_atomic"; ep_args += " [[buffer(" + convert_to_string(r.secondary_index) + ")"; if (interlocked_resources.count(var_id)) ep_args += ", raster_order_group(0)"; ep_args += "]]"; } break; } default: if (!ep_args.empty()) ep_args += ", "; if (!type.pointer) ep_args += get_type_address_space(get(var.basetype), var_id) + " " + type_to_glsl(type, var_id) + "& " + r.name; else ep_args += type_to_glsl(type, var_id) + " " + r.name; ep_args += " [[buffer(" + convert_to_string(r.index) + ")"; if (interlocked_resources.count(var_id)) ep_args += ", raster_order_group(0)"; ep_args += "]]"; break; } } } // Returns a string containing a comma-delimited list of args for the entry point function // This is the "classic" method of MSL 1 when we don't have argument buffer support. string CompilerMSL::entry_point_args_classic(bool append_comma) { string ep_args = entry_point_arg_stage_in(); entry_point_args_discrete_descriptors(ep_args); entry_point_args_builtin(ep_args); if (!ep_args.empty() && append_comma) ep_args += ", "; return ep_args; } void CompilerMSL::fix_up_shader_inputs_outputs() { auto &entry_func = this->get(ir.default_entry_point); // Emit a guard to ensure we don't execute beyond the last vertex. // Vertex shaders shouldn't have the problems with barriers in non-uniform control flow that // tessellation control shaders do, so early returns should be OK. We may need to revisit this // if it ever becomes possible to use barriers from a vertex shader. if (get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation) { entry_func.fixup_hooks_in.push_back([this]() { statement("if (any(", to_expression(builtin_invocation_id_id), " >= ", to_expression(builtin_stage_input_size_id), "))"); statement(" return;"); }); } // Look for sampled images and buffer. Add hooks to set up the swizzle constants or array lengths. ir.for_each_typed_id([&](uint32_t, SPIRVariable &var) { auto &type = get_variable_data_type(var); uint32_t var_id = var.self; bool ssbo = has_decoration(type.self, DecorationBufferBlock); if (var.storage == StorageClassUniformConstant && !is_hidden_variable(var)) { if (msl_options.swizzle_texture_samples && has_sampled_images && is_sampled_image_type(type)) { entry_func.fixup_hooks_in.push_back([this, &type, &var, var_id]() { bool is_array_type = !type.array.empty(); uint32_t desc_set = get_decoration(var_id, DecorationDescriptorSet); if (descriptor_set_is_argument_buffer(desc_set)) { statement("constant uint", is_array_type ? "* " : "& ", to_swizzle_expression(var_id), is_array_type ? " = &" : " = ", to_name(argument_buffer_ids[desc_set]), ".spvSwizzleConstants", "[", convert_to_string(get_metal_resource_index(var, SPIRType::Image)), "];"); } else { // If we have an array of images, we need to be able to index into it, so take a pointer instead. statement("constant uint", is_array_type ? "* " : "& ", to_swizzle_expression(var_id), is_array_type ? " = &" : " = ", to_name(swizzle_buffer_id), "[", convert_to_string(get_metal_resource_index(var, SPIRType::Image)), "];"); } }); } } else if ((var.storage == StorageClassStorageBuffer || (var.storage == StorageClassUniform && ssbo)) && !is_hidden_variable(var)) { if (buffers_requiring_array_length.count(var.self)) { entry_func.fixup_hooks_in.push_back([this, &type, &var, var_id]() { bool is_array_type = !type.array.empty(); uint32_t desc_set = get_decoration(var_id, DecorationDescriptorSet); if (descriptor_set_is_argument_buffer(desc_set)) { statement("constant uint", is_array_type ? "* " : "& ", to_buffer_size_expression(var_id), is_array_type ? " = &" : " = ", to_name(argument_buffer_ids[desc_set]), ".spvBufferSizeConstants", "[", convert_to_string(get_metal_resource_index(var, SPIRType::Image)), "];"); } else { // If we have an array of images, we need to be able to index into it, so take a pointer instead. statement("constant uint", is_array_type ? "* " : "& ", to_buffer_size_expression(var_id), is_array_type ? " = &" : " = ", to_name(buffer_size_buffer_id), "[", convert_to_string(get_metal_resource_index(var, type.basetype)), "];"); } }); } } }); // Builtin variables ir.for_each_typed_id([this, &entry_func](uint32_t, SPIRVariable &var) { uint32_t var_id = var.self; BuiltIn bi_type = ir.meta[var_id].decoration.builtin_type; if (var.storage != StorageClassInput && var.storage != StorageClassOutput) return; if (!interface_variable_exists_in_entry_point(var.self)) return; if (var.storage == StorageClassInput && is_builtin_variable(var) && active_input_builtins.get(bi_type)) { switch (bi_type) { case BuiltInSamplePosition: entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = get_sample_position(", to_expression(builtin_sample_id_id), ");"); }); break; case BuiltInFragCoord: if (is_sample_rate()) { entry_func.fixup_hooks_in.push_back([=]() { statement(to_expression(var_id), ".xy += get_sample_position(", to_expression(builtin_sample_id_id), ") - 0.5;"); }); } break; case BuiltInHelperInvocation: if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 3)) SPIRV_CROSS_THROW("simd_is_helper_thread() requires version 2.3 on iOS."); else if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("simd_is_helper_thread() requires version 2.1 on macOS."); entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = simd_is_helper_thread();"); }); break; case BuiltInInvocationId: // This is direct-mapped without multi-patch workgroups. if (get_execution_model() != ExecutionModelTessellationControl || !msl_options.multi_patch_workgroup) break; entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(builtin_invocation_id_id), ".x % ", this->get_entry_point().output_vertices, ";"); }); break; case BuiltInPrimitiveId: // This is natively supported by fragment and tessellation evaluation shaders. // In tessellation control shaders, this is direct-mapped without multi-patch workgroups. if (get_execution_model() != ExecutionModelTessellationControl || !msl_options.multi_patch_workgroup) break; entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = min(", to_expression(builtin_invocation_id_id), ".x / ", this->get_entry_point().output_vertices, ", spvIndirectParams[1]);"); }); break; case BuiltInPatchVertices: if (get_execution_model() == ExecutionModelTessellationEvaluation) entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(patch_stage_in_var_id), ".gl_in.size();"); }); else entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = spvIndirectParams[0];"); }); break; case BuiltInTessCoord: // Emit a fixup to account for the shifted domain. Don't do this for triangles; // MoltenVK will just reverse the winding order instead. if (msl_options.tess_domain_origin_lower_left && !get_entry_point().flags.get(ExecutionModeTriangles)) { string tc = to_expression(var_id); entry_func.fixup_hooks_in.push_back([=]() { statement(tc, ".y = 1.0 - ", tc, ".y;"); }); } break; case BuiltInSubgroupId: if (!msl_options.emulate_subgroups) break; // For subgroup emulation, this is the same as the local invocation index. entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(builtin_local_invocation_index_id), ";"); }); break; case BuiltInNumSubgroups: if (!msl_options.emulate_subgroups) break; // For subgroup emulation, this is the same as the workgroup size. entry_func.fixup_hooks_in.push_back([=]() { auto &type = expression_type(builtin_workgroup_size_id); string size_expr = to_expression(builtin_workgroup_size_id); if (type.vecsize >= 3) size_expr = join(size_expr, ".x * ", size_expr, ".y * ", size_expr, ".z"); else if (type.vecsize == 2) size_expr = join(size_expr, ".x * ", size_expr, ".y"); statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", size_expr, ";"); }); break; case BuiltInSubgroupLocalInvocationId: if (!msl_options.emulate_subgroups) break; // For subgroup emulation, assume subgroups of size 1. entry_func.fixup_hooks_in.push_back( [=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = 0;"); }); break; case BuiltInSubgroupSize: if (msl_options.emulate_subgroups) { // For subgroup emulation, assume subgroups of size 1. entry_func.fixup_hooks_in.push_back( [=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = 1;"); }); } else if (msl_options.fixed_subgroup_size != 0) { entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", msl_options.fixed_subgroup_size, ";"); }); } break; case BuiltInSubgroupEqMask: if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.2 on iOS."); if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1."); entry_func.fixup_hooks_in.push_back([=]() { if (msl_options.is_ios()) { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", "uint4(1 << ", to_expression(builtin_subgroup_invocation_id_id), ", uint3(0));"); } else { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(builtin_subgroup_invocation_id_id), " >= 32 ? uint4(0, (1 << (", to_expression(builtin_subgroup_invocation_id_id), " - 32)), uint2(0)) : uint4(1 << ", to_expression(builtin_subgroup_invocation_id_id), ", uint3(0));"); } }); break; case BuiltInSubgroupGeMask: if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.2 on iOS."); if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1."); if (msl_options.fixed_subgroup_size != 0) add_spv_func_and_recompile(SPVFuncImplSubgroupBallot); entry_func.fixup_hooks_in.push_back([=]() { // Case where index < 32, size < 32: // mask0 = bfi(0, 0xFFFFFFFF, index, size - index); // mask1 = bfi(0, 0xFFFFFFFF, 0, 0); // Gives 0 // Case where index < 32 but size >= 32: // mask0 = bfi(0, 0xFFFFFFFF, index, 32 - index); // mask1 = bfi(0, 0xFFFFFFFF, 0, size - 32); // Case where index >= 32: // mask0 = bfi(0, 0xFFFFFFFF, 32, 0); // Gives 0 // mask1 = bfi(0, 0xFFFFFFFF, index - 32, size - index); // This is expressed without branches to avoid divergent // control flow--hence the complicated min/max expressions. // This is further complicated by the fact that if you attempt // to bfi/bfe out-of-bounds on Metal, undefined behavior is the // result. if (msl_options.fixed_subgroup_size > 32) { // Don't use the subgroup size variable with fixed subgroup sizes, // since the variables could be defined in the wrong order. statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(insert_bits(0u, 0xFFFFFFFF, min(", to_expression(builtin_subgroup_invocation_id_id), ", 32u), (uint)max(32 - (int)", to_expression(builtin_subgroup_invocation_id_id), ", 0)), insert_bits(0u, 0xFFFFFFFF," " (uint)max((int)", to_expression(builtin_subgroup_invocation_id_id), " - 32, 0), ", msl_options.fixed_subgroup_size, " - max(", to_expression(builtin_subgroup_invocation_id_id), ", 32u)), uint2(0));"); } else if (msl_options.fixed_subgroup_size != 0) { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(insert_bits(0u, 0xFFFFFFFF, ", to_expression(builtin_subgroup_invocation_id_id), ", ", msl_options.fixed_subgroup_size, " - ", to_expression(builtin_subgroup_invocation_id_id), "), uint3(0));"); } else if (msl_options.is_ios()) { // On iOS, the SIMD-group size will currently never exceed 32. statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(insert_bits(0u, 0xFFFFFFFF, ", to_expression(builtin_subgroup_invocation_id_id), ", ", to_expression(builtin_subgroup_size_id), " - ", to_expression(builtin_subgroup_invocation_id_id), "), uint3(0));"); } else { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(insert_bits(0u, 0xFFFFFFFF, min(", to_expression(builtin_subgroup_invocation_id_id), ", 32u), (uint)max(min((int)", to_expression(builtin_subgroup_size_id), ", 32) - (int)", to_expression(builtin_subgroup_invocation_id_id), ", 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)", to_expression(builtin_subgroup_invocation_id_id), " - 32, 0), (uint)max((int)", to_expression(builtin_subgroup_size_id), " - (int)max(", to_expression(builtin_subgroup_invocation_id_id), ", 32u), 0)), uint2(0));"); } }); break; case BuiltInSubgroupGtMask: if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.2 on iOS."); if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1."); add_spv_func_and_recompile(SPVFuncImplSubgroupBallot); entry_func.fixup_hooks_in.push_back([=]() { // The same logic applies here, except now the index is one // more than the subgroup invocation ID. if (msl_options.fixed_subgroup_size > 32) { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(insert_bits(0u, 0xFFFFFFFF, min(", to_expression(builtin_subgroup_invocation_id_id), " + 1, 32u), (uint)max(32 - (int)", to_expression(builtin_subgroup_invocation_id_id), " - 1, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)", to_expression(builtin_subgroup_invocation_id_id), " + 1 - 32, 0), ", msl_options.fixed_subgroup_size, " - max(", to_expression(builtin_subgroup_invocation_id_id), " + 1, 32u)), uint2(0));"); } else if (msl_options.fixed_subgroup_size != 0) { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(insert_bits(0u, 0xFFFFFFFF, ", to_expression(builtin_subgroup_invocation_id_id), " + 1, ", msl_options.fixed_subgroup_size, " - ", to_expression(builtin_subgroup_invocation_id_id), " - 1), uint3(0));"); } else if (msl_options.is_ios()) { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(insert_bits(0u, 0xFFFFFFFF, ", to_expression(builtin_subgroup_invocation_id_id), " + 1, ", to_expression(builtin_subgroup_size_id), " - ", to_expression(builtin_subgroup_invocation_id_id), " - 1), uint3(0));"); } else { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(insert_bits(0u, 0xFFFFFFFF, min(", to_expression(builtin_subgroup_invocation_id_id), " + 1, 32u), (uint)max(min((int)", to_expression(builtin_subgroup_size_id), ", 32) - (int)", to_expression(builtin_subgroup_invocation_id_id), " - 1, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)", to_expression(builtin_subgroup_invocation_id_id), " + 1 - 32, 0), (uint)max((int)", to_expression(builtin_subgroup_size_id), " - (int)max(", to_expression(builtin_subgroup_invocation_id_id), " + 1, 32u), 0)), uint2(0));"); } }); break; case BuiltInSubgroupLeMask: if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.2 on iOS."); if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1."); add_spv_func_and_recompile(SPVFuncImplSubgroupBallot); entry_func.fixup_hooks_in.push_back([=]() { if (msl_options.is_ios()) { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(extract_bits(0xFFFFFFFF, 0, ", to_expression(builtin_subgroup_invocation_id_id), " + 1), uint3(0));"); } else { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(extract_bits(0xFFFFFFFF, 0, min(", to_expression(builtin_subgroup_invocation_id_id), " + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)", to_expression(builtin_subgroup_invocation_id_id), " + 1 - 32, 0)), uint2(0));"); } }); break; case BuiltInSubgroupLtMask: if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.2 on iOS."); if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1."); add_spv_func_and_recompile(SPVFuncImplSubgroupBallot); entry_func.fixup_hooks_in.push_back([=]() { if (msl_options.is_ios()) { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(extract_bits(0xFFFFFFFF, 0, ", to_expression(builtin_subgroup_invocation_id_id), "), uint3(0));"); } else { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = uint4(extract_bits(0xFFFFFFFF, 0, min(", to_expression(builtin_subgroup_invocation_id_id), ", 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)", to_expression(builtin_subgroup_invocation_id_id), " - 32, 0)), uint2(0));"); } }); break; case BuiltInViewIndex: if (!msl_options.multiview) { // According to the Vulkan spec, when not running under a multiview // render pass, ViewIndex is 0. entry_func.fixup_hooks_in.push_back([=]() { statement("const ", builtin_type_decl(bi_type), " ", to_expression(var_id), " = 0;"); }); } else if (msl_options.view_index_from_device_index) { // In this case, we take the view index from that of the device we're running on. entry_func.fixup_hooks_in.push_back([=]() { statement("const ", builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", msl_options.device_index, ";"); }); // We actually don't want to set the render_target_array_index here. // Since every physical device is rendering a different view, // there's no need for layered rendering here. } else if (!msl_options.multiview_layered_rendering) { // In this case, the views are rendered one at a time. The view index, then, // is just the first part of the "view mask". entry_func.fixup_hooks_in.push_back([=]() { statement("const ", builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(view_mask_buffer_id), "[0];"); }); } else if (get_execution_model() == ExecutionModelFragment) { // Because we adjusted the view index in the vertex shader, we have to // adjust it back here. entry_func.fixup_hooks_in.push_back([=]() { statement(to_expression(var_id), " += ", to_expression(view_mask_buffer_id), "[0];"); }); } else if (get_execution_model() == ExecutionModelVertex) { // Metal provides no special support for multiview, so we smuggle // the view index in the instance index. entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(view_mask_buffer_id), "[0] + (", to_expression(builtin_instance_idx_id), " - ", to_expression(builtin_base_instance_id), ") % ", to_expression(view_mask_buffer_id), "[1];"); statement(to_expression(builtin_instance_idx_id), " = (", to_expression(builtin_instance_idx_id), " - ", to_expression(builtin_base_instance_id), ") / ", to_expression(view_mask_buffer_id), "[1] + ", to_expression(builtin_base_instance_id), ";"); }); // In addition to setting the variable itself, we also need to // set the render_target_array_index with it on output. We have to // offset this by the base view index, because Metal isn't in on // our little game here. entry_func.fixup_hooks_out.push_back([=]() { statement(to_expression(builtin_layer_id), " = ", to_expression(var_id), " - ", to_expression(view_mask_buffer_id), "[0];"); }); } break; case BuiltInDeviceIndex: // Metal pipelines belong to the devices which create them, so we'll // need to create a MTLPipelineState for every MTLDevice in a grouped // VkDevice. We can assume, then, that the device index is constant. entry_func.fixup_hooks_in.push_back([=]() { statement("const ", builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", msl_options.device_index, ";"); }); break; case BuiltInWorkgroupId: if (!msl_options.dispatch_base || !active_input_builtins.get(BuiltInWorkgroupId)) break; // The vkCmdDispatchBase() command lets the client set the base value // of WorkgroupId. Metal has no direct equivalent; we must make this // adjustment ourselves. entry_func.fixup_hooks_in.push_back([=]() { statement(to_expression(var_id), " += ", to_dereferenced_expression(builtin_dispatch_base_id), ";"); }); break; case BuiltInGlobalInvocationId: if (!msl_options.dispatch_base || !active_input_builtins.get(BuiltInGlobalInvocationId)) break; // GlobalInvocationId is defined as LocalInvocationId + WorkgroupId * WorkgroupSize. // This needs to be adjusted too. entry_func.fixup_hooks_in.push_back([=]() { auto &execution = this->get_entry_point(); uint32_t workgroup_size_id = execution.workgroup_size.constant; if (workgroup_size_id) statement(to_expression(var_id), " += ", to_dereferenced_expression(builtin_dispatch_base_id), " * ", to_expression(workgroup_size_id), ";"); else statement(to_expression(var_id), " += ", to_dereferenced_expression(builtin_dispatch_base_id), " * uint3(", execution.workgroup_size.x, ", ", execution.workgroup_size.y, ", ", execution.workgroup_size.z, ");"); }); break; case BuiltInVertexId: case BuiltInVertexIndex: // This is direct-mapped normally. if (!msl_options.vertex_for_tessellation) break; entry_func.fixup_hooks_in.push_back([=]() { builtin_declaration = true; switch (msl_options.vertex_index_type) { case Options::IndexType::None: statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(builtin_invocation_id_id), ".x + ", to_expression(builtin_dispatch_base_id), ".x;"); break; case Options::IndexType::UInt16: case Options::IndexType::UInt32: statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", index_buffer_var_name, "[", to_expression(builtin_invocation_id_id), ".x] + ", to_expression(builtin_dispatch_base_id), ".x;"); break; } builtin_declaration = false; }); break; case BuiltInBaseVertex: // This is direct-mapped normally. if (!msl_options.vertex_for_tessellation) break; entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(builtin_dispatch_base_id), ".x;"); }); break; case BuiltInInstanceId: case BuiltInInstanceIndex: // This is direct-mapped normally. if (!msl_options.vertex_for_tessellation) break; entry_func.fixup_hooks_in.push_back([=]() { builtin_declaration = true; statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(builtin_invocation_id_id), ".y + ", to_expression(builtin_dispatch_base_id), ".y;"); builtin_declaration = false; }); break; case BuiltInBaseInstance: // This is direct-mapped normally. if (!msl_options.vertex_for_tessellation) break; entry_func.fixup_hooks_in.push_back([=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", to_expression(builtin_dispatch_base_id), ".y;"); }); break; default: break; } } else if (var.storage == StorageClassOutput && is_builtin_variable(var) && active_output_builtins.get(bi_type)) { if (bi_type == BuiltInSampleMask && get_execution_model() == ExecutionModelFragment && msl_options.additional_fixed_sample_mask != 0xffffffff) { // If the additional fixed sample mask was set, we need to adjust the sample_mask // output to reflect that. If the shader outputs the sample_mask itself too, we need // to AND the two masks to get the final one. if (does_shader_write_sample_mask) { entry_func.fixup_hooks_out.push_back([=]() { statement(to_expression(builtin_sample_mask_id), " &= ", msl_options.additional_fixed_sample_mask, ";"); }); } else { entry_func.fixup_hooks_out.push_back([=]() { statement(to_expression(builtin_sample_mask_id), " = ", msl_options.additional_fixed_sample_mask, ";"); }); } } } }); } // Returns the Metal index of the resource of the specified type as used by the specified variable. uint32_t CompilerMSL::get_metal_resource_index(SPIRVariable &var, SPIRType::BaseType basetype, uint32_t plane) { auto &execution = get_entry_point(); auto &var_dec = ir.meta[var.self].decoration; auto &var_type = get(var.basetype); uint32_t var_desc_set = (var.storage == StorageClassPushConstant) ? kPushConstDescSet : var_dec.set; uint32_t var_binding = (var.storage == StorageClassPushConstant) ? kPushConstBinding : var_dec.binding; // If a matching binding has been specified, find and use it. auto itr = resource_bindings.find({ execution.model, var_desc_set, var_binding }); // Atomic helper buffers for image atomics need to use secondary bindings as well. bool use_secondary_binding = (var_type.basetype == SPIRType::SampledImage && basetype == SPIRType::Sampler) || basetype == SPIRType::AtomicCounter; auto resource_decoration = use_secondary_binding ? SPIRVCrossDecorationResourceIndexSecondary : SPIRVCrossDecorationResourceIndexPrimary; if (plane == 1) resource_decoration = SPIRVCrossDecorationResourceIndexTertiary; if (plane == 2) resource_decoration = SPIRVCrossDecorationResourceIndexQuaternary; if (itr != end(resource_bindings)) { auto &remap = itr->second; remap.second = true; switch (basetype) { case SPIRType::Image: set_extended_decoration(var.self, resource_decoration, remap.first.msl_texture + plane); return remap.first.msl_texture + plane; case SPIRType::Sampler: set_extended_decoration(var.self, resource_decoration, remap.first.msl_sampler); return remap.first.msl_sampler; default: set_extended_decoration(var.self, resource_decoration, remap.first.msl_buffer); return remap.first.msl_buffer; } } // If we have already allocated an index, keep using it. if (has_extended_decoration(var.self, resource_decoration)) return get_extended_decoration(var.self, resource_decoration); auto &type = get(var.basetype); if (type_is_msl_framebuffer_fetch(type)) { // Frame-buffer fetch gets its fallback resource index from the input attachment index, // which is then treated as color index. return get_decoration(var.self, DecorationInputAttachmentIndex); } else if (msl_options.enable_decoration_binding) { // Allow user to enable decoration binding. // If there is no explicit mapping of bindings to MSL, use the declared binding as a fallback. if (has_decoration(var.self, DecorationBinding)) { var_binding = get_decoration(var.self, DecorationBinding); // Avoid emitting sentinel bindings. if (var_binding < 0x80000000u) return var_binding; } } // If we did not explicitly remap, allocate bindings on demand. // We cannot reliably use Binding decorations since SPIR-V and MSL's binding models are very different. bool allocate_argument_buffer_ids = false; if (var.storage != StorageClassPushConstant) allocate_argument_buffer_ids = descriptor_set_is_argument_buffer(var_desc_set); uint32_t binding_stride = 1; for (uint32_t i = 0; i < uint32_t(type.array.size()); i++) binding_stride *= to_array_size_literal(type, i); assert(binding_stride != 0); // If a binding has not been specified, revert to incrementing resource indices. uint32_t resource_index; if (allocate_argument_buffer_ids) { // Allocate from a flat ID binding space. resource_index = next_metal_resource_ids[var_desc_set]; next_metal_resource_ids[var_desc_set] += binding_stride; } else { // Allocate from plain bindings which are allocated per resource type. switch (basetype) { case SPIRType::Image: resource_index = next_metal_resource_index_texture; next_metal_resource_index_texture += binding_stride; break; case SPIRType::Sampler: resource_index = next_metal_resource_index_sampler; next_metal_resource_index_sampler += binding_stride; break; default: resource_index = next_metal_resource_index_buffer; next_metal_resource_index_buffer += binding_stride; break; } } set_extended_decoration(var.self, resource_decoration, resource_index); return resource_index; } bool CompilerMSL::type_is_msl_framebuffer_fetch(const SPIRType &type) const { return type.basetype == SPIRType::Image && type.image.dim == DimSubpassData && msl_options.use_framebuffer_fetch_subpasses; } string CompilerMSL::argument_decl(const SPIRFunction::Parameter &arg) { auto &var = get(arg.id); auto &type = get_variable_data_type(var); auto &var_type = get(arg.type); StorageClass storage = var_type.storage; bool is_pointer = var_type.pointer; // If we need to modify the name of the variable, make sure we use the original variable. // Our alias is just a shadow variable. uint32_t name_id = var.self; if (arg.alias_global_variable && var.basevariable) name_id = var.basevariable; bool constref = !arg.alias_global_variable && is_pointer && arg.write_count == 0; // Framebuffer fetch is plain value, const looks out of place, but it is not wrong. if (type_is_msl_framebuffer_fetch(type)) constref = false; bool type_is_image = type.basetype == SPIRType::Image || type.basetype == SPIRType::SampledImage || type.basetype == SPIRType::Sampler; // Arrays of images/samplers in MSL are always const. if (!type.array.empty() && type_is_image) constref = true; string decl; if (constref) decl += "const "; // If this is a combined image-sampler for a 2D image with floating-point type, // we emitted the 'spvDynamicImageSampler' type, and this is *not* an alias parameter // for a global, then we need to emit a "dynamic" combined image-sampler. // Unfortunately, this is necessary to properly support passing around // combined image-samplers with Y'CbCr conversions on them. bool is_dynamic_img_sampler = !arg.alias_global_variable && type.basetype == SPIRType::SampledImage && type.image.dim == Dim2D && type_is_floating_point(get(type.image.type)) && spv_function_implementations.count(SPVFuncImplDynamicImageSampler); // Allow Metal to use the array template to make arrays a value type string address_space = get_argument_address_space(var); bool builtin = is_builtin_variable(var); is_using_builtin_array = builtin; if (address_space == "threadgroup") is_using_builtin_array = true; if (var.basevariable && (var.basevariable == stage_in_ptr_var_id || var.basevariable == stage_out_ptr_var_id)) decl += type_to_glsl(type, arg.id); else if (builtin) decl += builtin_type_decl(static_cast(get_decoration(arg.id, DecorationBuiltIn)), arg.id); else if ((storage == StorageClassUniform || storage == StorageClassStorageBuffer) && is_array(type)) { is_using_builtin_array = true; decl += join(type_to_glsl(type, arg.id), "*"); } else if (is_dynamic_img_sampler) { decl += join("spvDynamicImageSampler<", type_to_glsl(get(type.image.type)), ">"); // Mark the variable so that we can handle passing it to another function. set_extended_decoration(arg.id, SPIRVCrossDecorationDynamicImageSampler); } else decl += type_to_glsl(type, arg.id); bool opaque_handle = storage == StorageClassUniformConstant; if (!builtin && !opaque_handle && !is_pointer && (storage == StorageClassFunction || storage == StorageClassGeneric)) { // If the argument is a pure value and not an opaque type, we will pass by value. if (msl_options.force_native_arrays && is_array(type)) { // We are receiving an array by value. This is problematic. // We cannot be sure of the target address space since we are supposed to receive a copy, // but this is not possible with MSL without some extra work. // We will have to assume we're getting a reference in thread address space. // If we happen to get a reference in constant address space, the caller must emit a copy and pass that. // Thread const therefore becomes the only logical choice, since we cannot "create" a constant array from // non-constant arrays, but we can create thread const from constant. decl = string("thread const ") + decl; decl += " (&"; const char *restrict_kw = to_restrict(name_id); if (*restrict_kw) { decl += " "; decl += restrict_kw; } decl += to_expression(name_id); decl += ")"; decl += type_to_array_glsl(type); } else { if (!address_space.empty()) decl = join(address_space, " ", decl); decl += " "; decl += to_expression(name_id); } } else if (is_array(type) && !type_is_image) { // Arrays of images and samplers are special cased. if (!address_space.empty()) decl = join(address_space, " ", decl); if (msl_options.argument_buffers) { uint32_t desc_set = get_decoration(name_id, DecorationDescriptorSet); if ((storage == StorageClassUniform || storage == StorageClassStorageBuffer) && descriptor_set_is_argument_buffer(desc_set)) { // An awkward case where we need to emit *more* address space declarations (yay!). // An example is where we pass down an array of buffer pointers to leaf functions. // It's a constant array containing pointers to constants. // The pointer array is always constant however. E.g. // device SSBO * constant (&array)[N]. // const device SSBO * constant (&array)[N]. // constant SSBO * constant (&array)[N]. // However, this only matters for argument buffers, since for MSL 1.0 style codegen, // we emit the buffer array on stack instead, and that seems to work just fine apparently. // If the argument was marked as being in device address space, any pointer to member would // be const device, not constant. if (argument_buffer_device_storage_mask & (1u << desc_set)) decl += " const device"; else decl += " constant"; } } decl += " (&"; const char *restrict_kw = to_restrict(name_id); if (*restrict_kw) { decl += " "; decl += restrict_kw; } decl += to_expression(name_id); decl += ")"; decl += type_to_array_glsl(type); } else if (!opaque_handle && (!pull_model_inputs.count(var.basevariable) || type.basetype == SPIRType::Struct)) { // If this is going to be a reference to a variable pointer, the address space // for the reference has to go before the '&', but after the '*'. if (!address_space.empty()) { if (decl.back() == '*') decl += join(" ", address_space, " "); else decl = join(address_space, " ", decl); } decl += "&"; decl += " "; decl += to_restrict(name_id); decl += to_expression(name_id); } else { if (!address_space.empty()) decl = join(address_space, " ", decl); decl += " "; decl += to_expression(name_id); } // Emulate texture2D atomic operations auto *backing_var = maybe_get_backing_variable(name_id); if (backing_var && atomic_image_vars.count(backing_var->self)) { decl += ", device atomic_" + type_to_glsl(get(var_type.image.type), 0); decl += "* " + to_expression(name_id) + "_atomic"; } is_using_builtin_array = false; return decl; } // If we're currently in the entry point function, and the object // has a qualified name, use it, otherwise use the standard name. string CompilerMSL::to_name(uint32_t id, bool allow_alias) const { if (current_function && (current_function->self == ir.default_entry_point)) { auto *m = ir.find_meta(id); if (m && !m->decoration.qualified_alias.empty()) return m->decoration.qualified_alias; } return Compiler::to_name(id, allow_alias); } // Returns a name that combines the name of the struct with the name of the member, except for Builtins string CompilerMSL::to_qualified_member_name(const SPIRType &type, uint32_t index) { // Don't qualify Builtin names because they are unique and are treated as such when building expressions BuiltIn builtin = BuiltInMax; if (is_member_builtin(type, index, &builtin)) return builtin_to_glsl(builtin, type.storage); // Strip any underscore prefix from member name string mbr_name = to_member_name(type, index); size_t startPos = mbr_name.find_first_not_of("_"); mbr_name = (startPos != string::npos) ? mbr_name.substr(startPos) : ""; return join(to_name(type.self), "_", mbr_name); } // Ensures that the specified name is permanently usable by prepending a prefix // if the first chars are _ and a digit, which indicate a transient name. string CompilerMSL::ensure_valid_name(string name, string pfx) { return (name.size() >= 2 && name[0] == '_' && isdigit(name[1])) ? (pfx + name) : name; } const std::unordered_set &CompilerMSL::get_reserved_keyword_set() { static const unordered_set keywords = { "kernel", "vertex", "fragment", "compute", "bias", "level", "gradient2d", "gradientcube", "gradient3d", "min_lod_clamp", "assert", "VARIABLE_TRACEPOINT", "STATIC_DATA_TRACEPOINT", "STATIC_DATA_TRACEPOINT_V", "METAL_ALIGN", "METAL_ASM", "METAL_CONST", "METAL_DEPRECATED", "METAL_ENABLE_IF", "METAL_FUNC", "METAL_INTERNAL", "METAL_NON_NULL_RETURN", "METAL_NORETURN", "METAL_NOTHROW", "METAL_PURE", "METAL_UNAVAILABLE", "METAL_IMPLICIT", "METAL_EXPLICIT", "METAL_CONST_ARG", "METAL_ARG_UNIFORM", "METAL_ZERO_ARG", "METAL_VALID_LOD_ARG", "METAL_VALID_LEVEL_ARG", "METAL_VALID_STORE_ORDER", "METAL_VALID_LOAD_ORDER", "METAL_VALID_COMPARE_EXCHANGE_FAILURE_ORDER", "METAL_COMPATIBLE_COMPARE_EXCHANGE_ORDERS", "METAL_VALID_RENDER_TARGET", "is_function_constant_defined", "CHAR_BIT", "SCHAR_MAX", "SCHAR_MIN", "UCHAR_MAX", "CHAR_MAX", "CHAR_MIN", "USHRT_MAX", "SHRT_MAX", "SHRT_MIN", "UINT_MAX", "INT_MAX", "INT_MIN", "FLT_DIG", "FLT_MANT_DIG", "FLT_MAX_10_EXP", "FLT_MAX_EXP", "FLT_MIN_10_EXP", "FLT_MIN_EXP", "FLT_RADIX", "FLT_MAX", "FLT_MIN", "FLT_EPSILON", "FP_ILOGB0", "FP_ILOGBNAN", "MAXFLOAT", "HUGE_VALF", "INFINITY", "NAN", "M_E_F", "M_LOG2E_F", "M_LOG10E_F", "M_LN2_F", "M_LN10_F", "M_PI_F", "M_PI_2_F", "M_PI_4_F", "M_1_PI_F", "M_2_PI_F", "M_2_SQRTPI_F", "M_SQRT2_F", "M_SQRT1_2_F", "HALF_DIG", "HALF_MANT_DIG", "HALF_MAX_10_EXP", "HALF_MAX_EXP", "HALF_MIN_10_EXP", "HALF_MIN_EXP", "HALF_RADIX", "HALF_MAX", "HALF_MIN", "HALF_EPSILON", "MAXHALF", "HUGE_VALH", "M_E_H", "M_LOG2E_H", "M_LOG10E_H", "M_LN2_H", "M_LN10_H", "M_PI_H", "M_PI_2_H", "M_PI_4_H", "M_1_PI_H", "M_2_PI_H", "M_2_SQRTPI_H", "M_SQRT2_H", "M_SQRT1_2_H", "DBL_DIG", "DBL_MANT_DIG", "DBL_MAX_10_EXP", "DBL_MAX_EXP", "DBL_MIN_10_EXP", "DBL_MIN_EXP", "DBL_RADIX", "DBL_MAX", "DBL_MIN", "DBL_EPSILON", "HUGE_VAL", "M_E", "M_LOG2E", "M_LOG10E", "M_LN2", "M_LN10", "M_PI", "M_PI_2", "M_PI_4", "M_1_PI", "M_2_PI", "M_2_SQRTPI", "M_SQRT2", "M_SQRT1_2", "quad_broadcast", }; return keywords; } const std::unordered_set &CompilerMSL::get_illegal_func_names() { static const unordered_set illegal_func_names = { "main", "saturate", "assert", "fmin3", "fmax3", "VARIABLE_TRACEPOINT", "STATIC_DATA_TRACEPOINT", "STATIC_DATA_TRACEPOINT_V", "METAL_ALIGN", "METAL_ASM", "METAL_CONST", "METAL_DEPRECATED", "METAL_ENABLE_IF", "METAL_FUNC", "METAL_INTERNAL", "METAL_NON_NULL_RETURN", "METAL_NORETURN", "METAL_NOTHROW", "METAL_PURE", "METAL_UNAVAILABLE", "METAL_IMPLICIT", "METAL_EXPLICIT", "METAL_CONST_ARG", "METAL_ARG_UNIFORM", "METAL_ZERO_ARG", "METAL_VALID_LOD_ARG", "METAL_VALID_LEVEL_ARG", "METAL_VALID_STORE_ORDER", "METAL_VALID_LOAD_ORDER", "METAL_VALID_COMPARE_EXCHANGE_FAILURE_ORDER", "METAL_COMPATIBLE_COMPARE_EXCHANGE_ORDERS", "METAL_VALID_RENDER_TARGET", "is_function_constant_defined", "CHAR_BIT", "SCHAR_MAX", "SCHAR_MIN", "UCHAR_MAX", "CHAR_MAX", "CHAR_MIN", "USHRT_MAX", "SHRT_MAX", "SHRT_MIN", "UINT_MAX", "INT_MAX", "INT_MIN", "FLT_DIG", "FLT_MANT_DIG", "FLT_MAX_10_EXP", "FLT_MAX_EXP", "FLT_MIN_10_EXP", "FLT_MIN_EXP", "FLT_RADIX", "FLT_MAX", "FLT_MIN", "FLT_EPSILON", "FP_ILOGB0", "FP_ILOGBNAN", "MAXFLOAT", "HUGE_VALF", "INFINITY", "NAN", "M_E_F", "M_LOG2E_F", "M_LOG10E_F", "M_LN2_F", "M_LN10_F", "M_PI_F", "M_PI_2_F", "M_PI_4_F", "M_1_PI_F", "M_2_PI_F", "M_2_SQRTPI_F", "M_SQRT2_F", "M_SQRT1_2_F", "HALF_DIG", "HALF_MANT_DIG", "HALF_MAX_10_EXP", "HALF_MAX_EXP", "HALF_MIN_10_EXP", "HALF_MIN_EXP", "HALF_RADIX", "HALF_MAX", "HALF_MIN", "HALF_EPSILON", "MAXHALF", "HUGE_VALH", "M_E_H", "M_LOG2E_H", "M_LOG10E_H", "M_LN2_H", "M_LN10_H", "M_PI_H", "M_PI_2_H", "M_PI_4_H", "M_1_PI_H", "M_2_PI_H", "M_2_SQRTPI_H", "M_SQRT2_H", "M_SQRT1_2_H", "DBL_DIG", "DBL_MANT_DIG", "DBL_MAX_10_EXP", "DBL_MAX_EXP", "DBL_MIN_10_EXP", "DBL_MIN_EXP", "DBL_RADIX", "DBL_MAX", "DBL_MIN", "DBL_EPSILON", "HUGE_VAL", "M_E", "M_LOG2E", "M_LOG10E", "M_LN2", "M_LN10", "M_PI", "M_PI_2", "M_PI_4", "M_1_PI", "M_2_PI", "M_2_SQRTPI", "M_SQRT2", "M_SQRT1_2", }; return illegal_func_names; } // Replace all names that match MSL keywords or Metal Standard Library functions. void CompilerMSL::replace_illegal_names() { // FIXME: MSL and GLSL are doing two different things here. // Agree on convention and remove this override. auto &keywords = get_reserved_keyword_set(); auto &illegal_func_names = get_illegal_func_names(); ir.for_each_typed_id([&](uint32_t self, SPIRVariable &) { auto *meta = ir.find_meta(self); if (!meta) return; auto &dec = meta->decoration; if (keywords.find(dec.alias) != end(keywords)) dec.alias += "0"; }); ir.for_each_typed_id([&](uint32_t self, SPIRFunction &) { auto *meta = ir.find_meta(self); if (!meta) return; auto &dec = meta->decoration; if (illegal_func_names.find(dec.alias) != end(illegal_func_names)) dec.alias += "0"; }); ir.for_each_typed_id([&](uint32_t self, SPIRType &) { auto *meta = ir.find_meta(self); if (!meta) return; for (auto &mbr_dec : meta->members) if (keywords.find(mbr_dec.alias) != end(keywords)) mbr_dec.alias += "0"; }); CompilerGLSL::replace_illegal_names(); } void CompilerMSL::replace_illegal_entry_point_names() { auto &illegal_func_names = get_illegal_func_names(); // It is important to this before we fixup identifiers, // since if ep_name is reserved, we will need to fix that up, // and then copy alias back into entry.name after the fixup. for (auto &entry : ir.entry_points) { // Change both the entry point name and the alias, to keep them synced. string &ep_name = entry.second.name; if (illegal_func_names.find(ep_name) != end(illegal_func_names)) ep_name += "0"; ir.meta[entry.first].decoration.alias = ep_name; } } void CompilerMSL::sync_entry_point_aliases_and_names() { for (auto &entry : ir.entry_points) entry.second.name = ir.meta[entry.first].decoration.alias; } string CompilerMSL::to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool ptr_chain) { if (index < uint32_t(type.member_type_index_redirection.size())) index = type.member_type_index_redirection[index]; auto *var = maybe_get(base); // If this is a buffer array, we have to dereference the buffer pointers. // Otherwise, if this is a pointer expression, dereference it. bool declared_as_pointer = false; if (var) { // Only allow -> dereference for block types. This is so we get expressions like // buffer[i]->first_member.second_member, rather than buffer[i]->first->second. bool is_block = has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock); bool is_buffer_variable = is_block && (var->storage == StorageClassUniform || var->storage == StorageClassStorageBuffer); declared_as_pointer = is_buffer_variable && is_array(get(var->basetype)); } if (declared_as_pointer || (!ptr_chain && should_dereference(base))) return join("->", to_member_name(type, index)); else return join(".", to_member_name(type, index)); } string CompilerMSL::to_qualifiers_glsl(uint32_t id) { string quals; auto &type = expression_type(id); if (type.storage == StorageClassWorkgroup) quals += "threadgroup "; return quals; } // The optional id parameter indicates the object whose type we are trying // to find the description for. It is optional. Most type descriptions do not // depend on a specific object's use of that type. string CompilerMSL::type_to_glsl(const SPIRType &type, uint32_t id) { string type_name; // Pointer? if (type.pointer) { const char *restrict_kw; type_name = join(get_type_address_space(type, id), " ", type_to_glsl(get(type.parent_type), id)); switch (type.basetype) { case SPIRType::Image: case SPIRType::SampledImage: case SPIRType::Sampler: // These are handles. break; default: // Anything else can be a raw pointer. type_name += "*"; restrict_kw = to_restrict(id); if (*restrict_kw) { type_name += " "; type_name += restrict_kw; } break; } return type_name; } switch (type.basetype) { case SPIRType::Struct: // Need OpName lookup here to get a "sensible" name for a struct. // Allow Metal to use the array template to make arrays a value type type_name = to_name(type.self); break; case SPIRType::Image: case SPIRType::SampledImage: return image_type_glsl(type, id); case SPIRType::Sampler: return sampler_type(type, id); case SPIRType::Void: return "void"; case SPIRType::AtomicCounter: return "atomic_uint"; case SPIRType::ControlPointArray: return join("patch_control_point<", type_to_glsl(get(type.parent_type), id), ">"); case SPIRType::Interpolant: return join("interpolant<", type_to_glsl(get(type.parent_type), id), ", interpolation::", has_decoration(type.self, DecorationNoPerspective) ? "no_perspective" : "perspective", ">"); // Scalars case SPIRType::Boolean: type_name = "bool"; break; case SPIRType::Char: case SPIRType::SByte: type_name = "char"; break; case SPIRType::UByte: type_name = "uchar"; break; case SPIRType::Short: type_name = "short"; break; case SPIRType::UShort: type_name = "ushort"; break; case SPIRType::Int: type_name = "int"; break; case SPIRType::UInt: type_name = "uint"; break; case SPIRType::Int64: if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("64-bit integers are only supported in MSL 2.2 and above."); type_name = "long"; break; case SPIRType::UInt64: if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("64-bit integers are only supported in MSL 2.2 and above."); type_name = "ulong"; break; case SPIRType::Half: type_name = "half"; break; case SPIRType::Float: type_name = "float"; break; case SPIRType::Double: type_name = "double"; // Currently unsupported break; default: return "unknown_type"; } // Matrix? if (type.columns > 1) type_name += to_string(type.columns) + "x"; // Vector or Matrix? if (type.vecsize > 1) type_name += to_string(type.vecsize); if (type.array.empty() || using_builtin_array()) { return type_name; } else { // Allow Metal to use the array template to make arrays a value type add_spv_func_and_recompile(SPVFuncImplUnsafeArray); string res; string sizes; for (uint32_t i = 0; i < uint32_t(type.array.size()); i++) { res += "spvUnsafeArray<"; sizes += ", "; sizes += to_array_size(type, i); sizes += ">"; } res += type_name + sizes; return res; } } string CompilerMSL::type_to_array_glsl(const SPIRType &type) { // Allow Metal to use the array template to make arrays a value type switch (type.basetype) { case SPIRType::AtomicCounter: case SPIRType::ControlPointArray: { return CompilerGLSL::type_to_array_glsl(type); } default: { if (using_builtin_array()) return CompilerGLSL::type_to_array_glsl(type); else return ""; } } } // Threadgroup arrays can't have a wrapper type std::string CompilerMSL::variable_decl(const SPIRVariable &variable) { if (variable.storage == StorageClassWorkgroup) { is_using_builtin_array = true; } std::string expr = CompilerGLSL::variable_decl(variable); if (variable.storage == StorageClassWorkgroup) { is_using_builtin_array = false; } return expr; } // GCC workaround of lambdas calling protected funcs std::string CompilerMSL::variable_decl(const SPIRType &type, const std::string &name, uint32_t id) { return CompilerGLSL::variable_decl(type, name, id); } std::string CompilerMSL::sampler_type(const SPIRType &type, uint32_t id) { auto *var = maybe_get(id); if (var && var->basevariable) { // Check against the base variable, and not a fake ID which might have been generated for this variable. id = var->basevariable; } if (!type.array.empty()) { if (!msl_options.supports_msl_version(2)) SPIRV_CROSS_THROW("MSL 2.0 or greater is required for arrays of samplers."); if (type.array.size() > 1) SPIRV_CROSS_THROW("Arrays of arrays of samplers are not supported in MSL."); // Arrays of samplers in MSL must be declared with a special array syntax ala C++11 std::array. // If we have a runtime array, it could be a variable-count descriptor set binding. uint32_t array_size = to_array_size_literal(type); if (array_size == 0) array_size = get_resource_array_size(id); if (array_size == 0) SPIRV_CROSS_THROW("Unsized array of samplers is not supported in MSL."); auto &parent = get(get_pointee_type(type).parent_type); return join("array<", sampler_type(parent, id), ", ", array_size, ">"); } else return "sampler"; } // Returns an MSL string describing the SPIR-V image type string CompilerMSL::image_type_glsl(const SPIRType &type, uint32_t id) { auto *var = maybe_get(id); if (var && var->basevariable) { // For comparison images, check against the base variable, // and not the fake ID which might have been generated for this variable. id = var->basevariable; } if (!type.array.empty()) { uint32_t major = 2, minor = 0; if (msl_options.is_ios()) { major = 1; minor = 2; } if (!msl_options.supports_msl_version(major, minor)) { if (msl_options.is_ios()) SPIRV_CROSS_THROW("MSL 1.2 or greater is required for arrays of textures."); else SPIRV_CROSS_THROW("MSL 2.0 or greater is required for arrays of textures."); } if (type.array.size() > 1) SPIRV_CROSS_THROW("Arrays of arrays of textures are not supported in MSL."); // Arrays of images in MSL must be declared with a special array syntax ala C++11 std::array. // If we have a runtime array, it could be a variable-count descriptor set binding. uint32_t array_size = to_array_size_literal(type); if (array_size == 0) array_size = get_resource_array_size(id); if (array_size == 0) SPIRV_CROSS_THROW("Unsized array of images is not supported in MSL."); auto &parent = get(get_pointee_type(type).parent_type); return join("array<", image_type_glsl(parent, id), ", ", array_size, ">"); } string img_type_name; // Bypass pointers because we need the real image struct auto &img_type = get(type.self).image; if (image_is_comparison(type, id)) { switch (img_type.dim) { case Dim1D: case Dim2D: if (img_type.dim == Dim1D && !msl_options.texture_1D_as_2D) { // Use a native Metal 1D texture img_type_name += "depth1d_unsupported_by_metal"; break; } if (img_type.ms && img_type.arrayed) { if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Multisampled array textures are supported from 2.1."); img_type_name += "depth2d_ms_array"; } else if (img_type.ms) img_type_name += "depth2d_ms"; else if (img_type.arrayed) img_type_name += "depth2d_array"; else img_type_name += "depth2d"; break; case Dim3D: img_type_name += "depth3d_unsupported_by_metal"; break; case DimCube: if (!msl_options.emulate_cube_array) img_type_name += (img_type.arrayed ? "depthcube_array" : "depthcube"); else img_type_name += (img_type.arrayed ? "depth2d_array" : "depthcube"); break; default: img_type_name += "unknown_depth_texture_type"; break; } } else { switch (img_type.dim) { case DimBuffer: if (img_type.ms || img_type.arrayed) SPIRV_CROSS_THROW("Cannot use texel buffers with multisampling or array layers."); if (msl_options.texture_buffer_native) { if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Native texture_buffer type is only supported in MSL 2.1."); img_type_name = "texture_buffer"; } else img_type_name += "texture2d"; break; case Dim1D: case Dim2D: case DimSubpassData: { bool subpass_array = img_type.dim == DimSubpassData && (msl_options.multiview || msl_options.arrayed_subpass_input); if (img_type.dim == Dim1D && !msl_options.texture_1D_as_2D) { // Use a native Metal 1D texture img_type_name += (img_type.arrayed ? "texture1d_array" : "texture1d"); break; } // Use Metal's native frame-buffer fetch API for subpass inputs. if (type_is_msl_framebuffer_fetch(type)) { auto img_type_4 = get(img_type.type); img_type_4.vecsize = 4; return type_to_glsl(img_type_4); } if (img_type.ms && (img_type.arrayed || subpass_array)) { if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Multisampled array textures are supported from 2.1."); img_type_name += "texture2d_ms_array"; } else if (img_type.ms) img_type_name += "texture2d_ms"; else if (img_type.arrayed || subpass_array) img_type_name += "texture2d_array"; else img_type_name += "texture2d"; break; } case Dim3D: img_type_name += "texture3d"; break; case DimCube: if (!msl_options.emulate_cube_array) img_type_name += (img_type.arrayed ? "texturecube_array" : "texturecube"); else img_type_name += (img_type.arrayed ? "texture2d_array" : "texturecube"); break; default: img_type_name += "unknown_texture_type"; break; } } // Append the pixel type img_type_name += "<"; img_type_name += type_to_glsl(get(img_type.type)); // For unsampled images, append the sample/read/write access qualifier. // For kernel images, the access qualifier my be supplied directly by SPIR-V. // Otherwise it may be set based on whether the image is read from or written to within the shader. if (type.basetype == SPIRType::Image && type.image.sampled == 2 && type.image.dim != DimSubpassData) { switch (img_type.access) { case AccessQualifierReadOnly: img_type_name += ", access::read"; break; case AccessQualifierWriteOnly: img_type_name += ", access::write"; break; case AccessQualifierReadWrite: img_type_name += ", access::read_write"; break; default: { auto *p_var = maybe_get_backing_variable(id); if (p_var && p_var->basevariable) p_var = maybe_get(p_var->basevariable); if (p_var && !has_decoration(p_var->self, DecorationNonWritable)) { img_type_name += ", access::"; if (!has_decoration(p_var->self, DecorationNonReadable)) img_type_name += "read_"; img_type_name += "write"; } break; } } } img_type_name += ">"; return img_type_name; } void CompilerMSL::emit_subgroup_op(const Instruction &i) { const uint32_t *ops = stream(i); auto op = static_cast(i.op); if (msl_options.emulate_subgroups) { // In this mode, only the GroupNonUniform cap is supported. The only op // we need to handle, then, is OpGroupNonUniformElect. if (op != OpGroupNonUniformElect) SPIRV_CROSS_THROW("Subgroup emulation does not support operations other than Elect."); // In this mode, the subgroup size is assumed to be one, so every invocation // is elected. emit_op(ops[0], ops[1], "true", true); return; } // Metal 2.0 is required. iOS only supports quad ops on 11.0 (2.0), with // full support in 13.0 (2.2). macOS only supports broadcast and shuffle on // 10.13 (2.0), with full support in 10.14 (2.1). // Note that Apple GPUs before A13 make no distinction between a quad-group // and a SIMD-group; all SIMD-groups are quad-groups on those. if (!msl_options.supports_msl_version(2)) SPIRV_CROSS_THROW("Subgroups are only supported in Metal 2.0 and up."); // If we need to do implicit bitcasts, make sure we do it with the correct type. uint32_t integer_width = get_integer_width_for_instruction(i); auto int_type = to_signed_basetype(integer_width); auto uint_type = to_unsigned_basetype(integer_width); if (msl_options.is_ios() && (!msl_options.supports_msl_version(2, 3) || !msl_options.ios_use_simdgroup_functions)) { switch (op) { default: SPIRV_CROSS_THROW("Subgroup ops beyond broadcast, ballot, and shuffle on iOS require Metal 2.3 and up."); case OpGroupNonUniformBroadcastFirst: if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("BroadcastFirst on iOS requires Metal 2.2 and up."); break; case OpGroupNonUniformElect: if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("Elect on iOS requires Metal 2.2 and up."); break; case OpGroupNonUniformAny: case OpGroupNonUniformAll: case OpGroupNonUniformAllEqual: case OpGroupNonUniformBallot: case OpGroupNonUniformInverseBallot: case OpGroupNonUniformBallotBitExtract: case OpGroupNonUniformBallotFindLSB: case OpGroupNonUniformBallotFindMSB: case OpGroupNonUniformBallotBitCount: if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("Ballot ops on iOS requires Metal 2.2 and up."); break; case OpGroupNonUniformBroadcast: case OpGroupNonUniformShuffle: case OpGroupNonUniformShuffleXor: case OpGroupNonUniformShuffleUp: case OpGroupNonUniformShuffleDown: case OpGroupNonUniformQuadSwap: case OpGroupNonUniformQuadBroadcast: break; } } if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 1)) { switch (op) { default: SPIRV_CROSS_THROW("Subgroup ops beyond broadcast and shuffle on macOS require Metal 2.1 and up."); case OpGroupNonUniformBroadcast: case OpGroupNonUniformShuffle: case OpGroupNonUniformShuffleXor: case OpGroupNonUniformShuffleUp: case OpGroupNonUniformShuffleDown: break; } } uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto scope = static_cast(evaluate_constant_u32(ops[2])); if (scope != ScopeSubgroup) SPIRV_CROSS_THROW("Only subgroup scope is supported."); switch (op) { case OpGroupNonUniformElect: if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) emit_op(result_type, id, "quad_is_first()", false); else emit_op(result_type, id, "simd_is_first()", false); break; case OpGroupNonUniformBroadcast: emit_binary_func_op(result_type, id, ops[3], ops[4], "spvSubgroupBroadcast"); break; case OpGroupNonUniformBroadcastFirst: emit_unary_func_op(result_type, id, ops[3], "spvSubgroupBroadcastFirst"); break; case OpGroupNonUniformBallot: emit_unary_func_op(result_type, id, ops[3], "spvSubgroupBallot"); break; case OpGroupNonUniformInverseBallot: emit_binary_func_op(result_type, id, ops[3], builtin_subgroup_invocation_id_id, "spvSubgroupBallotBitExtract"); break; case OpGroupNonUniformBallotBitExtract: emit_binary_func_op(result_type, id, ops[3], ops[4], "spvSubgroupBallotBitExtract"); break; case OpGroupNonUniformBallotFindLSB: emit_binary_func_op(result_type, id, ops[3], builtin_subgroup_size_id, "spvSubgroupBallotFindLSB"); break; case OpGroupNonUniformBallotFindMSB: emit_binary_func_op(result_type, id, ops[3], builtin_subgroup_size_id, "spvSubgroupBallotFindMSB"); break; case OpGroupNonUniformBallotBitCount: { auto operation = static_cast(ops[3]); switch (operation) { case GroupOperationReduce: emit_binary_func_op(result_type, id, ops[4], builtin_subgroup_size_id, "spvSubgroupBallotBitCount"); break; case GroupOperationInclusiveScan: emit_binary_func_op(result_type, id, ops[4], builtin_subgroup_invocation_id_id, "spvSubgroupBallotInclusiveBitCount"); break; case GroupOperationExclusiveScan: emit_binary_func_op(result_type, id, ops[4], builtin_subgroup_invocation_id_id, "spvSubgroupBallotExclusiveBitCount"); break; default: SPIRV_CROSS_THROW("Invalid BitCount operation."); break; } break; } case OpGroupNonUniformShuffle: emit_binary_func_op(result_type, id, ops[3], ops[4], "spvSubgroupShuffle"); break; case OpGroupNonUniformShuffleXor: emit_binary_func_op(result_type, id, ops[3], ops[4], "spvSubgroupShuffleXor"); break; case OpGroupNonUniformShuffleUp: emit_binary_func_op(result_type, id, ops[3], ops[4], "spvSubgroupShuffleUp"); break; case OpGroupNonUniformShuffleDown: emit_binary_func_op(result_type, id, ops[3], ops[4], "spvSubgroupShuffleDown"); break; case OpGroupNonUniformAll: if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) emit_unary_func_op(result_type, id, ops[3], "quad_all"); else emit_unary_func_op(result_type, id, ops[3], "simd_all"); break; case OpGroupNonUniformAny: if (msl_options.is_ios() && !msl_options.ios_use_simdgroup_functions) emit_unary_func_op(result_type, id, ops[3], "quad_any"); else emit_unary_func_op(result_type, id, ops[3], "simd_any"); break; case OpGroupNonUniformAllEqual: emit_unary_func_op(result_type, id, ops[3], "spvSubgroupAllEqual"); break; // clang-format off #define MSL_GROUP_OP(op, msl_op) \ case OpGroupNonUniform##op: \ { \ auto operation = static_cast(ops[3]); \ if (operation == GroupOperationReduce) \ emit_unary_func_op(result_type, id, ops[4], "simd_" #msl_op); \ else if (operation == GroupOperationInclusiveScan) \ emit_unary_func_op(result_type, id, ops[4], "simd_prefix_inclusive_" #msl_op); \ else if (operation == GroupOperationExclusiveScan) \ emit_unary_func_op(result_type, id, ops[4], "simd_prefix_exclusive_" #msl_op); \ else if (operation == GroupOperationClusteredReduce) \ { \ /* Only cluster sizes of 4 are supported. */ \ uint32_t cluster_size = evaluate_constant_u32(ops[5]); \ if (cluster_size != 4) \ SPIRV_CROSS_THROW("Metal only supports quad ClusteredReduce."); \ emit_unary_func_op(result_type, id, ops[4], "quad_" #msl_op); \ } \ else \ SPIRV_CROSS_THROW("Invalid group operation."); \ break; \ } MSL_GROUP_OP(FAdd, sum) MSL_GROUP_OP(FMul, product) MSL_GROUP_OP(IAdd, sum) MSL_GROUP_OP(IMul, product) #undef MSL_GROUP_OP // The others, unfortunately, don't support InclusiveScan or ExclusiveScan. #define MSL_GROUP_OP(op, msl_op) \ case OpGroupNonUniform##op: \ { \ auto operation = static_cast(ops[3]); \ if (operation == GroupOperationReduce) \ emit_unary_func_op(result_type, id, ops[4], "simd_" #msl_op); \ else if (operation == GroupOperationInclusiveScan) \ SPIRV_CROSS_THROW("Metal doesn't support InclusiveScan for OpGroupNonUniform" #op "."); \ else if (operation == GroupOperationExclusiveScan) \ SPIRV_CROSS_THROW("Metal doesn't support ExclusiveScan for OpGroupNonUniform" #op "."); \ else if (operation == GroupOperationClusteredReduce) \ { \ /* Only cluster sizes of 4 are supported. */ \ uint32_t cluster_size = evaluate_constant_u32(ops[5]); \ if (cluster_size != 4) \ SPIRV_CROSS_THROW("Metal only supports quad ClusteredReduce."); \ emit_unary_func_op(result_type, id, ops[4], "quad_" #msl_op); \ } \ else \ SPIRV_CROSS_THROW("Invalid group operation."); \ break; \ } #define MSL_GROUP_OP_CAST(op, msl_op, type) \ case OpGroupNonUniform##op: \ { \ auto operation = static_cast(ops[3]); \ if (operation == GroupOperationReduce) \ emit_unary_func_op_cast(result_type, id, ops[4], "simd_" #msl_op, type, type); \ else if (operation == GroupOperationInclusiveScan) \ SPIRV_CROSS_THROW("Metal doesn't support InclusiveScan for OpGroupNonUniform" #op "."); \ else if (operation == GroupOperationExclusiveScan) \ SPIRV_CROSS_THROW("Metal doesn't support ExclusiveScan for OpGroupNonUniform" #op "."); \ else if (operation == GroupOperationClusteredReduce) \ { \ /* Only cluster sizes of 4 are supported. */ \ uint32_t cluster_size = evaluate_constant_u32(ops[5]); \ if (cluster_size != 4) \ SPIRV_CROSS_THROW("Metal only supports quad ClusteredReduce."); \ emit_unary_func_op_cast(result_type, id, ops[4], "quad_" #msl_op, type, type); \ } \ else \ SPIRV_CROSS_THROW("Invalid group operation."); \ break; \ } MSL_GROUP_OP(FMin, min) MSL_GROUP_OP(FMax, max) MSL_GROUP_OP_CAST(SMin, min, int_type) MSL_GROUP_OP_CAST(SMax, max, int_type) MSL_GROUP_OP_CAST(UMin, min, uint_type) MSL_GROUP_OP_CAST(UMax, max, uint_type) MSL_GROUP_OP(BitwiseAnd, and) MSL_GROUP_OP(BitwiseOr, or) MSL_GROUP_OP(BitwiseXor, xor) MSL_GROUP_OP(LogicalAnd, and) MSL_GROUP_OP(LogicalOr, or) MSL_GROUP_OP(LogicalXor, xor) // clang-format on #undef MSL_GROUP_OP #undef MSL_GROUP_OP_CAST case OpGroupNonUniformQuadSwap: emit_binary_func_op(result_type, id, ops[3], ops[4], "spvQuadSwap"); break; case OpGroupNonUniformQuadBroadcast: emit_binary_func_op(result_type, id, ops[3], ops[4], "spvQuadBroadcast"); break; default: SPIRV_CROSS_THROW("Invalid opcode for subgroup."); } register_control_dependent_expression(id); } string CompilerMSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in_type) { if (out_type.basetype == in_type.basetype) return ""; assert(out_type.basetype != SPIRType::Boolean); assert(in_type.basetype != SPIRType::Boolean); bool integral_cast = type_is_integral(out_type) && type_is_integral(in_type); bool same_size_cast = out_type.width == in_type.width; if (integral_cast && same_size_cast) { // Trivial bitcast case, casts between integers. return type_to_glsl(out_type); } else { // Fall back to the catch-all bitcast in MSL. return "as_type<" + type_to_glsl(out_type) + ">"; } } bool CompilerMSL::emit_complex_bitcast(uint32_t, uint32_t, uint32_t) { return false; } // Returns an MSL string identifying the name of a SPIR-V builtin. // Output builtins are qualified with the name of the stage out structure. string CompilerMSL::builtin_to_glsl(BuiltIn builtin, StorageClass storage) { switch (builtin) { // Handle HLSL-style 0-based vertex/instance index. // Override GLSL compiler strictness case BuiltInVertexId: ensure_builtin(StorageClassInput, BuiltInVertexId); if (msl_options.enable_base_index_zero && msl_options.supports_msl_version(1, 1) && (msl_options.ios_support_base_vertex_instance || msl_options.is_macos())) { if (builtin_declaration) { if (needs_base_vertex_arg != TriState::No) needs_base_vertex_arg = TriState::Yes; return "gl_VertexID"; } else { ensure_builtin(StorageClassInput, BuiltInBaseVertex); return "(gl_VertexID - gl_BaseVertex)"; } } else { return "gl_VertexID"; } case BuiltInInstanceId: ensure_builtin(StorageClassInput, BuiltInInstanceId); if (msl_options.enable_base_index_zero && msl_options.supports_msl_version(1, 1) && (msl_options.ios_support_base_vertex_instance || msl_options.is_macos())) { if (builtin_declaration) { if (needs_base_instance_arg != TriState::No) needs_base_instance_arg = TriState::Yes; return "gl_InstanceID"; } else { ensure_builtin(StorageClassInput, BuiltInBaseInstance); return "(gl_InstanceID - gl_BaseInstance)"; } } else { return "gl_InstanceID"; } case BuiltInVertexIndex: ensure_builtin(StorageClassInput, BuiltInVertexIndex); if (msl_options.enable_base_index_zero && msl_options.supports_msl_version(1, 1) && (msl_options.ios_support_base_vertex_instance || msl_options.is_macos())) { if (builtin_declaration) { if (needs_base_vertex_arg != TriState::No) needs_base_vertex_arg = TriState::Yes; return "gl_VertexIndex"; } else { ensure_builtin(StorageClassInput, BuiltInBaseVertex); return "(gl_VertexIndex - gl_BaseVertex)"; } } else { return "gl_VertexIndex"; } case BuiltInInstanceIndex: ensure_builtin(StorageClassInput, BuiltInInstanceIndex); if (msl_options.enable_base_index_zero && msl_options.supports_msl_version(1, 1) && (msl_options.ios_support_base_vertex_instance || msl_options.is_macos())) { if (builtin_declaration) { if (needs_base_instance_arg != TriState::No) needs_base_instance_arg = TriState::Yes; return "gl_InstanceIndex"; } else { ensure_builtin(StorageClassInput, BuiltInBaseInstance); return "(gl_InstanceIndex - gl_BaseInstance)"; } } else { return "gl_InstanceIndex"; } case BuiltInBaseVertex: if (msl_options.supports_msl_version(1, 1) && (msl_options.ios_support_base_vertex_instance || msl_options.is_macos())) { needs_base_vertex_arg = TriState::No; return "gl_BaseVertex"; } else { SPIRV_CROSS_THROW("BaseVertex requires Metal 1.1 and Mac or Apple A9+ hardware."); } case BuiltInBaseInstance: if (msl_options.supports_msl_version(1, 1) && (msl_options.ios_support_base_vertex_instance || msl_options.is_macos())) { needs_base_instance_arg = TriState::No; return "gl_BaseInstance"; } else { SPIRV_CROSS_THROW("BaseInstance requires Metal 1.1 and Mac or Apple A9+ hardware."); } case BuiltInDrawIndex: SPIRV_CROSS_THROW("DrawIndex is not supported in MSL."); // When used in the entry function, output builtins are qualified with output struct name. // Test storage class as NOT Input, as output builtins might be part of generic type. // Also don't do this for tessellation control shaders. case BuiltInViewportIndex: if (!msl_options.supports_msl_version(2, 0)) SPIRV_CROSS_THROW("ViewportIndex requires Metal 2.0."); /* fallthrough */ case BuiltInFragDepth: case BuiltInFragStencilRefEXT: if ((builtin == BuiltInFragDepth && !msl_options.enable_frag_depth_builtin) || (builtin == BuiltInFragStencilRefEXT && !msl_options.enable_frag_stencil_ref_builtin)) break; /* fallthrough */ case BuiltInPosition: case BuiltInPointSize: case BuiltInClipDistance: case BuiltInCullDistance: case BuiltInLayer: case BuiltInSampleMask: if (get_execution_model() == ExecutionModelTessellationControl) break; if (storage != StorageClassInput && current_function && (current_function->self == ir.default_entry_point)) return stage_out_var_name + "." + CompilerGLSL::builtin_to_glsl(builtin, storage); break; case BuiltInBaryCoordNV: case BuiltInBaryCoordNoPerspNV: if (storage == StorageClassInput && current_function && (current_function->self == ir.default_entry_point)) return stage_in_var_name + "." + CompilerGLSL::builtin_to_glsl(builtin, storage); break; case BuiltInTessLevelOuter: if (get_execution_model() == ExecutionModelTessellationEvaluation) { if (storage != StorageClassOutput && !get_entry_point().flags.get(ExecutionModeTriangles) && current_function && (current_function->self == ir.default_entry_point)) return join(patch_stage_in_var_name, ".", CompilerGLSL::builtin_to_glsl(builtin, storage)); else break; } if (storage != StorageClassInput && current_function && (current_function->self == ir.default_entry_point)) return join(tess_factor_buffer_var_name, "[", to_expression(builtin_primitive_id_id), "].edgeTessellationFactor"); break; case BuiltInTessLevelInner: if (get_execution_model() == ExecutionModelTessellationEvaluation) { if (storage != StorageClassOutput && !get_entry_point().flags.get(ExecutionModeTriangles) && current_function && (current_function->self == ir.default_entry_point)) return join(patch_stage_in_var_name, ".", CompilerGLSL::builtin_to_glsl(builtin, storage)); else break; } if (storage != StorageClassInput && current_function && (current_function->self == ir.default_entry_point)) return join(tess_factor_buffer_var_name, "[", to_expression(builtin_primitive_id_id), "].insideTessellationFactor"); break; default: break; } return CompilerGLSL::builtin_to_glsl(builtin, storage); } // Returns an MSL string attribute qualifer for a SPIR-V builtin string CompilerMSL::builtin_qualifier(BuiltIn builtin) { auto &execution = get_entry_point(); switch (builtin) { // Vertex function in case BuiltInVertexId: return "vertex_id"; case BuiltInVertexIndex: return "vertex_id"; case BuiltInBaseVertex: return "base_vertex"; case BuiltInInstanceId: return "instance_id"; case BuiltInInstanceIndex: return "instance_id"; case BuiltInBaseInstance: return "base_instance"; case BuiltInDrawIndex: SPIRV_CROSS_THROW("DrawIndex is not supported in MSL."); // Vertex function out case BuiltInClipDistance: return "clip_distance"; case BuiltInPointSize: return "point_size"; case BuiltInPosition: if (position_invariant) { if (!msl_options.supports_msl_version(2, 1)) SPIRV_CROSS_THROW("Invariant position is only supported on MSL 2.1 and up."); return "position, invariant"; } else return "position"; case BuiltInLayer: return "render_target_array_index"; case BuiltInViewportIndex: if (!msl_options.supports_msl_version(2, 0)) SPIRV_CROSS_THROW("ViewportIndex requires Metal 2.0."); return "viewport_array_index"; // Tess. control function in case BuiltInInvocationId: if (msl_options.multi_patch_workgroup) { // Shouldn't be reached. SPIRV_CROSS_THROW("InvocationId is computed manually with multi-patch workgroups in MSL."); } return "thread_index_in_threadgroup"; case BuiltInPatchVertices: // Shouldn't be reached. SPIRV_CROSS_THROW("PatchVertices is derived from the auxiliary buffer in MSL."); case BuiltInPrimitiveId: switch (execution.model) { case ExecutionModelTessellationControl: if (msl_options.multi_patch_workgroup) { // Shouldn't be reached. SPIRV_CROSS_THROW("PrimitiveId is computed manually with multi-patch workgroups in MSL."); } return "threadgroup_position_in_grid"; case ExecutionModelTessellationEvaluation: return "patch_id"; case ExecutionModelFragment: if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 3)) SPIRV_CROSS_THROW("PrimitiveId on iOS requires MSL 2.3."); else if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("PrimitiveId on macOS requires MSL 2.2."); return "primitive_id"; default: SPIRV_CROSS_THROW("PrimitiveId is not supported in this execution model."); } // Tess. control function out case BuiltInTessLevelOuter: case BuiltInTessLevelInner: // Shouldn't be reached. SPIRV_CROSS_THROW("Tessellation levels are handled specially in MSL."); // Tess. evaluation function in case BuiltInTessCoord: return "position_in_patch"; // Fragment function in case BuiltInFrontFacing: return "front_facing"; case BuiltInPointCoord: return "point_coord"; case BuiltInFragCoord: return "position"; case BuiltInSampleId: return "sample_id"; case BuiltInSampleMask: return "sample_mask"; case BuiltInSamplePosition: // Shouldn't be reached. SPIRV_CROSS_THROW("Sample position is retrieved by a function in MSL."); case BuiltInViewIndex: if (execution.model != ExecutionModelFragment) SPIRV_CROSS_THROW("ViewIndex is handled specially outside fragment shaders."); // The ViewIndex was implicitly used in the prior stages to set the render_target_array_index, // so we can get it from there. return "render_target_array_index"; // Fragment function out case BuiltInFragDepth: if (execution.flags.get(ExecutionModeDepthGreater)) return "depth(greater)"; else if (execution.flags.get(ExecutionModeDepthLess)) return "depth(less)"; else return "depth(any)"; case BuiltInFragStencilRefEXT: return "stencil"; // Compute function in case BuiltInGlobalInvocationId: return "thread_position_in_grid"; case BuiltInWorkgroupId: return "threadgroup_position_in_grid"; case BuiltInNumWorkgroups: return "threadgroups_per_grid"; case BuiltInLocalInvocationId: return "thread_position_in_threadgroup"; case BuiltInLocalInvocationIndex: return "thread_index_in_threadgroup"; case BuiltInSubgroupSize: if (msl_options.emulate_subgroups || msl_options.fixed_subgroup_size != 0) // Shouldn't be reached. SPIRV_CROSS_THROW("Emitting threads_per_simdgroup attribute with fixed subgroup size??"); if (execution.model == ExecutionModelFragment) { if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("threads_per_simdgroup requires Metal 2.2 in fragment shaders."); return "threads_per_simdgroup"; } else { // thread_execution_width is an alias for threads_per_simdgroup, and it's only available since 1.0, // but not in fragment. return "thread_execution_width"; } case BuiltInNumSubgroups: if (msl_options.emulate_subgroups) // Shouldn't be reached. SPIRV_CROSS_THROW("NumSubgroups is handled specially with emulation."); if (!msl_options.supports_msl_version(2)) SPIRV_CROSS_THROW("Subgroup builtins require Metal 2.0."); return msl_options.is_ios() ? "quadgroups_per_threadgroup" : "simdgroups_per_threadgroup"; case BuiltInSubgroupId: if (msl_options.emulate_subgroups) // Shouldn't be reached. SPIRV_CROSS_THROW("SubgroupId is handled specially with emulation."); if (!msl_options.supports_msl_version(2)) SPIRV_CROSS_THROW("Subgroup builtins require Metal 2.0."); return msl_options.is_ios() ? "quadgroup_index_in_threadgroup" : "simdgroup_index_in_threadgroup"; case BuiltInSubgroupLocalInvocationId: if (msl_options.emulate_subgroups) // Shouldn't be reached. SPIRV_CROSS_THROW("SubgroupLocalInvocationId is handled specially with emulation."); if (execution.model == ExecutionModelFragment) { if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("thread_index_in_simdgroup requires Metal 2.2 in fragment shaders."); return "thread_index_in_simdgroup"; } else if (execution.model == ExecutionModelKernel || execution.model == ExecutionModelGLCompute || execution.model == ExecutionModelTessellationControl || (execution.model == ExecutionModelVertex && msl_options.vertex_for_tessellation)) { // We are generating a Metal kernel function. if (!msl_options.supports_msl_version(2)) SPIRV_CROSS_THROW("Subgroup builtins in kernel functions require Metal 2.0."); return msl_options.is_ios() ? "thread_index_in_quadgroup" : "thread_index_in_simdgroup"; } else SPIRV_CROSS_THROW("Subgroup builtins are not available in this type of function."); case BuiltInSubgroupEqMask: case BuiltInSubgroupGeMask: case BuiltInSubgroupGtMask: case BuiltInSubgroupLeMask: case BuiltInSubgroupLtMask: // Shouldn't be reached. SPIRV_CROSS_THROW("Subgroup ballot masks are handled specially in MSL."); case BuiltInBaryCoordNV: // TODO: AMD barycentrics as well? Seem to have different swizzle and 2 components rather than 3. if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 3)) SPIRV_CROSS_THROW("Barycentrics are only supported in MSL 2.3 and above on iOS."); else if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("Barycentrics are only supported in MSL 2.2 and above on macOS."); return "barycentric_coord, center_perspective"; case BuiltInBaryCoordNoPerspNV: // TODO: AMD barycentrics as well? Seem to have different swizzle and 2 components rather than 3. if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 3)) SPIRV_CROSS_THROW("Barycentrics are only supported in MSL 2.3 and above on iOS."); else if (!msl_options.supports_msl_version(2, 2)) SPIRV_CROSS_THROW("Barycentrics are only supported in MSL 2.2 and above on macOS."); return "barycentric_coord, center_no_perspective"; default: return "unsupported-built-in"; } } // Returns an MSL string type declaration for a SPIR-V builtin string CompilerMSL::builtin_type_decl(BuiltIn builtin, uint32_t id) { const SPIREntryPoint &execution = get_entry_point(); switch (builtin) { // Vertex function in case BuiltInVertexId: return "uint"; case BuiltInVertexIndex: return "uint"; case BuiltInBaseVertex: return "uint"; case BuiltInInstanceId: return "uint"; case BuiltInInstanceIndex: return "uint"; case BuiltInBaseInstance: return "uint"; case BuiltInDrawIndex: SPIRV_CROSS_THROW("DrawIndex is not supported in MSL."); // Vertex function out case BuiltInClipDistance: return "float"; case BuiltInPointSize: return "float"; case BuiltInPosition: return "float4"; case BuiltInLayer: return "uint"; case BuiltInViewportIndex: if (!msl_options.supports_msl_version(2, 0)) SPIRV_CROSS_THROW("ViewportIndex requires Metal 2.0."); return "uint"; // Tess. control function in case BuiltInInvocationId: return "uint"; case BuiltInPatchVertices: return "uint"; case BuiltInPrimitiveId: return "uint"; // Tess. control function out case BuiltInTessLevelInner: if (execution.model == ExecutionModelTessellationEvaluation) return !execution.flags.get(ExecutionModeTriangles) ? "float2" : "float"; return "half"; case BuiltInTessLevelOuter: if (execution.model == ExecutionModelTessellationEvaluation) return !execution.flags.get(ExecutionModeTriangles) ? "float4" : "float"; return "half"; // Tess. evaluation function in case BuiltInTessCoord: return execution.flags.get(ExecutionModeTriangles) ? "float3" : "float2"; // Fragment function in case BuiltInFrontFacing: return "bool"; case BuiltInPointCoord: return "float2"; case BuiltInFragCoord: return "float4"; case BuiltInSampleId: return "uint"; case BuiltInSampleMask: return "uint"; case BuiltInSamplePosition: return "float2"; case BuiltInViewIndex: return "uint"; case BuiltInHelperInvocation: return "bool"; case BuiltInBaryCoordNV: case BuiltInBaryCoordNoPerspNV: // Use the type as declared, can be 1, 2 or 3 components. return type_to_glsl(get_variable_data_type(get(id))); // Fragment function out case BuiltInFragDepth: return "float"; case BuiltInFragStencilRefEXT: return "uint"; // Compute function in case BuiltInGlobalInvocationId: case BuiltInLocalInvocationId: case BuiltInNumWorkgroups: case BuiltInWorkgroupId: return "uint3"; case BuiltInLocalInvocationIndex: case BuiltInNumSubgroups: case BuiltInSubgroupId: case BuiltInSubgroupSize: case BuiltInSubgroupLocalInvocationId: return "uint"; case BuiltInSubgroupEqMask: case BuiltInSubgroupGeMask: case BuiltInSubgroupGtMask: case BuiltInSubgroupLeMask: case BuiltInSubgroupLtMask: return "uint4"; case BuiltInDeviceIndex: return "int"; default: return "unsupported-built-in-type"; } } // Returns the declaration of a built-in argument to a function string CompilerMSL::built_in_func_arg(BuiltIn builtin, bool prefix_comma) { string bi_arg; if (prefix_comma) bi_arg += ", "; // Handle HLSL-style 0-based vertex/instance index. builtin_declaration = true; bi_arg += builtin_type_decl(builtin); bi_arg += " " + builtin_to_glsl(builtin, StorageClassInput); bi_arg += " [[" + builtin_qualifier(builtin) + "]]"; builtin_declaration = false; return bi_arg; } const SPIRType &CompilerMSL::get_physical_member_type(const SPIRType &type, uint32_t index) const { if (member_is_remapped_physical_type(type, index)) return get(get_extended_member_decoration(type.self, index, SPIRVCrossDecorationPhysicalTypeID)); else return get(type.member_types[index]); } SPIRType CompilerMSL::get_presumed_input_type(const SPIRType &ib_type, uint32_t index) const { SPIRType type = get_physical_member_type(ib_type, index); uint32_t loc = get_member_decoration(ib_type.self, index, DecorationLocation); if (inputs_by_location.count(loc)) { if (inputs_by_location.at(loc).vecsize > type.vecsize) type.vecsize = inputs_by_location.at(loc).vecsize; } return type; } uint32_t CompilerMSL::get_declared_type_array_stride_msl(const SPIRType &type, bool is_packed, bool row_major) const { // Array stride in MSL is always size * array_size. sizeof(float3) == 16, // unlike GLSL and HLSL where array stride would be 16 and size 12. // We could use parent type here and recurse, but that makes creating physical type remappings // far more complicated. We'd rather just create the final type, and ignore having to create the entire type // hierarchy in order to compute this value, so make a temporary type on the stack. auto basic_type = type; basic_type.array.clear(); basic_type.array_size_literal.clear(); uint32_t value_size = get_declared_type_size_msl(basic_type, is_packed, row_major); uint32_t dimensions = uint32_t(type.array.size()); assert(dimensions > 0); dimensions--; // Multiply together every dimension, except the last one. for (uint32_t dim = 0; dim < dimensions; dim++) { uint32_t array_size = to_array_size_literal(type, dim); value_size *= max(array_size, 1u); } return value_size; } uint32_t CompilerMSL::get_declared_struct_member_array_stride_msl(const SPIRType &type, uint32_t index) const { return get_declared_type_array_stride_msl(get_physical_member_type(type, index), member_is_packed_physical_type(type, index), has_member_decoration(type.self, index, DecorationRowMajor)); } uint32_t CompilerMSL::get_declared_input_array_stride_msl(const SPIRType &type, uint32_t index) const { return get_declared_type_array_stride_msl(get_presumed_input_type(type, index), false, has_member_decoration(type.self, index, DecorationRowMajor)); } uint32_t CompilerMSL::get_declared_type_matrix_stride_msl(const SPIRType &type, bool packed, bool row_major) const { // For packed matrices, we just use the size of the vector type. // Otherwise, MatrixStride == alignment, which is the size of the underlying vector type. if (packed) return (type.width / 8) * ((row_major && type.columns > 1) ? type.columns : type.vecsize); else return get_declared_type_alignment_msl(type, false, row_major); } uint32_t CompilerMSL::get_declared_struct_member_matrix_stride_msl(const SPIRType &type, uint32_t index) const { return get_declared_type_matrix_stride_msl(get_physical_member_type(type, index), member_is_packed_physical_type(type, index), has_member_decoration(type.self, index, DecorationRowMajor)); } uint32_t CompilerMSL::get_declared_input_matrix_stride_msl(const SPIRType &type, uint32_t index) const { return get_declared_type_matrix_stride_msl(get_presumed_input_type(type, index), false, has_member_decoration(type.self, index, DecorationRowMajor)); } uint32_t CompilerMSL::get_declared_struct_size_msl(const SPIRType &struct_type, bool ignore_alignment, bool ignore_padding) const { // If we have a target size, that is the declared size as well. if (!ignore_padding && has_extended_decoration(struct_type.self, SPIRVCrossDecorationPaddingTarget)) return get_extended_decoration(struct_type.self, SPIRVCrossDecorationPaddingTarget); if (struct_type.member_types.empty()) return 0; uint32_t mbr_cnt = uint32_t(struct_type.member_types.size()); // In MSL, a struct's alignment is equal to the maximum alignment of any of its members. uint32_t alignment = 1; if (!ignore_alignment) { for (uint32_t i = 0; i < mbr_cnt; i++) { uint32_t mbr_alignment = get_declared_struct_member_alignment_msl(struct_type, i); alignment = max(alignment, mbr_alignment); } } // Last member will always be matched to the final Offset decoration, but size of struct in MSL now depends // on physical size in MSL, and the size of the struct itself is then aligned to struct alignment. uint32_t spirv_offset = type_struct_member_offset(struct_type, mbr_cnt - 1); uint32_t msl_size = spirv_offset + get_declared_struct_member_size_msl(struct_type, mbr_cnt - 1); msl_size = (msl_size + alignment - 1) & ~(alignment - 1); return msl_size; } // Returns the byte size of a struct member. uint32_t CompilerMSL::get_declared_type_size_msl(const SPIRType &type, bool is_packed, bool row_major) const { switch (type.basetype) { case SPIRType::Unknown: case SPIRType::Void: case SPIRType::AtomicCounter: case SPIRType::Image: case SPIRType::SampledImage: case SPIRType::Sampler: SPIRV_CROSS_THROW("Querying size of opaque object."); default: { if (!type.array.empty()) { uint32_t array_size = to_array_size_literal(type); return get_declared_type_array_stride_msl(type, is_packed, row_major) * max(array_size, 1u); } if (type.basetype == SPIRType::Struct) return get_declared_struct_size_msl(type); if (is_packed) { return type.vecsize * type.columns * (type.width / 8); } else { // An unpacked 3-element vector or matrix column is the same memory size as a 4-element. uint32_t vecsize = type.vecsize; uint32_t columns = type.columns; if (row_major && columns > 1) swap(vecsize, columns); if (vecsize == 3) vecsize = 4; return vecsize * columns * (type.width / 8); } } } } uint32_t CompilerMSL::get_declared_struct_member_size_msl(const SPIRType &type, uint32_t index) const { return get_declared_type_size_msl(get_physical_member_type(type, index), member_is_packed_physical_type(type, index), has_member_decoration(type.self, index, DecorationRowMajor)); } uint32_t CompilerMSL::get_declared_input_size_msl(const SPIRType &type, uint32_t index) const { return get_declared_type_size_msl(get_presumed_input_type(type, index), false, has_member_decoration(type.self, index, DecorationRowMajor)); } // Returns the byte alignment of a type. uint32_t CompilerMSL::get_declared_type_alignment_msl(const SPIRType &type, bool is_packed, bool row_major) const { switch (type.basetype) { case SPIRType::Unknown: case SPIRType::Void: case SPIRType::AtomicCounter: case SPIRType::Image: case SPIRType::SampledImage: case SPIRType::Sampler: SPIRV_CROSS_THROW("Querying alignment of opaque object."); case SPIRType::Int64: SPIRV_CROSS_THROW("long types are not supported in buffers in MSL."); case SPIRType::UInt64: SPIRV_CROSS_THROW("ulong types are not supported in buffers in MSL."); case SPIRType::Double: SPIRV_CROSS_THROW("double types are not supported in buffers in MSL."); case SPIRType::Struct: { // In MSL, a struct's alignment is equal to the maximum alignment of any of its members. uint32_t alignment = 1; for (uint32_t i = 0; i < type.member_types.size(); i++) alignment = max(alignment, uint32_t(get_declared_struct_member_alignment_msl(type, i))); return alignment; } default: { // Alignment of packed type is the same as the underlying component or column size. // Alignment of unpacked type is the same as the vector size. // Alignment of 3-elements vector is the same as 4-elements (including packed using column). if (is_packed) { // If we have packed_T and friends, the alignment is always scalar. return type.width / 8; } else { // This is the general rule for MSL. Size == alignment. uint32_t vecsize = (row_major && type.columns > 1) ? type.columns : type.vecsize; return (type.width / 8) * (vecsize == 3 ? 4 : vecsize); } } } } uint32_t CompilerMSL::get_declared_struct_member_alignment_msl(const SPIRType &type, uint32_t index) const { return get_declared_type_alignment_msl(get_physical_member_type(type, index), member_is_packed_physical_type(type, index), has_member_decoration(type.self, index, DecorationRowMajor)); } uint32_t CompilerMSL::get_declared_input_alignment_msl(const SPIRType &type, uint32_t index) const { return get_declared_type_alignment_msl(get_presumed_input_type(type, index), false, has_member_decoration(type.self, index, DecorationRowMajor)); } bool CompilerMSL::skip_argument(uint32_t) const { return false; } void CompilerMSL::analyze_sampled_image_usage() { if (msl_options.swizzle_texture_samples) { SampledImageScanner scanner(*this); traverse_all_reachable_opcodes(get(ir.default_entry_point), scanner); } } bool CompilerMSL::SampledImageScanner::handle(spv::Op opcode, const uint32_t *args, uint32_t length) { switch (opcode) { case OpLoad: case OpImage: case OpSampledImage: { if (length < 3) return false; uint32_t result_type = args[0]; auto &type = compiler.get(result_type); if ((type.basetype != SPIRType::Image && type.basetype != SPIRType::SampledImage) || type.image.sampled != 1) return true; uint32_t id = args[1]; compiler.set(id, "", result_type, true); break; } case OpImageSampleExplicitLod: case OpImageSampleProjExplicitLod: case OpImageSampleDrefExplicitLod: case OpImageSampleProjDrefExplicitLod: case OpImageSampleImplicitLod: case OpImageSampleProjImplicitLod: case OpImageSampleDrefImplicitLod: case OpImageSampleProjDrefImplicitLod: case OpImageFetch: case OpImageGather: case OpImageDrefGather: compiler.has_sampled_images = compiler.has_sampled_images || compiler.is_sampled_image_type(compiler.expression_type(args[2])); compiler.needs_swizzle_buffer_def = compiler.needs_swizzle_buffer_def || compiler.has_sampled_images; break; default: break; } return true; } // If a needed custom function wasn't added before, add it and force a recompile. void CompilerMSL::add_spv_func_and_recompile(SPVFuncImpl spv_func) { if (spv_function_implementations.count(spv_func) == 0) { spv_function_implementations.insert(spv_func); suppress_missing_prototypes = true; force_recompile(); } } bool CompilerMSL::OpCodePreprocessor::handle(Op opcode, const uint32_t *args, uint32_t length) { // Since MSL exists in a single execution scope, function prototype declarations are not // needed, and clutter the output. If secondary functions are output (either as a SPIR-V // function implementation or as indicated by the presence of OpFunctionCall), then set // suppress_missing_prototypes to suppress compiler warnings of missing function prototypes. // Mark if the input requires the implementation of an SPIR-V function that does not exist in Metal. SPVFuncImpl spv_func = get_spv_func_impl(opcode, args); if (spv_func != SPVFuncImplNone) { compiler.spv_function_implementations.insert(spv_func); suppress_missing_prototypes = true; } switch (opcode) { case OpFunctionCall: suppress_missing_prototypes = true; break; // Emulate texture2D atomic operations case OpImageTexelPointer: { auto *var = compiler.maybe_get_backing_variable(args[2]); image_pointers[args[1]] = var ? var->self : ID(0); break; } case OpImageWrite: if (!compiler.msl_options.supports_msl_version(2, 2)) uses_resource_write = true; break; case OpStore: check_resource_write(args[0]); break; // Emulate texture2D atomic operations case OpAtomicExchange: case OpAtomicCompareExchange: case OpAtomicCompareExchangeWeak: case OpAtomicIIncrement: case OpAtomicIDecrement: case OpAtomicIAdd: case OpAtomicISub: case OpAtomicSMin: case OpAtomicUMin: case OpAtomicSMax: case OpAtomicUMax: case OpAtomicAnd: case OpAtomicOr: case OpAtomicXor: { uses_atomics = true; auto it = image_pointers.find(args[2]); if (it != image_pointers.end()) { compiler.atomic_image_vars.insert(it->second); } check_resource_write(args[2]); break; } case OpAtomicStore: { uses_atomics = true; auto it = image_pointers.find(args[0]); if (it != image_pointers.end()) { compiler.atomic_image_vars.insert(it->second); } check_resource_write(args[0]); break; } case OpAtomicLoad: { uses_atomics = true; auto it = image_pointers.find(args[2]); if (it != image_pointers.end()) { compiler.atomic_image_vars.insert(it->second); } break; } case OpGroupNonUniformInverseBallot: needs_subgroup_invocation_id = true; break; case OpGroupNonUniformBallotFindLSB: case OpGroupNonUniformBallotFindMSB: needs_subgroup_size = true; break; case OpGroupNonUniformBallotBitCount: if (args[3] == GroupOperationReduce) needs_subgroup_size = true; else needs_subgroup_invocation_id = true; break; case OpArrayLength: { auto *var = compiler.maybe_get_backing_variable(args[2]); if (var) compiler.buffers_requiring_array_length.insert(var->self); break; } case OpInBoundsAccessChain: case OpAccessChain: case OpPtrAccessChain: { // OpArrayLength might want to know if taking ArrayLength of an array of SSBOs. uint32_t result_type = args[0]; uint32_t id = args[1]; uint32_t ptr = args[2]; compiler.set(id, "", result_type, true); compiler.register_read(id, ptr, true); compiler.ir.ids[id].set_allow_type_rewrite(); break; } case OpExtInst: { uint32_t extension_set = args[2]; if (compiler.get(extension_set).ext == SPIRExtension::GLSL) { auto op_450 = static_cast(args[3]); switch (op_450) { case GLSLstd450InterpolateAtCentroid: case GLSLstd450InterpolateAtSample: case GLSLstd450InterpolateAtOffset: { if (!compiler.msl_options.supports_msl_version(2, 3)) SPIRV_CROSS_THROW("Pull-model interpolation requires MSL 2.3."); // Fragment varyings used with pull-model interpolation need special handling, // due to the way pull-model interpolation works in Metal. auto *var = compiler.maybe_get_backing_variable(args[4]); if (var) { compiler.pull_model_inputs.insert(var->self); auto &var_type = compiler.get_variable_element_type(*var); // In addition, if this variable has a 'Sample' decoration, we need the sample ID // in order to do default interpolation. if (compiler.has_decoration(var->self, DecorationSample)) { needs_sample_id = true; } else if (var_type.basetype == SPIRType::Struct) { // Now we need to check each member and see if it has this decoration. for (uint32_t i = 0; i < var_type.member_types.size(); ++i) { if (compiler.has_member_decoration(var_type.self, i, DecorationSample)) { needs_sample_id = true; break; } } } } break; } default: break; } } break; } default: break; } // If it has one, keep track of the instruction's result type, mapped by ID uint32_t result_type, result_id; if (compiler.instruction_to_result_type(result_type, result_id, opcode, args, length)) result_types[result_id] = result_type; return true; } // If the variable is a Uniform or StorageBuffer, mark that a resource has been written to. void CompilerMSL::OpCodePreprocessor::check_resource_write(uint32_t var_id) { auto *p_var = compiler.maybe_get_backing_variable(var_id); StorageClass sc = p_var ? p_var->storage : StorageClassMax; if (!compiler.msl_options.supports_msl_version(2, 1) && (sc == StorageClassUniform || sc == StorageClassStorageBuffer)) uses_resource_write = true; } // Returns an enumeration of a SPIR-V function that needs to be output for certain Op codes. CompilerMSL::SPVFuncImpl CompilerMSL::OpCodePreprocessor::get_spv_func_impl(Op opcode, const uint32_t *args) { switch (opcode) { case OpFMod: return SPVFuncImplMod; case OpFAdd: if (compiler.msl_options.invariant_float_math) { return SPVFuncImplFAdd; } break; case OpFMul: case OpOuterProduct: case OpMatrixTimesVector: case OpVectorTimesMatrix: case OpMatrixTimesMatrix: if (compiler.msl_options.invariant_float_math) { return SPVFuncImplFMul; } break; case OpTypeArray: { // Allow Metal to use the array template to make arrays a value type return SPVFuncImplUnsafeArray; } // Emulate texture2D atomic operations case OpAtomicExchange: case OpAtomicCompareExchange: case OpAtomicCompareExchangeWeak: case OpAtomicIIncrement: case OpAtomicIDecrement: case OpAtomicIAdd: case OpAtomicISub: case OpAtomicSMin: case OpAtomicUMin: case OpAtomicSMax: case OpAtomicUMax: case OpAtomicAnd: case OpAtomicOr: case OpAtomicXor: case OpAtomicLoad: case OpAtomicStore: { auto it = image_pointers.find(args[opcode == OpAtomicStore ? 0 : 2]); if (it != image_pointers.end()) { uint32_t tid = compiler.get(it->second).basetype; if (tid && compiler.get(tid).image.dim == Dim2D) return SPVFuncImplImage2DAtomicCoords; } break; } case OpImageFetch: case OpImageRead: case OpImageWrite: { // Retrieve the image type, and if it's a Buffer, emit a texel coordinate function uint32_t tid = result_types[args[opcode == OpImageWrite ? 0 : 2]]; if (tid && compiler.get(tid).image.dim == DimBuffer && !compiler.msl_options.texture_buffer_native) return SPVFuncImplTexelBufferCoords; break; } case OpExtInst: { uint32_t extension_set = args[2]; if (compiler.get(extension_set).ext == SPIRExtension::GLSL) { auto op_450 = static_cast(args[3]); switch (op_450) { case GLSLstd450Radians: return SPVFuncImplRadians; case GLSLstd450Degrees: return SPVFuncImplDegrees; case GLSLstd450FindILsb: return SPVFuncImplFindILsb; case GLSLstd450FindSMsb: return SPVFuncImplFindSMsb; case GLSLstd450FindUMsb: return SPVFuncImplFindUMsb; case GLSLstd450SSign: return SPVFuncImplSSign; case GLSLstd450Reflect: { auto &type = compiler.get(args[0]); if (type.vecsize == 1) return SPVFuncImplReflectScalar; break; } case GLSLstd450Refract: { auto &type = compiler.get(args[0]); if (type.vecsize == 1) return SPVFuncImplRefractScalar; break; } case GLSLstd450FaceForward: { auto &type = compiler.get(args[0]); if (type.vecsize == 1) return SPVFuncImplFaceForwardScalar; break; } case GLSLstd450MatrixInverse: { auto &mat_type = compiler.get(args[0]); switch (mat_type.columns) { case 2: return SPVFuncImplInverse2x2; case 3: return SPVFuncImplInverse3x3; case 4: return SPVFuncImplInverse4x4; default: break; } break; } default: break; } } break; } case OpGroupNonUniformBroadcast: return SPVFuncImplSubgroupBroadcast; case OpGroupNonUniformBroadcastFirst: return SPVFuncImplSubgroupBroadcastFirst; case OpGroupNonUniformBallot: return SPVFuncImplSubgroupBallot; case OpGroupNonUniformInverseBallot: case OpGroupNonUniformBallotBitExtract: return SPVFuncImplSubgroupBallotBitExtract; case OpGroupNonUniformBallotFindLSB: return SPVFuncImplSubgroupBallotFindLSB; case OpGroupNonUniformBallotFindMSB: return SPVFuncImplSubgroupBallotFindMSB; case OpGroupNonUniformBallotBitCount: return SPVFuncImplSubgroupBallotBitCount; case OpGroupNonUniformAllEqual: return SPVFuncImplSubgroupAllEqual; case OpGroupNonUniformShuffle: return SPVFuncImplSubgroupShuffle; case OpGroupNonUniformShuffleXor: return SPVFuncImplSubgroupShuffleXor; case OpGroupNonUniformShuffleUp: return SPVFuncImplSubgroupShuffleUp; case OpGroupNonUniformShuffleDown: return SPVFuncImplSubgroupShuffleDown; case OpGroupNonUniformQuadBroadcast: return SPVFuncImplQuadBroadcast; case OpGroupNonUniformQuadSwap: return SPVFuncImplQuadSwap; default: break; } return SPVFuncImplNone; } // Sort both type and meta member content based on builtin status (put builtins at end), // then by the required sorting aspect. void CompilerMSL::MemberSorter::sort() { // Create a temporary array of consecutive member indices and sort it based on how // the members should be reordered, based on builtin and sorting aspect meta info. size_t mbr_cnt = type.member_types.size(); SmallVector mbr_idxs(mbr_cnt); std::iota(mbr_idxs.begin(), mbr_idxs.end(), 0); // Fill with consecutive indices std::stable_sort(mbr_idxs.begin(), mbr_idxs.end(), *this); // Sort member indices based on sorting aspect bool sort_is_identity = true; for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++) { if (mbr_idx != mbr_idxs[mbr_idx]) { sort_is_identity = false; break; } } if (sort_is_identity) return; if (meta.members.size() < type.member_types.size()) { // This should never trigger in normal circumstances, but to be safe. meta.members.resize(type.member_types.size()); } // Move type and meta member info to the order defined by the sorted member indices. // This is done by creating temporary copies of both member types and meta, and then // copying back to the original content at the sorted indices. auto mbr_types_cpy = type.member_types; auto mbr_meta_cpy = meta.members; for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++) { type.member_types[mbr_idx] = mbr_types_cpy[mbr_idxs[mbr_idx]]; meta.members[mbr_idx] = mbr_meta_cpy[mbr_idxs[mbr_idx]]; } if (sort_aspect == SortAspect::Offset) { // If we're sorting by Offset, this might affect user code which accesses a buffer block. // We will need to redirect member indices from one index to sorted index. type.member_type_index_redirection = std::move(mbr_idxs); } } // Sort first by builtin status (put builtins at end), then by the sorting aspect. bool CompilerMSL::MemberSorter::operator()(uint32_t mbr_idx1, uint32_t mbr_idx2) { auto &mbr_meta1 = meta.members[mbr_idx1]; auto &mbr_meta2 = meta.members[mbr_idx2]; if (mbr_meta1.builtin != mbr_meta2.builtin) return mbr_meta2.builtin; else switch (sort_aspect) { case Location: return mbr_meta1.location < mbr_meta2.location; case LocationReverse: return mbr_meta1.location > mbr_meta2.location; case Offset: return mbr_meta1.offset < mbr_meta2.offset; case OffsetThenLocationReverse: return (mbr_meta1.offset < mbr_meta2.offset) || ((mbr_meta1.offset == mbr_meta2.offset) && (mbr_meta1.location > mbr_meta2.location)); case Alphabetical: return mbr_meta1.alias < mbr_meta2.alias; default: return false; } } CompilerMSL::MemberSorter::MemberSorter(SPIRType &t, Meta &m, SortAspect sa) : type(t) , meta(m) , sort_aspect(sa) { // Ensure enough meta info is available meta.members.resize(max(type.member_types.size(), meta.members.size())); } void CompilerMSL::remap_constexpr_sampler(VariableID id, const MSLConstexprSampler &sampler) { auto &type = get(get(id).basetype); if (type.basetype != SPIRType::SampledImage && type.basetype != SPIRType::Sampler) SPIRV_CROSS_THROW("Can only remap SampledImage and Sampler type."); if (!type.array.empty()) SPIRV_CROSS_THROW("Can not remap array of samplers."); constexpr_samplers_by_id[id] = sampler; } void CompilerMSL::remap_constexpr_sampler_by_binding(uint32_t desc_set, uint32_t binding, const MSLConstexprSampler &sampler) { constexpr_samplers_by_binding[{ desc_set, binding }] = sampler; } void CompilerMSL::cast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type) { auto *var = maybe_get_backing_variable(source_id); if (var) source_id = var->self; // Only interested in standalone builtin variables. if (!has_decoration(source_id, DecorationBuiltIn)) return; auto builtin = static_cast(get_decoration(source_id, DecorationBuiltIn)); auto expected_type = expr_type.basetype; auto expected_width = expr_type.width; switch (builtin) { case BuiltInGlobalInvocationId: case BuiltInLocalInvocationId: case BuiltInWorkgroupId: case BuiltInLocalInvocationIndex: case BuiltInWorkgroupSize: case BuiltInNumWorkgroups: case BuiltInLayer: case BuiltInViewportIndex: case BuiltInFragStencilRefEXT: case BuiltInPrimitiveId: case BuiltInSubgroupSize: case BuiltInSubgroupLocalInvocationId: case BuiltInViewIndex: case BuiltInVertexIndex: case BuiltInInstanceIndex: case BuiltInBaseInstance: case BuiltInBaseVertex: expected_type = SPIRType::UInt; expected_width = 32; break; case BuiltInTessLevelInner: case BuiltInTessLevelOuter: if (get_execution_model() == ExecutionModelTessellationControl) { expected_type = SPIRType::Half; expected_width = 16; } break; default: break; } if (expected_type != expr_type.basetype) { if (expected_width != expr_type.width) { // These are of different widths, so we cannot do a straight bitcast. expr = join(type_to_glsl(expr_type), "(", expr, ")"); } else { expr = bitcast_expression(expr_type, expected_type, expr); } } if (builtin == BuiltInTessCoord && get_entry_point().flags.get(ExecutionModeQuads) && expr_type.vecsize == 3) { // In SPIR-V, this is always a vec3, even for quads. In Metal, though, it's a float2 for quads. // The code is expecting a float3, so we need to widen this. expr = join("float3(", expr, ", 0)"); } } void CompilerMSL::cast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type) { auto *var = maybe_get_backing_variable(target_id); if (var) target_id = var->self; // Only interested in standalone builtin variables. if (!has_decoration(target_id, DecorationBuiltIn)) return; auto builtin = static_cast(get_decoration(target_id, DecorationBuiltIn)); auto expected_type = expr_type.basetype; auto expected_width = expr_type.width; switch (builtin) { case BuiltInLayer: case BuiltInViewportIndex: case BuiltInFragStencilRefEXT: case BuiltInPrimitiveId: case BuiltInViewIndex: expected_type = SPIRType::UInt; expected_width = 32; break; case BuiltInTessLevelInner: case BuiltInTessLevelOuter: expected_type = SPIRType::Half; expected_width = 16; break; default: break; } if (expected_type != expr_type.basetype) { if (expected_width != expr_type.width) { // These are of different widths, so we cannot do a straight bitcast. auto type = expr_type; type.basetype = expected_type; type.width = expected_width; expr = join(type_to_glsl(type), "(", expr, ")"); } else { auto type = expr_type; type.basetype = expected_type; expr = bitcast_expression(type, expr_type.basetype, expr); } } } string CompilerMSL::to_initializer_expression(const SPIRVariable &var) { // We risk getting an array initializer here with MSL. If we have an array. // FIXME: We cannot handle non-constant arrays being initialized. // We will need to inject spvArrayCopy here somehow ... auto &type = get(var.basetype); string expr; if (ir.ids[var.initializer].get_type() == TypeConstant && (!type.array.empty() || type.basetype == SPIRType::Struct)) expr = constant_expression(get(var.initializer)); else expr = CompilerGLSL::to_initializer_expression(var); // If the initializer has more vector components than the variable, add a swizzle. // FIXME: This can't handle arrays or structs. auto &init_type = expression_type(var.initializer); if (type.array.empty() && type.basetype != SPIRType::Struct && init_type.vecsize > type.vecsize) expr = enclose_expression(expr + vector_swizzle(type.vecsize, 0)); return expr; } string CompilerMSL::to_zero_initialized_expression(uint32_t) { return "{}"; } bool CompilerMSL::descriptor_set_is_argument_buffer(uint32_t desc_set) const { if (!msl_options.argument_buffers) return false; if (desc_set >= kMaxArgumentBuffers) return false; return (argument_buffer_discrete_mask & (1u << desc_set)) == 0; } bool CompilerMSL::is_supported_argument_buffer_type(const SPIRType &type) const { // Very specifically, image load-store in argument buffers are disallowed on MSL on iOS. // But we won't know when the argument buffer is encoded whether this image will have // a NonWritable decoration. So just use discrete arguments for all storage images // on iOS. bool is_storage_image = type.basetype == SPIRType::Image && type.image.sampled == 2; bool is_supported_type = !msl_options.is_ios() || !is_storage_image; return !type_is_msl_framebuffer_fetch(type) && is_supported_type; } void CompilerMSL::analyze_argument_buffers() { // Gather all used resources and sort them out into argument buffers. // Each argument buffer corresponds to a descriptor set in SPIR-V. // The [[id(N)]] values used correspond to the resource mapping we have for MSL. // Otherwise, the binding number is used, but this is generally not safe some types like // combined image samplers and arrays of resources. Metal needs different indices here, // while SPIR-V can have one descriptor set binding. To use argument buffers in practice, // you will need to use the remapping from the API. for (auto &id : argument_buffer_ids) id = 0; // Output resources, sorted by resource index & type. struct Resource { SPIRVariable *var; string name; SPIRType::BaseType basetype; uint32_t index; uint32_t plane; }; SmallVector resources_in_set[kMaxArgumentBuffers]; SmallVector inline_block_vars; bool set_needs_swizzle_buffer[kMaxArgumentBuffers] = {}; bool set_needs_buffer_sizes[kMaxArgumentBuffers] = {}; bool needs_buffer_sizes = false; ir.for_each_typed_id([&](uint32_t self, SPIRVariable &var) { if ((var.storage == StorageClassUniform || var.storage == StorageClassUniformConstant || var.storage == StorageClassStorageBuffer) && !is_hidden_variable(var)) { uint32_t desc_set = get_decoration(self, DecorationDescriptorSet); // Ignore if it's part of a push descriptor set. if (!descriptor_set_is_argument_buffer(desc_set)) return; uint32_t var_id = var.self; auto &type = get_variable_data_type(var); if (desc_set >= kMaxArgumentBuffers) SPIRV_CROSS_THROW("Descriptor set index is out of range."); const MSLConstexprSampler *constexpr_sampler = nullptr; if (type.basetype == SPIRType::SampledImage || type.basetype == SPIRType::Sampler) { constexpr_sampler = find_constexpr_sampler(var_id); if (constexpr_sampler) { // Mark this ID as a constexpr sampler for later in case it came from set/bindings. constexpr_samplers_by_id[var_id] = *constexpr_sampler; } } uint32_t binding = get_decoration(var_id, DecorationBinding); if (type.basetype == SPIRType::SampledImage) { add_resource_name(var_id); uint32_t plane_count = 1; if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable) plane_count = constexpr_sampler->planes; for (uint32_t i = 0; i < plane_count; i++) { uint32_t image_resource_index = get_metal_resource_index(var, SPIRType::Image, i); resources_in_set[desc_set].push_back( { &var, to_name(var_id), SPIRType::Image, image_resource_index, i }); } if (type.image.dim != DimBuffer && !constexpr_sampler) { uint32_t sampler_resource_index = get_metal_resource_index(var, SPIRType::Sampler); resources_in_set[desc_set].push_back( { &var, to_sampler_expression(var_id), SPIRType::Sampler, sampler_resource_index, 0 }); } } else if (inline_uniform_blocks.count(SetBindingPair{ desc_set, binding })) { inline_block_vars.push_back(var_id); } else if (!constexpr_sampler && is_supported_argument_buffer_type(type)) { // constexpr samplers are not declared as resources. // Inline uniform blocks are always emitted at the end. add_resource_name(var_id); resources_in_set[desc_set].push_back( { &var, to_name(var_id), type.basetype, get_metal_resource_index(var, type.basetype), 0 }); // Emulate texture2D atomic operations if (atomic_image_vars.count(var.self)) { uint32_t buffer_resource_index = get_metal_resource_index(var, SPIRType::AtomicCounter, 0); resources_in_set[desc_set].push_back( { &var, to_name(var_id) + "_atomic", SPIRType::Struct, buffer_resource_index, 0 }); } } // Check if this descriptor set needs a swizzle buffer. if (needs_swizzle_buffer_def && is_sampled_image_type(type)) set_needs_swizzle_buffer[desc_set] = true; else if (buffers_requiring_array_length.count(var_id) != 0) { set_needs_buffer_sizes[desc_set] = true; needs_buffer_sizes = true; } } }); if (needs_swizzle_buffer_def || needs_buffer_sizes) { uint32_t uint_ptr_type_id = 0; // We might have to add a swizzle buffer resource to the set. for (uint32_t desc_set = 0; desc_set < kMaxArgumentBuffers; desc_set++) { if (!set_needs_swizzle_buffer[desc_set] && !set_needs_buffer_sizes[desc_set]) continue; if (uint_ptr_type_id == 0) { uint_ptr_type_id = ir.increase_bound_by(1); // Create a buffer to hold extra data, including the swizzle constants. SPIRType uint_type_pointer = get_uint_type(); uint_type_pointer.pointer = true; uint_type_pointer.pointer_depth = 1; uint_type_pointer.parent_type = get_uint_type_id(); uint_type_pointer.storage = StorageClassUniform; set(uint_ptr_type_id, uint_type_pointer); set_decoration(uint_ptr_type_id, DecorationArrayStride, 4); } if (set_needs_swizzle_buffer[desc_set]) { uint32_t var_id = ir.increase_bound_by(1); auto &var = set(var_id, uint_ptr_type_id, StorageClassUniformConstant); set_name(var_id, "spvSwizzleConstants"); set_decoration(var_id, DecorationDescriptorSet, desc_set); set_decoration(var_id, DecorationBinding, kSwizzleBufferBinding); resources_in_set[desc_set].push_back( { &var, to_name(var_id), SPIRType::UInt, get_metal_resource_index(var, SPIRType::UInt), 0 }); } if (set_needs_buffer_sizes[desc_set]) { uint32_t var_id = ir.increase_bound_by(1); auto &var = set(var_id, uint_ptr_type_id, StorageClassUniformConstant); set_name(var_id, "spvBufferSizeConstants"); set_decoration(var_id, DecorationDescriptorSet, desc_set); set_decoration(var_id, DecorationBinding, kBufferSizeBufferBinding); resources_in_set[desc_set].push_back( { &var, to_name(var_id), SPIRType::UInt, get_metal_resource_index(var, SPIRType::UInt), 0 }); } } } // Now add inline uniform blocks. for (uint32_t var_id : inline_block_vars) { auto &var = get(var_id); uint32_t desc_set = get_decoration(var_id, DecorationDescriptorSet); add_resource_name(var_id); resources_in_set[desc_set].push_back( { &var, to_name(var_id), SPIRType::Struct, get_metal_resource_index(var, SPIRType::Struct), 0 }); } for (uint32_t desc_set = 0; desc_set < kMaxArgumentBuffers; desc_set++) { auto &resources = resources_in_set[desc_set]; if (resources.empty()) continue; assert(descriptor_set_is_argument_buffer(desc_set)); uint32_t next_id = ir.increase_bound_by(3); uint32_t type_id = next_id + 1; uint32_t ptr_type_id = next_id + 2; argument_buffer_ids[desc_set] = next_id; auto &buffer_type = set(type_id); buffer_type.basetype = SPIRType::Struct; if ((argument_buffer_device_storage_mask & (1u << desc_set)) != 0) { buffer_type.storage = StorageClassStorageBuffer; // Make sure the argument buffer gets marked as const device. set_decoration(next_id, DecorationNonWritable); // Need to mark the type as a Block to enable this. set_decoration(type_id, DecorationBlock); } else buffer_type.storage = StorageClassUniform; set_name(type_id, join("spvDescriptorSetBuffer", desc_set)); auto &ptr_type = set(ptr_type_id); ptr_type = buffer_type; ptr_type.pointer = true; ptr_type.pointer_depth = 1; ptr_type.parent_type = type_id; uint32_t buffer_variable_id = next_id; set(buffer_variable_id, ptr_type_id, StorageClassUniform); set_name(buffer_variable_id, join("spvDescriptorSet", desc_set)); // Ids must be emitted in ID order. sort(begin(resources), end(resources), [&](const Resource &lhs, const Resource &rhs) -> bool { return tie(lhs.index, lhs.basetype) < tie(rhs.index, rhs.basetype); }); uint32_t member_index = 0; for (auto &resource : resources) { auto &var = *resource.var; auto &type = get_variable_data_type(var); string mbr_name = ensure_valid_name(resource.name, "m"); if (resource.plane > 0) mbr_name += join(plane_name_suffix, resource.plane); set_member_name(buffer_type.self, member_index, mbr_name); if (resource.basetype == SPIRType::Sampler && type.basetype != SPIRType::Sampler) { // Have to synthesize a sampler type here. bool type_is_array = !type.array.empty(); uint32_t sampler_type_id = ir.increase_bound_by(type_is_array ? 2 : 1); auto &new_sampler_type = set(sampler_type_id); new_sampler_type.basetype = SPIRType::Sampler; new_sampler_type.storage = StorageClassUniformConstant; if (type_is_array) { uint32_t sampler_type_array_id = sampler_type_id + 1; auto &sampler_type_array = set(sampler_type_array_id); sampler_type_array = new_sampler_type; sampler_type_array.array = type.array; sampler_type_array.array_size_literal = type.array_size_literal; sampler_type_array.parent_type = sampler_type_id; buffer_type.member_types.push_back(sampler_type_array_id); } else buffer_type.member_types.push_back(sampler_type_id); } else { uint32_t binding = get_decoration(var.self, DecorationBinding); SetBindingPair pair = { desc_set, binding }; if (resource.basetype == SPIRType::Image || resource.basetype == SPIRType::Sampler || resource.basetype == SPIRType::SampledImage) { // Drop pointer information when we emit the resources into a struct. buffer_type.member_types.push_back(get_variable_data_type_id(var)); if (resource.plane == 0) set_qualified_name(var.self, join(to_name(buffer_variable_id), ".", mbr_name)); } else if (buffers_requiring_dynamic_offset.count(pair)) { // Don't set the qualified name here; we'll define a variable holding the corrected buffer address later. buffer_type.member_types.push_back(var.basetype); buffers_requiring_dynamic_offset[pair].second = var.self; } else if (inline_uniform_blocks.count(pair)) { // Put the buffer block itself into the argument buffer. buffer_type.member_types.push_back(get_variable_data_type_id(var)); set_qualified_name(var.self, join(to_name(buffer_variable_id), ".", mbr_name)); } else if (atomic_image_vars.count(var.self)) { // Emulate texture2D atomic operations. // Don't set the qualified name: it's already set for this variable, // and the code that references the buffer manually appends "_atomic" // to the name. uint32_t offset = ir.increase_bound_by(2); uint32_t atomic_type_id = offset; uint32_t type_ptr_id = offset + 1; SPIRType atomic_type; atomic_type.basetype = SPIRType::AtomicCounter; atomic_type.width = 32; atomic_type.vecsize = 1; set(atomic_type_id, atomic_type); atomic_type.pointer = true; atomic_type.parent_type = atomic_type_id; atomic_type.storage = StorageClassStorageBuffer; auto &atomic_ptr_type = set(type_ptr_id, atomic_type); atomic_ptr_type.self = atomic_type_id; buffer_type.member_types.push_back(type_ptr_id); } else { // Resources will be declared as pointers not references, so automatically dereference as appropriate. buffer_type.member_types.push_back(var.basetype); if (type.array.empty()) set_qualified_name(var.self, join("(*", to_name(buffer_variable_id), ".", mbr_name, ")")); else set_qualified_name(var.self, join(to_name(buffer_variable_id), ".", mbr_name)); } } set_extended_member_decoration(buffer_type.self, member_index, SPIRVCrossDecorationResourceIndexPrimary, resource.index); set_extended_member_decoration(buffer_type.self, member_index, SPIRVCrossDecorationInterfaceOrigID, var.self); member_index++; } } } void CompilerMSL::activate_argument_buffer_resources() { // For ABI compatibility, force-enable all resources which are part of argument buffers. ir.for_each_typed_id([&](uint32_t self, const SPIRVariable &) { if (!has_decoration(self, DecorationDescriptorSet)) return; uint32_t desc_set = get_decoration(self, DecorationDescriptorSet); if (descriptor_set_is_argument_buffer(desc_set)) active_interface_variables.insert(self); }); } bool CompilerMSL::using_builtin_array() const { return msl_options.force_native_arrays || is_using_builtin_array; } void CompilerMSL::set_combined_sampler_suffix(const char *suffix) { sampler_name_suffix = suffix; } const char *CompilerMSL::get_combined_sampler_suffix() const { return sampler_name_suffix.c_str(); } spirv-cross-2021.01.15/spirv_msl.hpp000066400000000000000000001374551400026215700171400ustar00rootroot00000000000000/* * Copyright 2016-2021 The Brenwill Workshop Ltd. * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_MSL_HPP #define SPIRV_CROSS_MSL_HPP #include "spirv_glsl.hpp" #include #include #include #include #include namespace SPIRV_CROSS_NAMESPACE { // Indicates the format of a shader input. Currently limited to specifying // if the input is an 8-bit unsigned integer, 16-bit unsigned integer, or // some other format. enum MSLShaderInputFormat { MSL_SHADER_INPUT_FORMAT_OTHER = 0, MSL_SHADER_INPUT_FORMAT_UINT8 = 1, MSL_SHADER_INPUT_FORMAT_UINT16 = 2, MSL_SHADER_INPUT_FORMAT_ANY16 = 3, MSL_SHADER_INPUT_FORMAT_ANY32 = 4, // Deprecated aliases. MSL_VERTEX_FORMAT_OTHER = MSL_SHADER_INPUT_FORMAT_OTHER, MSL_VERTEX_FORMAT_UINT8 = MSL_SHADER_INPUT_FORMAT_UINT8, MSL_VERTEX_FORMAT_UINT16 = MSL_SHADER_INPUT_FORMAT_UINT16, MSL_SHADER_INPUT_FORMAT_INT_MAX = 0x7fffffff }; // Defines MSL characteristics of an input variable at a particular location. // After compilation, it is possible to query whether or not this location was used. // If vecsize is nonzero, it must be greater than or equal to the vecsize declared in the shader, // or behavior is undefined. struct MSLShaderInput { uint32_t location = 0; MSLShaderInputFormat format = MSL_SHADER_INPUT_FORMAT_OTHER; spv::BuiltIn builtin = spv::BuiltInMax; uint32_t vecsize = 0; }; // Matches the binding index of a MSL resource for a binding within a descriptor set. // Taken together, the stage, desc_set and binding combine to form a reference to a resource // descriptor used in a particular shading stage. The count field indicates the number of // resources consumed by this binding, if the binding represents an array of resources. // If the resource array is a run-time-sized array, which are legal in GLSL or SPIR-V, this value // will be used to declare the array size in MSL, which does not support run-time-sized arrays. // For resources that are not held in a run-time-sized array, the count field does not need to be populated. // If using MSL 2.0 argument buffers, the descriptor set is not marked as a discrete descriptor set, // and (for iOS only) the resource is not a storage image (sampled != 2), the binding reference we // remap to will become an [[id(N)]] attribute within the "descriptor set" argument buffer structure. // For resources which are bound in the "classic" MSL 1.0 way or discrete descriptors, the remap will become a // [[buffer(N)]], [[texture(N)]] or [[sampler(N)]] depending on the resource types used. struct MSLResourceBinding { spv::ExecutionModel stage = spv::ExecutionModelMax; uint32_t desc_set = 0; uint32_t binding = 0; uint32_t count = 0; uint32_t msl_buffer = 0; uint32_t msl_texture = 0; uint32_t msl_sampler = 0; }; enum MSLSamplerCoord { MSL_SAMPLER_COORD_NORMALIZED = 0, MSL_SAMPLER_COORD_PIXEL = 1, MSL_SAMPLER_INT_MAX = 0x7fffffff }; enum MSLSamplerFilter { MSL_SAMPLER_FILTER_NEAREST = 0, MSL_SAMPLER_FILTER_LINEAR = 1, MSL_SAMPLER_FILTER_INT_MAX = 0x7fffffff }; enum MSLSamplerMipFilter { MSL_SAMPLER_MIP_FILTER_NONE = 0, MSL_SAMPLER_MIP_FILTER_NEAREST = 1, MSL_SAMPLER_MIP_FILTER_LINEAR = 2, MSL_SAMPLER_MIP_FILTER_INT_MAX = 0x7fffffff }; enum MSLSamplerAddress { MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO = 0, MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE = 1, MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER = 2, MSL_SAMPLER_ADDRESS_REPEAT = 3, MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT = 4, MSL_SAMPLER_ADDRESS_INT_MAX = 0x7fffffff }; enum MSLSamplerCompareFunc { MSL_SAMPLER_COMPARE_FUNC_NEVER = 0, MSL_SAMPLER_COMPARE_FUNC_LESS = 1, MSL_SAMPLER_COMPARE_FUNC_LESS_EQUAL = 2, MSL_SAMPLER_COMPARE_FUNC_GREATER = 3, MSL_SAMPLER_COMPARE_FUNC_GREATER_EQUAL = 4, MSL_SAMPLER_COMPARE_FUNC_EQUAL = 5, MSL_SAMPLER_COMPARE_FUNC_NOT_EQUAL = 6, MSL_SAMPLER_COMPARE_FUNC_ALWAYS = 7, MSL_SAMPLER_COMPARE_FUNC_INT_MAX = 0x7fffffff }; enum MSLSamplerBorderColor { MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK = 0, MSL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK = 1, MSL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE = 2, MSL_SAMPLER_BORDER_COLOR_INT_MAX = 0x7fffffff }; enum MSLFormatResolution { MSL_FORMAT_RESOLUTION_444 = 0, MSL_FORMAT_RESOLUTION_422, MSL_FORMAT_RESOLUTION_420, MSL_FORMAT_RESOLUTION_INT_MAX = 0x7fffffff }; enum MSLChromaLocation { MSL_CHROMA_LOCATION_COSITED_EVEN = 0, MSL_CHROMA_LOCATION_MIDPOINT, MSL_CHROMA_LOCATION_INT_MAX = 0x7fffffff }; enum MSLComponentSwizzle { MSL_COMPONENT_SWIZZLE_IDENTITY = 0, MSL_COMPONENT_SWIZZLE_ZERO, MSL_COMPONENT_SWIZZLE_ONE, MSL_COMPONENT_SWIZZLE_R, MSL_COMPONENT_SWIZZLE_G, MSL_COMPONENT_SWIZZLE_B, MSL_COMPONENT_SWIZZLE_A, MSL_COMPONENT_SWIZZLE_INT_MAX = 0x7fffffff }; enum MSLSamplerYCbCrModelConversion { MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709, MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601, MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020, MSL_SAMPLER_YCBCR_MODEL_CONVERSION_INT_MAX = 0x7fffffff }; enum MSLSamplerYCbCrRange { MSL_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW, MSL_SAMPLER_YCBCR_RANGE_INT_MAX = 0x7fffffff }; struct MSLConstexprSampler { MSLSamplerCoord coord = MSL_SAMPLER_COORD_NORMALIZED; MSLSamplerFilter min_filter = MSL_SAMPLER_FILTER_NEAREST; MSLSamplerFilter mag_filter = MSL_SAMPLER_FILTER_NEAREST; MSLSamplerMipFilter mip_filter = MSL_SAMPLER_MIP_FILTER_NONE; MSLSamplerAddress s_address = MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; MSLSamplerAddress t_address = MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; MSLSamplerAddress r_address = MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; MSLSamplerCompareFunc compare_func = MSL_SAMPLER_COMPARE_FUNC_NEVER; MSLSamplerBorderColor border_color = MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK; float lod_clamp_min = 0.0f; float lod_clamp_max = 1000.0f; int max_anisotropy = 1; // Sampler Y'CbCr conversion parameters uint32_t planes = 0; MSLFormatResolution resolution = MSL_FORMAT_RESOLUTION_444; MSLSamplerFilter chroma_filter = MSL_SAMPLER_FILTER_NEAREST; MSLChromaLocation x_chroma_offset = MSL_CHROMA_LOCATION_COSITED_EVEN; MSLChromaLocation y_chroma_offset = MSL_CHROMA_LOCATION_COSITED_EVEN; MSLComponentSwizzle swizzle[4]; // IDENTITY, IDENTITY, IDENTITY, IDENTITY MSLSamplerYCbCrModelConversion ycbcr_model = MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY; MSLSamplerYCbCrRange ycbcr_range = MSL_SAMPLER_YCBCR_RANGE_ITU_FULL; uint32_t bpc = 8; bool compare_enable = false; bool lod_clamp_enable = false; bool anisotropy_enable = false; bool ycbcr_conversion_enable = false; MSLConstexprSampler() { for (uint32_t i = 0; i < 4; i++) swizzle[i] = MSL_COMPONENT_SWIZZLE_IDENTITY; } bool swizzle_is_identity() const { return (swizzle[0] == MSL_COMPONENT_SWIZZLE_IDENTITY && swizzle[1] == MSL_COMPONENT_SWIZZLE_IDENTITY && swizzle[2] == MSL_COMPONENT_SWIZZLE_IDENTITY && swizzle[3] == MSL_COMPONENT_SWIZZLE_IDENTITY); } bool swizzle_has_one_or_zero() const { return (swizzle[0] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[0] == MSL_COMPONENT_SWIZZLE_ONE || swizzle[1] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[1] == MSL_COMPONENT_SWIZZLE_ONE || swizzle[2] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[2] == MSL_COMPONENT_SWIZZLE_ONE || swizzle[3] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[3] == MSL_COMPONENT_SWIZZLE_ONE); } }; // Special constant used in a MSLResourceBinding desc_set // element to indicate the bindings for the push constants. // Kinda deprecated. Just use ResourceBindingPushConstant{DescriptorSet,Binding} directly. static const uint32_t kPushConstDescSet = ResourceBindingPushConstantDescriptorSet; // Special constant used in a MSLResourceBinding binding // element to indicate the bindings for the push constants. // Kinda deprecated. Just use ResourceBindingPushConstant{DescriptorSet,Binding} directly. static const uint32_t kPushConstBinding = ResourceBindingPushConstantBinding; // Special constant used in a MSLResourceBinding binding // element to indicate the buffer binding for swizzle buffers. static const uint32_t kSwizzleBufferBinding = ~(1u); // Special constant used in a MSLResourceBinding binding // element to indicate the buffer binding for buffer size buffers to support OpArrayLength. static const uint32_t kBufferSizeBufferBinding = ~(2u); // Special constant used in a MSLResourceBinding binding // element to indicate the buffer binding used for the argument buffer itself. // This buffer binding should be kept as small as possible as all automatic bindings for buffers // will start at max(kArgumentBufferBinding) + 1. static const uint32_t kArgumentBufferBinding = ~(3u); static const uint32_t kMaxArgumentBuffers = 8; // The arbitrary maximum for the nesting of array of array copies. static const uint32_t kArrayCopyMultidimMax = 6; // Decompiles SPIR-V to Metal Shading Language class CompilerMSL : public CompilerGLSL { public: // Options for compiling to Metal Shading Language struct Options { typedef enum { iOS = 0, macOS = 1 } Platform; Platform platform = macOS; uint32_t msl_version = make_msl_version(1, 2); uint32_t texel_buffer_texture_width = 4096; // Width of 2D Metal textures used as 1D texel buffers uint32_t r32ui_linear_texture_alignment = 4; uint32_t r32ui_alignment_constant_id = 65535; uint32_t swizzle_buffer_index = 30; uint32_t indirect_params_buffer_index = 29; uint32_t shader_output_buffer_index = 28; uint32_t shader_patch_output_buffer_index = 27; uint32_t shader_tess_factor_buffer_index = 26; uint32_t buffer_size_buffer_index = 25; uint32_t view_mask_buffer_index = 24; uint32_t dynamic_offsets_buffer_index = 23; uint32_t shader_input_buffer_index = 22; uint32_t shader_index_buffer_index = 21; uint32_t shader_input_wg_index = 0; uint32_t device_index = 0; uint32_t enable_frag_output_mask = 0xffffffff; // Metal doesn't allow setting a fixed sample mask directly in the pipeline. // We can evade this restriction by ANDing the internal sample_mask output // of the shader with the additional fixed sample mask. uint32_t additional_fixed_sample_mask = 0xffffffff; bool enable_point_size_builtin = true; bool enable_frag_depth_builtin = true; bool enable_frag_stencil_ref_builtin = true; bool disable_rasterization = false; bool capture_output_to_buffer = false; bool swizzle_texture_samples = false; bool tess_domain_origin_lower_left = false; bool multiview = false; bool multiview_layered_rendering = true; bool view_index_from_device_index = false; bool dispatch_base = false; bool texture_1D_as_2D = false; // Enable use of MSL 2.0 indirect argument buffers. // MSL 2.0 must also be enabled. bool argument_buffers = false; // Ensures vertex and instance indices start at zero. This reflects the behavior of HLSL with SV_VertexID and SV_InstanceID. bool enable_base_index_zero = false; // Fragment output in MSL must have at least as many components as the render pass. // Add support to explicit pad out components. bool pad_fragment_output_components = false; // Specifies whether the iOS target version supports the [[base_vertex]] and [[base_instance]] attributes. bool ios_support_base_vertex_instance = false; // Use Metal's native frame-buffer fetch API for subpass inputs. bool use_framebuffer_fetch_subpasses = false; // Enables use of "fma" intrinsic for invariant float math bool invariant_float_math = false; // Emulate texturecube_array with texture2d_array for iOS where this type is not available bool emulate_cube_array = false; // Allow user to enable decoration binding bool enable_decoration_binding = false; // Requires MSL 2.1, use the native support for texel buffers. bool texture_buffer_native = false; // Forces all resources which are part of an argument buffer to be considered active. // This ensures ABI compatibility between shaders where some resources might be unused, // and would otherwise declare a different IAB. bool force_active_argument_buffer_resources = false; // Forces the use of plain arrays, which works around certain driver bugs on certain versions // of Intel Macbooks. See https://github.com/KhronosGroup/SPIRV-Cross/issues/1210. // May reduce performance in scenarios where arrays are copied around as value-types. bool force_native_arrays = false; // If a shader writes clip distance, also emit user varyings which // can be read in subsequent stages. bool enable_clip_distance_user_varying = true; // In a tessellation control shader, assume that more than one patch can be processed in a // single workgroup. This requires changes to the way the InvocationId and PrimitiveId // builtins are processed, but should result in more efficient usage of the GPU. bool multi_patch_workgroup = false; // If set, a vertex shader will be compiled as part of a tessellation pipeline. // It will be translated as a compute kernel, so it can use the global invocation ID // to index the output buffer. bool vertex_for_tessellation = false; // Assume that SubpassData images have multiple layers. Layered input attachments // are addressed relative to the Layer output from the vertex pipeline. This option // has no effect with multiview, since all input attachments are assumed to be layered // and will be addressed using the current ViewIndex. bool arrayed_subpass_input = false; // Whether to use SIMD-group or quadgroup functions to implement group nnon-uniform // operations. Some GPUs on iOS do not support the SIMD-group functions, only the // quadgroup functions. bool ios_use_simdgroup_functions = false; // If set, the subgroup size will be assumed to be one, and subgroup-related // builtins and operations will be emitted accordingly. This mode is intended to // be used by MoltenVK on hardware/software configurations which do not provide // sufficient support for subgroups. bool emulate_subgroups = false; // If nonzero, a fixed subgroup size to assume. Metal, similarly to VK_EXT_subgroup_size_control, // allows the SIMD-group size (aka thread execution width) to vary depending on // register usage and requirements. In certain circumstances--for example, a pipeline // in MoltenVK without VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT-- // this is undesirable. This fixes the value of the SubgroupSize builtin, instead of // mapping it to the Metal builtin [[thread_execution_width]]. If the thread // execution width is reduced, the extra invocations will appear to be inactive. // If zero, the SubgroupSize will be allowed to vary, and the builtin will be mapped // to the Metal [[thread_execution_width]] builtin. uint32_t fixed_subgroup_size = 0; enum class IndexType { None = 0, UInt16 = 1, UInt32 = 2 }; // The type of index in the index buffer, if present. For a compute shader, Metal // requires specifying the indexing at pipeline creation, rather than at draw time // as with graphics pipelines. This means we must create three different pipelines, // for no indexing, 16-bit indices, and 32-bit indices. Each requires different // handling for the gl_VertexIndex builtin. We may as well, then, create three // different shaders for these three scenarios. IndexType vertex_index_type = IndexType::None; // If set, a dummy [[sample_id]] input is added to a fragment shader if none is present. // This will force the shader to run at sample rate, assuming Metal does not optimize // the extra threads away. bool force_sample_rate_shading = false; bool is_ios() const { return platform == iOS; } bool is_macos() const { return platform == macOS; } void set_msl_version(uint32_t major, uint32_t minor = 0, uint32_t patch = 0) { msl_version = make_msl_version(major, minor, patch); } bool supports_msl_version(uint32_t major, uint32_t minor = 0, uint32_t patch = 0) const { return msl_version >= make_msl_version(major, minor, patch); } static uint32_t make_msl_version(uint32_t major, uint32_t minor = 0, uint32_t patch = 0) { return (major * 10000) + (minor * 100) + patch; } }; const Options &get_msl_options() const { return msl_options; } void set_msl_options(const Options &opts) { msl_options = opts; } // Provide feedback to calling API to allow runtime to disable pipeline // rasterization if vertex shader requires rasterization to be disabled. bool get_is_rasterization_disabled() const { return is_rasterization_disabled && (get_entry_point().model == spv::ExecutionModelVertex || get_entry_point().model == spv::ExecutionModelTessellationControl || get_entry_point().model == spv::ExecutionModelTessellationEvaluation); } // Provide feedback to calling API to allow it to pass an auxiliary // swizzle buffer if the shader needs it. bool needs_swizzle_buffer() const { return used_swizzle_buffer; } // Provide feedback to calling API to allow it to pass a buffer // containing STORAGE_BUFFER buffer sizes to support OpArrayLength. bool needs_buffer_size_buffer() const { return !buffers_requiring_array_length.empty(); } // Provide feedback to calling API to allow it to pass a buffer // containing the view mask for the current multiview subpass. bool needs_view_mask_buffer() const { return msl_options.multiview && !msl_options.view_index_from_device_index; } // Provide feedback to calling API to allow it to pass a buffer // containing the dispatch base workgroup ID. bool needs_dispatch_base_buffer() const { return msl_options.dispatch_base && !msl_options.supports_msl_version(1, 2); } // Provide feedback to calling API to allow it to pass an output // buffer if the shader needs it. bool needs_output_buffer() const { return capture_output_to_buffer && stage_out_var_id != ID(0); } // Provide feedback to calling API to allow it to pass a patch output // buffer if the shader needs it. bool needs_patch_output_buffer() const { return capture_output_to_buffer && patch_stage_out_var_id != ID(0); } // Provide feedback to calling API to allow it to pass an input threadgroup // buffer if the shader needs it. bool needs_input_threadgroup_mem() const { return capture_output_to_buffer && stage_in_var_id != ID(0); } explicit CompilerMSL(std::vector spirv); CompilerMSL(const uint32_t *ir, size_t word_count); explicit CompilerMSL(const ParsedIR &ir); explicit CompilerMSL(ParsedIR &&ir); // input is a shader input description used to fix up shader input variables. // If shader inputs are provided, is_msl_shader_input_used() will return true after // calling ::compile() if the location was used by the MSL code. void add_msl_shader_input(const MSLShaderInput &input); // resource is a resource binding to indicate the MSL buffer, // texture or sampler index to use for a particular SPIR-V description set // and binding. If resource bindings are provided, // is_msl_resource_binding_used() will return true after calling ::compile() if // the set/binding combination was used by the MSL code. void add_msl_resource_binding(const MSLResourceBinding &resource); // desc_set and binding are the SPIR-V descriptor set and binding of a buffer resource // in this shader. index is the index within the dynamic offset buffer to use. This // function marks that resource as using a dynamic offset (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC // or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC). This function only has any effect if argument buffers // are enabled. If so, the buffer will have its address adjusted at the beginning of the shader with // an offset taken from the dynamic offset buffer. void add_dynamic_buffer(uint32_t desc_set, uint32_t binding, uint32_t index); // desc_set and binding are the SPIR-V descriptor set and binding of a buffer resource // in this shader. This function marks that resource as an inline uniform block // (VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT). This function only has any effect if argument buffers // are enabled. If so, the buffer block will be directly embedded into the argument // buffer, instead of being referenced indirectly via pointer. void add_inline_uniform_block(uint32_t desc_set, uint32_t binding); // When using MSL argument buffers, we can force "classic" MSL 1.0 binding schemes for certain descriptor sets. // This corresponds to VK_KHR_push_descriptor in Vulkan. void add_discrete_descriptor_set(uint32_t desc_set); // If an argument buffer is large enough, it may need to be in the device storage space rather than // constant. Opt-in to this behavior here on a per set basis. void set_argument_buffer_device_address_space(uint32_t desc_set, bool device_storage); // Query after compilation is done. This allows you to check if an input location was used by the shader. bool is_msl_shader_input_used(uint32_t location); // NOTE: Only resources which are remapped using add_msl_resource_binding will be reported here. // Constexpr samplers are always assumed to be emitted. // No specific MSLResourceBinding remapping is required for constexpr samplers as long as they are remapped // by remap_constexpr_sampler(_by_binding). bool is_msl_resource_binding_used(spv::ExecutionModel model, uint32_t set, uint32_t binding) const; // This must only be called after a successful call to CompilerMSL::compile(). // For a variable resource ID obtained through reflection API, report the automatically assigned resource index. // If the descriptor set was part of an argument buffer, report the [[id(N)]], // or [[buffer/texture/sampler]] binding for other resources. // If the resource was a combined image sampler, report the image binding here, // use the _secondary version of this call to query the sampler half of the resource. // If no binding exists, uint32_t(-1) is returned. uint32_t get_automatic_msl_resource_binding(uint32_t id) const; // Same as get_automatic_msl_resource_binding, but should only be used for combined image samplers, in which case the // sampler's binding is returned instead. For any other resource type, -1 is returned. uint32_t get_automatic_msl_resource_binding_secondary(uint32_t id) const; // Same as get_automatic_msl_resource_binding, but should only be used for combined image samplers for multiplanar images, // in which case the second plane's binding is returned instead. For any other resource type, -1 is returned. uint32_t get_automatic_msl_resource_binding_tertiary(uint32_t id) const; // Same as get_automatic_msl_resource_binding, but should only be used for combined image samplers for triplanar images, // in which case the third plane's binding is returned instead. For any other resource type, -1 is returned. uint32_t get_automatic_msl_resource_binding_quaternary(uint32_t id) const; // Compiles the SPIR-V code into Metal Shading Language. std::string compile() override; // Remap a sampler with ID to a constexpr sampler. // Older iOS targets must use constexpr samplers in certain cases (PCF), // so a static sampler must be used. // The sampler will not consume a binding, but be declared in the entry point as a constexpr sampler. // This can be used on both combined image/samplers (sampler2D) or standalone samplers. // The remapped sampler must not be an array of samplers. // Prefer remap_constexpr_sampler_by_binding unless you're also doing reflection anyways. void remap_constexpr_sampler(VariableID id, const MSLConstexprSampler &sampler); // Same as remap_constexpr_sampler, except you provide set/binding, rather than variable ID. // Remaps based on ID take priority over set/binding remaps. void remap_constexpr_sampler_by_binding(uint32_t desc_set, uint32_t binding, const MSLConstexprSampler &sampler); // If using CompilerMSL::Options::pad_fragment_output_components, override the number of components we expect // to use for a particular location. The default is 4 if number of components is not overridden. void set_fragment_output_components(uint32_t location, uint32_t components); void set_combined_sampler_suffix(const char *suffix); const char *get_combined_sampler_suffix() const; protected: // An enum of SPIR-V functions that are implemented in additional // source code that is added to the shader if necessary. enum SPVFuncImpl { SPVFuncImplNone, SPVFuncImplMod, SPVFuncImplRadians, SPVFuncImplDegrees, SPVFuncImplFindILsb, SPVFuncImplFindSMsb, SPVFuncImplFindUMsb, SPVFuncImplSSign, SPVFuncImplArrayCopyMultidimBase, // Unfortunately, we cannot use recursive templates in the MSL compiler properly, // so stamp out variants up to some arbitrary maximum. SPVFuncImplArrayCopy = SPVFuncImplArrayCopyMultidimBase + 1, SPVFuncImplArrayOfArrayCopy2Dim = SPVFuncImplArrayCopyMultidimBase + 2, SPVFuncImplArrayOfArrayCopy3Dim = SPVFuncImplArrayCopyMultidimBase + 3, SPVFuncImplArrayOfArrayCopy4Dim = SPVFuncImplArrayCopyMultidimBase + 4, SPVFuncImplArrayOfArrayCopy5Dim = SPVFuncImplArrayCopyMultidimBase + 5, SPVFuncImplArrayOfArrayCopy6Dim = SPVFuncImplArrayCopyMultidimBase + 6, SPVFuncImplTexelBufferCoords, SPVFuncImplImage2DAtomicCoords, // Emulate texture2D atomic operations SPVFuncImplFMul, SPVFuncImplFAdd, SPVFuncImplCubemapTo2DArrayFace, SPVFuncImplUnsafeArray, // Allow Metal to use the array template to make arrays a value type SPVFuncImplInverse4x4, SPVFuncImplInverse3x3, SPVFuncImplInverse2x2, // It is very important that this come before *Swizzle and ChromaReconstruct*, to ensure it's // emitted before them. SPVFuncImplForwardArgs, // Likewise, this must come before *Swizzle. SPVFuncImplGetSwizzle, SPVFuncImplTextureSwizzle, SPVFuncImplGatherSwizzle, SPVFuncImplGatherCompareSwizzle, SPVFuncImplSubgroupBroadcast, SPVFuncImplSubgroupBroadcastFirst, SPVFuncImplSubgroupBallot, SPVFuncImplSubgroupBallotBitExtract, SPVFuncImplSubgroupBallotFindLSB, SPVFuncImplSubgroupBallotFindMSB, SPVFuncImplSubgroupBallotBitCount, SPVFuncImplSubgroupAllEqual, SPVFuncImplSubgroupShuffle, SPVFuncImplSubgroupShuffleXor, SPVFuncImplSubgroupShuffleUp, SPVFuncImplSubgroupShuffleDown, SPVFuncImplQuadBroadcast, SPVFuncImplQuadSwap, SPVFuncImplReflectScalar, SPVFuncImplRefractScalar, SPVFuncImplFaceForwardScalar, SPVFuncImplChromaReconstructNearest2Plane, SPVFuncImplChromaReconstructNearest3Plane, SPVFuncImplChromaReconstructLinear422CositedEven2Plane, SPVFuncImplChromaReconstructLinear422CositedEven3Plane, SPVFuncImplChromaReconstructLinear422Midpoint2Plane, SPVFuncImplChromaReconstructLinear422Midpoint3Plane, SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven2Plane, SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven3Plane, SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven2Plane, SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven3Plane, SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint2Plane, SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint3Plane, SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint2Plane, SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane, SPVFuncImplExpandITUFullRange, SPVFuncImplExpandITUNarrowRange, SPVFuncImplConvertYCbCrBT709, SPVFuncImplConvertYCbCrBT601, SPVFuncImplConvertYCbCrBT2020, SPVFuncImplDynamicImageSampler, }; // If the underlying resource has been used for comparison then duplicate loads of that resource must be too // Use Metal's native frame-buffer fetch API for subpass inputs. void emit_texture_op(const Instruction &i, bool sparse) override; void emit_binary_unord_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op); void emit_instruction(const Instruction &instr) override; void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count) override; void emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count) override; void emit_header() override; void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override; void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) override; void emit_subgroup_op(const Instruction &i) override; std::string to_texture_op(const Instruction &i, bool sparse, bool *forward, SmallVector &inherited_expressions) override; void emit_fixup() override; std::string to_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const std::string &qualifier = ""); void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const std::string &qualifier = "", uint32_t base_offset = 0) override; void emit_struct_padding_target(const SPIRType &type) override; std::string type_to_glsl(const SPIRType &type, uint32_t id = 0) override; // Allow Metal to use the array template to make arrays a value type std::string type_to_array_glsl(const SPIRType &type) override; // Threadgroup arrays can't have a wrapper type std::string variable_decl(const SPIRVariable &variable) override; // GCC workaround of lambdas calling protected functions (for older GCC versions) std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id = 0) override; std::string image_type_glsl(const SPIRType &type, uint32_t id = 0) override; std::string sampler_type(const SPIRType &type, uint32_t id); std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage) override; std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) override; std::string to_name(uint32_t id, bool allow_alias = true) const override; std::string to_function_name(const TextureFunctionNameArguments &args) override; std::string to_function_args(const TextureFunctionArguments &args, bool *p_forward) override; std::string to_initializer_expression(const SPIRVariable &var) override; std::string to_zero_initialized_expression(uint32_t type_id) override; std::string unpack_expression_type(std::string expr_str, const SPIRType &type, uint32_t physical_type_id, bool is_packed, bool row_major) override; // Returns true for BuiltInSampleMask because gl_SampleMask[] is an array in SPIR-V, but [[sample_mask]] is a scalar in Metal. bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const override; std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type) override; bool emit_complex_bitcast(uint32_t result_id, uint32_t id, uint32_t op0) override; bool skip_argument(uint32_t id) const override; std::string to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool ptr_chain) override; std::string to_qualifiers_glsl(uint32_t id) override; void replace_illegal_names() override; void declare_undefined_values() override; void declare_constant_arrays(); void replace_illegal_entry_point_names(); void sync_entry_point_aliases_and_names(); static const std::unordered_set &get_reserved_keyword_set(); static const std::unordered_set &get_illegal_func_names(); // Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries void declare_complex_constant_arrays(); bool is_patch_block(const SPIRType &type); bool is_non_native_row_major_matrix(uint32_t id) override; bool member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index) override; std::string convert_row_major_matrix(std::string exp_str, const SPIRType &exp_type, uint32_t physical_type_id, bool is_packed) override; void preprocess_op_codes(); void localize_global_variables(); void extract_global_variables_from_functions(); void mark_packable_structs(); void mark_as_packable(SPIRType &type); std::unordered_map> function_global_vars; void extract_global_variables_from_function(uint32_t func_id, std::set &added_arg_ids, std::unordered_set &global_var_ids, std::unordered_set &processed_func_ids); uint32_t add_interface_block(spv::StorageClass storage, bool patch = false); uint32_t add_interface_block_pointer(uint32_t ib_var_id, spv::StorageClass storage); struct InterfaceBlockMeta { struct LocationMeta { uint32_t num_components = 0; uint32_t ib_index = ~0u; }; std::unordered_map location_meta; bool strip_array = false; }; void add_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta); void add_composite_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta); void add_plain_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta); void add_plain_member_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, uint32_t index, InterfaceBlockMeta &meta); void add_composite_member_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var, uint32_t index, InterfaceBlockMeta &meta); uint32_t get_accumulated_member_location(const SPIRVariable &var, uint32_t mbr_idx, bool strip_array); void add_tess_level_input_to_interface_block(const std::string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var); void fix_up_interface_member_indices(spv::StorageClass storage, uint32_t ib_type_id); void mark_location_as_used_by_shader(uint32_t location, const SPIRType &type, spv::StorageClass storage); uint32_t ensure_correct_builtin_type(uint32_t type_id, spv::BuiltIn builtin); uint32_t ensure_correct_input_type(uint32_t type_id, uint32_t location, uint32_t num_components = 0); void emit_custom_templates(); void emit_custom_functions(); void emit_resources(); void emit_specialization_constants_and_structs(); void emit_interface_block(uint32_t ib_var_id); bool maybe_emit_array_assignment(uint32_t id_lhs, uint32_t id_rhs); uint32_t get_resource_array_size(uint32_t id) const; void fix_up_shader_inputs_outputs(); std::string func_type_decl(SPIRType &type); std::string entry_point_args_classic(bool append_comma); std::string entry_point_args_argument_buffer(bool append_comma); std::string entry_point_arg_stage_in(); void entry_point_args_builtin(std::string &args); void entry_point_args_discrete_descriptors(std::string &args); std::string to_qualified_member_name(const SPIRType &type, uint32_t index); std::string ensure_valid_name(std::string name, std::string pfx); std::string to_sampler_expression(uint32_t id); std::string to_swizzle_expression(uint32_t id); std::string to_buffer_size_expression(uint32_t id); bool is_sample_rate() const; bool is_direct_input_builtin(spv::BuiltIn builtin); std::string builtin_qualifier(spv::BuiltIn builtin); std::string builtin_type_decl(spv::BuiltIn builtin, uint32_t id = 0); std::string built_in_func_arg(spv::BuiltIn builtin, bool prefix_comma); std::string member_attribute_qualifier(const SPIRType &type, uint32_t index); std::string argument_decl(const SPIRFunction::Parameter &arg); std::string round_fp_tex_coords(std::string tex_coords, bool coord_is_fp); uint32_t get_metal_resource_index(SPIRVariable &var, SPIRType::BaseType basetype, uint32_t plane = 0); uint32_t get_ordered_member_location(uint32_t type_id, uint32_t index, uint32_t *comp = nullptr); // MSL packing rules. These compute the effective packing rules as observed by the MSL compiler in the MSL output. // These values can change depending on various extended decorations which control packing rules. // We need to make these rules match up with SPIR-V declared rules. uint32_t get_declared_type_size_msl(const SPIRType &type, bool packed, bool row_major) const; uint32_t get_declared_type_array_stride_msl(const SPIRType &type, bool packed, bool row_major) const; uint32_t get_declared_type_matrix_stride_msl(const SPIRType &type, bool packed, bool row_major) const; uint32_t get_declared_type_alignment_msl(const SPIRType &type, bool packed, bool row_major) const; uint32_t get_declared_struct_member_size_msl(const SPIRType &struct_type, uint32_t index) const; uint32_t get_declared_struct_member_array_stride_msl(const SPIRType &struct_type, uint32_t index) const; uint32_t get_declared_struct_member_matrix_stride_msl(const SPIRType &struct_type, uint32_t index) const; uint32_t get_declared_struct_member_alignment_msl(const SPIRType &struct_type, uint32_t index) const; uint32_t get_declared_input_size_msl(const SPIRType &struct_type, uint32_t index) const; uint32_t get_declared_input_array_stride_msl(const SPIRType &struct_type, uint32_t index) const; uint32_t get_declared_input_matrix_stride_msl(const SPIRType &struct_type, uint32_t index) const; uint32_t get_declared_input_alignment_msl(const SPIRType &struct_type, uint32_t index) const; const SPIRType &get_physical_member_type(const SPIRType &struct_type, uint32_t index) const; SPIRType get_presumed_input_type(const SPIRType &struct_type, uint32_t index) const; uint32_t get_declared_struct_size_msl(const SPIRType &struct_type, bool ignore_alignment = false, bool ignore_padding = false) const; std::string to_component_argument(uint32_t id); void align_struct(SPIRType &ib_type, std::unordered_set &aligned_structs); void mark_scalar_layout_structs(const SPIRType &ib_type); void mark_struct_members_packed(const SPIRType &type); void ensure_member_packing_rules_msl(SPIRType &ib_type, uint32_t index); bool validate_member_packing_rules_msl(const SPIRType &type, uint32_t index) const; std::string get_argument_address_space(const SPIRVariable &argument); std::string get_type_address_space(const SPIRType &type, uint32_t id, bool argument = false); const char *to_restrict(uint32_t id, bool space = true); SPIRType &get_stage_in_struct_type(); SPIRType &get_stage_out_struct_type(); SPIRType &get_patch_stage_in_struct_type(); SPIRType &get_patch_stage_out_struct_type(); std::string get_tess_factor_struct_name(); SPIRType &get_uint_type(); uint32_t get_uint_type_id(); void emit_atomic_func_op(uint32_t result_type, uint32_t result_id, const char *op, uint32_t mem_order_1, uint32_t mem_order_2, bool has_mem_order_2, uint32_t op0, uint32_t op1 = 0, bool op1_is_pointer = false, bool op1_is_literal = false, uint32_t op2 = 0); const char *get_memory_order(uint32_t spv_mem_sem); void add_pragma_line(const std::string &line); void add_typedef_line(const std::string &line); void emit_barrier(uint32_t id_exe_scope, uint32_t id_mem_scope, uint32_t id_mem_sem); void emit_array_copy(const std::string &lhs, uint32_t rhs_id, spv::StorageClass lhs_storage, spv::StorageClass rhs_storage) override; void build_implicit_builtins(); uint32_t build_constant_uint_array_pointer(); void emit_entry_point_declarations() override; uint32_t builtin_frag_coord_id = 0; uint32_t builtin_sample_id_id = 0; uint32_t builtin_sample_mask_id = 0; uint32_t builtin_vertex_idx_id = 0; uint32_t builtin_base_vertex_id = 0; uint32_t builtin_instance_idx_id = 0; uint32_t builtin_base_instance_id = 0; uint32_t builtin_view_idx_id = 0; uint32_t builtin_layer_id = 0; uint32_t builtin_invocation_id_id = 0; uint32_t builtin_primitive_id_id = 0; uint32_t builtin_subgroup_invocation_id_id = 0; uint32_t builtin_subgroup_size_id = 0; uint32_t builtin_dispatch_base_id = 0; uint32_t builtin_stage_input_size_id = 0; uint32_t builtin_local_invocation_index_id = 0; uint32_t builtin_workgroup_size_id = 0; uint32_t swizzle_buffer_id = 0; uint32_t buffer_size_buffer_id = 0; uint32_t view_mask_buffer_id = 0; uint32_t dynamic_offsets_buffer_id = 0; uint32_t uint_type_id = 0; bool does_shader_write_sample_mask = false; void cast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type) override; void cast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type) override; void emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression) override; void analyze_sampled_image_usage(); void prepare_access_chain_for_scalar_access(std::string &expr, const SPIRType &type, spv::StorageClass storage, bool &is_packed) override; void fix_up_interpolant_access_chain(const uint32_t *ops, uint32_t length); bool emit_tessellation_access_chain(const uint32_t *ops, uint32_t length); bool emit_tessellation_io_load(uint32_t result_type, uint32_t id, uint32_t ptr); bool is_out_of_bounds_tessellation_level(uint32_t id_lhs); void ensure_builtin(spv::StorageClass storage, spv::BuiltIn builtin); void mark_implicit_builtin(spv::StorageClass storage, spv::BuiltIn builtin, uint32_t id); std::string convert_to_f32(const std::string &expr, uint32_t components); Options msl_options; std::set spv_function_implementations; // Must be ordered to ensure declarations are in a specific order. std::map inputs_by_location; std::unordered_map inputs_by_builtin; std::unordered_set inputs_in_use; std::unordered_map fragment_output_components; std::set pragma_lines; std::set typedef_lines; SmallVector vars_needing_early_declaration; std::unordered_map, InternalHasher> resource_bindings; uint32_t next_metal_resource_index_buffer = 0; uint32_t next_metal_resource_index_texture = 0; uint32_t next_metal_resource_index_sampler = 0; // Intentionally uninitialized, works around MSVC 2013 bug. uint32_t next_metal_resource_ids[kMaxArgumentBuffers]; VariableID stage_in_var_id = 0; VariableID stage_out_var_id = 0; VariableID patch_stage_in_var_id = 0; VariableID patch_stage_out_var_id = 0; VariableID stage_in_ptr_var_id = 0; VariableID stage_out_ptr_var_id = 0; // Handle HLSL-style 0-based vertex/instance index. enum class TriState { Neutral, No, Yes }; TriState needs_base_vertex_arg = TriState::Neutral; TriState needs_base_instance_arg = TriState::Neutral; bool has_sampled_images = false; bool builtin_declaration = false; // Handle HLSL-style 0-based vertex/instance index. bool is_using_builtin_array = false; // Force the use of C style array declaration. bool using_builtin_array() const; bool is_rasterization_disabled = false; bool capture_output_to_buffer = false; bool needs_swizzle_buffer_def = false; bool used_swizzle_buffer = false; bool added_builtin_tess_level = false; bool needs_subgroup_invocation_id = false; bool needs_subgroup_size = false; bool needs_sample_id = false; std::string qual_pos_var_name; std::string stage_in_var_name = "in"; std::string stage_out_var_name = "out"; std::string patch_stage_in_var_name = "patchIn"; std::string patch_stage_out_var_name = "patchOut"; std::string sampler_name_suffix = "Smplr"; std::string swizzle_name_suffix = "Swzl"; std::string buffer_size_name_suffix = "BufferSize"; std::string plane_name_suffix = "Plane"; std::string input_wg_var_name = "gl_in"; std::string input_buffer_var_name = "spvIn"; std::string output_buffer_var_name = "spvOut"; std::string patch_output_buffer_var_name = "spvPatchOut"; std::string tess_factor_buffer_var_name = "spvTessLevel"; std::string index_buffer_var_name = "spvIndices"; spv::Op previous_instruction_opcode = spv::OpNop; // Must be ordered since declaration is in a specific order. std::map constexpr_samplers_by_id; std::unordered_map constexpr_samplers_by_binding; const MSLConstexprSampler *find_constexpr_sampler(uint32_t id) const; std::unordered_set buffers_requiring_array_length; SmallVector buffer_arrays; std::unordered_set atomic_image_vars; // Emulate texture2D atomic operations std::unordered_set pull_model_inputs; // Must be ordered since array is in a specific order. std::map> buffers_requiring_dynamic_offset; SmallVector disabled_frag_outputs; std::unordered_set inline_uniform_blocks; uint32_t argument_buffer_ids[kMaxArgumentBuffers]; uint32_t argument_buffer_discrete_mask = 0; uint32_t argument_buffer_device_storage_mask = 0; void analyze_argument_buffers(); bool descriptor_set_is_argument_buffer(uint32_t desc_set) const; uint32_t get_target_components_for_fragment_location(uint32_t location) const; uint32_t build_extended_vector_type(uint32_t type_id, uint32_t components, SPIRType::BaseType basetype = SPIRType::Unknown); uint32_t build_msl_interpolant_type(uint32_t type_id, bool is_noperspective); bool suppress_missing_prototypes = false; void add_spv_func_and_recompile(SPVFuncImpl spv_func); void activate_argument_buffer_resources(); bool type_is_msl_framebuffer_fetch(const SPIRType &type) const; bool is_supported_argument_buffer_type(const SPIRType &type) const; // OpcodeHandler that handles several MSL preprocessing operations. struct OpCodePreprocessor : OpcodeHandler { OpCodePreprocessor(CompilerMSL &compiler_) : compiler(compiler_) { } bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; CompilerMSL::SPVFuncImpl get_spv_func_impl(spv::Op opcode, const uint32_t *args); void check_resource_write(uint32_t var_id); CompilerMSL &compiler; std::unordered_map result_types; std::unordered_map image_pointers; // Emulate texture2D atomic operations bool suppress_missing_prototypes = false; bool uses_atomics = false; bool uses_resource_write = false; bool needs_subgroup_invocation_id = false; bool needs_subgroup_size = false; bool needs_sample_id = false; }; // OpcodeHandler that scans for uses of sampled images struct SampledImageScanner : OpcodeHandler { SampledImageScanner(CompilerMSL &compiler_) : compiler(compiler_) { } bool handle(spv::Op opcode, const uint32_t *args, uint32_t) override; CompilerMSL &compiler; }; // Sorts the members of a SPIRType and associated Meta info based on a settable sorting // aspect, which defines which aspect of the struct members will be used to sort them. // Regardless of the sorting aspect, built-in members always appear at the end of the struct. struct MemberSorter { enum SortAspect { Location, LocationReverse, Offset, OffsetThenLocationReverse, Alphabetical }; void sort(); bool operator()(uint32_t mbr_idx1, uint32_t mbr_idx2); MemberSorter(SPIRType &t, Meta &m, SortAspect sa); SPIRType &type; Meta &meta; SortAspect sort_aspect; }; }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_parser.cpp000066400000000000000000000745541400026215700176340ustar00rootroot00000000000000/* * Copyright 2018-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_parser.hpp" #include using namespace std; using namespace spv; namespace SPIRV_CROSS_NAMESPACE { Parser::Parser(vector spirv) { ir.spirv = move(spirv); } Parser::Parser(const uint32_t *spirv_data, size_t word_count) { ir.spirv = vector(spirv_data, spirv_data + word_count); } static bool decoration_is_string(Decoration decoration) { switch (decoration) { case DecorationHlslSemanticGOOGLE: return true; default: return false; } } static inline uint32_t swap_endian(uint32_t v) { return ((v >> 24) & 0x000000ffu) | ((v >> 8) & 0x0000ff00u) | ((v << 8) & 0x00ff0000u) | ((v << 24) & 0xff000000u); } static bool is_valid_spirv_version(uint32_t version) { switch (version) { // Allow v99 since it tends to just work. case 99: case 0x10000: // SPIR-V 1.0 case 0x10100: // SPIR-V 1.1 case 0x10200: // SPIR-V 1.2 case 0x10300: // SPIR-V 1.3 case 0x10400: // SPIR-V 1.4 case 0x10500: // SPIR-V 1.5 return true; default: return false; } } void Parser::parse() { auto &spirv = ir.spirv; auto len = spirv.size(); if (len < 5) SPIRV_CROSS_THROW("SPIRV file too small."); auto s = spirv.data(); // Endian-swap if we need to. if (s[0] == swap_endian(MagicNumber)) transform(begin(spirv), end(spirv), begin(spirv), [](uint32_t c) { return swap_endian(c); }); if (s[0] != MagicNumber || !is_valid_spirv_version(s[1])) SPIRV_CROSS_THROW("Invalid SPIRV format."); uint32_t bound = s[3]; const uint32_t MaximumNumberOfIDs = 0x3fffff; if (bound > MaximumNumberOfIDs) SPIRV_CROSS_THROW("ID bound exceeds limit of 0x3fffff.\n"); ir.set_id_bounds(bound); uint32_t offset = 5; SmallVector instructions; while (offset < len) { Instruction instr = {}; instr.op = spirv[offset] & 0xffff; instr.count = (spirv[offset] >> 16) & 0xffff; if (instr.count == 0) SPIRV_CROSS_THROW("SPIR-V instructions cannot consume 0 words. Invalid SPIR-V file."); instr.offset = offset + 1; instr.length = instr.count - 1; offset += instr.count; if (offset > spirv.size()) SPIRV_CROSS_THROW("SPIR-V instruction goes out of bounds."); instructions.push_back(instr); } for (auto &i : instructions) parse(i); for (auto &fixup : forward_pointer_fixups) { auto &target = get(fixup.first); auto &source = get(fixup.second); target.member_types = source.member_types; target.basetype = source.basetype; target.self = source.self; } forward_pointer_fixups.clear(); if (current_function) SPIRV_CROSS_THROW("Function was not terminated."); if (current_block) SPIRV_CROSS_THROW("Block was not terminated."); } const uint32_t *Parser::stream(const Instruction &instr) const { // If we're not going to use any arguments, just return nullptr. // We want to avoid case where we return an out of range pointer // that trips debug assertions on some platforms. if (!instr.length) return nullptr; if (instr.offset + instr.length > ir.spirv.size()) SPIRV_CROSS_THROW("Compiler::stream() out of range."); return &ir.spirv[instr.offset]; } static string extract_string(const vector &spirv, uint32_t offset) { string ret; for (uint32_t i = offset; i < spirv.size(); i++) { uint32_t w = spirv[i]; for (uint32_t j = 0; j < 4; j++, w >>= 8) { char c = w & 0xff; if (c == '\0') return ret; ret += c; } } SPIRV_CROSS_THROW("String was not terminated before EOF"); } void Parser::parse(const Instruction &instruction) { auto *ops = stream(instruction); auto op = static_cast(instruction.op); uint32_t length = instruction.length; switch (op) { case OpSourceContinued: case OpSourceExtension: case OpNop: case OpModuleProcessed: break; case OpString: { set(ops[0], extract_string(ir.spirv, instruction.offset + 1)); break; } case OpMemoryModel: ir.addressing_model = static_cast(ops[0]); ir.memory_model = static_cast(ops[1]); break; case OpSource: { auto lang = static_cast(ops[0]); switch (lang) { case SourceLanguageESSL: ir.source.es = true; ir.source.version = ops[1]; ir.source.known = true; ir.source.hlsl = false; break; case SourceLanguageGLSL: ir.source.es = false; ir.source.version = ops[1]; ir.source.known = true; ir.source.hlsl = false; break; case SourceLanguageHLSL: // For purposes of cross-compiling, this is GLSL 450. ir.source.es = false; ir.source.version = 450; ir.source.known = true; ir.source.hlsl = true; break; default: ir.source.known = false; break; } break; } case OpUndef: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; set(id, result_type); if (current_block) current_block->ops.push_back(instruction); break; } case OpCapability: { uint32_t cap = ops[0]; if (cap == CapabilityKernel) SPIRV_CROSS_THROW("Kernel capability not supported."); ir.declared_capabilities.push_back(static_cast(ops[0])); break; } case OpExtension: { auto ext = extract_string(ir.spirv, instruction.offset); ir.declared_extensions.push_back(move(ext)); break; } case OpExtInstImport: { uint32_t id = ops[0]; auto ext = extract_string(ir.spirv, instruction.offset + 1); if (ext == "GLSL.std.450") set(id, SPIRExtension::GLSL); else if (ext == "DebugInfo") set(id, SPIRExtension::SPV_debug_info); else if (ext == "SPV_AMD_shader_ballot") set(id, SPIRExtension::SPV_AMD_shader_ballot); else if (ext == "SPV_AMD_shader_explicit_vertex_parameter") set(id, SPIRExtension::SPV_AMD_shader_explicit_vertex_parameter); else if (ext == "SPV_AMD_shader_trinary_minmax") set(id, SPIRExtension::SPV_AMD_shader_trinary_minmax); else if (ext == "SPV_AMD_gcn_shader") set(id, SPIRExtension::SPV_AMD_gcn_shader); else set(id, SPIRExtension::Unsupported); // Other SPIR-V extensions which have ExtInstrs are currently not supported. break; } case OpExtInst: { // The SPIR-V debug information extended instructions might come at global scope. if (current_block) current_block->ops.push_back(instruction); break; } case OpEntryPoint: { auto itr = ir.entry_points.insert(make_pair(ops[1], SPIREntryPoint(ops[1], static_cast(ops[0]), extract_string(ir.spirv, instruction.offset + 2)))); auto &e = itr.first->second; // Strings need nul-terminator and consume the whole word. uint32_t strlen_words = uint32_t((e.name.size() + 1 + 3) >> 2); for (uint32_t i = strlen_words + 2; i < instruction.length; i++) e.interface_variables.push_back(ops[i]); // Set the name of the entry point in case OpName is not provided later. ir.set_name(ops[1], e.name); // If we don't have an entry, make the first one our "default". if (!ir.default_entry_point) ir.default_entry_point = ops[1]; break; } case OpExecutionMode: { auto &execution = ir.entry_points[ops[0]]; auto mode = static_cast(ops[1]); execution.flags.set(mode); switch (mode) { case ExecutionModeInvocations: execution.invocations = ops[2]; break; case ExecutionModeLocalSize: execution.workgroup_size.x = ops[2]; execution.workgroup_size.y = ops[3]; execution.workgroup_size.z = ops[4]; break; case ExecutionModeOutputVertices: execution.output_vertices = ops[2]; break; default: break; } break; } case OpName: { uint32_t id = ops[0]; ir.set_name(id, extract_string(ir.spirv, instruction.offset + 1)); break; } case OpMemberName: { uint32_t id = ops[0]; uint32_t member = ops[1]; ir.set_member_name(id, member, extract_string(ir.spirv, instruction.offset + 2)); break; } case OpDecorationGroup: { // Noop, this simply means an ID should be a collector of decorations. // The meta array is already a flat array of decorations which will contain the relevant decorations. break; } case OpGroupDecorate: { uint32_t group_id = ops[0]; auto &decorations = ir.meta[group_id].decoration; auto &flags = decorations.decoration_flags; // Copies decorations from one ID to another. Only copy decorations which are set in the group, // i.e., we cannot just copy the meta structure directly. for (uint32_t i = 1; i < length; i++) { uint32_t target = ops[i]; flags.for_each_bit([&](uint32_t bit) { auto decoration = static_cast(bit); if (decoration_is_string(decoration)) { ir.set_decoration_string(target, decoration, ir.get_decoration_string(group_id, decoration)); } else { ir.meta[target].decoration_word_offset[decoration] = ir.meta[group_id].decoration_word_offset[decoration]; ir.set_decoration(target, decoration, ir.get_decoration(group_id, decoration)); } }); } break; } case OpGroupMemberDecorate: { uint32_t group_id = ops[0]; auto &flags = ir.meta[group_id].decoration.decoration_flags; // Copies decorations from one ID to another. Only copy decorations which are set in the group, // i.e., we cannot just copy the meta structure directly. for (uint32_t i = 1; i + 1 < length; i += 2) { uint32_t target = ops[i + 0]; uint32_t index = ops[i + 1]; flags.for_each_bit([&](uint32_t bit) { auto decoration = static_cast(bit); if (decoration_is_string(decoration)) ir.set_member_decoration_string(target, index, decoration, ir.get_decoration_string(group_id, decoration)); else ir.set_member_decoration(target, index, decoration, ir.get_decoration(group_id, decoration)); }); } break; } case OpDecorate: case OpDecorateId: { // OpDecorateId technically supports an array of arguments, but our only supported decorations are single uint, // so merge decorate and decorate-id here. uint32_t id = ops[0]; auto decoration = static_cast(ops[1]); if (length >= 3) { ir.meta[id].decoration_word_offset[decoration] = uint32_t(&ops[2] - ir.spirv.data()); ir.set_decoration(id, decoration, ops[2]); } else ir.set_decoration(id, decoration); break; } case OpDecorateStringGOOGLE: { uint32_t id = ops[0]; auto decoration = static_cast(ops[1]); ir.set_decoration_string(id, decoration, extract_string(ir.spirv, instruction.offset + 2)); break; } case OpMemberDecorate: { uint32_t id = ops[0]; uint32_t member = ops[1]; auto decoration = static_cast(ops[2]); if (length >= 4) ir.set_member_decoration(id, member, decoration, ops[3]); else ir.set_member_decoration(id, member, decoration); break; } case OpMemberDecorateStringGOOGLE: { uint32_t id = ops[0]; uint32_t member = ops[1]; auto decoration = static_cast(ops[2]); ir.set_member_decoration_string(id, member, decoration, extract_string(ir.spirv, instruction.offset + 3)); break; } // Build up basic types. case OpTypeVoid: { uint32_t id = ops[0]; auto &type = set(id); type.basetype = SPIRType::Void; break; } case OpTypeBool: { uint32_t id = ops[0]; auto &type = set(id); type.basetype = SPIRType::Boolean; type.width = 1; break; } case OpTypeFloat: { uint32_t id = ops[0]; uint32_t width = ops[1]; auto &type = set(id); if (width == 64) type.basetype = SPIRType::Double; else if (width == 32) type.basetype = SPIRType::Float; else if (width == 16) type.basetype = SPIRType::Half; else SPIRV_CROSS_THROW("Unrecognized bit-width of floating point type."); type.width = width; break; } case OpTypeInt: { uint32_t id = ops[0]; uint32_t width = ops[1]; bool signedness = ops[2] != 0; auto &type = set(id); type.basetype = signedness ? to_signed_basetype(width) : to_unsigned_basetype(width); type.width = width; break; } // Build composite types by "inheriting". // NOTE: The self member is also copied! For pointers and array modifiers this is a good thing // since we can refer to decorations on pointee classes which is needed for UBO/SSBO, I/O blocks in geometry/tess etc. case OpTypeVector: { uint32_t id = ops[0]; uint32_t vecsize = ops[2]; auto &base = get(ops[1]); auto &vecbase = set(id); vecbase = base; vecbase.vecsize = vecsize; vecbase.self = id; vecbase.parent_type = ops[1]; break; } case OpTypeMatrix: { uint32_t id = ops[0]; uint32_t colcount = ops[2]; auto &base = get(ops[1]); auto &matrixbase = set(id); matrixbase = base; matrixbase.columns = colcount; matrixbase.self = id; matrixbase.parent_type = ops[1]; break; } case OpTypeArray: { uint32_t id = ops[0]; auto &arraybase = set(id); uint32_t tid = ops[1]; auto &base = get(tid); arraybase = base; arraybase.parent_type = tid; uint32_t cid = ops[2]; ir.mark_used_as_array_length(cid); auto *c = maybe_get(cid); bool literal = c && !c->specialization; // We're copying type information into Array types, so we'll need a fixup for any physical pointer // references. if (base.forward_pointer) forward_pointer_fixups.push_back({ id, tid }); arraybase.array_size_literal.push_back(literal); arraybase.array.push_back(literal ? c->scalar() : cid); // Do NOT set arraybase.self! break; } case OpTypeRuntimeArray: { uint32_t id = ops[0]; auto &base = get(ops[1]); auto &arraybase = set(id); // We're copying type information into Array types, so we'll need a fixup for any physical pointer // references. if (base.forward_pointer) forward_pointer_fixups.push_back({ id, ops[1] }); arraybase = base; arraybase.array.push_back(0); arraybase.array_size_literal.push_back(true); arraybase.parent_type = ops[1]; // Do NOT set arraybase.self! break; } case OpTypeImage: { uint32_t id = ops[0]; auto &type = set(id); type.basetype = SPIRType::Image; type.image.type = ops[1]; type.image.dim = static_cast(ops[2]); type.image.depth = ops[3] == 1; type.image.arrayed = ops[4] != 0; type.image.ms = ops[5] != 0; type.image.sampled = ops[6]; type.image.format = static_cast(ops[7]); type.image.access = (length >= 9) ? static_cast(ops[8]) : AccessQualifierMax; break; } case OpTypeSampledImage: { uint32_t id = ops[0]; uint32_t imagetype = ops[1]; auto &type = set(id); type = get(imagetype); type.basetype = SPIRType::SampledImage; type.self = id; break; } case OpTypeSampler: { uint32_t id = ops[0]; auto &type = set(id); type.basetype = SPIRType::Sampler; break; } case OpTypePointer: { uint32_t id = ops[0]; // Very rarely, we might receive a FunctionPrototype here. // We won't be able to compile it, but we shouldn't crash when parsing. // We should be able to reflect. auto *base = maybe_get(ops[2]); auto &ptrbase = set(id); if (base) ptrbase = *base; ptrbase.pointer = true; ptrbase.pointer_depth++; ptrbase.storage = static_cast(ops[1]); if (ptrbase.storage == StorageClassAtomicCounter) ptrbase.basetype = SPIRType::AtomicCounter; if (base && base->forward_pointer) forward_pointer_fixups.push_back({ id, ops[2] }); ptrbase.parent_type = ops[2]; // Do NOT set ptrbase.self! break; } case OpTypeForwardPointer: { uint32_t id = ops[0]; auto &ptrbase = set(id); ptrbase.pointer = true; ptrbase.pointer_depth++; ptrbase.storage = static_cast(ops[1]); ptrbase.forward_pointer = true; if (ptrbase.storage == StorageClassAtomicCounter) ptrbase.basetype = SPIRType::AtomicCounter; break; } case OpTypeStruct: { uint32_t id = ops[0]; auto &type = set(id); type.basetype = SPIRType::Struct; for (uint32_t i = 1; i < length; i++) type.member_types.push_back(ops[i]); // Check if we have seen this struct type before, with just different // decorations. // // Add workaround for issue #17 as well by looking at OpName for the struct // types, which we shouldn't normally do. // We should not normally have to consider type aliases like this to begin with // however ... glslang issues #304, #307 cover this. // For stripped names, never consider struct type aliasing. // We risk declaring the same struct multiple times, but type-punning is not allowed // so this is safe. bool consider_aliasing = !ir.get_name(type.self).empty(); if (consider_aliasing) { for (auto &other : global_struct_cache) { if (ir.get_name(type.self) == ir.get_name(other) && types_are_logically_equivalent(type, get(other))) { type.type_alias = other; break; } } if (type.type_alias == TypeID(0)) global_struct_cache.push_back(id); } break; } case OpTypeFunction: { uint32_t id = ops[0]; uint32_t ret = ops[1]; auto &func = set(id, ret); for (uint32_t i = 2; i < length; i++) func.parameter_types.push_back(ops[i]); break; } case OpTypeAccelerationStructureKHR: { uint32_t id = ops[0]; auto &type = set(id); type.basetype = SPIRType::AccelerationStructure; break; } case OpTypeRayQueryKHR: { uint32_t id = ops[0]; auto &type = set(id); type.basetype = SPIRType::RayQuery; break; } // Variable declaration // All variables are essentially pointers with a storage qualifier. case OpVariable: { uint32_t type = ops[0]; uint32_t id = ops[1]; auto storage = static_cast(ops[2]); uint32_t initializer = length == 4 ? ops[3] : 0; if (storage == StorageClassFunction) { if (!current_function) SPIRV_CROSS_THROW("No function currently in scope"); current_function->add_local_variable(id); } set(id, type, storage, initializer); break; } // OpPhi // OpPhi is a fairly magical opcode. // It selects temporary variables based on which parent block we *came from*. // In high-level languages we can "de-SSA" by creating a function local, and flush out temporaries to this function-local // variable to emulate SSA Phi. case OpPhi: { if (!current_function) SPIRV_CROSS_THROW("No function currently in scope"); if (!current_block) SPIRV_CROSS_THROW("No block currently in scope"); uint32_t result_type = ops[0]; uint32_t id = ops[1]; // Instead of a temporary, create a new function-wide temporary with this ID instead. auto &var = set(id, result_type, spv::StorageClassFunction); var.phi_variable = true; current_function->add_local_variable(id); for (uint32_t i = 2; i + 2 <= length; i += 2) current_block->phi_variables.push_back({ ops[i], ops[i + 1], id }); break; } // Constants case OpSpecConstant: case OpConstant: { uint32_t id = ops[1]; auto &type = get(ops[0]); if (type.width > 32) set(id, ops[0], ops[2] | (uint64_t(ops[3]) << 32), op == OpSpecConstant); else set(id, ops[0], ops[2], op == OpSpecConstant); break; } case OpSpecConstantFalse: case OpConstantFalse: { uint32_t id = ops[1]; set(id, ops[0], uint32_t(0), op == OpSpecConstantFalse); break; } case OpSpecConstantTrue: case OpConstantTrue: { uint32_t id = ops[1]; set(id, ops[0], uint32_t(1), op == OpSpecConstantTrue); break; } case OpConstantNull: { uint32_t id = ops[1]; uint32_t type = ops[0]; ir.make_constant_null(id, type, true); break; } case OpSpecConstantComposite: case OpConstantComposite: { uint32_t id = ops[1]; uint32_t type = ops[0]; auto &ctype = get(type); // We can have constants which are structs and arrays. // In this case, our SPIRConstant will be a list of other SPIRConstant ids which we // can refer to. if (ctype.basetype == SPIRType::Struct || !ctype.array.empty()) { set(id, type, ops + 2, length - 2, op == OpSpecConstantComposite); } else { uint32_t elements = length - 2; if (elements > 4) SPIRV_CROSS_THROW("OpConstantComposite only supports 1, 2, 3 and 4 elements."); SPIRConstant remapped_constant_ops[4]; const SPIRConstant *c[4]; for (uint32_t i = 0; i < elements; i++) { // Specialization constants operations can also be part of this. // We do not know their value, so any attempt to query SPIRConstant later // will fail. We can only propagate the ID of the expression and use to_expression on it. auto *constant_op = maybe_get(ops[2 + i]); auto *undef_op = maybe_get(ops[2 + i]); if (constant_op) { if (op == OpConstantComposite) SPIRV_CROSS_THROW("Specialization constant operation used in OpConstantComposite."); remapped_constant_ops[i].make_null(get(constant_op->basetype)); remapped_constant_ops[i].self = constant_op->self; remapped_constant_ops[i].constant_type = constant_op->basetype; remapped_constant_ops[i].specialization = true; c[i] = &remapped_constant_ops[i]; } else if (undef_op) { // Undefined, just pick 0. remapped_constant_ops[i].make_null(get(undef_op->basetype)); remapped_constant_ops[i].constant_type = undef_op->basetype; c[i] = &remapped_constant_ops[i]; } else c[i] = &get(ops[2 + i]); } set(id, type, c, elements, op == OpSpecConstantComposite); } break; } // Functions case OpFunction: { uint32_t res = ops[0]; uint32_t id = ops[1]; // Control uint32_t type = ops[3]; if (current_function) SPIRV_CROSS_THROW("Must end a function before starting a new one!"); current_function = &set(id, res, type); break; } case OpFunctionParameter: { uint32_t type = ops[0]; uint32_t id = ops[1]; if (!current_function) SPIRV_CROSS_THROW("Must be in a function!"); current_function->add_parameter(type, id); set(id, type, StorageClassFunction); break; } case OpFunctionEnd: { if (current_block) { // Very specific error message, but seems to come up quite often. SPIRV_CROSS_THROW( "Cannot end a function before ending the current block.\n" "Likely cause: If this SPIR-V was created from glslang HLSL, make sure the entry point is valid."); } current_function = nullptr; break; } // Blocks case OpLabel: { // OpLabel always starts a block. if (!current_function) SPIRV_CROSS_THROW("Blocks cannot exist outside functions!"); uint32_t id = ops[0]; current_function->blocks.push_back(id); if (!current_function->entry_block) current_function->entry_block = id; if (current_block) SPIRV_CROSS_THROW("Cannot start a block before ending the current block."); current_block = &set(id); break; } // Branch instructions end blocks. case OpBranch: { if (!current_block) SPIRV_CROSS_THROW("Trying to end a non-existing block."); uint32_t target = ops[0]; current_block->terminator = SPIRBlock::Direct; current_block->next_block = target; current_block = nullptr; break; } case OpBranchConditional: { if (!current_block) SPIRV_CROSS_THROW("Trying to end a non-existing block."); current_block->condition = ops[0]; current_block->true_block = ops[1]; current_block->false_block = ops[2]; current_block->terminator = SPIRBlock::Select; current_block = nullptr; break; } case OpSwitch: { if (!current_block) SPIRV_CROSS_THROW("Trying to end a non-existing block."); current_block->terminator = SPIRBlock::MultiSelect; current_block->condition = ops[0]; current_block->default_block = ops[1]; for (uint32_t i = 2; i + 2 <= length; i += 2) current_block->cases.push_back({ ops[i], ops[i + 1] }); // If we jump to next block, make it break instead since we're inside a switch case block at that point. ir.block_meta[current_block->next_block] |= ParsedIR::BLOCK_META_MULTISELECT_MERGE_BIT; current_block = nullptr; break; } case OpKill: { if (!current_block) SPIRV_CROSS_THROW("Trying to end a non-existing block."); current_block->terminator = SPIRBlock::Kill; current_block = nullptr; break; } case OpTerminateRayKHR: // NV variant is not a terminator. if (!current_block) SPIRV_CROSS_THROW("Trying to end a non-existing block."); current_block->terminator = SPIRBlock::TerminateRay; current_block = nullptr; break; case OpIgnoreIntersectionKHR: // NV variant is not a terminator. if (!current_block) SPIRV_CROSS_THROW("Trying to end a non-existing block."); current_block->terminator = SPIRBlock::IgnoreIntersection; current_block = nullptr; break; case OpReturn: { if (!current_block) SPIRV_CROSS_THROW("Trying to end a non-existing block."); current_block->terminator = SPIRBlock::Return; current_block = nullptr; break; } case OpReturnValue: { if (!current_block) SPIRV_CROSS_THROW("Trying to end a non-existing block."); current_block->terminator = SPIRBlock::Return; current_block->return_value = ops[0]; current_block = nullptr; break; } case OpUnreachable: { if (!current_block) SPIRV_CROSS_THROW("Trying to end a non-existing block."); current_block->terminator = SPIRBlock::Unreachable; current_block = nullptr; break; } case OpSelectionMerge: { if (!current_block) SPIRV_CROSS_THROW("Trying to modify a non-existing block."); current_block->next_block = ops[0]; current_block->merge = SPIRBlock::MergeSelection; ir.block_meta[current_block->next_block] |= ParsedIR::BLOCK_META_SELECTION_MERGE_BIT; if (length >= 2) { if (ops[1] & SelectionControlFlattenMask) current_block->hint = SPIRBlock::HintFlatten; else if (ops[1] & SelectionControlDontFlattenMask) current_block->hint = SPIRBlock::HintDontFlatten; } break; } case OpLoopMerge: { if (!current_block) SPIRV_CROSS_THROW("Trying to modify a non-existing block."); current_block->merge_block = ops[0]; current_block->continue_block = ops[1]; current_block->merge = SPIRBlock::MergeLoop; ir.block_meta[current_block->self] |= ParsedIR::BLOCK_META_LOOP_HEADER_BIT; ir.block_meta[current_block->merge_block] |= ParsedIR::BLOCK_META_LOOP_MERGE_BIT; ir.continue_block_to_loop_header[current_block->continue_block] = BlockID(current_block->self); // Don't add loop headers to continue blocks, // which would make it impossible branch into the loop header since // they are treated as continues. if (current_block->continue_block != BlockID(current_block->self)) ir.block_meta[current_block->continue_block] |= ParsedIR::BLOCK_META_CONTINUE_BIT; if (length >= 3) { if (ops[2] & LoopControlUnrollMask) current_block->hint = SPIRBlock::HintUnroll; else if (ops[2] & LoopControlDontUnrollMask) current_block->hint = SPIRBlock::HintDontUnroll; } break; } case OpSpecConstantOp: { if (length < 3) SPIRV_CROSS_THROW("OpSpecConstantOp not enough arguments."); uint32_t result_type = ops[0]; uint32_t id = ops[1]; auto spec_op = static_cast(ops[2]); set(id, result_type, spec_op, ops + 3, length - 3); break; } case OpLine: { // OpLine might come at global scope, but we don't care about those since they will not be declared in any // meaningful correct order. // Ignore all OpLine directives which live outside a function. if (current_block) current_block->ops.push_back(instruction); // Line directives may arrive before first OpLabel. // Treat this as the line of the function declaration, // so warnings for arguments can propagate properly. if (current_function) { // Store the first one we find and emit it before creating the function prototype. if (current_function->entry_line.file_id == 0) { current_function->entry_line.file_id = ops[0]; current_function->entry_line.line_literal = ops[1]; } } break; } case OpNoLine: { // OpNoLine might come at global scope. if (current_block) current_block->ops.push_back(instruction); break; } // Actual opcodes. default: { if (!current_block) SPIRV_CROSS_THROW("Currently no block to insert opcode."); current_block->ops.push_back(instruction); break; } } } bool Parser::types_are_logically_equivalent(const SPIRType &a, const SPIRType &b) const { if (a.basetype != b.basetype) return false; if (a.width != b.width) return false; if (a.vecsize != b.vecsize) return false; if (a.columns != b.columns) return false; if (a.array.size() != b.array.size()) return false; size_t array_count = a.array.size(); if (array_count && memcmp(a.array.data(), b.array.data(), array_count * sizeof(uint32_t)) != 0) return false; if (a.basetype == SPIRType::Image || a.basetype == SPIRType::SampledImage) { if (memcmp(&a.image, &b.image, sizeof(SPIRType::Image)) != 0) return false; } if (a.member_types.size() != b.member_types.size()) return false; size_t member_types = a.member_types.size(); for (size_t i = 0; i < member_types; i++) { if (!types_are_logically_equivalent(get(a.member_types[i]), get(b.member_types[i]))) return false; } return true; } bool Parser::variable_storage_is_aliased(const SPIRVariable &v) const { auto &type = get(v.basetype); auto *type_meta = ir.find_meta(type.self); bool ssbo = v.storage == StorageClassStorageBuffer || (type_meta && type_meta->decoration.decoration_flags.get(DecorationBufferBlock)); bool image = type.basetype == SPIRType::Image; bool counter = type.basetype == SPIRType::AtomicCounter; bool is_restrict; if (ssbo) is_restrict = ir.get_buffer_block_flags(v).get(DecorationRestrict); else is_restrict = ir.has_decoration(v.self, DecorationRestrict); return !is_restrict && (ssbo || image || counter); } } // namespace SPIRV_CROSS_NAMESPACE spirv-cross-2021.01.15/spirv_parser.hpp000066400000000000000000000050101400026215700176160ustar00rootroot00000000000000/* * Copyright 2018-2021 Arm Limited * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_PARSER_HPP #define SPIRV_CROSS_PARSER_HPP #include "spirv_cross_parsed_ir.hpp" #include namespace SPIRV_CROSS_NAMESPACE { class Parser { public: Parser(const uint32_t *spirv_data, size_t word_count); Parser(std::vector spirv); void parse(); ParsedIR &get_parsed_ir() { return ir; } private: ParsedIR ir; SPIRFunction *current_function = nullptr; SPIRBlock *current_block = nullptr; void parse(const Instruction &instr); const uint32_t *stream(const Instruction &instr) const; template T &set(uint32_t id, P &&... args) { ir.add_typed_id(static_cast(T::type), id); auto &var = variant_set(ir.ids[id], std::forward

(args)...); var.self = id; return var; } template T &get(uint32_t id) { return variant_get(ir.ids[id]); } template T *maybe_get(uint32_t id) { if (ir.ids[id].get_type() == static_cast(T::type)) return &get(id); else return nullptr; } template const T &get(uint32_t id) const { return variant_get(ir.ids[id]); } template const T *maybe_get(uint32_t id) const { if (ir.ids[id].get_type() == T::type) return &get(id); else return nullptr; } // This must be an ordered data structure so we always pick the same type aliases. SmallVector global_struct_cache; SmallVector> forward_pointer_fixups; bool types_are_logically_equivalent(const SPIRType &a, const SPIRType &b) const; bool variable_storage_is_aliased(const SPIRVariable &v) const; }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/spirv_reflect.cpp000066400000000000000000000522721400026215700177550ustar00rootroot00000000000000/* * Copyright 2018-2021 Bradley Austin Davis * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #include "spirv_reflect.hpp" #include "spirv_glsl.hpp" #include using namespace spv; using namespace SPIRV_CROSS_NAMESPACE; using namespace std; namespace simple_json { enum class Type { Object, Array, }; using State = std::pair; using Stack = std::stack; class Stream { Stack stack; StringStream<> buffer; uint32_t indent{ 0 }; char current_locale_radix_character = '.'; public: void set_current_locale_radix_character(char c) { current_locale_radix_character = c; } void begin_json_object(); void end_json_object(); void emit_json_key(const std::string &key); void emit_json_key_value(const std::string &key, const std::string &value); void emit_json_key_value(const std::string &key, bool value); void emit_json_key_value(const std::string &key, uint32_t value); void emit_json_key_value(const std::string &key, int32_t value); void emit_json_key_value(const std::string &key, float value); void emit_json_key_object(const std::string &key); void emit_json_key_array(const std::string &key); void begin_json_array(); void end_json_array(); void emit_json_array_value(const std::string &value); void emit_json_array_value(uint32_t value); void emit_json_array_value(bool value); std::string str() const { return buffer.str(); } private: inline void statement_indent() { for (uint32_t i = 0; i < indent; i++) buffer << " "; } template inline void statement_inner(T &&t) { buffer << std::forward(t); } template inline void statement_inner(T &&t, Ts &&... ts) { buffer << std::forward(t); statement_inner(std::forward(ts)...); } template inline void statement(Ts &&... ts) { statement_indent(); statement_inner(std::forward(ts)...); buffer << '\n'; } template void statement_no_return(Ts &&... ts) { statement_indent(); statement_inner(std::forward(ts)...); } }; } // namespace simple_json using namespace simple_json; // Hackery to emit JSON without using nlohmann/json C++ library (which requires a // higher level of compiler compliance than is required by SPIRV-Cross void Stream::begin_json_array() { if (!stack.empty() && stack.top().second) { statement_inner(",\n"); } statement("["); ++indent; stack.emplace(Type::Array, false); } void Stream::end_json_array() { if (stack.empty() || stack.top().first != Type::Array) SPIRV_CROSS_THROW("Invalid JSON state"); if (stack.top().second) { statement_inner("\n"); } --indent; statement_no_return("]"); stack.pop(); if (!stack.empty()) { stack.top().second = true; } } void Stream::emit_json_array_value(const std::string &value) { if (stack.empty() || stack.top().first != Type::Array) SPIRV_CROSS_THROW("Invalid JSON state"); if (stack.top().second) statement_inner(",\n"); statement_no_return("\"", value, "\""); stack.top().second = true; } void Stream::emit_json_array_value(uint32_t value) { if (stack.empty() || stack.top().first != Type::Array) SPIRV_CROSS_THROW("Invalid JSON state"); if (stack.top().second) statement_inner(",\n"); statement_no_return(std::to_string(value)); stack.top().second = true; } void Stream::emit_json_array_value(bool value) { if (stack.empty() || stack.top().first != Type::Array) SPIRV_CROSS_THROW("Invalid JSON state"); if (stack.top().second) statement_inner(",\n"); statement_no_return(value ? "true" : "false"); stack.top().second = true; } void Stream::begin_json_object() { if (!stack.empty() && stack.top().second) { statement_inner(",\n"); } statement("{"); ++indent; stack.emplace(Type::Object, false); } void Stream::end_json_object() { if (stack.empty() || stack.top().first != Type::Object) SPIRV_CROSS_THROW("Invalid JSON state"); if (stack.top().second) { statement_inner("\n"); } --indent; statement_no_return("}"); stack.pop(); if (!stack.empty()) { stack.top().second = true; } } void Stream::emit_json_key(const std::string &key) { if (stack.empty() || stack.top().first != Type::Object) SPIRV_CROSS_THROW("Invalid JSON state"); if (stack.top().second) statement_inner(",\n"); statement_no_return("\"", key, "\" : "); stack.top().second = true; } void Stream::emit_json_key_value(const std::string &key, const std::string &value) { emit_json_key(key); statement_inner("\"", value, "\""); } void Stream::emit_json_key_value(const std::string &key, uint32_t value) { emit_json_key(key); statement_inner(value); } void Stream::emit_json_key_value(const std::string &key, int32_t value) { emit_json_key(key); statement_inner(value); } void Stream::emit_json_key_value(const std::string &key, float value) { emit_json_key(key); statement_inner(convert_to_string(value, current_locale_radix_character)); } void Stream::emit_json_key_value(const std::string &key, bool value) { emit_json_key(key); statement_inner(value ? "true" : "false"); } void Stream::emit_json_key_object(const std::string &key) { emit_json_key(key); statement_inner("{\n"); ++indent; stack.emplace(Type::Object, false); } void Stream::emit_json_key_array(const std::string &key) { emit_json_key(key); statement_inner("[\n"); ++indent; stack.emplace(Type::Array, false); } void CompilerReflection::set_format(const std::string &format) { if (format != "json") { SPIRV_CROSS_THROW("Unsupported format"); } } string CompilerReflection::compile() { json_stream = std::make_shared(); json_stream->set_current_locale_radix_character(current_locale_radix_character); json_stream->begin_json_object(); reorder_type_alias(); emit_entry_points(); emit_types(); emit_resources(); emit_specialization_constants(); json_stream->end_json_object(); return json_stream->str(); } static bool naturally_emit_type(const SPIRType &type) { return type.basetype == SPIRType::Struct && !type.pointer && type.array.empty(); } bool CompilerReflection::type_is_reference(const SPIRType &type) const { // Physical pointers and arrays of physical pointers need to refer to the pointee's type. return type_is_top_level_physical_pointer(type) || (!type.array.empty() && type_is_top_level_physical_pointer(get(type.parent_type))); } void CompilerReflection::emit_types() { bool emitted_open_tag = false; SmallVector physical_pointee_types; // If we have physical pointers or arrays of physical pointers, it's also helpful to emit the pointee type // and chain the type hierarchy. For POD, arrays can emit the entire type in-place. ir.for_each_typed_id([&](uint32_t self, SPIRType &type) { if (naturally_emit_type(type)) { emit_type(self, emitted_open_tag); } else if (type_is_reference(type)) { if (!naturally_emit_type(this->get(type.parent_type)) && find(physical_pointee_types.begin(), physical_pointee_types.end(), type.parent_type) == physical_pointee_types.end()) { physical_pointee_types.push_back(type.parent_type); } } }); for (uint32_t pointee_type : physical_pointee_types) emit_type(pointee_type, emitted_open_tag); if (emitted_open_tag) { json_stream->end_json_object(); } } void CompilerReflection::emit_type(uint32_t type_id, bool &emitted_open_tag) { auto &type = get(type_id); auto name = type_to_glsl(type); if (!emitted_open_tag) { json_stream->emit_json_key_object("types"); emitted_open_tag = true; } json_stream->emit_json_key_object("_" + std::to_string(type_id)); json_stream->emit_json_key_value("name", name); if (type_is_top_level_physical_pointer(type)) { json_stream->emit_json_key_value("type", "_" + std::to_string(type.parent_type)); json_stream->emit_json_key_value("physical_pointer", true); } else if (!type.array.empty()) { emit_type_array(type); json_stream->emit_json_key_value("type", "_" + std::to_string(type.parent_type)); json_stream->emit_json_key_value("array_stride", get_decoration(type_id, DecorationArrayStride)); } else { json_stream->emit_json_key_array("members"); // FIXME ideally we'd like to emit the size of a structure as a // convenience to people parsing the reflected JSON. The problem // is that there's no implicit size for a type. It's final size // will be determined by the top level declaration in which it's // included. So there might be one size for the struct if it's // included in a std140 uniform block and another if it's included // in a std430 uniform block. // The solution is to include *all* potential sizes as a map of // layout type name to integer, but that will probably require // some additional logic being written in this class, or in the // parent CompilerGLSL class. auto size = type.member_types.size(); for (uint32_t i = 0; i < size; ++i) { emit_type_member(type, i); } json_stream->end_json_array(); } json_stream->end_json_object(); } void CompilerReflection::emit_type_member(const SPIRType &type, uint32_t index) { auto &membertype = get(type.member_types[index]); json_stream->begin_json_object(); auto name = to_member_name(type, index); // FIXME we'd like to emit the offset of each member, but such offsets are // context dependent. See the comment above regarding structure sizes json_stream->emit_json_key_value("name", name); if (type_is_reference(membertype)) { json_stream->emit_json_key_value("type", "_" + std::to_string(membertype.parent_type)); } else if (membertype.basetype == SPIRType::Struct) { json_stream->emit_json_key_value("type", "_" + std::to_string(membertype.self)); } else { json_stream->emit_json_key_value("type", type_to_glsl(membertype)); } emit_type_member_qualifiers(type, index); json_stream->end_json_object(); } void CompilerReflection::emit_type_array(const SPIRType &type) { if (!type_is_top_level_physical_pointer(type) && !type.array.empty()) { json_stream->emit_json_key_array("array"); // Note that we emit the zeros here as a means of identifying // unbounded arrays. This is necessary as otherwise there would // be no way of differentiating between float[4] and float[4][] for (const auto &value : type.array) json_stream->emit_json_array_value(value); json_stream->end_json_array(); json_stream->emit_json_key_array("array_size_is_literal"); for (const auto &value : type.array_size_literal) json_stream->emit_json_array_value(value); json_stream->end_json_array(); } } void CompilerReflection::emit_type_member_qualifiers(const SPIRType &type, uint32_t index) { auto &membertype = get(type.member_types[index]); emit_type_array(membertype); auto &memb = ir.meta[type.self].members; if (index < memb.size()) { auto &dec = memb[index]; if (dec.decoration_flags.get(DecorationLocation)) json_stream->emit_json_key_value("location", dec.location); if (dec.decoration_flags.get(DecorationOffset)) json_stream->emit_json_key_value("offset", dec.offset); // Array stride is a property of the array type, not the struct. if (has_decoration(type.member_types[index], DecorationArrayStride)) json_stream->emit_json_key_value("array_stride", get_decoration(type.member_types[index], DecorationArrayStride)); if (dec.decoration_flags.get(DecorationMatrixStride)) json_stream->emit_json_key_value("matrix_stride", dec.matrix_stride); if (dec.decoration_flags.get(DecorationRowMajor)) json_stream->emit_json_key_value("row_major", true); if (type_is_top_level_physical_pointer(membertype)) json_stream->emit_json_key_value("physical_pointer", true); } } string CompilerReflection::execution_model_to_str(spv::ExecutionModel model) { switch (model) { case ExecutionModelVertex: return "vert"; case ExecutionModelTessellationControl: return "tesc"; case ExecutionModelTessellationEvaluation: return "tese"; case ExecutionModelGeometry: return "geom"; case ExecutionModelFragment: return "frag"; case ExecutionModelGLCompute: return "comp"; case ExecutionModelRayGenerationNV: return "rgen"; case ExecutionModelIntersectionNV: return "rint"; case ExecutionModelAnyHitNV: return "rahit"; case ExecutionModelClosestHitNV: return "rchit"; case ExecutionModelMissNV: return "rmiss"; case ExecutionModelCallableNV: return "rcall"; default: return "???"; } } // FIXME include things like the local_size dimensions, geometry output vertex count, etc void CompilerReflection::emit_entry_points() { auto entries = get_entry_points_and_stages(); if (!entries.empty()) { // Needed to make output deterministic. sort(begin(entries), end(entries), [](const EntryPoint &a, const EntryPoint &b) -> bool { if (a.execution_model < b.execution_model) return true; else if (a.execution_model > b.execution_model) return false; else return a.name < b.name; }); json_stream->emit_json_key_array("entryPoints"); for (auto &e : entries) { json_stream->begin_json_object(); json_stream->emit_json_key_value("name", e.name); json_stream->emit_json_key_value("mode", execution_model_to_str(e.execution_model)); if (e.execution_model == ExecutionModelGLCompute) { const auto &spv_entry = get_entry_point(e.name, e.execution_model); SpecializationConstant spec_x, spec_y, spec_z; get_work_group_size_specialization_constants(spec_x, spec_y, spec_z); json_stream->emit_json_key_array("workgroup_size"); json_stream->emit_json_array_value(spec_x.id != ID(0) ? spec_x.constant_id : spv_entry.workgroup_size.x); json_stream->emit_json_array_value(spec_y.id != ID(0) ? spec_y.constant_id : spv_entry.workgroup_size.y); json_stream->emit_json_array_value(spec_z.id != ID(0) ? spec_z.constant_id : spv_entry.workgroup_size.z); json_stream->end_json_array(); json_stream->emit_json_key_array("workgroup_size_is_spec_constant_id"); json_stream->emit_json_array_value(spec_x.id != ID(0)); json_stream->emit_json_array_value(spec_y.id != ID(0)); json_stream->emit_json_array_value(spec_z.id != ID(0)); json_stream->end_json_array(); } json_stream->end_json_object(); } json_stream->end_json_array(); } } void CompilerReflection::emit_resources() { auto res = get_shader_resources(); emit_resources("subpass_inputs", res.subpass_inputs); emit_resources("inputs", res.stage_inputs); emit_resources("outputs", res.stage_outputs); emit_resources("textures", res.sampled_images); emit_resources("separate_images", res.separate_images); emit_resources("separate_samplers", res.separate_samplers); emit_resources("images", res.storage_images); emit_resources("ssbos", res.storage_buffers); emit_resources("ubos", res.uniform_buffers); emit_resources("push_constants", res.push_constant_buffers); emit_resources("counters", res.atomic_counters); emit_resources("acceleration_structures", res.acceleration_structures); } void CompilerReflection::emit_resources(const char *tag, const SmallVector &resources) { if (resources.empty()) { return; } json_stream->emit_json_key_array(tag); for (auto &res : resources) { auto &type = get_type(res.type_id); auto typeflags = ir.meta[type.self].decoration.decoration_flags; auto &mask = get_decoration_bitset(res.id); // If we don't have a name, use the fallback for the type instead of the variable // for SSBOs and UBOs since those are the only meaningful names to use externally. // Push constant blocks are still accessed by name and not block name, even though they are technically Blocks. bool is_push_constant = get_storage_class(res.id) == StorageClassPushConstant; bool is_block = get_decoration_bitset(type.self).get(DecorationBlock) || get_decoration_bitset(type.self).get(DecorationBufferBlock); ID fallback_id = !is_push_constant && is_block ? ID(res.base_type_id) : ID(res.id); json_stream->begin_json_object(); if (type.basetype == SPIRType::Struct) { json_stream->emit_json_key_value("type", "_" + std::to_string(res.base_type_id)); } else { json_stream->emit_json_key_value("type", type_to_glsl(type)); } json_stream->emit_json_key_value("name", !res.name.empty() ? res.name : get_fallback_name(fallback_id)); { bool ssbo_block = type.storage == StorageClassStorageBuffer || (type.storage == StorageClassUniform && typeflags.get(DecorationBufferBlock)); if (ssbo_block) { auto buffer_flags = get_buffer_block_flags(res.id); if (buffer_flags.get(DecorationNonReadable)) json_stream->emit_json_key_value("writeonly", true); if (buffer_flags.get(DecorationNonWritable)) json_stream->emit_json_key_value("readonly", true); if (buffer_flags.get(DecorationRestrict)) json_stream->emit_json_key_value("restrict", true); if (buffer_flags.get(DecorationCoherent)) json_stream->emit_json_key_value("coherent", true); } } emit_type_array(type); { bool is_sized_block = is_block && (get_storage_class(res.id) == StorageClassUniform || get_storage_class(res.id) == StorageClassUniformConstant || get_storage_class(res.id) == StorageClassStorageBuffer); if (is_sized_block) { uint32_t block_size = uint32_t(get_declared_struct_size(get_type(res.base_type_id))); json_stream->emit_json_key_value("block_size", block_size); } } if (type.storage == StorageClassPushConstant) json_stream->emit_json_key_value("push_constant", true); if (mask.get(DecorationLocation)) json_stream->emit_json_key_value("location", get_decoration(res.id, DecorationLocation)); if (mask.get(DecorationRowMajor)) json_stream->emit_json_key_value("row_major", true); if (mask.get(DecorationColMajor)) json_stream->emit_json_key_value("column_major", true); if (mask.get(DecorationIndex)) json_stream->emit_json_key_value("index", get_decoration(res.id, DecorationIndex)); if (type.storage != StorageClassPushConstant && mask.get(DecorationDescriptorSet)) json_stream->emit_json_key_value("set", get_decoration(res.id, DecorationDescriptorSet)); if (mask.get(DecorationBinding)) json_stream->emit_json_key_value("binding", get_decoration(res.id, DecorationBinding)); if (mask.get(DecorationInputAttachmentIndex)) json_stream->emit_json_key_value("input_attachment_index", get_decoration(res.id, DecorationInputAttachmentIndex)); if (mask.get(DecorationOffset)) json_stream->emit_json_key_value("offset", get_decoration(res.id, DecorationOffset)); // For images, the type itself adds a layout qualifer. // Only emit the format for storage images. if (type.basetype == SPIRType::Image && type.image.sampled == 2) { const char *fmt = format_to_glsl(type.image.format); if (fmt != nullptr) json_stream->emit_json_key_value("format", std::string(fmt)); } json_stream->end_json_object(); } json_stream->end_json_array(); } void CompilerReflection::emit_specialization_constants() { auto specialization_constants = get_specialization_constants(); if (specialization_constants.empty()) return; json_stream->emit_json_key_array("specialization_constants"); for (const auto &spec_const : specialization_constants) { auto &c = get(spec_const.id); auto type = get(c.constant_type); json_stream->begin_json_object(); json_stream->emit_json_key_value("name", get_name(spec_const.id)); json_stream->emit_json_key_value("id", spec_const.constant_id); json_stream->emit_json_key_value("type", type_to_glsl(type)); json_stream->emit_json_key_value("variable_id", spec_const.id); switch (type.basetype) { case SPIRType::UInt: json_stream->emit_json_key_value("default_value", c.scalar()); break; case SPIRType::Int: json_stream->emit_json_key_value("default_value", c.scalar_i32()); break; case SPIRType::Float: json_stream->emit_json_key_value("default_value", c.scalar_f32()); break; case SPIRType::Boolean: json_stream->emit_json_key_value("default_value", c.scalar() != 0); break; default: break; } json_stream->end_json_object(); } json_stream->end_json_array(); } string CompilerReflection::to_member_name(const SPIRType &type, uint32_t index) const { auto *type_meta = ir.find_meta(type.self); if (type_meta) { auto &memb = type_meta->members; if (index < memb.size() && !memb[index].alias.empty()) return memb[index].alias; else return join("_m", index); } else return join("_m", index); } spirv-cross-2021.01.15/spirv_reflect.hpp000066400000000000000000000047101400026215700177540ustar00rootroot00000000000000/* * Copyright 2018-2021 Bradley Austin Davis * * 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. */ /* * At your option, you may choose to accept this material under either: * 1. The Apache License, Version 2.0, found at , or * 2. The MIT License, found at . * SPDX-License-Identifier: Apache-2.0 OR MIT. */ #ifndef SPIRV_CROSS_REFLECT_HPP #define SPIRV_CROSS_REFLECT_HPP #include "spirv_glsl.hpp" #include namespace simple_json { class Stream; } namespace SPIRV_CROSS_NAMESPACE { class CompilerReflection : public CompilerGLSL { using Parent = CompilerGLSL; public: explicit CompilerReflection(std::vector spirv_) : Parent(std::move(spirv_)) { options.vulkan_semantics = true; } CompilerReflection(const uint32_t *ir_, size_t word_count) : Parent(ir_, word_count) { options.vulkan_semantics = true; } explicit CompilerReflection(const ParsedIR &ir_) : CompilerGLSL(ir_) { options.vulkan_semantics = true; } explicit CompilerReflection(ParsedIR &&ir_) : CompilerGLSL(std::move(ir_)) { options.vulkan_semantics = true; } void set_format(const std::string &format); std::string compile() override; private: static std::string execution_model_to_str(spv::ExecutionModel model); void emit_entry_points(); void emit_types(); void emit_resources(); void emit_specialization_constants(); void emit_type(uint32_t type_id, bool &emitted_open_tag); void emit_type_member(const SPIRType &type, uint32_t index); void emit_type_member_qualifiers(const SPIRType &type, uint32_t index); void emit_type_array(const SPIRType &type); void emit_resources(const char *tag, const SmallVector &resources); bool type_is_reference(const SPIRType &type) const; std::string to_member_name(const SPIRType &type, uint32_t index) const; std::shared_ptr json_stream; }; } // namespace SPIRV_CROSS_NAMESPACE #endif spirv-cross-2021.01.15/test_shaders.py000077500000000000000000001056461400026215700174530ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright 2015-2021 Arm Limited # # 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. import sys import os import os.path import subprocess import tempfile import re import itertools import hashlib import shutil import argparse import codecs import json import multiprocessing import errno from functools import partial class Paths(): def __init__(self, spirv_cross, glslang, spirv_as, spirv_val, spirv_opt): self.spirv_cross = spirv_cross self.glslang = glslang self.spirv_as = spirv_as self.spirv_val = spirv_val self.spirv_opt = spirv_opt def remove_file(path): #print('Removing file:', path) os.remove(path) def create_temporary(suff = ''): f, path = tempfile.mkstemp(suffix = suff) os.close(f) #print('Creating temporary:', path) return path def parse_stats(stats): m = re.search('([0-9]+) work registers', stats) registers = int(m.group(1)) if m else 0 m = re.search('([0-9]+) uniform registers', stats) uniform_regs = int(m.group(1)) if m else 0 m_list = re.findall('(-?[0-9]+)\s+(-?[0-9]+)\s+(-?[0-9]+)', stats) alu_short = float(m_list[1][0]) if m_list else 0 ls_short = float(m_list[1][1]) if m_list else 0 tex_short = float(m_list[1][2]) if m_list else 0 alu_long = float(m_list[2][0]) if m_list else 0 ls_long = float(m_list[2][1]) if m_list else 0 tex_long = float(m_list[2][2]) if m_list else 0 return (registers, uniform_regs, alu_short, ls_short, tex_short, alu_long, ls_long, tex_long) def get_shader_type(shader): _, ext = os.path.splitext(shader) if ext == '.vert': return '--vertex' elif ext == '.frag': return '--fragment' elif ext == '.comp': return '--compute' elif ext == '.tesc': return '--tessellation_control' elif ext == '.tese': return '--tessellation_evaluation' elif ext == '.geom': return '--geometry' else: return '' def get_shader_stats(shader): path = create_temporary() p = subprocess.Popen(['malisc', get_shader_type(shader), '--core', 'Mali-T760', '-V', shader], stdout = subprocess.PIPE, stderr = subprocess.PIPE) stdout, stderr = p.communicate() remove_file(path) if p.returncode != 0: print(stderr.decode('utf-8')) raise OSError('malisc failed') p.wait() returned = stdout.decode('utf-8') return parse_stats(returned) def print_msl_compiler_version(): try: subprocess.check_call(['xcrun', '--sdk', 'iphoneos', 'metal', '--version']) print('...are the Metal compiler characteristics.\n') # display after so xcrun FNF is silent except OSError as e: if (e.errno != errno.ENOENT): # Ignore xcrun not found error raise except subprocess.CalledProcessError: pass def msl_compiler_supports_version(version): try: subprocess.check_call(['xcrun', '--sdk', 'macosx', 'metal', '-x', 'metal', '-std=macos-metal' + version, '-'], stdin = subprocess.DEVNULL, stdout = subprocess.DEVNULL, stderr = subprocess.DEVNULL) print('Current SDK supports MSL {0}. Enabling validation for MSL {0} shaders.'.format(version)) return True except OSError as e: print('Failed to check if MSL {} is not supported. It probably is not.'.format(version)) return False except subprocess.CalledProcessError: print('Current SDK does NOT support MSL {0}. Disabling validation for MSL {0} shaders.'.format(version)) return False def path_to_msl_standard(shader): if '.ios.' in shader: if '.msl2.' in shader: return '-std=ios-metal2.0' elif '.msl21.' in shader: return '-std=ios-metal2.1' elif '.msl22.' in shader: return '-std=ios-metal2.2' elif '.msl23.' in shader: return '-std=ios-metal2.3' elif '.msl11.' in shader: return '-std=ios-metal1.1' elif '.msl10.' in shader: return '-std=ios-metal1.0' else: return '-std=ios-metal1.2' else: if '.msl2.' in shader: return '-std=macos-metal2.0' elif '.msl21.' in shader: return '-std=macos-metal2.1' elif '.msl22.' in shader: return '-std=macos-metal2.2' elif '.msl23.' in shader: return '-std=macos-metal2.3' elif '.msl11.' in shader: return '-std=macos-metal1.1' else: return '-std=macos-metal1.2' def path_to_msl_standard_cli(shader): if '.msl2.' in shader: return '20000' elif '.msl21.' in shader: return '20100' elif '.msl22.' in shader: return '20200' elif '.msl23.' in shader: return '20300' elif '.msl11.' in shader: return '10100' else: return '10200' def validate_shader_msl(shader, opt): msl_path = reference_path(shader[0], shader[1], opt) try: if '.ios.' in msl_path: msl_os = 'iphoneos' else: msl_os = 'macosx' subprocess.check_call(['xcrun', '--sdk', msl_os, 'metal', '-x', 'metal', path_to_msl_standard(msl_path), '-Werror', '-Wno-unused-variable', msl_path]) print('Compiled Metal shader: ' + msl_path) # display after so xcrun FNF is silent except OSError as oe: if (oe.errno != errno.ENOENT): # Ignore xcrun not found error raise except subprocess.CalledProcessError: print('Error compiling Metal shader: ' + msl_path) raise RuntimeError('Failed to compile Metal shader') def cross_compile_msl(shader, spirv, opt, iterations, paths): spirv_path = create_temporary() msl_path = create_temporary(os.path.basename(shader)) spirv_env = 'vulkan1.1spv1.4' if ('.spv14.' in shader) else 'vulkan1.1' spirv_cmd = [paths.spirv_as, '--target-env', spirv_env, '-o', spirv_path, shader] if '.preserve.' in shader: spirv_cmd.append('--preserve-numeric-ids') if spirv: subprocess.check_call(spirv_cmd) else: subprocess.check_call([paths.glslang, '--amb' ,'--target-env', 'vulkan1.1', '-V', '-o', spirv_path, shader]) if opt and (not shader_is_invalid_spirv(shader)): if '.graphics-robust-access.' in shader: subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '--graphics-robust-access', '-o', spirv_path, spirv_path]) else: subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path]) spirv_cross_path = paths.spirv_cross msl_args = [spirv_cross_path, '--output', msl_path, spirv_path, '--msl', '--iterations', str(iterations)] msl_args.append('--msl-version') msl_args.append(path_to_msl_standard_cli(shader)) if not '.nomain.' in shader: msl_args.append('--entry') msl_args.append('main') if '.swizzle.' in shader: msl_args.append('--msl-swizzle-texture-samples') if '.ios.' in shader: msl_args.append('--msl-ios') if '.pad-fragment.' in shader: msl_args.append('--msl-pad-fragment-output') if '.capture.' in shader: msl_args.append('--msl-capture-output') if '.domain.' in shader: msl_args.append('--msl-domain-lower-left') if '.argument.' in shader: msl_args.append('--msl-argument-buffers') if '.texture-buffer-native.' in shader: msl_args.append('--msl-texture-buffer-native') if '.framebuffer-fetch.' in shader: msl_args.append('--msl-framebuffer-fetch') if '.invariant-float-math.' in shader: msl_args.append('--msl-invariant-float-math') if '.emulate-cube-array.' in shader: msl_args.append('--msl-emulate-cube-array') if '.discrete.' in shader: # Arbitrary for testing purposes. msl_args.append('--msl-discrete-descriptor-set') msl_args.append('2') msl_args.append('--msl-discrete-descriptor-set') msl_args.append('3') if '.force-active.' in shader: msl_args.append('--msl-force-active-argument-buffer-resources') if '.line.' in shader: msl_args.append('--emit-line-directives') if '.multiview.' in shader: msl_args.append('--msl-multiview') if '.no-layered.' in shader: msl_args.append('--msl-multiview-no-layered-rendering') if '.viewfromdev.' in shader: msl_args.append('--msl-view-index-from-device-index') if '.dispatchbase.' in shader: msl_args.append('--msl-dispatch-base') if '.dynamic-buffer.' in shader: # Arbitrary for testing purposes. msl_args.append('--msl-dynamic-buffer') msl_args.append('0') msl_args.append('0') msl_args.append('--msl-dynamic-buffer') msl_args.append('1') msl_args.append('2') if '.inline-block.' in shader: # Arbitrary for testing purposes. msl_args.append('--msl-inline-uniform-block') msl_args.append('0') msl_args.append('0') if '.device-argument-buffer.' in shader: msl_args.append('--msl-device-argument-buffer') msl_args.append('0') msl_args.append('--msl-device-argument-buffer') msl_args.append('1') if '.force-native-array.' in shader: msl_args.append('--msl-force-native-arrays') if '.zero-initialize.' in shader: msl_args.append('--force-zero-initialized-variables') if '.frag-output.' in shader: # Arbitrary for testing purposes. msl_args.append('--msl-disable-frag-depth-builtin') msl_args.append('--msl-disable-frag-stencil-ref-builtin') msl_args.append('--msl-enable-frag-output-mask') msl_args.append('0x000000ca') if '.no-user-varying.' in shader: msl_args.append('--msl-no-clip-distance-user-varying') if '.shader-inputs.' in shader: # Arbitrary for testing purposes. msl_args.append('--msl-shader-input') msl_args.append('0') msl_args.append('u8') msl_args.append('2') msl_args.append('--msl-shader-input') msl_args.append('1') msl_args.append('u16') msl_args.append('3') msl_args.append('--msl-shader-input') msl_args.append('6') msl_args.append('other') msl_args.append('4') if '.multi-patch.' in shader: msl_args.append('--msl-multi-patch-workgroup') # Arbitrary for testing purposes. msl_args.append('--msl-shader-input') msl_args.append('0') msl_args.append('any32') msl_args.append('3') msl_args.append('--msl-shader-input') msl_args.append('1') msl_args.append('any16') msl_args.append('2') if '.for-tess.' in shader: msl_args.append('--msl-vertex-for-tessellation') if '.fixed-sample-mask.' in shader: msl_args.append('--msl-additional-fixed-sample-mask') msl_args.append('0x00000022') if '.arrayed-subpass.' in shader: msl_args.append('--msl-arrayed-subpass-input') if '.1d-as-2d.' in shader: msl_args.append('--msl-texture-1d-as-2d') if '.simd.' in shader: msl_args.append('--msl-ios-use-simdgroup-functions') if '.emulate-subgroup.' in shader: msl_args.append('--msl-emulate-subgroups') if '.fixed-subgroup.' in shader: # Arbitrary for testing purposes. msl_args.append('--msl-fixed-subgroup-size') msl_args.append('32') if '.force-sample.' in shader: msl_args.append('--msl-force-sample-rate-shading') if '.decoration-binding.' in shader: msl_args.append('--msl-decoration-binding') subprocess.check_call(msl_args) if not shader_is_invalid_spirv(msl_path): subprocess.check_call([paths.spirv_val, '--scalar-block-layout', '--target-env', spirv_env, spirv_path]) return (spirv_path, msl_path) def shader_model_hlsl(shader): if '.vert' in shader: if '.sm30.' in shader: return '-Tvs_3_0' else: return '-Tvs_5_1' elif '.frag' in shader: if '.sm30.' in shader: return '-Tps_3_0' else: return '-Tps_5_1' elif '.comp' in shader: return '-Tcs_5_1' else: return None def shader_to_win_path(shader): # It's (very) convenient to be able to run HLSL testing in wine on Unix-likes, so support that. try: with subprocess.Popen(['winepath', '-w', shader], stdout = subprocess.PIPE, stderr = subprocess.PIPE) as f: stdout_data, stderr_data = f.communicate() return stdout_data.decode('utf-8') except OSError as oe: if (oe.errno != errno.ENOENT): # Ignore not found errors return shader except subprocess.CalledProcessError: raise return shader ignore_fxc = False def validate_shader_hlsl(shader, force_no_external_validation, paths): test_glslang = True if '.nonuniformresource.' in shader: test_glslang = False if '.fxconly.' in shader: test_glslang = False hlsl_args = [paths.glslang, '--amb', '-e', 'main', '-D', '--target-env', 'vulkan1.1', '-V', shader] if '.sm30.' in shader: hlsl_args.append('--hlsl-dx9-compatible') if test_glslang: subprocess.check_call(hlsl_args) is_no_fxc = '.nofxc.' in shader global ignore_fxc if (not ignore_fxc) and (not force_no_external_validation) and (not is_no_fxc): try: win_path = shader_to_win_path(shader) args = ['fxc', '-nologo', shader_model_hlsl(shader), win_path] if '.nonuniformresource.' in shader: args.append('/enable_unbounded_descriptor_tables') subprocess.check_call(args) except OSError as oe: if (oe.errno != errno.ENOENT): # Ignore not found errors print('Failed to run FXC.') ignore_fxc = True raise else: print('Could not find FXC.') ignore_fxc = True except subprocess.CalledProcessError: print('Failed compiling HLSL shader:', shader, 'with FXC.') raise RuntimeError('Failed compiling HLSL shader') def shader_to_sm(shader): if '.sm62.' in shader: return '62' elif '.sm60.' in shader: return '60' elif '.sm51.' in shader: return '51' elif '.sm30.' in shader: return '30' else: return '50' def cross_compile_hlsl(shader, spirv, opt, force_no_external_validation, iterations, paths): spirv_path = create_temporary() hlsl_path = create_temporary(os.path.basename(shader)) spirv_cmd = [paths.spirv_as, '--target-env', 'vulkan1.1', '-o', spirv_path, shader] if '.preserve.' in shader: spirv_cmd.append('--preserve-numeric-ids') if spirv: subprocess.check_call(spirv_cmd) else: subprocess.check_call([paths.glslang, '--amb', '--target-env', 'vulkan1.1', '-V', '-o', spirv_path, shader]) if opt and (not shader_is_invalid_spirv(hlsl_path)): subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path]) spirv_cross_path = paths.spirv_cross sm = shader_to_sm(shader) hlsl_args = [spirv_cross_path, '--entry', 'main', '--output', hlsl_path, spirv_path, '--hlsl-enable-compat', '--hlsl', '--shader-model', sm, '--iterations', str(iterations)] if '.line.' in shader: hlsl_args.append('--emit-line-directives') if '.force-uav.' in shader: hlsl_args.append('--hlsl-force-storage-buffer-as-uav') if '.zero-initialize.' in shader: hlsl_args.append('--force-zero-initialized-variables') if '.nonwritable-uav-texture.' in shader: hlsl_args.append('--hlsl-nonwritable-uav-texture-as-srv') if '.native-16bit.' in shader: hlsl_args.append('--hlsl-enable-16bit-types') if '.flatten-matrix-vertex-input.' in shader: hlsl_args.append('--hlsl-flatten-matrix-vertex-input-semantics') subprocess.check_call(hlsl_args) if not shader_is_invalid_spirv(hlsl_path): subprocess.check_call([paths.spirv_val, '--scalar-block-layout', '--target-env', 'vulkan1.1', spirv_path]) validate_shader_hlsl(hlsl_path, force_no_external_validation, paths) return (spirv_path, hlsl_path) def cross_compile_reflect(shader, spirv, opt, iterations, paths): spirv_path = create_temporary() reflect_path = create_temporary(os.path.basename(shader)) spirv_cmd = [paths.spirv_as, '--target-env', 'vulkan1.1', '-o', spirv_path, shader] if '.preserve.' in shader: spirv_cmd.append('--preserve-numeric-ids') if spirv: subprocess.check_call(spirv_cmd) else: subprocess.check_call([paths.glslang, '--amb', '--target-env', 'vulkan1.1', '-V', '-o', spirv_path, shader]) if opt and (not shader_is_invalid_spirv(reflect_path)): subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path]) spirv_cross_path = paths.spirv_cross sm = shader_to_sm(shader) subprocess.check_call([spirv_cross_path, '--entry', 'main', '--output', reflect_path, spirv_path, '--reflect', '--iterations', str(iterations)]) return (spirv_path, reflect_path) def validate_shader(shader, vulkan, paths): if vulkan: spirv_14 = '.spv14.' in shader glslang_env = 'spirv1.4' if spirv_14 else 'vulkan1.1' subprocess.check_call([paths.glslang, '--amb', '--target-env', glslang_env, '-V', shader]) else: subprocess.check_call([paths.glslang, shader]) def cross_compile(shader, vulkan, spirv, invalid_spirv, eliminate, is_legacy, flatten_ubo, sso, flatten_dim, opt, push_ubo, iterations, paths): spirv_path = create_temporary() glsl_path = create_temporary(os.path.basename(shader)) spirv_14 = '.spv14.' in shader spirv_env = 'vulkan1.1spv1.4' if spirv_14 else 'vulkan1.1' if vulkan or spirv: vulkan_glsl_path = create_temporary('vk' + os.path.basename(shader)) spirv_cmd = [paths.spirv_as, '--target-env', spirv_env, '-o', spirv_path, shader] if '.preserve.' in shader: spirv_cmd.append('--preserve-numeric-ids') if spirv: subprocess.check_call(spirv_cmd) else: glslang_env = 'spirv1.4' if spirv_14 else 'vulkan1.1' subprocess.check_call([paths.glslang, '--amb', '--target-env', glslang_env, '-V', '-o', spirv_path, shader]) if opt and (not invalid_spirv): subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path]) if not invalid_spirv: subprocess.check_call([paths.spirv_val, '--scalar-block-layout', '--target-env', spirv_env, spirv_path]) extra_args = ['--iterations', str(iterations)] if eliminate: extra_args += ['--remove-unused-variables'] if is_legacy: extra_args += ['--version', '100', '--es'] if flatten_ubo: extra_args += ['--flatten-ubo'] if sso: extra_args += ['--separate-shader-objects'] if flatten_dim: extra_args += ['--flatten-multidimensional-arrays'] if push_ubo: extra_args += ['--glsl-emit-push-constant-as-ubo'] if '.line.' in shader: extra_args += ['--emit-line-directives'] if '.no-samplerless.' in shader: extra_args += ['--vulkan-glsl-disable-ext-samplerless-texture-functions'] if '.no-qualifier-deduction.' in shader: extra_args += ['--disable-storage-image-qualifier-deduction'] if '.framebuffer-fetch.' in shader: extra_args += ['--glsl-remap-ext-framebuffer-fetch', '0', '0'] extra_args += ['--glsl-remap-ext-framebuffer-fetch', '1', '1'] extra_args += ['--glsl-remap-ext-framebuffer-fetch', '2', '2'] extra_args += ['--glsl-remap-ext-framebuffer-fetch', '3', '3'] if '.zero-initialize.' in shader: extra_args += ['--force-zero-initialized-variables'] if '.force-flattened-io.' in shader: extra_args += ['--glsl-force-flattened-io-blocks'] spirv_cross_path = paths.spirv_cross # A shader might not be possible to make valid GLSL from, skip validation for this case. if (not ('nocompat' in glsl_path)) or (not vulkan): subprocess.check_call([spirv_cross_path, '--entry', 'main', '--output', glsl_path, spirv_path] + extra_args) if not 'nocompat' in glsl_path: validate_shader(glsl_path, False, paths) else: remove_file(glsl_path) glsl_path = None if (vulkan or spirv) and (not is_legacy): subprocess.check_call([spirv_cross_path, '--entry', 'main', '-V', '--output', vulkan_glsl_path, spirv_path] + extra_args) validate_shader(vulkan_glsl_path, True, paths) # SPIR-V shaders might just want to validate Vulkan GLSL output, we don't always care about the output. if not vulkan: remove_file(vulkan_glsl_path) return (spirv_path, glsl_path, vulkan_glsl_path if vulkan else None) def make_unix_newline(buf): decoded = codecs.decode(buf, 'utf-8') decoded = decoded.replace('\r', '') return codecs.encode(decoded, 'utf-8') def md5_for_file(path): md5 = hashlib.md5() with open(path, 'rb') as f: for chunk in iter(lambda: make_unix_newline(f.read(8192)), b''): md5.update(chunk) return md5.digest() def make_reference_dir(path): base = os.path.dirname(path) if not os.path.exists(base): os.makedirs(base) def reference_path(directory, relpath, opt): split_paths = os.path.split(directory) reference_dir = os.path.join(split_paths[0], 'reference/' + ('opt/' if opt else '')) reference_dir = os.path.join(reference_dir, split_paths[1]) return os.path.join(reference_dir, relpath) def regression_check_reflect(shader, json_file, args): reference = reference_path(shader[0], shader[1], args.opt) + '.json' joined_path = os.path.join(shader[0], shader[1]) print('Reference shader reflection path:', reference) if os.path.exists(reference): actual = md5_for_file(json_file) expected = md5_for_file(reference) if actual != expected: if args.update: print('Generated reflection json has changed for {}!'.format(reference)) # If we expect changes, update the reference file. if os.path.exists(reference): remove_file(reference) make_reference_dir(reference) shutil.move(json_file, reference) else: print('Generated reflection json in {} does not match reference {}!'.format(json_file, reference)) with open(json_file, 'r') as f: print('') print('Generated:') print('======================') print(f.read()) print('======================') print('') # Otherwise, fail the test. Keep the shader file around so we can inspect. if not args.keep: remove_file(json_file) raise RuntimeError('Does not match reference') else: remove_file(json_file) else: print('Found new shader {}. Placing generated source code in {}'.format(joined_path, reference)) make_reference_dir(reference) shutil.move(json_file, reference) def regression_check(shader, glsl, args): reference = reference_path(shader[0], shader[1], args.opt) joined_path = os.path.join(shader[0], shader[1]) print('Reference shader path:', reference) if os.path.exists(reference): if md5_for_file(glsl) != md5_for_file(reference): if args.update: print('Generated source code has changed for {}!'.format(reference)) # If we expect changes, update the reference file. if os.path.exists(reference): remove_file(reference) make_reference_dir(reference) shutil.move(glsl, reference) else: print('Generated source code in {} does not match reference {}!'.format(glsl, reference)) with open(glsl, 'r') as f: print('') print('Generated:') print('======================') print(f.read()) print('======================') print('') # Otherwise, fail the test. Keep the shader file around so we can inspect. if not args.keep: remove_file(glsl) raise RuntimeError('Does not match reference') else: remove_file(glsl) else: print('Found new shader {}. Placing generated source code in {}'.format(joined_path, reference)) make_reference_dir(reference) shutil.move(glsl, reference) def shader_is_vulkan(shader): return '.vk.' in shader def shader_is_desktop(shader): return '.desktop.' in shader def shader_is_eliminate_dead_variables(shader): return '.noeliminate.' not in shader def shader_is_spirv(shader): return '.asm.' in shader def shader_is_invalid_spirv(shader): return '.invalid.' in shader def shader_is_legacy(shader): return '.legacy.' in shader def shader_is_flatten_ubo(shader): return '.flatten.' in shader def shader_is_sso(shader): return '.sso.' in shader def shader_is_flatten_dimensions(shader): return '.flatten_dim.' in shader def shader_is_noopt(shader): return '.noopt.' in shader def shader_is_push_ubo(shader): return '.push-ubo.' in shader def test_shader(stats, shader, args, paths): joined_path = os.path.join(shader[0], shader[1]) vulkan = shader_is_vulkan(shader[1]) desktop = shader_is_desktop(shader[1]) eliminate = shader_is_eliminate_dead_variables(shader[1]) is_spirv = shader_is_spirv(shader[1]) invalid_spirv = shader_is_invalid_spirv(shader[1]) is_legacy = shader_is_legacy(shader[1]) flatten_ubo = shader_is_flatten_ubo(shader[1]) sso = shader_is_sso(shader[1]) flatten_dim = shader_is_flatten_dimensions(shader[1]) noopt = shader_is_noopt(shader[1]) push_ubo = shader_is_push_ubo(shader[1]) print('Testing shader:', joined_path) spirv, glsl, vulkan_glsl = cross_compile(joined_path, vulkan, is_spirv, invalid_spirv, eliminate, is_legacy, flatten_ubo, sso, flatten_dim, args.opt and (not noopt), push_ubo, args.iterations, paths) # Only test GLSL stats if we have a shader following GL semantics. if stats and (not vulkan) and (not is_spirv) and (not desktop): cross_stats = get_shader_stats(glsl) if glsl: regression_check(shader, glsl, args) if vulkan_glsl: regression_check((shader[0], shader[1] + '.vk'), vulkan_glsl, args) remove_file(spirv) if stats and (not vulkan) and (not is_spirv) and (not desktop): pristine_stats = get_shader_stats(joined_path) a = [] a.append(shader[1]) for i in pristine_stats: a.append(str(i)) for i in cross_stats: a.append(str(i)) print(','.join(a), file = stats) def test_shader_msl(stats, shader, args, paths): joined_path = os.path.join(shader[0], shader[1]) print('\nTesting MSL shader:', joined_path) is_spirv = shader_is_spirv(shader[1]) noopt = shader_is_noopt(shader[1]) spirv, msl = cross_compile_msl(joined_path, is_spirv, args.opt and (not noopt), args.iterations, paths) regression_check(shader, msl, args) # Uncomment the following line to print the temp SPIR-V file path. # This temp SPIR-V file is not deleted until after the Metal validation step below. # If Metal validation fails, the temp SPIR-V file can be copied out and # used as input to an invocation of spirv-cross to debug from Xcode directly. # To do so, build spriv-cross using `make DEBUG=1`, then run the spriv-cross # executable from Xcode using args: `--msl --entry main --output msl_path spirv_path`. # print('SPRIV shader: ' + spirv) shader_is_msl22 = 'msl22' in joined_path shader_is_msl23 = 'msl23' in joined_path skip_validation = (shader_is_msl22 and (not args.msl22)) or (shader_is_msl23 and (not args.msl23)) if '.invalid.' in joined_path: skip_validation = True if (not args.force_no_external_validation) and (not skip_validation): validate_shader_msl(shader, args.opt) remove_file(spirv) def test_shader_hlsl(stats, shader, args, paths): joined_path = os.path.join(shader[0], shader[1]) print('Testing HLSL shader:', joined_path) is_spirv = shader_is_spirv(shader[1]) noopt = shader_is_noopt(shader[1]) spirv, hlsl = cross_compile_hlsl(joined_path, is_spirv, args.opt and (not noopt), args.force_no_external_validation, args.iterations, paths) regression_check(shader, hlsl, args) remove_file(spirv) def test_shader_reflect(stats, shader, args, paths): joined_path = os.path.join(shader[0], shader[1]) print('Testing shader reflection:', joined_path) is_spirv = shader_is_spirv(shader[1]) noopt = shader_is_noopt(shader[1]) spirv, reflect = cross_compile_reflect(joined_path, is_spirv, args.opt and (not noopt), args.iterations, paths) regression_check_reflect(shader, reflect, args) remove_file(spirv) def test_shader_file(relpath, stats, args, backend): paths = Paths(args.spirv_cross, args.glslang, args.spirv_as, args.spirv_val, args.spirv_opt) try: if backend == 'msl': test_shader_msl(stats, (args.folder, relpath), args, paths) elif backend == 'hlsl': test_shader_hlsl(stats, (args.folder, relpath), args, paths) elif backend == 'reflect': test_shader_reflect(stats, (args.folder, relpath), args, paths) else: test_shader(stats, (args.folder, relpath), args, paths) return None except Exception as e: return e def test_shaders_helper(stats, backend, args): all_files = [] for root, dirs, files in os.walk(os.path.join(args.folder)): files = [ f for f in files if not f.startswith(".") ] #ignore system files (esp OSX) for i in files: path = os.path.join(root, i) relpath = os.path.relpath(path, args.folder) all_files.append(relpath) # The child processes in parallel execution mode don't have the proper state for the global args variable, so # at this point we need to switch to explicit arguments if args.parallel: with multiprocessing.Pool(multiprocessing.cpu_count()) as pool: results = [] for f in all_files: results.append(pool.apply_async(test_shader_file, args = (f, stats, args, backend))) pool.close() pool.join() results_completed = [res.get() for res in results] for error in results_completed: if error is not None: print('Error:', error) sys.exit(1) else: for i in all_files: e = test_shader_file(i, stats, args, backend) if e is not None: print('Error:', e) sys.exit(1) def test_shaders(backend, args): if args.malisc: with open('stats.csv', 'w') as stats: print('Shader,OrigRegs,OrigUniRegs,OrigALUShort,OrigLSShort,OrigTEXShort,OrigALULong,OrigLSLong,OrigTEXLong,CrossRegs,CrossUniRegs,CrossALUShort,CrossLSShort,CrossTEXShort,CrossALULong,CrossLSLong,CrossTEXLong', file = stats) test_shaders_helper(stats, backend, args) else: test_shaders_helper(None, backend, args) def main(): parser = argparse.ArgumentParser(description = 'Script for regression testing.') parser.add_argument('folder', help = 'Folder containing shader files to test.') parser.add_argument('--update', action = 'store_true', help = 'Updates reference files if there is a mismatch. Use when legitimate changes in output is found.') parser.add_argument('--keep', action = 'store_true', help = 'Leave failed GLSL shaders on disk if they fail regression. Useful for debugging.') parser.add_argument('--malisc', action = 'store_true', help = 'Use malisc offline compiler to determine static cycle counts before and after spirv-cross.') parser.add_argument('--msl', action = 'store_true', help = 'Test Metal backend.') parser.add_argument('--metal', action = 'store_true', help = 'Deprecated Metal option. Use --msl instead.') parser.add_argument('--hlsl', action = 'store_true', help = 'Test HLSL backend.') parser.add_argument('--force-no-external-validation', action = 'store_true', help = 'Disable all external validation.') parser.add_argument('--opt', action = 'store_true', help = 'Run SPIRV-Tools optimization passes as well.') parser.add_argument('--reflect', action = 'store_true', help = 'Test reflection backend.') parser.add_argument('--parallel', action = 'store_true', help = 'Execute tests in parallel. Useful for doing regression quickly, but bad for debugging and stat output.') parser.add_argument('--spirv-cross', default = './spirv-cross', help = 'Explicit path to spirv-cross') parser.add_argument('--glslang', default = 'glslangValidator', help = 'Explicit path to glslangValidator') parser.add_argument('--spirv-as', default = 'spirv-as', help = 'Explicit path to spirv-as') parser.add_argument('--spirv-val', default = 'spirv-val', help = 'Explicit path to spirv-val') parser.add_argument('--spirv-opt', default = 'spirv-opt', help = 'Explicit path to spirv-opt') parser.add_argument('--iterations', default = 1, type = int, help = 'Number of iterations to run SPIRV-Cross (benchmarking)') args = parser.parse_args() if not args.folder: sys.stderr.write('Need shader folder.\n') sys.exit(1) if (args.parallel and (args.malisc or args.force_no_external_validation or args.update)): sys.stderr.write('Parallel execution is disabled when using the flags --update, --malisc or --force-no-external-validation\n') args.parallel = False args.msl22 = False args.msl23 = False if args.msl: print_msl_compiler_version() args.msl22 = msl_compiler_supports_version('2.2') args.msl23 = msl_compiler_supports_version('2.3') backend = 'glsl' if (args.msl or args.metal): backend = 'msl' elif args.hlsl: backend = 'hlsl' elif args.reflect: backend = 'reflect' test_shaders(backend, args) if args.malisc: print('Stats in stats.csv!') print('Tests completed!') if __name__ == '__main__': main() spirv-cross-2021.01.15/test_shaders.sh000077500000000000000000000030621400026215700174220ustar00rootroot00000000000000#!/bin/bash OPTS=$@ if [ -z "$SPIRV_CROSS_PATH" ]; then echo "Building spirv-cross" make -j$(nproc) SPIRV_CROSS_PATH="./spirv-cross" fi export PATH="./external/glslang-build/output/bin:./external/spirv-tools-build/output/bin:.:$PATH" echo "Using glslangValidation in: $(which glslangValidator)." echo "Using spirv-opt in: $(which spirv-opt)." echo "Using SPIRV-Cross in: \"$SPIRV_CROSS_PATH\"." ./test_shaders.py shaders ${OPTS} --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders ${OPTS} --opt --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-no-opt ${OPTS} --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-msl ${OPTS} --msl --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-msl ${OPTS} --msl --opt --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-msl-no-opt ${OPTS} --msl --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-hlsl ${OPTS} --hlsl --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-hlsl ${OPTS} --hlsl --opt --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-hlsl-no-opt ${OPTS} --hlsl --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-reflection ${OPTS} --reflect --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-ue4 ${OPTS} --msl --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-ue4 ${OPTS} --msl --opt --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 ./test_shaders.py shaders-ue4-no-opt ${OPTS} --msl --spirv-cross "$SPIRV_CROSS_PATH" || exit 1 spirv-cross-2021.01.15/tests-other/000077500000000000000000000000001400026215700166535ustar00rootroot00000000000000spirv-cross-2021.01.15/tests-other/c_api_test.c000066400000000000000000000150701400026215700211340ustar00rootroot00000000000000/* Smoke test for the C API. */ #ifdef _MSC_VER #define _CRT_SECURE_NO_WARNINGS #endif #include #include #include #define SPVC_CHECKED_CALL(x) do { \ if ((x) != SPVC_SUCCESS) { \ fprintf(stderr, "Failed at line %d.\n", __LINE__); \ exit(1); \ } \ } while(0) #define SPVC_CHECKED_CALL_NEGATIVE(x) do { \ g_fail_on_error = SPVC_FALSE; \ if ((x) == SPVC_SUCCESS) { \ fprintf(stderr, "Failed at line %d.\n", __LINE__); \ exit(1); \ } \ g_fail_on_error = SPVC_TRUE; \ } while(0) static int read_file(const char *path, SpvId **buffer, size_t *word_count) { long len; FILE *file = fopen(path, "rb"); if (!file) return -1; fseek(file, 0, SEEK_END); len = ftell(file); rewind(file); *buffer = malloc(len); if (fread(*buffer, 1, len, file) != (size_t)len) { fclose(file); free(*buffer); return -1; } fclose(file); *word_count = len / sizeof(SpvId); return 0; } static spvc_bool g_fail_on_error = SPVC_TRUE; static void error_callback(void *userdata, const char *error) { (void)userdata; if (g_fail_on_error) { fprintf(stderr, "Error: %s\n", error); exit(1); } else printf("Expected error hit: %s.\n", error); } static void dump_resource_list(spvc_compiler compiler, spvc_resources resources, spvc_resource_type type, const char *tag) { const spvc_reflected_resource *list = NULL; size_t count = 0; size_t i; SPVC_CHECKED_CALL(spvc_resources_get_resource_list_for_type(resources, type, &list, &count)); printf("%s\n", tag); for (i = 0; i < count; i++) { printf("ID: %u, BaseTypeID: %u, TypeID: %u, Name: %s\n", list[i].id, list[i].base_type_id, list[i].type_id, list[i].name); printf(" Set: %u, Binding: %u\n", spvc_compiler_get_decoration(compiler, list[i].id, SpvDecorationDescriptorSet), spvc_compiler_get_decoration(compiler, list[i].id, SpvDecorationBinding)); } } static void dump_resources(spvc_compiler compiler, spvc_resources resources) { dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_UNIFORM_BUFFER, "UBO"); dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_STORAGE_BUFFER, "SSBO"); dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_PUSH_CONSTANT, "Push"); dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS, "Samplers"); dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_SEPARATE_IMAGE, "Image"); dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_SAMPLED_IMAGE, "Combined image samplers"); dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_STAGE_INPUT, "Stage input"); dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_STAGE_OUTPUT, "Stage output"); dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_STORAGE_IMAGE, "Storage image"); dump_resource_list(compiler, resources, SPVC_RESOURCE_TYPE_SUBPASS_INPUT, "Subpass input"); } static void compile(spvc_compiler compiler, const char *tag) { const char *result = NULL; SPVC_CHECKED_CALL(spvc_compiler_compile(compiler, &result)); printf("\n%s\n=======\n", tag); printf("%s\n=======\n", result); } int main(int argc, char **argv) { const char *rev = NULL; spvc_context context = NULL; spvc_parsed_ir ir = NULL; spvc_compiler compiler_glsl = NULL; spvc_compiler compiler_hlsl = NULL; spvc_compiler compiler_msl = NULL; spvc_compiler compiler_cpp = NULL; spvc_compiler compiler_json = NULL; spvc_compiler compiler_none = NULL; spvc_compiler_options options = NULL; spvc_resources resources = NULL; SpvId *buffer = NULL; size_t word_count = 0; rev = spvc_get_commit_revision_and_timestamp(); if (!rev || *rev == '\0') return 1; printf("Revision: %s\n", rev); if (argc != 5) return 1; if (read_file(argv[1], &buffer, &word_count) < 0) return 1; unsigned abi_major, abi_minor, abi_patch; spvc_get_version(&abi_major, &abi_minor, &abi_patch); if (abi_major != strtoul(argv[2], NULL, 0)) { fprintf(stderr, "VERSION_MAJOR mismatch!\n"); return 1; } if (abi_minor != strtoul(argv[3], NULL, 0)) { fprintf(stderr, "VERSION_MINOR mismatch!\n"); return 1; } if (abi_patch != strtoul(argv[4], NULL, 0)) { fprintf(stderr, "VERSION_PATCH mismatch!\n"); return 1; } SPVC_CHECKED_CALL(spvc_context_create(&context)); spvc_context_set_error_callback(context, error_callback, NULL); SPVC_CHECKED_CALL(spvc_context_parse_spirv(context, buffer, word_count, &ir)); SPVC_CHECKED_CALL(spvc_context_create_compiler(context, SPVC_BACKEND_GLSL, ir, SPVC_CAPTURE_MODE_COPY, &compiler_glsl)); SPVC_CHECKED_CALL(spvc_context_create_compiler(context, SPVC_BACKEND_HLSL, ir, SPVC_CAPTURE_MODE_COPY, &compiler_hlsl)); SPVC_CHECKED_CALL(spvc_context_create_compiler(context, SPVC_BACKEND_MSL, ir, SPVC_CAPTURE_MODE_COPY, &compiler_msl)); SPVC_CHECKED_CALL(spvc_context_create_compiler(context, SPVC_BACKEND_CPP, ir, SPVC_CAPTURE_MODE_COPY, &compiler_cpp)); SPVC_CHECKED_CALL(spvc_context_create_compiler(context, SPVC_BACKEND_JSON, ir, SPVC_CAPTURE_MODE_COPY, &compiler_json)); SPVC_CHECKED_CALL(spvc_context_create_compiler(context, SPVC_BACKEND_NONE, ir, SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler_none)); SPVC_CHECKED_CALL(spvc_compiler_create_compiler_options(compiler_none, &options)); SPVC_CHECKED_CALL(spvc_compiler_install_compiler_options(compiler_none, options)); SPVC_CHECKED_CALL(spvc_compiler_create_compiler_options(compiler_json, &options)); SPVC_CHECKED_CALL(spvc_compiler_install_compiler_options(compiler_json, options)); SPVC_CHECKED_CALL(spvc_compiler_create_compiler_options(compiler_cpp, &options)); SPVC_CHECKED_CALL(spvc_compiler_install_compiler_options(compiler_cpp, options)); SPVC_CHECKED_CALL(spvc_compiler_create_compiler_options(compiler_msl, &options)); SPVC_CHECKED_CALL(spvc_compiler_install_compiler_options(compiler_msl, options)); SPVC_CHECKED_CALL(spvc_compiler_create_compiler_options(compiler_hlsl, &options)); SPVC_CHECKED_CALL(spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_HLSL_SHADER_MODEL, 50)); SPVC_CHECKED_CALL_NEGATIVE(spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_PLATFORM, 1)); SPVC_CHECKED_CALL(spvc_compiler_install_compiler_options(compiler_hlsl, options)); SPVC_CHECKED_CALL(spvc_compiler_create_compiler_options(compiler_glsl, &options)); SPVC_CHECKED_CALL(spvc_compiler_install_compiler_options(compiler_glsl, options)); SPVC_CHECKED_CALL(spvc_compiler_create_shader_resources(compiler_none, &resources)); dump_resources(compiler_none, resources); compile(compiler_glsl, "GLSL"); compile(compiler_hlsl, "HLSL"); compile(compiler_msl, "MSL"); compile(compiler_json, "JSON"); compile(compiler_cpp, "CPP"); spvc_context_destroy(context); free(buffer); return 0; } spirv-cross-2021.01.15/tests-other/c_api_test.spv000066400000000000000000000023641400026215700215240ustar00rootroot00000000000000#& GLSL.std.450mainmainSSBOa ssbo UBO auboPusharegistersuTexture uImage"uSeparateTexture%uSamplerH#GG "G !H #G G"G!H#GG"G!G "G !G G""G"!G%"G%!!  ;  +     ;    ;    ;  ; !;!"# $#;$%6A =A =A >8spirv-cross-2021.01.15/tests-other/hlsl_resource_binding.spv000066400000000000000000000014341400026215700237520ustar00rootroot00000000000000# GLSL.std.450main main FragColor uSamplervUVRegisterscolorregistersG G "G !GH#G!  ;    ;  ;  ;  +  6=  =WA=> 8spirv-cross-2021.01.15/tests-other/hlsl_resource_bindings.cpp000066400000000000000000000050041400026215700241040ustar00rootroot00000000000000// Testbench for HLSL resource binding APIs. // It does not validate output at the moment, but it's useful for ad-hoc testing. #include #include #include #include #define SPVC_CHECKED_CALL(x) do { \ if ((x) != SPVC_SUCCESS) { \ fprintf(stderr, "Failed at line %d.\n", __LINE__); \ exit(1); \ } \ } while(0) static std::vector read_file(const char *path) { long len; FILE *file = fopen(path, "rb"); if (!file) return {}; fseek(file, 0, SEEK_END); len = ftell(file); rewind(file); std::vector buffer(len / sizeof(SpvId)); if (fread(buffer.data(), 1, len, file) != (size_t)len) { fclose(file); return {}; } fclose(file); return buffer; } int main(int argc, char **argv) { if (argc != 2) return EXIT_FAILURE; auto buffer = read_file(argv[1]); if (buffer.empty()) return EXIT_FAILURE; spvc_context ctx; spvc_parsed_ir parsed_ir; spvc_compiler compiler; SPVC_CHECKED_CALL(spvc_context_create(&ctx)); SPVC_CHECKED_CALL(spvc_context_parse_spirv(ctx, buffer.data(), buffer.size(), &parsed_ir)); SPVC_CHECKED_CALL(spvc_context_create_compiler(ctx, SPVC_BACKEND_HLSL, parsed_ir, SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler)); spvc_compiler_options opts; SPVC_CHECKED_CALL(spvc_compiler_create_compiler_options(compiler, &opts)); SPVC_CHECKED_CALL(spvc_compiler_options_set_uint(opts, SPVC_COMPILER_OPTION_HLSL_SHADER_MODEL, 51)); SPVC_CHECKED_CALL(spvc_compiler_install_compiler_options(compiler, opts)); spvc_hlsl_resource_binding binding; spvc_hlsl_resource_binding_init(&binding); binding.stage = SpvExecutionModelFragment; binding.desc_set = 1; binding.binding = 4; binding.srv.register_space = 2; binding.srv.register_binding = 3; binding.sampler.register_space = 4; binding.sampler.register_binding = 5; SPVC_CHECKED_CALL(spvc_compiler_hlsl_add_resource_binding(compiler, &binding)); binding.desc_set = SPVC_HLSL_PUSH_CONSTANT_DESC_SET; binding.binding = SPVC_HLSL_PUSH_CONSTANT_BINDING; binding.cbv.register_space = 0; binding.cbv.register_binding = 4; SPVC_CHECKED_CALL(spvc_compiler_hlsl_add_resource_binding(compiler, &binding)); const char *str; SPVC_CHECKED_CALL(spvc_compiler_compile(compiler, &str)); fprintf(stderr, "Output:\n%s\n", str); if (!spvc_compiler_hlsl_is_resource_used(compiler, SpvExecutionModelFragment, 1, 4)) return EXIT_FAILURE; if (!spvc_compiler_hlsl_is_resource_used(compiler, SpvExecutionModelFragment, SPVC_HLSL_PUSH_CONSTANT_DESC_SET, SPVC_HLSL_PUSH_CONSTANT_BINDING)) return EXIT_FAILURE; } spirv-cross-2021.01.15/tests-other/hlsl_wave_mask.cpp000066400000000000000000000062051400026215700223610ustar00rootroot00000000000000// Ad-hoc test that the wave op masks work as expected. #include #include using namespace glm; static uvec4 gl_SubgroupEqMask; static uvec4 gl_SubgroupGeMask; static uvec4 gl_SubgroupGtMask; static uvec4 gl_SubgroupLeMask; static uvec4 gl_SubgroupLtMask; using uint4 = uvec4; static void test_main(unsigned wave_index) { const auto WaveGetLaneIndex = [&]() { return wave_index; }; gl_SubgroupEqMask = 1u << (WaveGetLaneIndex() - uint4(0, 32, 64, 96)); if (WaveGetLaneIndex() >= 32) gl_SubgroupEqMask.x = 0; if (WaveGetLaneIndex() >= 64 || WaveGetLaneIndex() < 32) gl_SubgroupEqMask.y = 0; if (WaveGetLaneIndex() >= 96 || WaveGetLaneIndex() < 64) gl_SubgroupEqMask.z = 0; if (WaveGetLaneIndex() < 96) gl_SubgroupEqMask.w = 0; gl_SubgroupGeMask = ~((1u << (WaveGetLaneIndex() - uint4(0, 32, 64, 96))) - 1u); if (WaveGetLaneIndex() >= 32) gl_SubgroupGeMask.x = 0u; if (WaveGetLaneIndex() >= 64) gl_SubgroupGeMask.y = 0u; if (WaveGetLaneIndex() >= 96) gl_SubgroupGeMask.z = 0u; if (WaveGetLaneIndex() < 32) gl_SubgroupGeMask.y = ~0u; if (WaveGetLaneIndex() < 64) gl_SubgroupGeMask.z = ~0u; if (WaveGetLaneIndex() < 96) gl_SubgroupGeMask.w = ~0u; uint gt_lane_index = WaveGetLaneIndex() + 1; gl_SubgroupGtMask = ~((1u << (gt_lane_index - uint4(0, 32, 64, 96))) - 1u); if (gt_lane_index >= 32) gl_SubgroupGtMask.x = 0u; if (gt_lane_index >= 64) gl_SubgroupGtMask.y = 0u; if (gt_lane_index >= 96) gl_SubgroupGtMask.z = 0u; if (gt_lane_index >= 128) gl_SubgroupGtMask.w = 0u; if (gt_lane_index < 32) gl_SubgroupGtMask.y = ~0u; if (gt_lane_index < 64) gl_SubgroupGtMask.z = ~0u; if (gt_lane_index < 96) gl_SubgroupGtMask.w = ~0u; uint le_lane_index = WaveGetLaneIndex() + 1; gl_SubgroupLeMask = (1u << (le_lane_index - uint4(0, 32, 64, 96))) - 1u; if (le_lane_index >= 32) gl_SubgroupLeMask.x = ~0u; if (le_lane_index >= 64) gl_SubgroupLeMask.y = ~0u; if (le_lane_index >= 96) gl_SubgroupLeMask.z = ~0u; if (le_lane_index >= 128) gl_SubgroupLeMask.w = ~0u; if (le_lane_index < 32) gl_SubgroupLeMask.y = 0u; if (le_lane_index < 64) gl_SubgroupLeMask.z = 0u; if (le_lane_index < 96) gl_SubgroupLeMask.w = 0u; gl_SubgroupLtMask = (1u << (WaveGetLaneIndex() - uint4(0, 32, 64, 96))) - 1u; if (WaveGetLaneIndex() >= 32) gl_SubgroupLtMask.x = ~0u; if (WaveGetLaneIndex() >= 64) gl_SubgroupLtMask.y = ~0u; if (WaveGetLaneIndex() >= 96) gl_SubgroupLtMask.z = ~0u; if (WaveGetLaneIndex() < 32) gl_SubgroupLtMask.y = 0u; if (WaveGetLaneIndex() < 64) gl_SubgroupLtMask.z = 0u; if (WaveGetLaneIndex() < 96) gl_SubgroupLtMask.w = 0u; } int main() { for (unsigned subgroup_id = 0; subgroup_id < 128; subgroup_id++) { test_main(subgroup_id); for (unsigned bit = 0; bit < 128; bit++) { assert(bool(gl_SubgroupEqMask[bit / 32] & (1u << (bit & 31))) == (bit == subgroup_id)); assert(bool(gl_SubgroupGtMask[bit / 32] & (1u << (bit & 31))) == (bit > subgroup_id)); assert(bool(gl_SubgroupGeMask[bit / 32] & (1u << (bit & 31))) == (bit >= subgroup_id)); assert(bool(gl_SubgroupLtMask[bit / 32] & (1u << (bit & 31))) == (bit < subgroup_id)); assert(bool(gl_SubgroupLeMask[bit / 32] & (1u << (bit & 31))) == (bit <= subgroup_id)); } } } spirv-cross-2021.01.15/tests-other/msl_constexpr_test.cpp000066400000000000000000000100161400026215700233140ustar00rootroot00000000000000// Testbench for MSL constexpr samplers. // It does not validate output, but it's useful for ad-hoc testing. #ifdef _MSC_VER #define _CRT_SECURE_NO_WARNINGS #endif #include #include #include #include #define SPVC_CHECKED_CALL(x) do { \ if ((x) != SPVC_SUCCESS) { \ fprintf(stderr, "Failed at line %d.\n", __LINE__); \ exit(1); \ } \ } while(0) #define SPVC_CHECKED_CALL_NEGATIVE(x) do { \ g_fail_on_error = SPVC_FALSE; \ if ((x) == SPVC_SUCCESS) { \ fprintf(stderr, "Failed at line %d.\n", __LINE__); \ exit(1); \ } \ g_fail_on_error = SPVC_TRUE; \ } while(0) static std::vector read_file(const char *path) { long len; FILE *file = fopen(path, "rb"); if (!file) return {}; fseek(file, 0, SEEK_END); len = ftell(file); rewind(file); std::vector buffer(len / sizeof(SpvId)); if (fread(buffer.data(), 1, len, file) != (size_t)len) { fclose(file); return {}; } fclose(file); return buffer; } int main(int argc, char **argv) { if (argc != 2) return EXIT_FAILURE; auto buffer = read_file(argv[1]); if (buffer.empty()) return EXIT_FAILURE; spvc_context ctx; spvc_parsed_ir parsed_ir; spvc_compiler compiler; SPVC_CHECKED_CALL(spvc_context_create(&ctx)); SPVC_CHECKED_CALL(spvc_context_parse_spirv(ctx, buffer.data(), buffer.size(), &parsed_ir)); SPVC_CHECKED_CALL(spvc_context_create_compiler(ctx, SPVC_BACKEND_MSL, parsed_ir, SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler)); spvc_msl_resource_binding binding; spvc_msl_resource_binding_init(&binding); binding.desc_set = 1; binding.binding = 2; binding.stage = SpvExecutionModelFragment; binding.msl_texture = 0; binding.msl_sampler = 0; SPVC_CHECKED_CALL(spvc_compiler_msl_add_resource_binding(compiler, &binding)); binding.binding = 3; binding.msl_texture = 1; binding.msl_sampler = 1000; // Will be remapped anyways, sanity check. SPVC_CHECKED_CALL(spvc_compiler_msl_add_resource_binding(compiler, &binding)); binding.desc_set = 2; binding.binding = 2; binding.msl_texture = 2; SPVC_CHECKED_CALL(spvc_compiler_msl_add_resource_binding(compiler, &binding)); binding.binding = 3; binding.msl_texture = 3; SPVC_CHECKED_CALL(spvc_compiler_msl_add_resource_binding(compiler, &binding)); spvc_msl_constexpr_sampler samp; spvc_msl_constexpr_sampler_init(&samp); samp.s_address = SPVC_MSL_SAMPLER_ADDRESS_REPEAT; samp.t_address = SPVC_MSL_SAMPLER_ADDRESS_REPEAT; samp.r_address = SPVC_MSL_SAMPLER_ADDRESS_REPEAT; SPVC_CHECKED_CALL(spvc_compiler_msl_remap_constexpr_sampler_by_binding(compiler, 1, 3, &samp)); samp.s_address = SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; samp.t_address = SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; samp.r_address = SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; SPVC_CHECKED_CALL(spvc_compiler_msl_remap_constexpr_sampler_by_binding(compiler, 2, 4, &samp)); samp.compare_enable = SPVC_TRUE; samp.compare_func = SPVC_MSL_SAMPLER_COMPARE_FUNC_LESS; samp.s_address = SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; samp.t_address = SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; samp.r_address = SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; SPVC_CHECKED_CALL(spvc_compiler_msl_remap_constexpr_sampler_by_binding(compiler, 2, 5, &samp)); const char *str; SPVC_CHECKED_CALL(spvc_compiler_compile(compiler, &str)); // Should not be marked as used. if (spvc_compiler_msl_is_resource_used(compiler, SpvExecutionModelFragment, 2, 4)) return EXIT_FAILURE; // Should not be marked as used. if (spvc_compiler_msl_is_resource_used(compiler, SpvExecutionModelFragment, 2, 5)) return EXIT_FAILURE; // Should be marked, as a sanity check. if (!spvc_compiler_msl_is_resource_used(compiler, SpvExecutionModelFragment, 1, 2)) return EXIT_FAILURE; if (!spvc_compiler_msl_is_resource_used(compiler, SpvExecutionModelFragment, 1, 3)) return EXIT_FAILURE; if (!spvc_compiler_msl_is_resource_used(compiler, SpvExecutionModelFragment, 2, 2)) return EXIT_FAILURE; if (!spvc_compiler_msl_is_resource_used(compiler, SpvExecutionModelFragment, 2, 3)) return EXIT_FAILURE; fprintf(stderr, "Output:\n%s\n", str); } spirv-cross-2021.01.15/tests-other/msl_constexpr_test.spv000066400000000000000000000031701400026215700233450ustar00rootroot00000000000000#? GLSL.std.450main mainfunc( FragColor uImage2uSampler2vUV$uImageShadow2&uSamplerShadow20uSampler7uSamplerShadowG G "G !G"G!GG$"G$!G&"G&!G0"G0!G7"G7!!  ;    ;  ;  ; + " #";#$;&(" /;/0 6(;676=10=2O322W413Q54> 5=(87=9Q:9Y;89:=< =<;> =9>86=  =V=OWQ= ! > !="%$='&V()%'=*Q+*Y,)*+=- .-,> .8spirv-cross-2021.01.15/tests-other/msl_resource_binding.spv000066400000000000000000000026201400026215700236010ustar00rootroot00000000000000#/ GLSL.std.450main +main FragColor UBO x UBO2yUzVw 'uTexture+vUVG H #G G "G !H#GG"G!H#GG"G!H#GG "G !G'"G'!G+!  ;     ;  +   ; ; ;  $%$ &%;&') *);*+6A =A=A=A! ="!#"=%('=),+W-(,.#-> .8spirv-cross-2021.01.15/tests-other/msl_resource_bindings.cpp000066400000000000000000000047441400026215700237470ustar00rootroot00000000000000// Testbench for MSL resource binding APIs. // It does not validate output at the moment, but it's useful for ad-hoc testing. #include #include #include #include #define SPVC_CHECKED_CALL(x) do { \ if ((x) != SPVC_SUCCESS) { \ fprintf(stderr, "Failed at line %d.\n", __LINE__); \ exit(1); \ } \ } while(0) static std::vector read_file(const char *path) { long len; FILE *file = fopen(path, "rb"); if (!file) return {}; fseek(file, 0, SEEK_END); len = ftell(file); rewind(file); std::vector buffer(len / sizeof(SpvId)); if (fread(buffer.data(), 1, len, file) != (size_t)len) { fclose(file); return {}; } fclose(file); return buffer; } int main(int argc, char **argv) { if (argc != 2) return EXIT_FAILURE; auto buffer = read_file(argv[1]); if (buffer.empty()) return EXIT_FAILURE; spvc_context ctx; spvc_parsed_ir parsed_ir; spvc_compiler compiler; SPVC_CHECKED_CALL(spvc_context_create(&ctx)); SPVC_CHECKED_CALL(spvc_context_parse_spirv(ctx, buffer.data(), buffer.size(), &parsed_ir)); SPVC_CHECKED_CALL(spvc_context_create_compiler(ctx, SPVC_BACKEND_MSL, parsed_ir, SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler)); SPVC_CHECKED_CALL(spvc_compiler_msl_add_discrete_descriptor_set(compiler, 3)); spvc_compiler_options opts; SPVC_CHECKED_CALL(spvc_compiler_create_compiler_options(compiler, &opts)); SPVC_CHECKED_CALL(spvc_compiler_options_set_bool(opts, SPVC_COMPILER_OPTION_MSL_ARGUMENT_BUFFERS, SPVC_TRUE)); SPVC_CHECKED_CALL(spvc_compiler_options_set_uint(opts, SPVC_COMPILER_OPTION_MSL_VERSION, 20000)); SPVC_CHECKED_CALL(spvc_compiler_install_compiler_options(compiler, opts)); spvc_msl_resource_binding binding; spvc_msl_resource_binding_init(&binding); binding.binding = SPVC_MSL_ARGUMENT_BUFFER_BINDING; binding.stage = SpvExecutionModelFragment; binding.desc_set = 0; binding.msl_buffer = 2; SPVC_CHECKED_CALL(spvc_compiler_msl_add_resource_binding(compiler, &binding)); binding.desc_set = 1; binding.msl_buffer = 3; SPVC_CHECKED_CALL(spvc_compiler_msl_add_resource_binding(compiler, &binding)); const char *str; SPVC_CHECKED_CALL(spvc_compiler_compile(compiler, &str)); fprintf(stderr, "Output:\n%s\n", str); if (!spvc_compiler_msl_is_resource_used(compiler, SpvExecutionModelFragment, 0, SPVC_MSL_ARGUMENT_BUFFER_BINDING)) return EXIT_FAILURE; if (!spvc_compiler_msl_is_resource_used(compiler, SpvExecutionModelFragment, 1, SPVC_MSL_ARGUMENT_BUFFER_BINDING)) return EXIT_FAILURE; } spirv-cross-2021.01.15/tests-other/msl_ycbcr_conversion_test.cpp000066400000000000000000000057001400026215700246420ustar00rootroot00000000000000// Testbench for MSL constexpr samplers, with Y'CbCr conversion. // It does not validate output, but it's useful for ad-hoc testing. #ifdef _MSC_VER #define _CRT_SECURE_NO_WARNINGS #endif #include #include #include #include #define SPVC_CHECKED_CALL(x) do { \ if ((x) != SPVC_SUCCESS) { \ fprintf(stderr, "Failed at line %d.\n", __LINE__); \ exit(1); \ } \ } while(0) #define SPVC_CHECKED_CALL_NEGATIVE(x) do { \ g_fail_on_error = SPVC_FALSE; \ if ((x) == SPVC_SUCCESS) { \ fprintf(stderr, "Failed at line %d.\n", __LINE__); \ exit(1); \ } \ g_fail_on_error = SPVC_TRUE; \ } while(0) static std::vector read_file(const char *path) { long len; FILE *file = fopen(path, "rb"); if (!file) return {}; fseek(file, 0, SEEK_END); len = ftell(file); rewind(file); std::vector buffer(len / sizeof(SpvId)); if (fread(buffer.data(), 1, len, file) != (size_t)len) { fclose(file); return {}; } fclose(file); return buffer; } int main(int argc, char **argv) { if (argc != 2) return EXIT_FAILURE; auto buffer = read_file(argv[1]); if (buffer.empty()) return EXIT_FAILURE; spvc_context ctx; spvc_parsed_ir parsed_ir; spvc_compiler compiler; spvc_compiler_options options; SPVC_CHECKED_CALL(spvc_context_create(&ctx)); SPVC_CHECKED_CALL(spvc_context_parse_spirv(ctx, buffer.data(), buffer.size(), &parsed_ir)); SPVC_CHECKED_CALL(spvc_context_create_compiler(ctx, SPVC_BACKEND_MSL, parsed_ir, SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler)); SPVC_CHECKED_CALL(spvc_compiler_create_compiler_options(compiler, &options)); SPVC_CHECKED_CALL(spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_VERSION, SPVC_MAKE_MSL_VERSION(2, 0, 0))); SPVC_CHECKED_CALL(spvc_compiler_install_compiler_options(compiler, options)); spvc_msl_resource_binding binding; spvc_msl_resource_binding_init(&binding); binding.desc_set = 1; binding.binding = 2; binding.stage = SpvExecutionModelFragment; binding.msl_texture = 0; binding.msl_sampler = 0; SPVC_CHECKED_CALL(spvc_compiler_msl_add_resource_binding(compiler, &binding)); spvc_msl_constexpr_sampler samp; spvc_msl_sampler_ycbcr_conversion conv; spvc_msl_constexpr_sampler_init(&samp); spvc_msl_sampler_ycbcr_conversion_init(&conv); conv.planes = 3; conv.resolution = SPVC_MSL_FORMAT_RESOLUTION_422; conv.chroma_filter = SPVC_MSL_SAMPLER_FILTER_LINEAR; conv.x_chroma_offset = SPVC_MSL_CHROMA_LOCATION_MIDPOINT; conv.ycbcr_model = SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020; conv.ycbcr_range = SPVC_MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW; conv.bpc = 8; SPVC_CHECKED_CALL(spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr(compiler, 1, 2, &samp, &conv)); const char *str; SPVC_CHECKED_CALL(spvc_compiler_compile(compiler, &str)); // Should be marked, as a sanity check. if (!spvc_compiler_msl_is_resource_used(compiler, SpvExecutionModelFragment, 1, 2)) return EXIT_FAILURE; fprintf(stderr, "Output:\n%s\n", str); } spirv-cross-2021.01.15/tests-other/msl_ycbcr_conversion_test.spv000066400000000000000000000013301400026215700246630ustar00rootroot00000000000000# GLSL.std.450mainmainfunc(FragColorvUVuSamplerGGG"G!!   ;      ;   +  ;6986= =OWQ >8spirv-cross-2021.01.15/tests-other/msl_ycbcr_conversion_test_2.spv000066400000000000000000000015101400026215700251040ustar00rootroot00000000000000#  GLSL.std.450mainmain foo(s21; sbar(s21;sbaz(FragColorvUVuSamplerGGG"G!!    !   ; ;; 6986 7  = =W>86 7 9 8698spirv-cross-2021.01.15/tests-other/small_vector.cpp000066400000000000000000000127631400026215700220620ustar00rootroot00000000000000/* * Copyright 2019-2021 Hans-Kristian Arntzen * * 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 "spirv_cross.hpp" #include using namespace spirv_cross; // Test the tricky bits of the implementation. // Running the entire test suite on this implementation should find all other potential issues. static int allocations = 0; static int deallocations = 0; #define SPVC_ASSERT(x) do { \ if (!(x)) SPIRV_CROSS_THROW("Assert: " #x " failed!"); \ } while(0) struct RAIIInt { RAIIInt(int v_) : v(v_) { allocations++; } ~RAIIInt() { deallocations++; } RAIIInt() { allocations++; } RAIIInt(const RAIIInt &other) { v = other.v; allocations++; } RAIIInt(RAIIInt &&other) SPIRV_CROSS_NOEXCEPT { v = other.v; allocations++; } RAIIInt &operator=(RAIIInt &&) = default; RAIIInt &operator=(const RAIIInt &) = default; int v = 0; }; static void propagate_stack_to_heap() { SmallVector ints; ints.emplace_back(1); ints.emplace_back(2); auto *old_data = ints.data(); SPVC_ASSERT(ints[0].v == 1); SPVC_ASSERT(ints[1].v == 2); ints.emplace_back(3); SPVC_ASSERT(old_data != ints.data()); SPVC_ASSERT(ints[0].v == 1); SPVC_ASSERT(ints[1].v == 2); SPVC_ASSERT(ints[2].v == 3); SPVC_ASSERT(ints.size() == 3); } static void insert_end() { SmallVector ints; ints.emplace_back(1); ints.emplace_back(2); const RAIIInt new_ints[3] = { 10, 20, 30 }; ints.insert(ints.end(), new_ints, new_ints + 3); SPVC_ASSERT(ints.size() == 5); SPVC_ASSERT(ints[0].v == 1); SPVC_ASSERT(ints[1].v == 2); SPVC_ASSERT(ints[2].v == 10); SPVC_ASSERT(ints[3].v == 20); SPVC_ASSERT(ints[4].v == 30); } static void insert_begin_realloc() { SmallVector ints; ints.emplace_back(1); ints.emplace_back(2); const RAIIInt new_ints[3] = { 10, 20, 30 }; ints.insert(ints.begin(), new_ints, new_ints + 3); SPVC_ASSERT(ints.size() == 5); SPVC_ASSERT(ints[0].v == 10); SPVC_ASSERT(ints[1].v == 20); SPVC_ASSERT(ints[2].v == 30); SPVC_ASSERT(ints[3].v == 1); SPVC_ASSERT(ints[4].v == 2); } static void insert_middle_realloc() { SmallVector ints; ints.emplace_back(1); ints.emplace_back(2); const RAIIInt new_ints[3] = { 10, 20, 30 }; ints.insert(ints.begin() + 1, new_ints, new_ints + 3); SPVC_ASSERT(ints.size() == 5); SPVC_ASSERT(ints[0].v == 1); SPVC_ASSERT(ints[1].v == 10); SPVC_ASSERT(ints[2].v == 20); SPVC_ASSERT(ints[3].v == 30); SPVC_ASSERT(ints[4].v == 2); } static void insert_begin_no_realloc() { SmallVector ints; ints.reserve(10); ints.emplace_back(1); ints.emplace_back(2); const RAIIInt new_ints[3] = { 10, 20, 30 }; ints.insert(ints.begin(), new_ints, new_ints + 3); SPVC_ASSERT(ints.size() == 5); SPVC_ASSERT(ints[0].v == 10); SPVC_ASSERT(ints[1].v == 20); SPVC_ASSERT(ints[2].v == 30); SPVC_ASSERT(ints[3].v == 1); SPVC_ASSERT(ints[4].v == 2); } static void insert_middle_no_realloc() { SmallVector ints; ints.reserve(10); ints.emplace_back(1); ints.emplace_back(2); const RAIIInt new_ints[3] = { 10, 20, 30 }; ints.insert(ints.begin() + 1, new_ints, new_ints + 3); SPVC_ASSERT(ints.size() == 5); SPVC_ASSERT(ints[0].v == 1); SPVC_ASSERT(ints[1].v == 10); SPVC_ASSERT(ints[2].v == 20); SPVC_ASSERT(ints[3].v == 30); SPVC_ASSERT(ints[4].v == 2); } static void erase_end() { SmallVector ints; ints.emplace_back(1); ints.emplace_back(2); ints.emplace_back(3); ints.emplace_back(4); ints.erase(ints.begin() + 1, ints.end()); SPVC_ASSERT(ints.size() == 1); SPVC_ASSERT(ints[0].v == 1); } static void erase_middle() { SmallVector ints; ints.emplace_back(1); ints.emplace_back(2); ints.emplace_back(3); ints.emplace_back(4); ints.erase(ints.begin() + 1, ints.end() - 1); SPVC_ASSERT(ints.size() == 2); SPVC_ASSERT(ints[0].v == 1); SPVC_ASSERT(ints[1].v == 4); } static void erase_start() { SmallVector ints; ints.emplace_back(1); ints.emplace_back(2); ints.emplace_back(3); ints.emplace_back(4); ints.erase(ints.begin(), ints.end() - 2); SPVC_ASSERT(ints.size() == 2); SPVC_ASSERT(ints[0].v == 3); SPVC_ASSERT(ints[1].v == 4); } static void convert_to_std_vector() { SmallVector foo; foo.push_back(1); foo.push_back(2); std::vector ints(foo); SPVC_ASSERT(ints.size() == 2); SPVC_ASSERT(foo.size() == 2); SPVC_ASSERT(ints[0].v == 1); SPVC_ASSERT(ints[1].v == 2); // This doesn't work on MSVC 2013. Ignore it. #if !(defined(_MSC_VER) && _MSC_VER < 1900) SmallVector> move_only_buffer; move_only_buffer.emplace_back(new RAIIInt(40)); std::vector> move_only_vector(std::move(move_only_buffer)); SPVC_ASSERT(move_only_vector.size() == 1); SPVC_ASSERT(move_only_vector[0]->v == 40); #endif } int main() { propagate_stack_to_heap(); insert_end(); insert_begin_realloc(); insert_begin_no_realloc(); insert_middle_realloc(); insert_middle_no_realloc(); erase_end(); erase_middle(); erase_start(); convert_to_std_vector(); SPVC_ASSERT(allocations > 0 && deallocations > 0 && deallocations == allocations); } spirv-cross-2021.01.15/tests-other/typed_id_test.cpp000066400000000000000000000020001400026215700222070ustar00rootroot00000000000000#include "spirv_common.hpp" using namespace SPIRV_CROSS_NAMESPACE; int main() { // Construct from uint32_t. VariableID var_id = 10; TypeID type_id = 20; ConstantID constant_id = 30; // Assign from uint32_t. var_id = 100; type_id = 40; constant_id = 60; // Construct generic ID. ID generic_var_id = var_id; ID generic_type_id = type_id; ID generic_constant_id = constant_id; // Assign generic id. generic_var_id = var_id; generic_type_id = type_id; generic_constant_id = constant_id; // Assign generic ID to typed ID var_id = generic_var_id; type_id = generic_type_id; constant_id = generic_constant_id; // Implicit conversion to uint32_t. uint32_t a; a = var_id; a = type_id; a = constant_id; a = generic_var_id; a = generic_type_id; a = generic_constant_id; // Copy assignment. var_id = VariableID(10); type_id = TypeID(10); constant_id = ConstantID(10); // These operations are blocked, assign or construction from mismatched types. //var_id = type_id; //var_id = TypeID(100); }spirv-cross-2021.01.15/update_test_shaders.sh000077500000000000000000000000511400026215700207570ustar00rootroot00000000000000#!/bin/bash ./test_shaders.sh --update